LangChain: Framework para aplicaciones con LLM

Qué cubre este artículo sobre LangChain

• Qué es LangChain y para qué lo puedes usar.
• Los conceptos centrales: Chain, Prompt Template, Retriever, Agent y más.
• Por qué un framework suele ser preferible a usar la API directa.
• Instalación y un primer ejemplo funcional con Ollama.
• Cómo funcionan RAG y agentes con LangChain.
• Errores típicos y trampas al empezar.

Introducción: LangChain explicado claramente

LangChain es un framework open source para Python y JavaScript que te permite construir aplicaciones basadas en Large Language Models. Proporciona bloques prefabricados que puedes combinar en una Chain. Una Chain es una secuencia ejecutable que comprende un prompt, una llamada al modelo y el procesamiento de la respuesta.

Muchas tareas recurrentes ya están resueltas: cargar PDFs, buscar en un Vector Store, llamar a un motor de búsqueda o convertir la respuesta del modelo en una estructura limpia. De este modo escribes menos código de integración y puedes enfocarte en tu lógica específica.

LangGraph, que se construye sobre LangChain, se trata en un artículo separado en LangGraph para evitar repetir contenido.

¿Por qué necesito LangChain?

Imagina que quieres conectar un LLM local con un PDF y una búsqueda web. Sin un framework, combinarías varias librerías con APIs diferentes. LangChain te ahorra mucho de ese código de integración. Cargas un PDF con un Document Loader, lo divides en chunks, los almacenas en un Vector Store e integras los resultados en una Chain. Para la búsqueda web seleccionas una herramienta apropiada del conjunto disponible.

Además, LangChain es portátil. Muchos componentes funcionan tanto con APIs en la nube como con modelos locales. Si comienzas con Ollama y luego quieres probar otro modelo, frecuentemente solo necesitas cambiar una línea.

LangChain en breve

En esencia, LangChain proporciona los siguientes componentes:

• Models: Abstracciones para Chat Models, LLMs y Embeddings.
• Prompt Templates: Plantillas que transforman entradas a un formato consistente.
• Document Loaders: Módulos que convierten formatos de archivo en texto.
• Text Splitters: Herramientas para dividir textos largos en chunks.
• Vector Stores: Bases de datos para búsqueda semántica.
• Retrievers: Componentes que obtienen documentos relevantes de un Vector Store.
• Output Parser: Herramientas para convertir respuestas del modelo a estructuras fijas.
• Chains: Pasos vinculados que se ejecutan como una canalización.
• Agents: Componentes que deciden automáticamente qué herramientas utilizar.
• Memory: Formas de mantener contexto a través de múltiples mensajes.

El estilo más reciente se llama LCEL, LangChain Expression Language. Con él encadenas componentes usando el operador pipe |, casi como en pipes de Unix.

Para quién está pensado LangChain

LangChain está dirigido a desarrolladores que quieren integrar modelos de lenguaje en aplicaciones. Debes estar familiarizado con Python o JavaScript y no tener miedo de pip o npm. Tener experiencia previa en RAG o agentes facilita el aprendizaje, pero no es obligatorio. Si prefieres trabajar de forma visual, LangFlow es más adecuado. Para grafos de estado complejos, LangGraph vale la pena.

Términos importantes alrededor de LangChain

Término	Significado
Chain	Una secuencia coherente de pasos, generalmente prompt, modelo y parser.
Prompt Template	Una plantilla que transforma entradas a un formato consistente para el modelo.
Retriever	Un componente que devuelve documentos relevantes de un Vector Store.
Document Loader	Un módulo que convierte PDFs, archivos de texto o páginas web en documentos.
Output Parser	Ayuda a convertir la salida del modelo a una estructura deseada como listas u objetos.
Agent	Un mecanismo que decide automáticamente qué herramientas y pasos son necesarios.
Tool	Una función que un agente o chain puede llamar, como una búsqueda web.
Memory	Almacenamiento para mensajes anteriores o resultados intermedios.
Callback	Un hook que te permite registrar eventos durante la ejecución.
LCEL	LangChain Expression Language, la notación pipe para encadenar componentes.

LangChain versus API directa

Para un simple juego de pregunta-respuesta, la API directa a menudo es más rápida. Pero tan pronto como combinas varios pasos, te encuentras con estos puntos:

• Repeticiones: Formatos de prompt, lógica de reintentos y manejo de errores los debes implementar tú mismo.
• Cambios de formato: Cada proveedor de modelo tiene un formato de mensaje diferente. LangChain normaliza estas diferencias.
• Integración de datos: Conectar PDFs, páginas web y almacenes de vectores genera mucho trabajo tedioso.
• Mantenibilidad: Una Chain formada por componentes prefabricados es más fácil de leer y adaptar.

