LangChain, LlamaIndex y LangGraph: frameworks para orqu…

Un LLM suelto (con su API key) hace demos bonitos. Llevarlo a producción requiere orquestar: prompts, memoria, herramientas, RAG, manejo de errores, logs, escalado. Hacerlo a mano es reinventar la rueda cada vez.

Para eso existen frameworks de orquestación: LangChain, LlamaIndex y LangGraph son los tres más usados en 2026. Cada uno tiene un enfoque distinto.

En este artículo te explico qué hace cada uno, cuándo conviene y cómo combinarlos.

Si quieres el contexto, lee nuestro pilar LLM para SEO: cómo usar GPT-5, Ollama y LM Studio y la guía de RAG explicado.

¿Qué es un framework de orquestación para LLMs?

Un framework de orquestación es una biblioteca de código que te da componentes preconstruidos para construir aplicaciones con LLMs sin tener que reinventar todo cada vez.

Lo que te da un framework:

Conexión a múltiples LLMs (OpenAI, Anthropic, Google, modelos locales)
Sistema de prompts con templates y versionado
Memoria de conversación (corto y largo plazo)
Integración con herramientas externas (APIs, bases de datos, búsqueda web)
RAG con embeddings y bases vectoriales
Agentes que ejecutan acciones (no solo responden)
Manejo de errores y reintentos
Logging y observabilidad

Lo que NO te da:

El LLM en sí (lo eliges tú)
La base de datos vectorial (la eliges tú)
El frontend (lo construyes tú)

Analogía: un framework de orquestación es como un framework web (Next.js, Django). Te da la estructura, tú pones la lógica de negocio y el contenido.

LangChain: el framework generalista

LangChain es el framework más usado del ecosistema LLM. Piensa en él como el “todo-en-uno”.

Fortalezas:

Conexión a 100+ LLMs y herramientas con interfaces unificadas
Componentes modulares: prompts, chains, agents, memory, tools
LangSmith para observabilidad (logs, traces, debugging)
Gran ecosistema (loaders, retrievers, document transformers)
Documentación extensiva y comunidad grande

Casos ideales:

Aplicaciones LLM complejas con múltiples pasos
Agentes que necesitan razonamiento
Chatbots con herramientas externas (búsqueda web, APIs, bases de datos)
Pipelines de procesamiento con LLM

Limitaciones:

Curva de aprendizaje empinada (muchos conceptos)
API cambia frecuentemente (versiones breaking)
A veces es overkill para tareas simples

Ejemplo mínimo:

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-5-mini")
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un experto en {tema}. Responde en español colombiano."),
    ("user", "{pregunta}")
])

chain = prompt | llm
respuesta = chain.invoke({"tema": "SEO", "pregunta": "¿Qué es AEO?"})
print(respuesta.content)

LlamaIndex: el especialista en RAG

LlamaIndex está enfocado en una sola cosa pero la hace muy bien: ingestión de datos y RAG.

Fortalezas:

El mejor para indexar documentos (PDFs, Word, Notion, web, bases de datos)
Carga + fragmenta + embebe + almacena en vector DB, todo automático
Query engines potentes con re-ranking, hybrid search, filtering
Integración nativa con 20+ vector DBs
Soporta agentes simples sobre datos indexados

Casos ideales:

RAG sobre documentos (manuales, contratos, políticas)
Buscadores internos inteligentes (como el caso del marketplace de lujo)
Chatbots que responden con base documental
Análisis de grandes corpus de documentos

Limitaciones:

Menos flexible para flujos no-RAG
Comunidad más pequeña que LangChain
Menos ejemplos de producción a gran escala

Ejemplo mínimo:

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader("documentos/").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
respuesta = query_engine.query("¿Cuál es la política de devoluciones?")
print(respuesta.response)

LangGraph: el framework para agentes complejos

LangGraph (parte de LangChain) está especializado en agentes con estado y ciclos. Mientras LangChain maneja flujos lineales, LangGraph maneja flujos cíclicos con memoria persistente.

Fortalezas:

Grafos de estado para agentes complejos
Memoria persistente entre sesiones
Human-in-the-loop (intervención humana en el flujo)
Cycles y branching nativo
Ideal para agentes multi-paso

