¿Qué es LangChain? Framework, componentes y usos en empresa

Llevas semanas leyendo sobre agentes de IA y cada tutorial de YouTube empieza igual: instalan LangChain, enchufan cuatro líneas de Python y el agente "funciona". Lo que no te cuentan es qué está pasando por debajo, por qué hay developers que lo abandonan a mitad del proyecto, ni cuándo tiene sentido usarlo y cuándo no. Eso es exactamente lo que cubre esta guía.

En GuruSup llevamos años construyendo agentes de IA para empresas sobre LangChain y su ecosistema. Hemos montado pipelines de producción, hemos tropezado con sus abstracciones en el peor momento y hemos migrado partes a LangGraph cuando el proyecto lo pedía. Lo que sigue no es la documentación oficial traducida: es lo que sabemos después de usarlo en casos reales.

¿Qué es LangChain y qué problema resuelve?

LangChain es un framework open source para construir aplicaciones y agentes sobre modelos de lenguaje grandes (LLMs). Disponible en Python y JavaScript, su idea central es simple: en lugar de que escribas tú a mano el código que conecta un LLM con una base de datos, con una API externa o con el historial de una conversación, LangChain te da componentes reutilizables que ya resuelven esa fontanería.

Lo fundó Harrison Chase en octubre de 2022, tres semanas antes del lanzamiento de ChatGPT. El timing fue perfecto: cuando el mundo de repente quiso conectar LLMs a cosas reales, LangChain ya tenía una respuesta. En junio de 2023 era el proyecto de código abierto de más rápido crecimiento en GitHub.

El problema que resuelve tiene dos caras. La primera es la integración: un LLM por sí solo es un modelo estadístico. Para que responda sobre tus documentos internos, llame a tu API de reservas o recuerde lo que el cliente dijo hace tres mensajes, necesitas código de pegamento. Mucho. LangChain estandardiza ese código en componentes nombrados que cualquier developer puede reutilizar sin reinventar la rueda. La segunda cara es la experimentación: como los componentes son intercambiables, puedes cambiar de GPT-4 a Claude o de un vector store a otro con cambios mínimos en el código. Eso vale mucho cuando el ecosistema de LLMs cambia cada semana.

Lo que LangChain no resuelve —y conviene dejarlo claro desde el principio— es la lógica de negocio ni la arquitectura de tu agente. Que tengas acceso a un framework no significa que el diseño de tu sistema sea correcto. Esa parte sigue siendo tuya.

¿Cómo funciona LangChain por dentro?

El núcleo de LangChain es una biblioteca de abstracciones: representaciones de procesos complejos como objetos reutilizables. Cada abstracción encapsula una operación —llamar a un modelo, recuperar documentos, gestionar memoria— y expone una interfaz común. Así puedes componer piezas sin saber cómo están implementadas por dentro.

Dicho de otro modo: LangChain convierte "llama al modelo X con el prompt Y, busca en la base de datos Z y devuelve el resultado en formato JSON" en algo que se puede escribir en tres líneas. La magia y el problema están en el mismo sitio: cuanta más magia, menos control.

¿Qué son los chains en LangChain?

Los chains son la columna vertebral del framework. Una chain es una secuencia de operaciones que se ejecutan en orden: llamas a chain.invoke() y el sistema pasa la entrada por cada paso hasta producir una salida. El chain más básico —`LLMChain`— combina un modelo con un prompt template y devuelve la respuesta del LLM.

Pero los chains pueden ser tan complejos como necesites. Puedes tener un chain que primero busca documentos relevantes en un vector store, después los inyecta en un prompt, después llama al modelo y finalmente parsea la salida en un objeto Python estructurado. Todo en secuencia, todo sin que tengas que gestionar el estado entre pasos.

La versión moderna de esto es LCEL —LangChain Expression Language—, la forma preferida de construir chains desde la versión 0.1. En lugar de instanciar clases como `LLMChain`, encadenas componentes con el operador `|` de Python:

chain = prompt | modelo | parser
resultado = chain.invoke({"pregunta": "¿Qué es el chunking en RAG?"})

