Módulo 1: Modelos y Providers

Introducción: El Ecosistema LangChain Moderno

Descripción

LangChain es el framework más adoptado para construir aplicaciones con LLMs. Pero "LangChain" ya no es un solo paquete — es un ecosistema de herramientas que va desde conectar con un modelo hasta orquestar sistemas multi-agente en producción.

En esta cápsula vas a entender cómo encaja cada pieza del ecosistema, qué paquetes necesitas instalar, y cómo configurar tu entorno para trabajar con LangChain v1.2+. Al terminar, tendrás todo listo para empezar a escribir código en la siguiente cápsula.

¿Dónde estamos en la guía?

Este es el Módulo 1 de la guía LangChain & LangGraph: From Chains to Agents. Es el punto de partida: antes de crear agentes, tools, o workflows, necesitas dominar la pieza más fundamental — conectar con modelos de lenguaje y ejecutarlos.

La guía tiene 4 bloques progresivos:

Bloque 1: LangChain Core (Módulos 1-4)     ← ESTÁS AQUÍ
Bloque 2: LangGraph Fundamentals (Módulos 5-7)
Bloque 3: LangGraph Avanzado (Módulos 8-10)
Bloque 4: Producción (Módulos 11-12)

Todo lo que construyas en módulos posteriores — tools, agentes, workflows, multi-agente — depende de saber inicializar modelos, ejecutarlos, y obtener respuestas estructuradas. Este módulo te da esa base.

El ecosistema LangChain en 2026

LangChain ya no es un solo paquete monolítico. Desde la versión 1.0 (Octubre 2025), el ecosistema se reorganizó en componentes claros con responsabilidades definidas.

Los 3 niveles de abstracción

┌────────────────────────────────────────────────┐
│  Deep Agents                                   │
│  "Batteries-included"                          │
│  Planning, subagents, filesystem, memoria      │
│  → Para agentes autónomos de larga duración    │
├────────────────────────────────────────────────┤
│  LangChain (create_agent + Middleware)         │
│  "Alto nivel"                                  │
│  Agentes en <10 líneas, tools, middleware      │
│  → Para el 80% de casos de uso                 │
├────────────────────────────────────────────────┤
│  LangGraph (StateGraph + Functional API)       │
│  "Bajo nivel"                                  │
│  Grafos, nodos, edges, workflows custom        │
│  → Para control total del flujo de ejecución   │
└────────────────────────────────────────────────┘

LangSmith complementa como la plataforma de observabilidad: tracing, debugging y evaluación de todo lo que construyas con los niveles anteriores.

¿Cuándo usas cada nivel?

LangGraph (bajo nivel): Cuando necesitas control total sobre el flujo — decidir exactamente qué nodo ejecuta qué, cuándo hacer loops, cuándo pausar. Piensa en un director de orquesta que controla cada instrumento.
LangChain (alto nivel): Cuando quieres un agente funcional en pocas líneas. create_agent te da el 80% de lo que necesitas sin tocar grafos. Piensa en usar una app — funciona sin que entiendas los detalles internos.
Deep Agents (batteries-included): Cuando necesitas un agente que planifique sus propios pasos, cree archivos, y delegue a sub-agentes. Piensa en un empleado senior que recibe una tarea y la ejecuta de principio a fin.

No necesitas entender los 3 niveles ahora — los irás dominando módulo a módulo. Pero es útil saber que existen para tener el mapa mental completo.

¿Cómo se conectan entre sí?

Tu código
    │
    ▼
init_chat_model("openai:gpt-4.1")      ← Módulo 1: conectar con modelos
    │
    ▼
model.bind_tools([search, calc])         ← Módulo 2: agregar herramientas
    │
    ▼
create_agent(model, tools)               ← Módulo 3: crear agente autónomo
    │
    ▼
@wrap_model_call + middleware            ← Módulo 4: interceptar y personalizar
    │
    ▼
StateGraph / @entrypoint                 ← Módulos 5-7: workflows como grafos
    │
    ▼