Casos ideales:

Agentes que ejecutan tareas complejas (investigar, planificar, ejecutar)
Workflows que requieren ciclos de retroalimentación
Sistemas donde el humano aprueba acciones antes de ejecutarse
Chatbots que mantienen estado a largo plazo

Limitaciones:

Más complejo que LangChain básico
Requiere entender grafos de estado
Documentación menos madura

Ejemplo conceptual:

from langgraph.graph import StateGraph

# El agente pasa por varios nodos:
# 1. Entender pregunta
# 2. Buscar info (RAG)
# 3. Decidir si necesita más info
# 4. Si sí, vuelve a buscar; si no, responde
# 5. Escalar a humano si confianza < 80%

workflow = StateGraph(State)
workflow.add_node("entender", entender_pregunta)
workflow.add_node("buscar", buscar_en_rag)
workflow.add_node("responder", generar_respuesta)
workflow.add_node("escalar", escalar_a_humano)

workflow.add_conditional_edges("entender", decidir_siguiente_paso)

Cuándo usar cada uno (tabla de decisión)

Caso de uso	LangChain	LlamaIndex	LangGraph
RAG sobre documentos	✅ bueno	✅ mejor	✅ bueno
Chatbot conversacional básico	✅ mejor	❌ overkill	❌ overkill
Agente que ejecuta acciones	✅ bueno	⚠️ limitado	✅ mejor
Pipeline de procesamiento	✅ mejor	❌ no	⚠️ limitado
Memoria persistente	✅ bueno	⚠️ limitado	✅ mejor
Buscador interno inteligente	✅ bueno	✅ mejor	⚠️ overkill
Agente con múltiples herramientas	✅ bueno	⚠️ limitado	✅ mejor
Caso simple (1 prompt + 1 LLM)	❌ overkill	❌ overkill	❌ overkill

Resumen rápido:

RAG sobre muchos documentos → LlamaIndex
Chatbot conversacional → LangChain
Agente complejo multi-paso → LangGraph
Pipeline de procesamiento → LangChain
Combinación → LangChain + LlamaIndex (como tools dentro de un agente LangGraph)

Cómo se combinan en la práctica

La realidad es que la mayoría de aplicaciones en producción combinan los 3.

Ejemplo: chatbot de soporte técnico

┌─────────────────┐
│ LangChain       │  ← orquestación principal (prompts, memoria, herramientas)
│                 │
│  ┌───────────┐  │
│  │ LlamaIndex│  │  ← RAG sobre manuales técnicos (10.000 páginas)
│  └───────────┘  │
│                 │
│  ┌───────────┐  │
│  │ LangGraph │  │  ← flujo del agente:
│  └───────────┘  │    - entiende pregunta
│                 │    - busca en RAG
│                 │    - decide si escalar a humano
│                 │    - responde con contexto
└─────────────────┘

Caso real (Codify Tech): construimos un agente de soporte para un SaaS contable con:

LangChain como orquestador (memoria de conversación, manejo de errores)
LlamaIndex para indexar los manuales del producto (50 PDFs, 200 páginas cada uno)
LangGraph para el flujo del agente (decide si responder, escalar o pedir más info)

Resultado: 70% de tickets resueltos automáticamente, 30% escalados a humano con contexto completo.

Los frameworks menos conocidos pero útiles

Además de los 3 grandes, hay frameworks especializados que vale la pena mencionar:

Haystack (deepset)

Enfocado en pipelines RAG para producción
Muy usado en Europa
Mejor para casos enterprise con datos estructurados

Semantic Kernel (Microsoft)

Framework LLM para .NET
Integración nativa con Azure
Bueno si tu stack es Microsoft

DSPy (Stanford)

Framework que optimiza prompts automáticamente
Trata los prompts como parámetros optimizables
Para casos donde necesitas máximo rendimiento

LlamaIndex Workflows

Versión reciente de LlamaIndex para flujos cíclicos
Combina lo mejor de LlamaIndex (RAG) con LangGraph (flujos)