LangChain no es obligatorio, pero es una herramienta útil cuando tu aplicación crece más allá de simples prompts.

Instalación

Para la mayoría de ejemplos, estos comandos son suficientes:

pip install langchain langchain-community langchain-ollama

Para PDFs añades:

pip install pypdf

Para Chroma como almacén de vectores:

pip install chromadb

Para JavaScript:

npm install langchain

Usa Python 3.9 o más reciente. Ollama debe estar instalado y tener al menos un modelo disponible. Más detalles en el artículo Ollama.

Primer ejemplo

Una forma simple de empezar es con una Chain formada por Prompt Template, modelo y Output Parser:

from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

model = ChatOllama(model="llama3.2")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Du bist ein freundlicher Assistent, der kurz und klar antwortet."),
    ("human", "Erkläre mir {thema} in drei Sätzen."),
])

parser = StrOutputParser()

chain = prompt | model | parser

antwort = chain.invoke({"thema": "LangChain"})
print(antwort)

El Prompt Template recibe la variable thema, el modelo responde y el parser devuelve el texto limpio.

RAG con LangChain

RAG, o Retrieval-Augmented Generation, es un caso de uso frecuente. El flujo es:

1. Carga documentos con un Document Loader.
2. Divídelos en chunks pequeños.
3. Calcula embeddings y guárdalos en un Vector Store.
4. Al consultar, recupera los chunks más relevantes.
5. Combina los chunks encontrados y la pregunta del usuario en una Chain.

Un ejemplo mínimo con Ollama, un PDF y Chroma:

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_ollama import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_ollama import ChatOllama
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain
from langchain_core.prompts import ChatPromptTemplate

loader = PyPDFLoader("dokument.pdf")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings)

retriever = vectorstore.as_retriever()

model = ChatOllama(model="llama3.2")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Beantworte die Frage ausschließlich anhand des bereitgestellten Kontexts."),
    ("human", "Kontext: {context}\n\nFrage: {input}"),
])

combine_chain = create_stuff_documents_chain(model, prompt)
rag_chain = create_retrieval_chain(retriever, combine_chain)

antwort = rag_chain.invoke({"input": "Was steht im Dokument zum Thema Kosten?"})
print(antwort["answer"])

Puedes transferir este patrón a diferentes tipos de archivo, modelos de embeddings y almacenes de vectores. Encontrarás más contexto en Lokales RAG y RAG Grundlagen.

Agentes con LangChain

Los agentes deciden por sí solos qué herramientas invocar. Un ejemplo simple de ReAct:

from langchain_ollama import ChatOllama
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

model = ChatOllama(model="llama3.2")
tools = [DuckDuckGoSearchRun()]

prompt = hub.pull("hwchase17/react")

