En este tutorial, creamos un agente optimizador de rutas de estilo de producción para un centro de despacho logístico utilizando las últimas API del agente LangChain. Diseñamos un flujo de trabajo basado en herramientas en el que el agente calcula de manera confiable distancias, ETA y rutas óptimas en lugar de adivinar, y aplicamos resultados estructurados para que los resultados se puedan utilizar directamente en sistemas posteriores. Integramos cálculos geográficos, perfiles de velocidad configurables, zonas de amortiguamiento de tráfico y optimización de rutas de múltiples paradas, asegurando que el agente se comporte de manera determinista y al mismo tiempo razone de manera flexible a través de herramientas.
Configuramos el entorno de ejecución y nos aseguramos de que todas las bibliotecas requeridas estén instaladas e importadas correctamente. Cargamos de forma segura la clave API de OpenAI para que el agente pueda interactuar con el modelo de lenguaje sin codificar credenciales. También preparamos las dependencias centrales que impulsan las herramientas, los agentes y los resultados estructurados.
Definimos los datos del dominio central que representan plataformas, astilleros y depósitos junto con sus coordenadas geográficas. Establecemos perfiles de velocidad y un multiplicador de tráfico predeterminado para reflejar condiciones de conducción realistas. También implementamos la función de distancia de Haversine, que sirve como columna vertebral matemática de todas las decisiones de ruta.
retorno flotador(haversine_km(sa[“lat”]sí[“lon”]alguien[“lat”]alguien[“lon”])) def _eta_minutos(distancia_km: flotador, velocidad_km/h: flotador, tráfico_multiplicador: flotador) -> flotador: velocidad = max(flotador(velocidad_kmph), 1e-6) base_minutos = (distancia_km / velocidad) * 60.0 return float(base_minutos * max(float(traffic_multiplier), 0.0)) def Compute_route_metrics(ruta: Lista[str]speed_kmph: flotante, tráfico_multiplicador: flotante) -> Dict[str, Any]: si len(ruta) < 2: elevar ValueError("La ruta debe incluir al menos origen y destino.") para s en la ruta: _assert_site_exists(s) piernas = [] total_km = 0.0 total_min = 0.0 para i en el rango (len (ruta) - 1): a, b = ruta[i]camino[i + 1] d_km = _distancia_entre(a, b) t_min = _eta_minutos(d_km, velocidad_kmph, tráfico_multiplicador) leg.append({"desde": a, "hasta": b, "distancia_km": d_km, "eta_minutos": t_min}) total_km += d_km total_min += t_min return {"ruta": ruta, "distancia_km": float(total_km), "eta_minutos": flotador(total_min), "piernas": piernas}
Construimos funciones de utilidad de bajo nivel que validan los nombres de los sitios y calculan distancias y tiempos de viaje. Implementamos lógica para calcular métricas de ruta total y por tramo de forma determinista. Esto garantiza que cada ETA y distancia devuelta por el agente se base en un cálculo explícito en lugar de en una inferencia.
max_stops = int(max(0, max_stops)) candidatos = []
para k en rango(0, min(len(waypoints), max_stops) + 1): para permanente en permutaciones(waypoints, k): candidatos.append([origin, *perm, destination]) si [origin, destination] no en candidatos: candidatos.insert(0, [origin, destination]) devolver candidatos def find_best_route(origen: cadena, destino: cadena, permitidos_waypoints: opcional[List[str]], max_stops: int, speed_kmph: float, Traffic_multiplier: float, objetivo: str, top_k: int) -> Dict[str, Any]: origen = _normalize_site_name(origen) destino = _normalize_site_name(destino) _assert_site_exists(origen) _assert_site_exists(destino) permitido_waypoints = permitido_waypoints o []
para w en puntos_de_ruta permitidos: _assert_site_exists(_normalize_site_name(w)) objetivo = (objetivo o “eta”).strip().lower() si el objetivo no está en {“eta”, “distancia”}: elevar ValueError(“el objetivo debe ser uno de: ‘eta’, ‘distancia'”) top_k = max(1, int(top_k)) candidatos = _all_paths_with_waypoints(origen, destino, permitidos_waypoints, max_stops=max_stops) puntuados = []
para ruta en candidatos: métricas = Compute_route_metrics(ruta, velocidad_kmph=velocidad_kmph, tráfico_multiplier=traffic_multiplier) puntuación = métricas[“eta_minutes”] si objetivo == “eta” más métricas[“distance_km”]
anotado.append((puntuación, métricas)) anotado.sort(clave=lambda x: x[0]) mejor = puntuado[0][1]
alternativas = [m for _, m in scored[1:top_k]]return {“mejor”: mejor, “alternativas”: alternativas, “objetivo”: objetivo}
Introducimos una lógica de enrutamiento de múltiples paradas generando rutas candidatas con puntos de referencia opcionales. Evaluamos cada ruta candidata frente a un objetivo de optimización claro, como ETA o distancia. Luego clasificamos las rutas y extraemos la mejor opción junto con un conjunto de alternativas sólidas.
para nombre en SITES.keys(): n = name.lower() common = len(set(q) & set(n)) bonus = 5 si q y q en n else 0 scoring.append((common + bonus, nombre)) scoring.sort(key=lambda x: x[0]reverso=Verdadero) retorno [name for _, name in scored[:max_suggestions]]@tool def Compute_direct_route(origen: str, destino: str, road_class: str = “arterial”, Traffic_multiplier: float = DEFAULT_TRAFFIC_MULTIPLIER) -> Dict[str, Any]: origen = _normalize_site_name(origen) destino = _normalize_site_name(destino) rc = (road_class o “arterial”).strip().lower() si rc no está en SPEED_PROFILES: aumente ValueError(f”Carretera_clase desconocida ‘{road_class}’. Utilice uno de: {sorted(SPEED_PROFILES.keys())}”) velocidad = SPEED_PROFILES[rc]
devolver cálculo_ruta_métrica ([origin, destination]velocidad_kmph=velocidad, tráfico_multiplicador=float(traffic_multiplier)) @tool def optimizar_ruta(origen: cadena, destino: cadena, puntos_de_ruta permitidos: Opcional[List[str]]= Ninguno, max_stops: int = 2, road_class: str = “arterial”, Traffic_multiplier: float = DEFAULT_TRAFFIC_MULTIPLIER, objetivo: str = “eta”, top_k: int = 3) -> Dict[str, Any]: origen = _normalize_site_name(origen) destino = _normalize_site_name(destino) rc = (road_class o “arterial”).strip().lower() si rc no está en SPEED_PROFILES: aumente ValueError(f”Carretera_clase desconocida ‘{road_class}’. Utilice uno de: {sorted(SPEED_PROFILES.keys())}”) velocidad = SPEED_PROFILES[rc]
puntos_de_ruta permitidos = puntos_de_ruta_permitidos o []
puntos_waypoints permitidos = [_normalize_site_name(w) for w in allowed_waypoints]
return find_best_route(origen, destino, puntos_de_ruta permitidos, int(max_stops), float(velocidad), float(traffic_multiplier), str(objetivo), int(top_k))
Exponemos la lógica de enrutamiento y descubrimiento como herramientas invocables para el agente. Permitimos que el agente enumere sitios, inspeccione los detalles del sitio, resuelva nombres ambiguos y calcule rutas tanto directas como optimizadas. Esta capa de herramientas garantiza que el agente siempre razone llamando a funciones verificadas en lugar de alucinar resultados.
distancia_km: flotación eta_minutos: tramos de flotación: Lista[RouteLeg]
objetivo: clase str RouteDecision(BaseModel): elegido: alternativas de RoutePlan: lista[RoutePlan] = []
suposiciones: dictado[str, Any] = {} notas: str = “” auditoría: Lista[str] = []
llm = ChatOpenAI(model=”gpt-4o-mini”, temperatura=0.2) SYSTEM_PROMPT = ( “Usted es el agente optimizador de rutas para un centro de despacho de logística.\n” “DEBE usar herramientas para cualquier cálculo de distancia/ETA.\n” “Devuelva SÓLO la decisión de ruta estructurada.” ) route_agent = create_agent( model=llm, tools=[list_sites, get_site_details, suggest_site, compute_direct_route, optimize_route]system_prompt=SYSTEM_PROMPT, Response_format=RouteDecision, ) def get_route_decision(origen: str, destino: str, road_class: str = “arterial”, Traffic_multiplier: float = DEFAULT_TRAFFIC_MULTIPLIER, Allow_waypoints: Opcional[List[str]]= Ninguno, max_stops: int = 2, objetivo: str = “eta”, top_k: int = 3) -> RouteDecision: user_msg = { “role”: “user”, “content”: ( f”Optimizar la ruta desde {origen} a {destino}.\n” f”road_class={road_class}, Traffic_multiplier={traffic_multiplier}\n” f”objective={objective}, top_k={top_k}\n” f”allowed_waypoints={allowed_waypoints}, max_stops={max_stops}\n” “Devuelve solo la RouteDecision estructurada), } result = route_agent.invoke({“messages”: [user_msg]}) devolver resultado[“structured_response”]
decisión1 = get_route_decision(“Yard_Main”, “Rig_B”, road_class=”arterial”, tráfico_multiplier=1.12) print(decisión1.model_dump()) decisión2 = get_route_decision(“Rig_C”, “Rig_B”, road_class=”carretera”, tráfico_multiplier=1.08, permitido_waypoints=[“Depot_1”, “Depot_2”, “Yard_Main”]max_stops=2, objetivo=”eta”, top_k=3) print(decisión2.model_dump())
Definimos esquemas Pydantic estrictos para aplicar resultados estructurados y legibles por máquina del agente. Inicializamos el modelo de lenguaje y creamos el agente con un formato de respuesta y aviso del sistema claro. Luego demostramos cómo invocar al agente y obtener decisiones de ruta confiables y listas para flujos de trabajo logísticos reales.
En conclusión, hemos implementado un agente de optimización de rutas robusto y extensible que selecciona la mejor ruta entre sitios y al mismo tiempo explica claramente sus supuestos y alternativas. Demostramos cómo la combinación de una lógica de enrutamiento determinista con un LLM de llamada de herramientas produce decisiones confiables y auditables adecuadas para operaciones logísticas reales. Esta base nos permite ampliar fácilmente el sistema con datos de tráfico en vivo, restricciones de flota u objetivos basados en costos, lo que convierte al agente en un componente práctico en una plataforma más grande de despacho o gestión de flotas.
Consulte los códigos completos aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.