Insight: no te cases con un solo framework. Los mejores proyectos combinan 2-3 según el caso.

Cuándo NO usar un framework

Hay casos donde un framework es overkill:

❌ Tarea simple: “dame un prompt, dame un LLM, dame la respuesta” → un script de 20 líneas basta
❌ Latencia crítica: los frameworks añaden ~50-200ms de overhead por abstracción
❌ Aprendizaje: antes de usar LangChain, entiende bien qué resuelven sus abstracciones

Test rápido: ¿estás haciendo algo que podrías resolver con un script de 50 líneas? Si sí, probablemente no necesitas framework.

El error más común al empezar

“Voy a usar LangChain para todo.”

Realidad: LangChain es poderoso pero opinionado. Si solo necesitas un script que llame a GPT-5 con un prompt, no necesitas LangChain.

Mejor approach:

Empieza con un script simple (5-10 líneas)
Cuando crezca, refactoriza usando componentes
Cuando sea complejo, adopta un framework
Cuando necesites agentes multi-paso, evalúa LangGraph

Regla de oro: usa el framework más simple que resuelva tu problema. LangChain no es la respuesta a todo.

Cómo elegir tu stack en 2026

Stack recomendado para 80% de proyectos:

Componente	Herramienta
LLM	GPT-5 mini (costo/calidad) o Llama 3.3 local (privacidad)
Orquestación	LangChain (para flujos generales)
RAG	LlamaIndex (para indexar docs)
Vector DB	Pinecone (producción) o Chroma (prototipos)
Embeddings	OpenAI text-embedding-3-small
Agentes complejos	LangGraph
Observabilidad	LangSmith
Deploy	FastAPI + Docker o Next.js API routes

Para empezar rápido (MVP en 1 semana):

Python + LangChain básico
LlamaIndex para RAG sobre 1 fuente de datos
GPT-5 mini como LLM
Pinecone serverless para vectores
FastAPI para el backend
Frontend: widget de chat genérico

Para producción seria:

Todo lo anterior + LangGraph para agentes
LangSmith para observabilidad
Tests automatizados de prompts
Pipeline de re-indexación automática
Monitoring de costos por consulta

Recursos para aprender

Documentación oficial:

LangChain: python.langchain.com
LlamaIndex: docs.llamaindex.ai
LangGraph: langchain-ai.github.io/langgraph/

Cursos:

DeepLearning.AI tiene cursos gratis de LangChain
La documentación oficial tiene tutoriales paso a paso

Comunidad:

Discord de LangChain (~50k miembros)
GitHub Discussions de LlamaIndex
r/LocalLLaMA para temas de modelos locales

Insight: la mejor forma de aprender es construir algo pequeño primero. Un bot de FAQs con LangChain básico. Después un RAG con LlamaIndex. Después un agente con LangGraph. Esa progresión cubre el 90% del aprendizaje necesario.

Siguiente paso

¿Quieres implementar una aplicación LLM en producción? En Codify Tech diseñamos e implementamos pipelines LLM usando LangChain, LlamaIndex y LangGraph. Hacemos una auditoría + arquitectura donde te mostramos:

Qué framework tiene sentido para tu caso
Arquitectura técnica recomendada
Estimación de costos y plazos
Plan de implementación paso a paso

Sin compromiso. Sin venta forzada.

👉 Solicita tu auditoría de arquitectura LLM o escríbenos a [email protected].

Otros artículos del cluster AI que te van a servir:

LangChain, LlamaIndex y LangGraph: frameworks para orquestar LLMs en producción

¿Qué es un framework de orquestación para LLMs?

LangChain: el framework generalista

LlamaIndex: el especialista en RAG

LangGraph: el framework para agentes complejos

Cuándo usar cada uno (tabla de decisión)

Cómo se combinan en la práctica

Ejemplo: chatbot de soporte técnico

Los frameworks menos conocidos pero útiles

Haystack (deepset)

Semantic Kernel (Microsoft)

DSPy (Stanford)

LlamaIndex Workflows

Cuándo NO usar un framework

El error más común al empezar

Cómo elegir tu stack en 2026

Recursos para aprender

Siguiente paso

Etiquetas