agent = create_react_agent(model, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

antwort = agent_executor.invoke({"input": "Wie ist das Wetter heute in Berlin?"})
print(antwort["output"])

No todos los modelos dominan el Tool-Calling de manera fiable. Qwen, Mistral o Command R suelen funcionar mejor que las variantes muy pequeñas. Encontrarás más detalles en Tool-Calling y Qué es un Agente de IA.

LangChain y Ollama

LangChain se comunica con Ollama a través de las clases ChatOllama, Ollama y OllamaEmbeddings:

• ChatOllama: Para prompts de chat con roles como system, human e ai.
• Ollama: Para modelos de completación de texto.
• OllamaEmbeddings: Para embeddings locales en proyectos RAG.

Ejemplo con ChatOllama:

from langchain_ollama import ChatOllama

model = ChatOllama(
    model="llama3.2",
    temperature=0.7,
    base_url="http://localhost:11434"
)

antwort = model.invoke("Erkläre LangChain in einem Satz.")
print(antwort.content)

Asegúrate de que Ollama esté activo y el modelo elegido ya disponible. Más detalles sobre la API en Ollama API.

LangChain vs. LangGraph vs. LangFlow

Aspecto	LangChain	LangGraph	LangFlow
Nivel	Framework para chains e integraciones.	Motor de grafos basado en LangChain.	Editor visual para flujos LangChain.
Código	Python o JavaScript.	Python o JavaScript.	Sin código hasta bajo código.
Fortalezas	Prototipos rápidos, RAG, Tool-Calling.	Workflows basados en estado, bucles, Multi-Agent.	Pipelines visuales y organizadas.
Flujo de control	Lineal o condicional a través de chains.	Como grafo con nodos y aristas.	A través de bloques conectados.
Curva de aprendizaje	Moderada.	Un poco más alta.	Baja si prefieres evitar código.
Ideal para	Primeros proyectos y pipelines establecidos.	Árboles de decisión complejos.	Experimentar y demostrar.

LangGraph lo tratamos por separado porque introduce conceptos propios como State, Nodes y Conditional Edges. LangFlow es útil para entender flujos sin profundizar en código. LangChain sigue siendo el terreno común para ambos.

Obstáculos comunes con LangChain

• Usar la clase de modelo incorrecta: Ollama y ChatOllama no son intercambiables. Para prompts de chat necesitas ChatOllama.
• Ignorar el límite de tokens: Las chains largas con mucho contexto pueden rebasar la ventana de contexto.
• Elegir el parser de salida equivocado: JsonOutputParser falla si el modelo no entrega JSON válido. StrOutputParser es más seguro para empezar.
• El retriever retorna malos resultados: RAG depende mucho del chunking, el modelo de embedding y los parámetros de top-k.
• Agentes con modelos débiles: Los modelos pequeños a menudo no entienden Tool-Calling de forma fiable.
• Confusión de versiones: Los tutoriales antiguos usan rutas de importación obsoletas como langchain.chat_models.
• Falta de manejo de errores: Las llamadas a API pueden fallar. Implementa bloques try-except o reintentos desde el principio.
• Demasiadas dependencias: Instala solo las integraciones que realmente uses.

Hardware, costos y seguridad con LangChain

LangChain en sí es gratuito y de código abierto. Los costos provienen de los modelos e infraestructura. En local pagas por hardware y energía, no por llamada. Las APIs en la nube cobran por token, pero se ejecutan en hardware menos potente.

Para operación local: cuanto más grande es el modelo, más RAM o VRAM necesitas. Un modelo de 7B suele funcionar en 8 GB de VRAM gracias a la cuantización, mientras que las variantes más grandes exigen mucho más. RAG añade carga adicional a través de embeddings y almacenes vectoriales, pero sigue siendo relativamente económico.

La seguridad importa cuando los agentes pueden hacer búsquedas web o leer archivos. Revisa permisos y sandboxing antes de exponer un deployment públicamente.

Enlaces adicionales e información sobre LangChain

• Descripción de herramientas de desarrollo para frameworks relacionados.
• LangGraph para flujos complejos basados en estado.
• LangFlow para el enfoque visual.
• Qué es un Agente de IA para el concepto de agentes.
• Tool-Calling para funciones externas.
• RAG local y Fundamentos de RAG para aplicaciones basadas en datos.
• Ollama y Ollama API para operación de modelos locales.

FAQ: LangChain - Preguntas frecuentes

¿Es LangChain gratuito?

Sí. El framework es de código abierto. Los costos surgen solo de modelos, hosting o servicios adicionales.

¿Necesito conocimientos de Python?

Sí, para la mayoría de los tutoriales. También existe una versión de JavaScript, pero el stack de Python es el más difundido.

¿Puedo ejecutar LangChain completamente en local?

Sí. Con Ollama, modelos locales y almacenes vectoriales locales como Chroma o FAISS es posible.

¿Cuál es la diferencia entre LangChain y LlamaIndex?

LangChain cubre chains, herramientas y agentes. LlamaIndex se enfoca más en RAG y en trabajar con tus propios datos.

¿Qué modelo es mejor para LangChain?

Para chains simples, modelos pequeños como Llama 3.2 son suficientes. Para RAG y agentes, recurres a variantes más potentes como Mistral, Qwen o Command R.

¿Cómo aprendo mejor?

Construye un primer ejemplo de chain, amplía con RAG y luego prueba agentes. BotServ.de ofrece artículos de introducción apropiados.

¿Por qué hay tantos paquetes langchain-*?

LangChain se dividió para mantener las dependencias limpias. langchain es el núcleo, langchain-community contiene integraciones, langchain-ollama vincula Ollama.

¿Qué es LCEL?

LCEL significa LangChain Expression Language. La usas para encadenar componentes con el operador pipe.

¿Puedo usar LangChain con mi propio modelo fine-tuneado?

Sí, siempre que el modelo sea accesible a través de una interfaz compatible.

¿Hay alternativas a LangChain?

Sí. Además de LlamaIndex, LangGraph y LangFlow, CrewAI, Haystack o implementaciones propias son opciones.

¿Qué tan estable es la API?

LangChain evoluciona rápidamente. Asegúrate de que los tutoriales coincidan con tu versión instalada para evitar importes obsoletos.

Fuentes y lecturas adicionales

• LangChain Documentation: https://python.langchain.com/
• LangChain JS/TS Documentation: https://js.langchain.com/
• LangChain GitHub Repository: https://github.com/langchain-ai/langchain
• Ollama LangChain-Integration: https://python.langchain.com/docs/integrations/chat/ollama/
• LangGraph: https://langchain-ai.github.io/langgraph/
• LangFlow: https://www.langflow.org/