Checkpointing + HITL + Multi-Agent      ← Módulos 8-10: producción avanzada
    │
    ▼
Deep Agents + LangSmith                 ← Módulos 11-12: autonomía y observability

Cada módulo construye sobre el anterior. Lo que aprendes aquí — inicializar modelos y ejecutarlos — es el cimiento de todo lo demás.

Arquitectura de paquetes

El ecosistema moderno se divide en paquetes con responsabilidades claras:

Paquete	Qué contiene	Cuándo lo usas
`langchain-core`	Interfaces base (BaseChatModel, BaseMessage, Runnable)	Siempre — es la dependencia de todo
`langchain`	`init_chat_model`, `create_agent`, middleware system	Cuando creas agentes y aplicaciones
`langchain-openai`	ChatOpenAI, OpenAIEmbeddings	Si usas modelos de OpenAI
`langchain-anthropic`	ChatAnthropic	Si usas modelos de Anthropic
`langchain-google-genai`	ChatGoogleGenerativeAI	Si usas modelos de Google
`langchain-ollama`	ChatOllama	Si usas modelos locales con Ollama
`langgraph`	StateGraph, Functional API, checkpointing	Cuando necesitas workflows como grafos
`langsmith`	SDK para tracing y evaluación	Cuando monitoreas en producción

La idea clave: en vez de un paquete gigante que instala todo, solo instalas lo que necesitas. Si usas OpenAI y Anthropic, instalas langchain, langchain-openai y langchain-anthropic.

Analogía: Piensa en un sistema de bloques LEGO. langchain-core es la base plate sobre la que todo se monta. langchain son las piezas de construcción principales. Los paquetes de proveedores (langchain-openai, etc.) son kits temáticos que agregas según lo que quieras construir. No compras todos los kits — solo los que necesitas.

¿Por qué v1.2+ y no legacy?

Si buscas tutoriales de LangChain en internet, encontrarás mucho código que usa APIs que ya no se recomiendan:

API Legacy (pre-v1.0)	API Moderna (v1.2+)
`LLMChain`	`model.invoke()`
`SequentialChain`	`chain1 \| chain2` (pipe)
`AgentExecutor`	`create_agent()`
`ConversationChain`	Agent + memoria
`from langchain.llms import OpenAI`	`init_chat_model("openai:gpt-4.1")`

Esta guía enseña exclusivamente las APIs modernas — las que usarás en producción y las que tienen soporte activo. En la Cápsula 07 incluimos un mapeo completo legacy → moderno para que puedas traducir cualquier tutorial antiguo.

¿Por qué importa? Si aprendes con APIs legacy, tendrás que reaprender cuando migres a producción. Si aprendes con APIs modernas desde el principio, tu código es production-ready desde el día uno. Además, las APIs modernas son más simples — init_chat_model("openai:gpt-4.1") reemplaza 5-10 líneas de imports y configuración manual.

Qué dominarás en este módulo

Al completar las 8 cápsulas de este módulo, serás capaz de:

✅ Inicializar modelos de cualquier proveedor con init_chat_model
✅ Configurar parámetros como temperature, max_tokens, timeout y retries
✅ Ejecutar modelos con los 3 modos fundamentales: invoke, stream y batch
✅ Obtener respuestas structured con Pydantic, TypedDict y JSON Schema
✅ Procesar contenido multimodal (imágenes, audio, video)
✅ Configurar modelos locales, caching y rate limiting para producción

Mapa del módulo

Cápsula	Tema	Qué aprenderás
02	init_chat_model y proveedores	Inicializar modelos de OpenAI, Anthropic, Google y Ollama con una sola función
03	Parámetros y configuración	temperature, max_tokens, timeout, retries, modelos configurables en runtime
04	Invoke, Stream y Batch	Los 3 modos de ejecución: respuesta completa, tokens progresivos, procesamiento paralelo
05	Structured Output	Obtener respuestas tipadas (Pydantic, TypedDict, JSON Schema) en vez de texto libre
06	Multimodal y Reasoning	Procesar imágenes/audio/video, surfacing de pasos de razonamiento del modelo
07	Modelos locales, caching y rate limiting	Ollama, prompt caching, InMemoryRateLimiter, mapeo API legacy → moderna
08	Proyecto: Chat multi-proveedor	Sistema de chat con fallback automático entre proveedores, streaming y metadata

