LangChain

Resumen

LangChain es un framework para construir aplicaciones impulsadas por modelos de lenguaje. Su valor principal es ofrecer componentes componibles para conectar prompts, modelos, herramientas, retrievers, parsers e integraciones externas sin reescribir la misma plomería en cada proyecto.

Importa cuando una aplicación LLM deja de ser una llamada aislada al modelo. Un asistente con RAG necesita cargar documentos, recuperar contexto, armar prompts, llamar un modelo, parsear salida y manejar errores. LangChain entrega abstracciones e integraciones para ensamblar esas piezas con menos código ad hoc.

Alcance y supuestos

Este paquete cubre LangChain a nivel conceptual: qué problema resuelve, qué componentes suele coordinar y cuándo conviene usarlo frente a SDKs directos, LangGraph o código propio.

No cubre una guía completa del SDK, LangSmith, deployment, tracing avanzado ni la API exacta por versión. Tampoco cubre en detalle LangGraph, que es la pieza enfocada en agentes stateful y workflows con grafos. Asume que entiendes prompts, llamadas a LLMs, herramientas, retrievers y flujos básicos de aplicación.

Modelo mental

Piensa en LangChain como una caja de conectores para armar una línea de producción con LLMs. Una estación prepara el prompt, otra consulta documentos, otra llama al modelo, otra transforma la salida y otra conecta con herramientas externas. Puedes cablear esas piezas sin fabricar cada adaptador desde cero.

El modelo no desaparece; sigue siendo el motor que genera texto o decisiones. LangChain organiza lo que ocurre alrededor del modelo: entrada, contexto, integración, composición y salida. Esa organización ayuda cuando el proyecto empieza a tener muchos proveedores, fuentes de datos o patrones repetidos.

La clave es no confundir framework con arquitectura. Usar LangChain no garantiza buen diseño. Si los límites del flujo son confusos, si los prompts no están evaluados o si los datos recuperados son malos, el framework solo hará más cómodo construir un sistema frágil.

Uso práctico

Usa LangChain cuando necesitas componer varias piezas de una aplicación LLM:

• ✅ Un flujo RAG puede combinar loader, splitter, embeddings, vector store, retriever, prompt, chat model y parser.
• ✅ Un prototipo con varios proveedores puede beneficiarse de interfaces comunes para modelos, tools y documentos.
• ❌ Si solo haces una llamada simple a un modelo, el SDK directo suele ser más claro y con menos dependencia.
• ❌ Si necesitas estado durable, ciclos, interrupciones humanas y routing condicional complejo, LangGraph encaja mejor.

Ejemplo trabajado: armar un mini flujo RAG componible

Supón que necesitas responder preguntas sobre documentación interna. El flujo no es solo "llamar al modelo". Primero recuperas contexto, luego construyes un prompt y finalmente parseas la respuesta.

Una versión conceptual del flujo se puede modelar así:

type DocumentChunk = {
  id: string;
  text: string;
};

type Retriever = {
  retrieve(query: string): Promise<DocumentChunk[]>;
};

type ChatModel = {
  invoke(messages: { role: "system" | "user"; content: string }[]): Promise<string>;
};

Luego compones piezas pequeñas:

function buildRagPrompt(question: string, chunks: DocumentChunk[]) {
  const context = chunks.map((chunk) => `Fuente ${chunk.id}: ${chunk.text}`).join("\n\n");

  return [
    {
      role: "system" as const,
      content: "Responde solo con el contexto entregado. Si falta evidencia, dilo.",
    },
    {
      role: "user" as const,
      content: `Contexto:\n${context}\n\nPregunta: ${question}`,
    },
  ];
}

async function answerWithContext(question: string, retriever: Retriever, model: ChatModel) {
  const chunks = await retriever.retrieve(question);
  const messages = buildRagPrompt(question, chunks);
  return model.invoke(messages);
}

LangChain aporta abstracciones e integraciones para que esas piezas no sean contratos caseros en cada app. En vez de escribir adapters desde cero para cada proveedor, puedes usar componentes existentes para chat models, retrievers, tools, document loaders y parsers.

La decisión de usarlo debería considerar cuatro preguntas:

1. ¿El flujo conecta varias piezas LLM reutilizables?
2. ¿Necesitas cambiar de proveedor o integración sin reescribir todo?
3. ¿El equipo gana velocidad con abstracciones comunes?
4. ¿La complejidad del framework sigue siendo menor que la complejidad que evita?

Si la respuesta es sí, LangChain puede acelerar desarrollo. Si la aplicación es pequeña o altamente especializada, un SDK directo más funciones propias puede ser más simple y transparente.

Evidencia

• LangChain documentation, Home presenta LangChain como parte de la plataforma para construir agentes con código usando LangChain, LangGraph y Deep Agents.
• LangChain Reference describe LangChain como una forma de empezar a construir agentes y aplicaciones con LLMs, conectando modelos e integraciones.
• LangChain documentation, Python integrations documenta integraciones para modelos, tools, document loaders, vector stores, retrievers y más.