Integración de modelos OpenAI y Anthropic con LangChain

Integrar varios modelos en un sistema multiagentes es más simple y potente con una arquitectura agnóstica. Con LangGraph como orquestador y LangChain como intermediario, puedes cambiar entre OpenAI y Anthropic sin reescribir tu flujo. Aquí verás cómo configurar claves, enviar history de chat con system/human/AI message y usar la función init chat model para mantener una API homogénea.

¿Cómo integrar language models en un sistema multiagentes?

En un entorno de múltiples agentes, cada agente puede usar el modelo más apropiado para su tarea. LangGraph define la lógica y la coordinación con grafos y un state graph que almacena mensajes, mientras que los language models son los “cerebros” que razonan y actúan. La ventaja clave: arquitectura agnóstica o híbrida.

• LangGraph: orquestador de nodos y estado compartido entre agentes.
• LangChain: utilidades para conectar modelos de forma agnóstica y uniforme.
• Puedes usar SDKs directos de OpenAI, Gemini, Hugging Face o Llama Index en cada nodo.
• Misma API de invocación: invocas con invoke y cambias el modelo con mínimas modificaciones.

¿Qué pasos necesitas para configurar claves y probar un modelo?

Para trabajar con modelos, primero carga variables de entorno. Evita imprimir tus keys: un notebook guarda el historial de ejecuciones y puede exponerlas.

¿Cómo cargar variables de entorno .env sin exponer keys?

import os
from dotenv import load_dotenv

load_dotenv()
# Verifica que la variable exista sin imprimirla
assert os.getenv("OPENAI_API_KEY") is not None

• Usa .env y load_dotenv() para cargar tus claves.
• Evita print(API_KEY). Si lo hiciste, borra la celda para no dejar rastros.

¿Cómo probar ChatOpenAI e interpretar la respuesta?

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
response = llm.invoke("Hola, hola, ¿cómo estás?")
print(type(response))  # AIMessage
print(response.text)   # Contenido de la respuesta

• Respuesta típica: saludo y oferta de ayuda.
• Ejemplo de latencia: ~1.2 s con un modelo rápido, ~1.3 s en otra llamada.
• Cambiar de modelo es cambiar una línea: model="gpt-3.5-turbo" a otro de la misma familia.

¿Cómo manejar historial y cambiar de proveedor sin reescribir código?

El history permite que el modelo “recuerde” el contexto. Con SystemMessage, HumanMessage y AIMessage defines instrucciones, entradas y salidas previas. El state graph de LangGraph recolecta ese historial para cualquier agente o nodo.

¿Cómo enviar el historial de chat con system, human y AI message?

from langchain.schema import SystemMessage, HumanMessage, AIMessage

history = [
    SystemMessage(content="Eres un asistente útil."),
    HumanMessage(content="Me llamo Juan."),
    AIMessage(content="Hola Juan, ¿cómo estás?"),
    HumanMessage(content="¿Cómo me llamo?")
]

response = llm.invoke(history)
print(response.text)  # "Te llamas Juan"

• El modelo responde “Te llamas Juan” porque el nombre está en el history.
• Con LangGraph puedes tener ese history disponible en cualquier nodo.

¿Cómo cambiar a Anthropic e instalar la dependencia?

Para usar la familia de Anthropic, agrega su key a tu .env e instala el conector.

pip install -U langchain-anthropic --pre

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="TU_MODELO_ANTHROPIC", temperature=0.7)
response = llm.invoke(history)
print(response.text)  # "Tu nombre es Juan..."

• Ejemplo de latencia: ~1.7 s con un modelo de Anthropic.
• El código casi no cambia: solo la declaración del modelo y la dependencia.

¿Para qué usar init chat model en una arquitectura agnóstica?

Cuando los modelos comparten hiperparámetros comunes (como temperatura y nombre del modelo), init chat model compacta la configuración y conserva la misma API de invoke.

# import adecuado según tu instalación
from langchain import init_chat_model

llm = init_chat_model(
    model="gpt-4",           # o el que prefieras
    model_provider="openai", # por ejemplo: "anthropic", "google", "mistral"
    temperature=0.3
)

response = llm.invoke(history)
print(response.text)

• Ventaja: cambiar de proveedor sin reescribir imports ni lógica.
• Requisito: instalar la dependencia del proveedor que uses.
• Internamente, la función hace un gran if por model provider y verifica el paquete instalado.
• Hiperparámetros: todos comparten temperatura y modelo. Algunos, como Gemini, permiten además top-k y top-p.

Habilidades y conceptos prácticos que se aplican: - Arquitectura agnóstica con frameworks: cambia de OpenAI a Anthropic manteniendo el mismo flujo. - Gestión de variables de entorno: .env, load_dotenv() y cuidado con las keys. - Estructuración de prompts con system/human/AI message para dar contexto e instrucciones. - Historial de chat y state graph para memoria conversacional entre nodos. - Hiperparámetros como temperatura, y según el proveedor, top-k y top-p. - API homogénea con invoke e init chat model para rapidez y mantenibilidad.

¿Con qué modelo vas a probar primero y qué history usarás para explorar cómo cambia la respuesta al variar la temperatura? Comparte tus pruebas y hallazgos en los comentarios.