Conectar grandes modelos de lenguaje a un grafo de agentes es lo que transforma una estructura de nodos en un sistema verdaderamente inteligente. Con LangGraph y LangChain puedes integrar LLMs de OpenAI, Anthropic, Gemini y más sin reescribir tu código, manteniendo una arquitectura agnóstica e híbrida ideal para sistemas multiagente.

¿Por qué usar LangGraph para conectar varios LLMs?

En un sistema multiagente, lo natural es que cada agente use el modelo más adecuado para su tarea. Algunos frameworks limitan esa libertad: el de OpenAI te ata a sus modelos y el ADK de Google se enfoca en Gemini. LangGraph es agnóstico, así que puedes conectarte a cualquier proveedor.

La división de responsabilidades queda clara desde el inicio [2:00]:

• LangGraph actúa como orquestador de nodos y estado.
• LangChain funciona como intermediario para conectar modelos.
• Los SDK directos (OpenAI, Gemini, Hugging Face) siguen siendo opción válida dentro de cada nodo.

¿Qué es un agente en LangGraph? Es un componente que razona y ejecuta tareas por sí mismo. El grafo solo controla cómo se coordinan esos agentes entre nodos y edges.

¿Cómo cargar las variables de entorno antes de invocar un modelo?

Antes de tocar cualquier LLM necesitas tus API keys disponibles. La práctica estándar en Python es usar dotenv para cargarlas desde un archivo .env [3:30].

python import os from dotenv import load_dotenv load_dotenv()

Si load_dotenv() retorna True, las variables ya están en memoria. Puedes verificarlo imprimiendo temporalmente la key, pero borra esa línea enseguida: los notebooks guardan el output de cada celda y tu llave podría quedar expuesta en el repositorio.

¿Cómo invocar un modelo de OpenAI desde LangChain?

La conexión a un modelo se hace instanciando una clase y llamando al método invoke. Ese patrón es la clave de la portabilidad: todos los proveedores usan la misma API homogénea.

python from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-4", temperature=0) response = llm.invoke("Hola, ¿cómo estás?") print(response.text)

La respuesta llega como un AIMessage. Cambiar de modelo es trivial: pasar de GPT-4 a GPT-3.5 Turbo solo requiere modificar el nombre del modelo. En la demo, GPT-4 tardó cerca de 2 segundos y GPT-3.5 Turbo respondió en 1.2 segundos [7:30].

¿Cómo enviar un historial de chat al modelo?

Un LLM no recuerda nada por sí solo. Si quieres que sepa cómo te llamas, necesitas mandarle el historial completo armado con los tipos de mensaje correctos.

Los tres mensajes base son:

• SystemMessage: instrucciones, rol y goals del asistente. Aquí vive tu prompt engineering.
• HumanMessage: lo que dice el usuario.
• AIMessage: lo que respondió la IA en turnos anteriores.

¿Cómo le doy memoria a un LLM sin estado? Pasándole un array con todo el historial de mensajes en cada llamada. El modelo lee la conversación completa y responde con contexto.

Esto se conecta directamente con el StateGraph de LangGraph, que va recolectando los mensajes y los deja disponibles en cualquier nodo del grafo [10:30].

¿Cómo conectar Anthropic Claude al mismo flujo?

Cambiar de proveedor implica tres pasos: generar la key en console.anthropic.com, agregarla al .env e instalar la librería específica.

bash pip install --pre langchain-anthropic

El flag --pre solo es necesario mientras la versión esté en alfa. Después, el código cliente es casi idéntico al de OpenAI:

python from langchain_anthropic import ChatAnthropic llm = ChatAnthropic(model="claude-3-5-sonnet", temperature=0) response = llm.invoke(history)

Claude respondió el historial en 1.7 segundos y recordó el nombre del usuario porque recibió la conversación completa [13:00].

¿Qué hace init_chat_model y cuándo conviene usarlo?

La mayoría de modelos comparte hiperparámetros básicos como temperature y model. Para no repetir imports y declaraciones, LangChain ofrece una función unificada.

python from langchain.chat_models import init_chat_model llm = init_chat_model("claude-3-5-sonnet", model_provider="anthropic", temperature=0)

Cambiar a OpenAI con GPT-4 es modificar dos strings. El resto del código permanece intacto: invoke, temperatura y manejo de respuesta funcionan igual.

Por dentro, init_chat_model es un gran if que detecta el model_provider y carga el import correspondiente. Eso significa dos cosas importantes:

• Sigues necesitando instalar la dependencia de cada proveedor (langchain-openai, langchain-anthropic, langchain-google-vertexai, etc.).
• La función ejecuta un check_package y te avisa si falta el paquete del proveedor que pediste.

¿Cuándo no usar init_chat_model? Cuando necesites hiperparámetros muy específicos como top-K y top-P en Gemini, que no todos los modelos exponen. En ese caso, instancia directamente la clase del proveedor.

La ventaja real de init_chat_model aparece dentro de un grafo: puedes hacer switch de modelo según el nodo o la tarea sin tocar la lógica de orquestación [16:00].

Próximo paso: meter el cerebro al nodo

Ya tienes los LLMs conectados de forma agnóstica y un historial que viaja por el grafo. Falta lo más interesante: enchufar uno de estos modelos como el cerebro de un nodo específico dentro del StateGraph. Antes de seguir, prueba con Claude y GPT jugando con la temperatura y diferentes historiales. ¿Cuál se ajusta mejor a tu caso? Cuéntalo en los comentarios.