init_chat_model y Proveedores

Descripción de la cápsula

init_chat_model es la función universal de LangChain para inicializar modelos de cualquier proveedor. En vez de importar clases diferentes para cada proveedor (ChatOpenAI, ChatAnthropic, ChatGoogleGenerativeAI), usas una sola función que resuelve todo internamente.

En esta cápsula aprenderás a usar init_chat_model con los proveedores principales (OpenAI, Anthropic, Google, Ollama), entender los string identifiers que usa para resolver modelos, y configurar API keys correctamente. Al terminar, podrás conectar con cualquier modelo de lenguaje en una sola línea de código.

Todo lo que aprendes aquí es la base del mini-proyecto del módulo: un chat multi-proveedor con fallback automático.

init_chat_model: la función universal

El problema que resuelve

Sin init_chat_model, cada proveedor requiere su propia clase y patrón de inicialización:

# Sin init_chat_model — imports y clases diferentes por proveedor

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI

openai_model = ChatOpenAI(model="gpt-4.1")
anthropic_model = ChatAnthropic(model="claude-sonnet-4-20250514")
google_model = ChatGoogleGenerativeAI(model="gemini-2.0-flash")

Funciona, pero si quieres cambiar de proveedor tienes que cambiar imports, clases y posiblemente parámetros. Con init_chat_model, una función lo resuelve todo:

# Con init_chat_model — una función, cualquier proveedor

from langchain.chat_models import init_chat_model

openai_model = init_chat_model("openai:gpt-4.1")
anthropic_model = init_chat_model("anthropic:claude-sonnet-4-20250514")
google_model = init_chat_model("google_genai:gemini-2.0-flash")

Misma función, misma interfaz, cualquier proveedor. El cambio de proveedor es un cambio de string.

Ejemplo básico

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Inicializar un modelo de OpenAI
model = init_chat_model("openai:gpt-4.1-mini")

# Ejecutar con invoke
response = model.invoke("¿Qué es LangChain en una frase?")
print(response.content)
# Output esperado: LangChain es un framework open-source para construir
# aplicaciones con modelos de lenguaje.

Eso es todo. Una línea para inicializar, una línea para ejecutar.

String identifiers

init_chat_model usa un formato estándar para identificar modelos:

proveedor:modelo

Ejemplos:

Formato alternativo: sin prefijo de proveedor

También puedes pasar el modelo y el proveedor por separado:

# Estas dos líneas son equivalentes
model = init_chat_model("openai:gpt-4.1")
model = init_chat_model("gpt-4.1", model_provider="openai")

El formato con prefijo ("openai:gpt-4.1") es más conciso y recomendado. El formato con model_provider es útil cuando el nombre del modelo es dinámico (viene de una variable o config).

# Útil cuando el modelo viene de configuración
model_name = config.get("model_name")       # "gpt-4.1"
provider = config.get("model_provider")      # "openai"

model = init_chat_model(model_name, model_provider=provider)

Proveedores soportados

OpenAI

Paquete: pip install langchain-openai API key: OPENAI_API_KEY

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# GPT-4.1 — modelo principal
model = init_chat_model("openai:gpt-4.1")
response = model.invoke("Explica qué es RAG en 2 frases")
print(response.content)

# GPT-4.1 Mini — más rápido y económico
model_mini = init_chat_model("openai:gpt-4.1-mini")
response = model_mini.invoke("Hola")
print(response.content)

# o3-mini — modelo con reasoning (piensa antes de responder)
model_reasoning = init_chat_model("openai:o3-mini")
response = model_reasoning.invoke("Resuelve: 15 * 23 + 47")
print(response.content)

Modelos recomendados:

• gpt-4.1 — El más capaz de OpenAI para tareas complejas
• gpt-4.1-mini — Balance entre costo y capacidad. Ideal para la mayoría de casos
• o3-mini — Para tareas que requieren razonamiento paso a paso

Anthropic

Paquete: pip install langchain-anthropic API key: ANTHROPIC_API_KEY

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Claude Sonnet 4 — balance calidad/velocidad
model = init_chat_model("anthropic:claude-sonnet-4-20250514")
response = model.invoke("Explica la diferencia entre RAG y fine-tuning")
print(response.content)

# Claude Haiku 4 — el más rápido de Anthropic
model_fast = init_chat_model("anthropic:claude-haiku-4-20250514")
response = model_fast.invoke("Resume este texto en una frase: [texto]")
print(response.content)

Modelos recomendados:

• claude-sonnet-4-20250514 — Ideal para la mayoría de tareas
• claude-haiku-4-20250514 — Muy rápido, ideal para clasificación y tareas simples

Google (Gemini)

Paquete: pip install langchain-google-genai API key: GOOGLE_API_KEY

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Gemini 2.0 Flash — rápido y con buena calidad
model = init_chat_model("google_genai:gemini-2.0-flash")
response = model.invoke("¿Cuáles son los 3 pilares de la observability?")
print(response.content)

Modelos recomendados:

• gemini-2.0-flash — Rápido y económico, buena opción como fallback

