LangChain: el framework para orquestar aplicaciones con LLM

javi
Cadenas de eslabones metálicos representando integración de componentes

LangChain es probablemente el framework más adoptado para construir aplicaciones con LLMs en 2023. 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.

Lo que incluye

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

  • LLM wrappers: una 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, y exponer una función question-answering. Todo en 8 líneas operativas. La velocidad de prototipado es real.

Patrones donde aporta de verdad

Tres casos donde LangChain me parece 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 en 2023 que conviene conocer:

  • Demasiada abstracción. Para casos simples, esconde lo que realmente está pasando bajo capas. Debug se vuelve difícil cuando algo falla — necesitas entender la abstracción + lo que hay debajo.
  • API inestable. Cambios incompatibles entre versiones menores. Código de hace 3 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 te parece pesado, hay opciones:

  • LlamaIndex: foco específico en RAG y document indexing, menos pretensión de “framework universal”. Más sencillo si tu caso es retrieval.
  • Instructor: 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 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.

Mi recomendación

Para 2023 propongo el siguiente criterio:

  • Prototipos, hackathons, exploración: LangChain. Te 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 te bloquea por performance o opacidad: no dudes en migrar 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 en 2023. 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.

Síguenos en jacar.es para más sobre frameworks de IA, RAG y construcción de productos LLM.

Entradas relacionadas