O Brasil enterra R$ 20 bilhões por ano em resíduos (ABRELPE, 2026). Cada real desse valor vai para coleta, transporte e aterros sanitários. Enquanto isso, startups como a Green Mining já provam que é possível automatizar a triagem com 95% de acerto usando apenas uma câmera e um modelo de visão computacional.

O problema não é tecnológico. É de escala. O Brasil recicla apenas 4% dos 80 milhões de toneladas de lixo que gera anualmente (ABRELPE, 2026). O resto vira passivo ambiental ou custo municipal.

A boa notícia: ferramentas de machine learning gratuitas, combinadas com dados abertos, podem transformar essa realidade. Neste tutorial, você vai aprender a construir um sistema de otimização de rotas de coleta com Python, integrar com APIs de dados municipais e criar um dashboard para reduzir custos operacionais.

Segundo a ABRELPE (2026), cada tonelada de resíduo reciclável que deixa de ir para o aterro economiza R$ 300 em transporte e disposição final. Com IA, o custo de triagem cai para menos de R$ 50 por tonelada.

Por que Otimizar Rotas de Coleta?

A coleta de resíduos representa até 60% dos custos operacionais de um município. Caminhões percorrem trajetos ineficientes, consomem diesel em excesso e geram emissões desnecessárias. A otimização de rotas com machine learning pode reduzir o consumo de combustível em até 15% e o tempo de coleta em 20% (CNM, 2026).

A Green Mining, startup brasileira sediada em São Paulo, desenvolveu um sistema que processa 1.200 itens por hora em esteiras de reciclagem. O modelo atinge precisão de 95% na separação de resíduos recicláveis. A tecnologia usa redes neurais convolucionais treinadas em milhares de imagens de lixo doméstico e industrial.

O impacto financeiro é direto. Segundo a Confederação Nacional de Municípios (CNM, 2026), a adoção de IA na gestão de resíduos pode reduzir os custos municipais em até 30%. Isso significa economia de R$ 6 bilhões por ano para as prefeituras.

Para municípios de médio porte, o investimento em câmeras e servidores locais se paga em menos de 18 meses. O maior gargalo hoje não é hardware, mas a falta de profissionais capacitados para implementar esses sistemas.

Passo a Passo: Construindo um Otimizador de Rotas com Python

Vamos montar um pipeline funcional usando Python e a biblioteca OR-Tools do Google. O sistema será capaz de otimizar rotas de coleta para uma frota de caminhões, considerando restrições de capacidade, tempo e janelas de serviço.

1. Configuração do Ambiente

Instale as dependências necessárias:

pip install ortools pandas numpy streamlit folium

O OR-Tools é uma biblioteca de código aberto para problemas de otimização combinatória, incluindo o Problema do Roteamento de Veículos (VRP).

2. Coleta e Preparação dos Dados

Use dados abertos de rotas de coleta da sua cidade. A plataforma Dados Abertos Brasil disponibiliza informações de frequência, volume e localização dos pontos de coleta. Baixe os arquivos em formato CSV ou JSON.

Exemplo de estrutura de dados:

ponto_id,latitude,longitude,volume_kg,frequencia_dias
P001,-23.5505,-46.6333,500,segunda_quarta_sexta
P002,-23.5510,-46.6340,300,terca_quinta_sabado
P003,-23.5515,-46.6345,700,segunda_quarta_sexta

Organize os dados em um DataFrame pandas:

import pandas as pd

df = pd.read_csv('rotas_coleta.csv') print(df.head())

3. Modelagem do Problema de Roteamento

Defina as distâncias entre pontos usando a fórmula de Haversine (para coordenadas geográficas) ou uma matriz de distâncias real (via API do Google Maps ou OpenStreetMap).

import numpy as np
from math import radians, sin, cos, sqrt, atan2

def haversine(lat1, lon1, lat2, lon2): R = 6371 # Raio da Terra em km dlat = radians(lat2 - lat1) dlon = radians(lon2 - lon1) a = sin(dlat/2)**2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon/2)**2 c = 2 * atan2(sqrt(a), sqrt(1-a)) return R * c

Criar matriz de distâncias

num_pontos = len(df) dist_matrix = np.zeros((num_pontos, num_pontos)) for i in range(num_pontos): for j in range(num_pontos): dist_matrix[i][j] = haversine(df.iloc[i]['latitude'], df.iloc[i]['longitude'], df.iloc[j]['latitude'], df.iloc[j]['longitude'])

4. Otimização com OR-Tools

Configure o problema de roteamento com restrições de capacidade dos caminhões (ex.: 5 toneladas) e janelas de tempo (ex.: coleta entre 6h e 12h).

from ortools.constraint_solver import routing_enums_pb2, pywrapcp

Criar o modelo de roteamento

manager = pywrapcp.RoutingIndexManager(num_pontos, num_veiculos=3, depot_index=0) routing = pywrapcp.RoutingModel(manager)

Função de custo (distância)

def distance_callback(from_index, to_index): from_node = manager.IndexToNode(from_index) to_node = manager.IndexToNode(to_index) return int(dist_matrix[from_node][to_node] * 1000) # converter para metros

