LangChain: el framework para orquestar aplicaciones con LLM

Actualizado: 2026-05-03

LangChain^[1] es probablemente el framework más adoptado para construir aplicaciones con LLMs. Su propuesta: en lugar de hacer llamadas directas a la API de OpenAI y montar tu propio plumbing, usa un conjunto coherente de abstracciones para componer pipelines complejos. Cubrimos cuándo aporta valor real, cuándo añade complejidad innecesaria, y los componentes que conviene conocer.

Puntos clave

• LangChain es un superconjunto: LLM wrappers, prompt templates, chains, retrievers, agentes, memoria y document loaders en una interfaz coherente.
• Brilla en prototipos, orquestación multi-LLM y equipos junior — donde la uniformidad y la velocidad de exploración importan más que la optimización.
• Sus críticas son justas: API inestable entre versiones menores, abstracciones que ocultan lo que pasa debajo, y penalización de rendimiento en producción a escala.
• Para producción de caso único bien definido, código directo suele ganar en mantenibilidad.
• LlamaIndex, Instructor y llamadas directas son alternativas razonables para casos específicos.

Lo que incluye

LangChain es un superconjunto de funcionalidades. Las áreas principales:

• LLM wrappers: interfaz uniforme sobre OpenAI, Anthropic, modelos locales (Llama 2, Mistral), Hugging Face, etc.
• Prompts y prompt templates: gestión de plantillas reusables con variables, ejemplos few-shot y composición.
• Chains: secuencias de pasos. La más simple ata un prompt template a un LLM. Las complejas orquestan retrieval, validación y múltiples llamadas.
• Retrievers: abstracción sobre BD vectoriales (Chroma, Pinecone, Qdrant, pgvector) con interfaz consistente.
• Agents: loops de “decisión + acción” basados en function calling o el patrón ReAct.
• Memory: gestión de historial de conversación con distintas estrategias (buffer, summary, window).
• Document loaders: lectores de PDF, web, Notion, Slack, base de datos, Google Drive y docenas más.
• Output parsers: validación y conversión de salida del LLM a tipos estructurados.

Esta amplitud es a la vez su fortaleza y su crítica más frecuente.

Un ejemplo mínimo de RAG

Lo que era 100 líneas de código directo se reduce a esto:

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI

docs = TextLoader("manual.txt").load()
splits = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50).split_documents(docs)
db = Chroma.from_documents(splits, OpenAIEmbeddings())
qa = RetrievalQA.from_chain_type(llm=ChatOpenAI(), retriever=db.as_retriever())
print(qa.run("¿Qué dice el manual sobre la garantía?"))

Cargar documento, partirlo en chunks, embebido, indexar, configurar retriever, conectar a LLM, exponer función question-answering — todo en ocho líneas operativas. La velocidad de prototipado es real.

Patrones donde aporta de verdad

Tres casos donde LangChain es la elección correcta:

• Prototipos y exploración. Cuando estás validando si una idea funciona, llegar rápido a una demo importa más que tener código óptimo.
• Orquestación con múltiples LLMs y tools. Si tu sistema combina OpenAI, Anthropic, búsqueda web, BD interna y memoria conversacional, LangChain ya tiene cada pieza con interfaz consistente.
• Equipos junior con LLMs. Las abstracciones reducen el espacio de errores comunes (formato de prompts, gestión de tokens, parseo de salida).

Críticas frecuentes (justificadas)

LangChain ha recibido críticas serias que conviene conocer:

• Demasiada abstracción. Para casos simples, esconde lo que realmente está pasando bajo capas. El debug se vuelve difícil cuando algo falla — necesitas entender la abstracción y lo que hay debajo.
• API inestable. Cambios incompatibles entre versiones menores. Código de hace tres meses puede no compilar hoy.
• Sobre-ingeniería. Algunas abstracciones parecen diseñadas para impresionar más que para resolver problemas reales (chains de chains de chains).
• Performance penalty. Capa de Python sobre llamadas HTTP añade latencia. Para producción a escala, codear más cerca del metal puede valer la pena.
• Documentación volátil. La librería evoluciona tan rápido que los tutoriales y blogs públicos están desfasados constantemente.

Ante esto, ha emergido una corriente de “LangChain too much for me” — equipos que prefieren código directo. Para producción seria, esa crítica es legítima.

Alternativas y filosofías diferentes

Si LangChain parece pesado, hay opciones:

• LlamaIndex^[2]: foco específico en RAG y document indexing, menos pretensión de “framework universal”. Más sencillo si tu caso es retrieval.
• Instructor^[3]: para extracción estructurada con Pydantic. Mucho más simple si solo necesitas eso.
• Llamadas directas + utilidades pequeñas. Para muchos productos en producción es la opción más mantenible: openai-python + tu lógica + tu BD vectorial favorita.
• Semantic Kernel^[4] de Microsoft. Más alineado con .NET pero con Python disponible.

La elección correcta depende de cuánto del framework realmente necesitas y cuánta magia toleras debajo. Los mismos criterios que aplicarías al comparar embeddings de texto — empezar simple, medir, migrar cuando tenga sentido.

Cuándo usar cada opción

• Prototipos, hackathons, exploración: LangChain. Ahorra horas de plumbing.
• Producción de un único caso de uso bien definido: muy probablemente código directo. Mantenibilidad gana a velocidad inicial.
• Producto con múltiples flujos LLM, integraciones múltiples, equipo grande: LangChain o equivalente. La uniformidad importa.
• Si LangChain bloquea por performance u opacidad: migra a código directo o LlamaIndex en módulos críticos. La migración no es traumática si tu lógica de negocio está bien separada.

Conclusión

LangChain es un framework valioso que ha acelerado la maduración del ecosistema LLM. Sus críticas son justas pero su utilidad también. La clave está en aplicarlo donde sus abstracciones aportan más que ocultan. Para productos serios, conocerlo es útil aunque al final decidas no usarlo — entender sus patrones te dirá qué necesita estar en tu código.

1. LangChain
2. LlamaIndex
3. Instructor
4. Semantic Kernel