LCEL tiene ventajas reales sobre la API clásica: soporte nativo de streaming, ejecución paralela de ramas, tracing automático con LangSmith y una sintaxis más legible. Si empiezas hoy con LangChain, empieza por LCEL. La API antigua de chains (`LLMChain`, `SequentialChain`, `RouterChain`) sigue funcionando pero está en modo mantenimiento.

¿Qué son los prompt templates?

Un prompt template es una plantilla reutilizable para construir el prompt que le envías al modelo. En lugar de construir el string manualmente cada vez —concatenando variables, instrucciones de sistema y ejemplos—, defines la estructura una vez y la rellenas con variables en tiempo de ejecución.

La clase `ChatPromptTemplate` permite separar el system prompt (instrucciones al modelo sobre su rol y comportamiento) del human message (lo que viene del usuario). Este control es más importante de lo que parece: la diferencia entre un agente que responde bien y uno que alucina a menudo vive en cómo está construido el sistema de instrucciones.

Los templates también admiten few-shot prompting: inyectar ejemplos de preguntas y respuestas correctas para guiar el comportamiento del modelo. Para una empresa que necesita que el agente responda siempre con un tono concreto o en un formato específico, los templates son la herramienta.

¿Qué es la memory en LangChain?

Los LLMs son stateless por naturaleza: cada llamada es independiente y el modelo no recuerda nada de las anteriores. Si quieres que tu agente mantenga el contexto de una conversación —saber a qué pregunta anterior se refiere el usuario cuando dice "eso que dijiste antes"—, tienes que gestionar ese estado tú mismo.

LangChain incluye módulos de memory que automatizan esa gestión. Hay varios niveles de complejidad:

• ConversationBufferMemory: guarda la conversación entera y la inyecta en cada prompt. Funciona bien para conversaciones cortas; se vuelve caro y problemático cuando el historial crece.
• ConversationBufferWindowMemory: solo guarda los últimos N intercambios. Controla el coste de tokens a cambio de perder contexto antiguo.
• ConversationSummaryMemory: usa el propio LLM para resumir la conversación a medida que crece y guarda el resumen en lugar del historial completo. Más sofisticado, pero añade latencia y coste.

En producción, la memoria de LangChain tiene limitaciones reales. Si el volumen de conversaciones es alto o necesitas persistir el estado entre sesiones de distintos usuarios, acabarás gestionando la memoria fuera del framework —en una base de datos— y usando LangChain solo como interfaz de llamada al modelo. Eso no es un defecto, es la realidad de escalar.

¿Qué son los tools en LangChain?

Un LLM, por sí solo, no sabe qué temperatura hace en Madrid hoy ni puede consultar tu base de datos de clientes. Los tools son funciones que le das al modelo para que pueda interactuar con el mundo real.

LangChain incluye tools prediseñadas: búsqueda en Google, consulta a Wikipedia, Wolfram Alpha para matemáticas, acceso a APIs REST genéricas. Pero lo más útil para una empresa es la capacidad de crear tools propias: una función que busca en tu CRM, otra que consulta el stock de un producto, otra que envía un correo. Le das esas herramientas al agente y él decide cuándo usarlas en función de la pregunta.

El mecanismo por debajo es el tool calling —también llamado function calling— que soportan los modelos modernos de OpenAI, Anthropic, Google y otros. El modelo no ejecuta el código directamente: devuelve un objeto estructurado que dice "quiero llamar a esta función con estos argumentos", el framework ejecuta la función y devuelve el resultado al modelo para que continúe. LangChain gestiona ese ciclo de llamada-respuesta por ti. Para proyectos donde varios agentes necesitan compartir las mismas herramientas de forma estandarizada, el Model Context Protocol (MCP) define cómo exponer esas herramientas sin duplicar integraciones en cada agente.

¿Qué son los agents en LangChain?

Un agent es la pieza que hace que todo lo anterior trabaje junto de forma autónoma. Donde un chain tiene una secuencia fija de pasos, un agent decide en tiempo de ejecución qué pasos dar: selecciona qué tool usar, observa el resultado, decide si necesita otra tool o si ya tiene suficiente información para responder.

El patrón más común es ReAct (Reasoning + Acting): el modelo piensa en voz alta (reasoning), decide una acción (acting), observa el resultado y repite hasta que puede responder. LangChain implementa este patrón con `create_react_agent()` y la función `AgentExecutor`.