transit_callback_index = routing.RegisterTransitCallback(distance_callback) routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

Restrição de capacidade (kg)

def demand_callback(from_index): from_node = manager.IndexToNode(from_index) return int(df.iloc[from_node]['volume_kg'])

demand_callback_index = routing.RegisterUnaryTransitCallback(demand_callback) routing.AddDimensionWithVehicleCapacity( demand_callback_index, 0, # slack [5000, 5000, 5000], # capacidade de cada veículo (kg) True, # start cumul to zero 'Capacity')

Configurar heurística de busca

search_parameters = pywrapcp.DefaultRoutingSearchParameters() search_parameters.first_solution_strategy = ( routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)

Resolver

solution = routing.SolveWithParameters(search_parameters)

5. Visualização das Rotas

Use Folium para exibir as rotas otimizadas em um mapa interativo:

import folium

m = folium.Map(location=[-23.5505, -46.6333], zoom_start=12)

for vehicle_id in range(num_veiculos): index = routing.Start(vehicle_id) route_coords = [] while not routing.IsEnd(index): node = manager.IndexToNode(index) route_coords.append((df.iloc[node]['latitude'], df.iloc[node]['longitude'])) index = solution.Value(routing.NextVar(index)) node = manager.IndexToNode(index) route_coords.append((df.iloc[node]['latitude'], df.iloc[node]['longitude'])) folium.PolyLine(route_coords, color=f'color_{vehicle_id}', weight=2.5, opacity=1).add_to(m)

m.save('rotas_otimizadas.html')

6. Dashboard de Monitoramento

Use Streamlit para criar um dashboard que exibe a economia de combustível, tempo de coleta e quilometragem percorrida:

import streamlit as st
import pandas as pd

st.title('Monitor de Otimização de Rotas') st.metric('Economia de combustível (R$/mês)', 'R$ 12.500,00') st.metric('Redução de tempo de coleta (%)', '18%') st.metric('Quilometragem total (km/dia)', '320')

data = pd.DataFrame({ 'Veículo': ['Caminhão 1', 'Caminhão 2', 'Caminhão 3'], 'Distância (km)': [120, 100, 100], 'Paradas': [15, 12, 10], 'Volume (kg)': [4800, 4500, 4200] }) st.dataframe(data)

Integração com Dados Abertos de Coleta Municipal

O otimizador sozinho não resolve a logística. É preciso conectar a otimização de rotas com os dados de coleta seletiva das prefeituras.

A plataforma Dados Abertos Brasil disponibiliza informações de rotas de coleta, frequência e volume de resíduos por bairro. Use a API pública da prefeitura da sua cidade para obter esses dados.

Exemplo de requisição para a API da cidade de São Paulo:

import requests
import json

url = 'https://api.prefeitura.sp.gov.br/coleta/v1/rotas' params = {'regiao': 'zona_sul', 'ano': 2026} response = requests.get(url, params=params) rotas = response.json()

Com os dados de rota, é possível otimizar o trajeto dos caminhões. Um algoritmo simples de roteirização pode reduzir o consumo de diesel em 15% (CNM, 2026). Combine isso com a classificação em tempo real e você tem um sistema de logística reversa inteligente.

Tabela Comparativa: Custos da Coleta Tradicional vs. Otimizada

Os números mostram que, para frotas acima de 5 caminhões, a otimização se paga em menos de 6 meses.

Como Escalar para Municípios Menores

Nem toda cidade tem verba para servidores caros. A solução é usar algoritmos leves como o OR-Tools, que roda em um notebook comum. O custo total de implementação fica abaixo de R$ 5.000, incluindo treinamento da equipe.

A Solví, uma das maiores operadoras de resíduos do Brasil, já testa essa abordagem em cooperativas de catadores em Minas Gerais. O sistema identifica materiais recicláveis na esteira e aciona um alerta sonoro para o catador retirar o item. A produtividade subiu 40% nos primeiros três meses de operação.

Para prefeituras, a integração com sistemas de nota fiscal eletrônica de resíduos (como o MTR) permite rastrear cada quilo de material reciclável desde a coleta até a destinação final.

Checklist de Implementação

• Coletar dados abertos de rotas de coleta da sua cidade
• Instalar Python e as bibliotecas necessárias (OR-Tools, pandas, streamlit)
• Modelar o problema de roteamento com restrições de capacidade e tempo
• Executar a otimização e visualizar as rotas em mapa
• Criar dashboard de monitoramento com Streamlit
• Integrar com API de dados municipais para atualização em tempo real
• Testar o sistema com dados históricos e ajustar parâmetros
• Implementar em campo e medir a economia real

Artigos Relacionados

• Como Conversar com os Dados do Governo Brasileiro Usando IA: 3 Caminhos (Python, n8n ou MCP) em 2026
• Construa um Assistente de IA no WhatsApp: Take Blip, n8n e Maritaca AI (Tutorial 2026)
• IA no Campo Brasileiro em 2026: 3 Casos Reais que Estão Aumentando a Produtividade em 40%