Ollama (modelos locales)

Paquete: pip install langchain-ollama Requisito: Ollama instalado y corriendo localmente

# Instalar Ollama: https://ollama.ai
# Descargar un modelo
ollama pull llama3.1
ollama pull mistral

from langchain.chat_models import init_chat_model

# No necesita API key — corre en tu máquina
model = init_chat_model("ollama:llama3.1")
response = model.invoke("¿Qué es un vector database?")
print(response.content)

# Mistral — alternativa ligera
model_mistral = init_chat_model("ollama:mistral")
response = model_mistral.invoke("Hola")
print(response.content)

Ventajas de modelos locales:

• ✅ Sin costo por uso (corre en tu máquina)
• ✅ Sin latencia de red
• ✅ Datos nunca salen de tu máquina (privacidad)

Desventajas:

• ❌ Menor calidad que GPT-4.1 o Claude Sonnet
• ❌ Requiere GPU potente para modelos grandes
• ❌ Más lento en hardware limitado

Azure OpenAI

Paquete: pip install langchain-openai API key: AZURE_OPENAI_API_KEY + AZURE_OPENAI_ENDPOINT

from langchain.chat_models import init_chat_model

model = init_chat_model(
    "openai:gpt-4.1",
    model_provider="azure_openai",
    azure_endpoint="https://tu-recurso.openai.azure.com/",
    api_version="2024-12-01-preview"
)
response = model.invoke("Hola desde Azure")
print(response.content)

Azure OpenAI es útil en entornos enterprise donde la organización ya tiene contratos con Microsoft.

Inicialización directa vs init_chat_model

Ambas formas funcionan. Elige según tu caso:

Recomendación: Usa init_chat_model como default. Solo usa clases directas si necesitas autocompletado avanzado del IDE para parámetros específicos de un proveedor.

# Recomendado para la mayoría de casos
model = init_chat_model("openai:gpt-4.1")

# Alternativa cuando necesitas parámetros muy específicos del proveedor
from langchain_openai import ChatOpenAI
model = ChatOpenAI(
    model="gpt-4.1",
    organization="org-abc123",
    default_headers={"X-Custom-Header": "value"}
)

Configurar API keys correctamente

Método recomendado: archivo .env

# .env (en la raíz de tu proyecto)
OPENAI_API_KEY=sk-proj-tu-key-aqui
ANTHROPIC_API_KEY=sk-ant-tu-key-aqui
GOOGLE_API_KEY=tu-key-aqui

from dotenv import load_dotenv
load_dotenv()  # Carga las variables del .env

from langchain.chat_models import init_chat_model

# Los paquetes de LangChain buscan automáticamente estas variables
model = init_chat_model("openai:gpt-4.1")  # Usa OPENAI_API_KEY

Método alternativo: pasar explícitamente

model = init_chat_model("openai:gpt-4.1", api_key="sk-proj-...")

No recomendado para código que se comparte o se sube a git. Útil solo para testing rápido.

Variables de entorno por proveedor

Conexión con el proyecto

En el Chat Multi-Proveedor con Fallback (proyecto de este módulo):

• Usarás init_chat_model para inicializar 3 proveedores diferentes
• El string identifier te permitirá cambiar proveedores con un simple cambio de config
• El fallback automático probará proveedor 1 → proveedor 2 → proveedor 3

Todo lo que aprendes aquí se aplica directamente en la Cápsula 08.

Troubleshooting

Problema 1: ImportError: cannot import name 'init_chat_model'

Causa: Versión de langchain demasiado antigua. Solución:

pip install --upgrade langchain langchain-core

Problema 2: ValueError: Could not find chat model provider for ...

Causa: El paquete del proveedor no está instalado. Solución:

# Para OpenAI
pip install langchain-openai

# Para Anthropic
pip install langchain-anthropic

# Para Google
pip install langchain-google-genai

Problema 3: AuthenticationError o Invalid API Key

Causa: API key ausente, incorrecta, o no cargada. Solución:

# Verificar que la key existe
import os
from dotenv import load_dotenv
load_dotenv()

print(os.getenv("OPENAI_API_KEY"))  # Debe mostrar tu key
# Si muestra None, revisa tu archivo .env

Problema 4: Ollama no responde

Causa: Ollama no está corriendo o el modelo no está descargado. Solución:

# Verificar que Ollama está corriendo
ollama list

# Si no aparece el modelo, descárgalo
ollama pull llama3.1

# Verificar que el servidor responde
curl http://localhost:11434/api/tags

Ejercicios

Ejercicio 1: Tu primer modelo (Fácil)

Inicializa un modelo de OpenAI con init_chat_model y hazle una pregunta simple. Imprime la respuesta.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-4.1-mini")
response = model.invoke("¿Cuál es la capital de Francia?")
print(response.content)
# Output esperado: La capital de Francia es París.

Ejercicio 2: Cambiar de proveedor (Fácil)