Flujo de aprendizaje: Primero aprenderás a conectar con modelos (02). Luego a configurarlos finamente (03). Después a ejecutarlos de 3 formas diferentes (04). Con eso dominado, avanzarás a obtener respuestas structured (05), procesar contenido multimodal (06), y optimizar para producción (07). Al final, integrarás todo en un mini-proyecto funcional (08).

Conexión con el proyecto

Mini-Proyecto de este módulo: Chat Multi-Proveedor con Fallback

En la Cápsula 08 construirás un sistema de chat que:

Conecta con 3 proveedores (OpenAI, Anthropic, Google)
Implementa fallback automático — si un proveedor falla, pasa al siguiente
Muestra respuestas con streaming (tokens progresivos)
Retorna metadata structured (qué proveedor respondió, latencia, tokens usados)

Cada concepto que aprendes en las cápsulas 02-07 se aplica directamente en este proyecto.

Conexión con la guía completa

Los modelos que configuras aquí son la base de todo lo que viene:

Módulo 2: Les agregarás tools (herramientas que el modelo puede invocar)
Módulo 3: Los convertirás en agentes autónomos con create_agent
Módulo 4: Interceptarás sus llamadas con el sistema de middleware
Módulos 5-12: Los orquestarás en workflows, grafos y sistemas multi-agente

Límites: qué NO cubre este módulo

❌ Tools y tool calling — Se cubre en Módulo 2
❌ Agentes (create_agent) — Se cubre en Módulo 3
❌ RAG (Retrieval-Augmented Generation) — Se cubre en la guía Advanced RAG Techniques
❌ Embeddings — Se usan en RAG; se mencionan brevemente pero no se profundizan
❌ APIs deprecated (LLMChain, AgentExecutor) — Solo se incluye tabla de mapeo en Cápsula 07

Setup técnico

Prerequisitos

Antes de continuar, verifica que tienes:

✅ Python 3.11+ instalado
✅ pip o uv como gestor de paquetes
✅ Al menos una API key de un proveedor LLM (OpenAI o Anthropic recomendado)
✅ Un editor de código (VS Code, Cursor, PyCharm)
✅ Familiaridad con terminal/CLI

Verificación rápida:

python --version
# Debe mostrar Python 3.11.x o superior

Instalación

# Crear entorno virtual
python -m venv langchain-env
source langchain-env/bin/activate  # Mac/Linux
# langchain-env\Scripts\activate   # Windows

# Instalar paquetes core
pip install langchain langchain-core

# Instalar proveedores (instala los que vayas a usar)
pip install langchain-openai       # Para OpenAI
pip install langchain-anthropic    # Para Anthropic
pip install langchain-google-genai # Para Google Gemini
pip install langchain-ollama       # Para modelos locales

# Utilidades
pip install python-dotenv          # Para manejar API keys
pip install pydantic               # Para Structured Output

Configurar API keys

Crea un archivo .env en la raíz de tu proyecto:

# .env
OPENAI_API_KEY=sk-proj-tu-key-aqui
ANTHROPIC_API_KEY=sk-ant-tu-key-aqui
GOOGLE_API_KEY=tu-key-aqui

Cárgalas en tu código:

from dotenv import load_dotenv
load_dotenv()

# Las API keys se cargan automáticamente como variables de entorno
# Los paquetes de LangChain las detectan sin configuración adicional

Nunca hardcodees API keys en tu código. Siempre usa .env + python-dotenv.

Agrega .env a tu .gitignore para que nunca se suba a un repositorio:

# .gitignore
.env
__pycache__/
langchain-env/

Verificar que todo funciona

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("Di 'hola' en una palabra")
print(response.content)
# Output esperado: Hola