Un agent de LangChain bien configurado puede hacer cosas como: recibir la pregunta de un cliente, buscar en la base de conocimiento de la empresa, consultar el estado de un pedido vía API, y responder con la información combinada de ambas fuentes, todo sin que ningún humano intervenga. Eso es lo que hace que los agentes sean útiles en atención al cliente con IA.

La limitación es el control: en un agent, el número de pasos no está garantizado de antemano. Si el modelo se equivoca en un paso intermedio, puede entrar en bucles o acumular errores que se propagan. Por eso en producción se combinan agentes con human-in-the-loop —puntos donde un humano revisa antes de que el sistema continúe— especialmente para acciones irreversibles.

¿Qué es LCEL?

LCEL (LangChain Expression Language) merece su propia explicación porque es la apuesta central del framework desde 2023 y la mayoría de los tutoriales en español todavía lo pasan por alto.

LCEL es una interfaz declarativa para componer componentes usando el operador `|`. Cualquier objeto que implemente la interfaz `Runnable` —modelos, prompts, parsers, retrievers, tools— puede conectarse en un pipeline. El resultado es un nuevo `Runnable` que se puede invocar, hacer streaming, paralelizar o trazar igual que cualquiera de sus partes.

Lo que LCEL aporta en producción:

• Streaming nativo: el primer token llega al usuario antes de que termine la generación completa, sin código extra.
• Ejecución paralela: `RunnableParallel` ejecuta varias ramas a la vez y combina los resultados.
• Tracing automático: cada invocación se registra en LangSmith sin instrumentación adicional.
• Composibilidad: puedes encapsular un chain LCEL como un componente y meterlo dentro de otro chain mayor.

La analogía que más ayuda: si los chains clásicos son como macros de Excel —funcionan pero son difíciles de depurar y mantener—, LCEL se parece más a pipes de Unix, donde cada componente hace una cosa y la composición es explícita.

¿Qué es LangSmith y por qué importa en producción?

LangSmith es la plataforma de observabilidad del ecosistema LangChain. Lanzada en otoño de 2023, resuelve un problema concreto: cuando tu agente falla en producción, ¿dónde ha fallado? ¿En el retrieval? ¿En el prompt? ¿En la selección de tool? Sin tracing, debuggear un agente es rebuscar en logs que no están pensados para eso.

LangSmith registra cada paso de cada invocación: el prompt que entró, la respuesta que salió, qué tools se llamaron, cuántos tokens costó y cuánto tardó. Eso te permite detectar patrones de fallo, comparar distintas versiones de un prompt con datos reales y evaluar el rendimiento con LLM-as-a-judge —otro modelo que puntúa si la respuesta del agente fue correcta.

LangSmith no requiere usar LangChain: tiene SDKs para Python, TypeScript, Go y Java, y se puede instrumentar cualquier stack con OpenTelemetry. Pero la integración con LangChain/LangGraph es nativa y no requiere configuración extra.

Para proyectos en producción, LangSmith deja de ser opcional. Sin observabilidad no puedes mejorar un agente de forma sistemática. Puedes intuir que algo va mal; no puedes demostrar que tu cambio lo arregló.

¿LangChain, LangGraph o LlamaIndex?

Esta es la pregunta que más aparece cuando las empresas empiezan a evaluar qué framework usar. La respuesta depende de lo que estés construyendo.

• **Para qué** — LangChain: Pipelines y agentes con LLMs · LangGraph: Agentes complejos con control fino · LlamaIndex: RAG y búsqueda sobre datos
• **Modelo de ejecución** — LangChain: Secuencial / chains · LangGraph: Grafo de estados (stateful) · LlamaIndex: Pipelines de ingesta y query
• **Flexibilidad** — LangChain: Alta pero abstracta · LangGraph: Muy alta, control total · LlamaIndex: Alta en el dominio RAG
• **Curva de aprendizaje** — LangChain: Media · LangGraph: Alta · LlamaIndex: Media
• **Cuándo elegirlo** — LangChain: Prototipado rápido, pipelines estándar · LangGraph: Agentes con bucles, human-in-the-loop, multiagente · LlamaIndex: RAG avanzado, bases de conocimiento complejas