Modifica el ejercicio anterior para usar Anthropic en vez de OpenAI. Solo deberías cambiar una línea.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Solo cambia el string identifier
model = init_chat_model("anthropic:claude-haiku-4-20250514")
response = model.invoke("¿Cuál es la capital de Francia?")
print(response.content)
# Output esperado: La capital de Francia es París.

Ejercicio 3: Múltiples proveedores (Medio)

Crea una función ask_model(provider, question) que acepte un nombre de proveedor ("openai", "anthropic", "google") y una pregunta, inicialice el modelo correcto, y retorne la respuesta.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

MODELS = {
    "openai": "openai:gpt-4.1-mini",
    "anthropic": "anthropic:claude-haiku-4-20250514",
    "google": "google_genai:gemini-2.0-flash",
}

def ask_model(provider: str, question: str) -> str:
    """Inicializa el modelo del proveedor indicado y retorna la respuesta."""
    if provider not in MODELS:
        raise ValueError(f"Proveedor no soportado: {provider}")
    
    model = init_chat_model(MODELS[provider])
    response = model.invoke(question)
    return response.content

# Uso
print(ask_model("openai", "Di hola en japonés"))
print(ask_model("anthropic", "Di hola en japonés"))
# Output esperado: こんにちは (Konnichiwa) — o variantes

Ejercicio 4: Comparar respuestas (Medio)

Crea un script que haga la misma pregunta a 2 proveedores diferentes y compare sus respuestas lado a lado. Imprime el proveedor, su respuesta, y el tipo de objeto retornado.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

providers = {
    "OpenAI": "openai:gpt-4.1-mini",
    "Anthropic": "anthropic:claude-haiku-4-20250514",
}

question = "¿Qué es un embedding en una frase?"

for name, model_id in providers.items():
    model = init_chat_model(model_id)
    response = model.invoke(question)
    
    print(f"--- {name} ---")
    print(f"Respuesta: {response.content}")
    print(f"Tipo: {type(response)}")
    print(f"Metadata: {response.response_metadata.get('model_name', 'N/A')}")
    print()

# Output esperado:
# --- OpenAI ---
# Respuesta: Un embedding es una representación numérica...
# Tipo: <class 'langchain_core.messages.ai.AIMessage'>
# Metadata: gpt-4.1-mini
#
# --- Anthropic ---
# Respuesta: Un embedding es un vector numérico...
# Tipo: <class 'langchain_core.messages.ai.AIMessage'>
# Metadata: N/A

Ejercicio 5: Modelo dinámico desde config (Difícil)

Crea un sistema donde el modelo se configura desde un diccionario de configuración (simulando un archivo de config). La función debe aceptar el config dict, inicializar el modelo, y retornar la respuesta con metadata del proveedor usado.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

def chat_with_config(config: dict, question: str) -> dict:
    """
    Inicializa modelo basado en config y retorna respuesta con metadata.
    
    Config esperado:
    {
        "model": "gpt-4.1-mini",
        "provider": "openai",
        "temperature": 0.7
    }
    """
    model = init_chat_model(
        config["model"],
        model_provider=config["provider"],
        temperature=config.get("temperature", 0.7)
    )
    
    response = model.invoke(question)
    
    return {
        "answer": response.content,
        "provider": config["provider"],
        "model": config["model"],
        "tokens": response.usage_metadata if hasattr(response, "usage_metadata") else None
    }

# Config de producción
prod_config = {
    "model": "gpt-4.1-mini",
    "provider": "openai",
    "temperature": 0.3
}

# Config de desarrollo (más barato)
dev_config = {
    "model": "gpt-4.1-nano",
    "provider": "openai",
    "temperature": 0.7
}

result = chat_with_config(prod_config, "¿Qué es LangChain?")
print(f"Proveedor: {result['provider']}")
print(f"Modelo: {result['model']}")
print(f"Respuesta: {result['answer'][:100]}...")

Resumen

En esta cápsula aprendiste:

• init_chat_model es la función universal para inicializar modelos de cualquier proveedor
• Los string identifiers siguen el formato proveedor:modelo (ej: "openai:gpt-4.1")
• Puedes separar modelo y proveedor con el parámetro model_provider
• Los proveedores principales son OpenAI, Anthropic, Google (cloud) y Ollama (local)
• Cada proveedor requiere su paquete (langchain-openai, etc.) y su API key
• La interfaz es idéntica entre proveedores — cambiar proveedor = cambiar un string
• Usa .env + python-dotenv para manejar API keys de forma segura

Próxima cápsula: Parámetros y configuración — aprenderás a afinar el comportamiento del modelo con temperature, max_tokens, timeout, y modelos configurables en runtime.

Recursos adicionales

1. init_chat_model API Reference - Documentación completa de la función
2. Chat Models Universal Init - How-to guide oficial
3. LangChain Integrations: Chat Models - Lista completa de proveedores soportados
4. OpenAI Models Documentation - Modelos disponibles en OpenAI
5. Anthropic Models Documentation - Modelos disponibles en Anthropic
6. Ollama Library - Modelos disponibles para ejecución local
7. python-dotenv Documentation - Manejo de variables de entorno

Módulo 1 — LangChain & LangGraph: From Chains to Agents