Si ves la respuesta del modelo, tu setup está listo.

Si algo falla, los errores más comunes son:

Error	Causa	Solución
`ModuleNotFoundError: No module named 'langchain'`	Paquete no instalado	`pip install langchain`
`AuthenticationError`	API key inválida o ausente	Verifica tu `.env` y que `load_dotenv()` se ejecute antes
`ModuleNotFoundError: No module named 'langchain_openai'`	Paquete de proveedor faltante	`pip install langchain-openai`
`RateLimitError`	Excediste la cuota de tu API key	Espera o configura rate limiting (Cápsula 07)

Versiones y compatibilidad

Esta guía cubre LangChain v1.2+ y LangGraph v1.0+.

Versiones mínimas requeridas:

Paquete	Versión mínima
`langchain`	0.3+
`langchain-core`	0.3+
`langchain-openai`	0.3+
`langchain-anthropic`	0.3+
`langgraph`	0.2+
Python	3.11+

Para verificar tus versiones:

pip show langchain langchain-core langchain-openai

¿Por qué LangChain y no directamente las APIs?

Podrías usar directamente openai.chat.completions.create() o anthropic.messages.create(). Funcionan bien. Entonces, ¿por qué un framework?

Sin LangChain — cambiar de OpenAI a Anthropic requiere reescribir código:

# OpenAI directo
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hola"}]
)
print(response.choices[0].message.content)

# Anthropic directo — API diferente, estructura diferente
from anthropic import Anthropic
client = Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hola"}]
)
print(response.content[0].text)

Con LangChain — cambias una línea:

from langchain.chat_models import init_chat_model

# Cambiar proveedor = cambiar UN string
model = init_chat_model("openai:gpt-4.1")
# model = init_chat_model("anthropic:claude-sonnet-4-20250514")
# model = init_chat_model("google_genai:gemini-2.0-flash")

response = model.invoke("Hola")
print(response.content)

Misma interfaz, cualquier proveedor. Además, LangChain te da streaming, batch processing, structured output, tool calling, y middleware — todo con la misma API consistente. A medida que tus aplicaciones crecen, el framework te ahorra semanas de código repetitivo.

Evidencia de éxito

Al terminar este módulo, sabrás que tuviste éxito si:

✅ Puedes inicializar un modelo de cualquier proveedor con una sola línea
✅ Entiendes la diferencia entre invoke, stream y batch y cuándo usar cada uno
✅ Obtienes respuestas structured (Pydantic) en vez de parsear texto libre
✅ Tu proyecto de chat multi-proveedor funciona con fallback automático
✅ Puedes traducir código legacy de LangChain a APIs modernas

Resumen

LangChain en 2026 es un ecosistema de paquetes con 3 niveles de abstracción: LangGraph (bajo nivel), LangChain (alto nivel), y Deep Agents (batteries-included)
Solo instalas los paquetes que necesitas — no hay monolito
La ventaja principal del framework es la interfaz unificada: misma API para cualquier proveedor
Esta guía enseña exclusivamente APIs modernas (v1.2+), no legacy
Este módulo cubre la pieza más fundamental: conectar con modelos, ejecutarlos, y obtener respuestas structured
El mini-proyecto integra todo: chat multi-proveedor con fallback, streaming y metadata
Setup: Python 3.11+, paquetes instalados, API keys en .env
Todo lo que aprendes aquí es el cimiento de los 11 módulos siguientes

Recursos adicionales

LangChain Python Documentation - Documentación oficial completa
LangChain API Reference - Referencia de todas las clases y funciones
LangGraph Documentation - Documentación oficial de LangGraph
LangSmith Documentation - Plataforma de observabilidad
LangChain Blog - Artículos técnicos y announcements del equipo
LangChain GitHub - Código fuente y ejemplos

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

Siguiente cápsula: init_chat_model y proveedores — aprenderás a conectar con cualquier modelo de lenguaje con una sola función universal.

Siguiente →init_chat_model y Proveedores