LangGraph —creado por el mismo equipo de LangChain— reemplaza a LangChain cuando el agente necesita control de flujo explícito: bucles condicionales, estados persistentes entre pasos, colaboración entre múltiples agentes, puntos de aprobación humana. En lugar de chains, usa un grafo de nodos y aristas donde tú defines exactamente qué puede pasar después de cada paso. Es más verboso y más complejo, pero en producción eso se convierte en control y fiabilidad. Si quieres profundizar, tenemos una guía completa sobre qué es LangGraph.

LlamaIndex —antes LlamaIndex, antes GPT Index— está optimizado para el problema de conectar LLMs con datos: ingesta, chunking, indexado, retrieval y query. Tiene conectores nativos para centenares de formatos y fuentes, y sus abstracciones de indexado son más ricas que las de LangChain. Si tu proyecto es fundamentalmente un sistema RAG sobre grandes volúmenes de documentos, LlamaIndex puede ser mejor punto de partida que LangChain. Detallamos las diferencias en la guía de qué es LlamaIndex.

En proyectos reales de empresa, estos tres frameworks coexisten: LangChain para la capa de integración con LLMs y prompts, LangGraph para la lógica de agente, LlamaIndex para el pipeline de RAG, LangSmith para la observabilidad de todo el conjunto.

Las críticas reales a LangChain: cuándo su abstracción estorba

LangChain tiene críticas fundadas y conviene conocerlas antes de comprometerse con él. El argumento más común entre developers experimentados es que la abstracción oculta demasiado en el momento equivocado.

Cuando algo falla en un chain complejo —el modelo devuelve un formato inesperado, un parser lanza una excepción, la tool no devuelve lo que el agente esperaba—, el stack trace que obtienes mezcla código tuyo con internals del framework. Depurar se convierte en arqueología. Para un developer que sabe exactamente lo que quiere, escribir las llamadas directamente a la API del modelo puede ser más rápido y más controlable que entender cómo LangChain gestiona ese caso.

La segunda crítica es la inestabilidad de la API. LangChain ha tenido cambios de breaking en sus versiones principales y ha reorganizado su estructura de paquetes varias veces. Código que funcionaba en 0.0.x puede necesitar reescritura significativa en 0.3.x. Para un equipo pequeño que no tiene tiempo de seguir los changelogs, eso es un coste real.

La tercera crítica, más profunda, es que las abstracciones de LangChain tienen fugas: cuando el comportamiento real del LLM no encaja con lo que el framework espera —y eso pasa más a menudo de lo que los tutoriales muestran—, acabas peleando contra el framework en lugar de con el problema. En esos casos, la "simplificación" se convierte en complejidad accidental.

Cuándo tiene sentido alejarse de LangChain:

• Si controlas todo el stack y tienes developers expertos: llamadas directas a la API + código propio puede ser más limpio.
• Si tu agente necesita lógica de control muy específica: empieza directamente con LangGraph.
• Si el problema es puramente RAG: evalúa LlamaIndex antes de comprometerte.
• Si el tiempo de debug te está matando: plantéate reducir la capa de abstracción.

Nada de esto significa que LangChain sea malo. Significa que es una herramienta con un contexto de uso óptimo, como cualquier otra. Para prototipado rápido, para integrar rápidamente un LLM en un workflow existente, para equipos que empiezan con agentes, LangChain sigue siendo la opción con mejor ratio velocidad/control. El problema es cuando se usa para todo por defecto, sin evaluar si es la herramienta correcta.

¿Para qué usan LangChain las empresas?

El patrón de uso más común en empresa no es el agente autónomo de ciencia ficción: es un sistema que responde preguntas sobre documentación interna de forma fiable y rápida. Eso se construye con LangChain (o LlamaIndex) como capa de RAG, LangGraph si hay lógica condicional, y LangSmith para verificar que funciona en producción.

Los casos que más se repiten:

Atención al cliente automatizada. El agente lee la base de conocimiento de la empresa —políticas, FAQs, fichas de producto, documentación de servicio— y responde sin escalar al equipo humano. Cada respuesta cita de dónde viene la información. Si no sabe, escala. LangChain gestiona el retrieval y la llamada al modelo; la lógica de escalado va en LangGraph. El resultado es un agente de atención al cliente que resuelve entre el 60% y el 80% de las consultas sin intervención humana, según el tipo de negocio.

Búsqueda interna sobre documentación. Empresas con grandes volúmenes de contratos, normativa interna, manuales técnicos o expedientes necesitan que su equipo pueda hacer preguntas en lenguaje natural y recibir respuestas precisas, no una lista de documentos donde "puede estar". LangChain conecta los documentos indexados con el modelo y devuelve la respuesta con la fuente. Eso es exactamente lo que resuelve un software de base de conocimiento con IA.

Automatización de procesos con datos externos. Un agente que consulta el estado de un pedido en el ERP, lo cruza con la información del cliente en el CRM y redacta un correo de respuesta. O uno que lee una factura en PDF, extrae los campos relevantes y los vuelca en el sistema contable. LangChain gestiona la orquestación de esas llamadas y el formato de las respuestas.

Asistentes internos para equipos. El departamento de ventas pregunta sobre el pipeline, el de soporte consulta el historial de incidencias, el de RRHH busca en la normativa laboral. Un agente sobre la documentación interna de la empresa, bien construido, reduce el tiempo que los equipos pasan buscando información de forma significativa.

En todos estos casos, LangChain no es el producto: es la infraestructura que hace posible el producto. Lo que decide si funciona bien o mal no es el framework en sí, sino cómo se construye el sistema de retrieval, cómo se diseñan los prompts y cómo se evalúa en producción.

Preguntas frecuentes sobre LangChain

¿LangChain es gratuito? El framework open source es gratuito y está bajo licencia MIT. LangSmith tiene un tier gratuito y planes de pago para equipos y empresas con mayores volúmenes de tracing y evaluaciones.

¿Qué lenguaje de programación necesito para usar LangChain? Python es la opción principal y la más documentada. Existe LangChain.js para JavaScript/TypeScript, aunque el ecosistema en Python es considerablemente más amplio.

¿LangChain funciona con modelos open source o solo con OpenAI? Con cualquier LLM que tenga API. GPT-4, Claude, Gemini, LLaMA, DeepSeek, Mistral, Granite... LangChain es agnóstico al modelo. Esa es una de sus ventajas reales: puedes empezar con GPT-4o y cambiar a un modelo más económico sin reescribir la lógica de la aplicación.

¿ChatGPT usa LangChain? No. ChatGPT es una aplicación de OpenAI que usa sus propios modelos GPT directamente, sin LangChain. LangChain es un framework que los developers usan para construir sus propias aplicaciones sobre modelos como GPT-4.

¿Cuándo debería usar LangGraph en vez de LangChain? Cuando tu agente necesita bucles, estados persistentes entre pasos, múltiples agentes colaborando o puntos de aprobación humana. Para pipelines lineales y agentes sencillos, LangChain (con LCEL) es suficiente. Puedes leer la diferencia en detalle en la guía de qué es LangGraph.

¿LangChain sirve para construir RAG? Sí, tiene todos los componentes: document loaders, text splitters, vector store integrations, retrievers. Para RAG avanzado sobre grandes volúmenes de documentos, LlamaIndex suele ofrecer abstracciones más ricas. Comparamos ambas opciones en la guía de qué es LlamaIndex.

Empieza con lo que resuelve tu problema, no con lo que está de moda

LangChain tiene el nombre más conocido del ecosistema de agentes, pero eso no lo convierte automáticamente en la solución a tu problema. Si necesitas conectar un LLM a tu documentación y responder preguntas de forma fiable, es probablemente la forma más rápida de llegar a un prototipo funcional. Si necesitas un agente con flujos complejos y control fino, empieza por LangGraph desde el principio. Si el problema central es la calidad del retrieval sobre un corpus grande, mira LlamaIndex antes de comprometerte.

Lo que no cambia en ningún caso: sin observabilidad no puedes mejorar un agente en producción. LangSmith, o cualquier alternativa de tracing, no es opcional en cuanto el sistema empiece a responder a usuarios reales.

Si estás evaluando construir este tipo de sistemas para tu empresa —atención al cliente, búsqueda interna, automatización de procesos— y quieres saber qué arquitectura tiene sentido para tu caso concreto, en GuruSup te contamos lo que hemos aprendido montando agentes de IA para empresas españolas.