Libera el Potencial de LangChain en el Desarrollo Moderno de Aplicaciones de IA
Updated on
LangChain ha evolucionado drásticamente desde 2023. Lo que comenzó como un simple wrapper alrededor de LLMs ahora es un framework completo de aplicaciones de IA con soporte para:
- LCEL (LangChain Expression Language)
- Runnables
- LangGraph (workflows de agentes con estado y alta fiabilidad)
- OpenAI function calling
- Tool calling
- Sistemas avanzados de memoria
- Pipelines modernos de documentos para RAG
Esta guía actualizada te ofrece una comprensión preparada para 2025 de LangChain y de cómo construir aplicaciones reales con LLM usando la API moderna de OpenAI.
Conceptos Básicos de LangChain
🌟 LangChain Hoy: Un Framework Moderno para Apps de IA
Las aplicaciones modernas con LLM necesitan mucho más que generación de texto en bruto:
- herramientas
- memoria
- recuperación de documentos
- gestión de estado
- workflows de varios pasos
- manejo de errores
- determinismo
LangChain proporciona estos elementos básicos mediante Runnables, LCEL y LangGraph, permitiendo a los desarrolladores crear sistemas de agentes y workflows fiables.
🔗 Workflows Secuenciales con LCEL (Actualizado)
LCEL te permite componer pipelines de LLM como si fueran funciones:
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
model = ChatOpenAI(model="gpt-4.1")
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant."),
("user", "{question}")
])
chain = prompt | model
chain.invoke({"question": "Explain LangChain LCEL in one paragraph."})Esto reemplaza las antiguas APIs de “SequentialChain”.
Primeros Pasos con LangChain
📦 Instalación
pip install langchain langchain-openai langgraph faiss-cpuSi usas LangGraph:
pip install langgraph💬 LLMs y Prompt Templates (API Moderna)
LangChain ahora utiliza interfaces de ChatModel:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4.1", temperature=0)Los Prompt Templates siguen siendo muy potentes:
from langchain_core.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_template(
"Summarize the following text:\n\n{text}"
)⛓️ Cadenas con LCEL (en lugar de la antigua “Chains API”)
Construyes cadenas con LCEL:
chain = prompt | llm⚙️ Herramientas y Agentes (Mejores Prácticas 2025)
Los enfoques antiguos como initialize_agent, el “ReAct agent” y el estilo MiniChain están obsoletos.
El enfoque recomendado es:
Usar LangGraph para workflows de agentes
LangGraph ofrece:
- gestión de estado
- políticas de reintento
- edges deterministas
- tool calling
- persistencia
Ejemplo de nodo de agente:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="gpt-4.1",
temperature=0,
streaming=False
)Ejemplo de tool calling:
from langchain_core.tools import tool
@tool
def search_wiki(query: str):
"""Search Wikipedia topics."""
import wikipedia
return wikipedia.summary(query)
tools = [search_wiki]Conectar con el LLM:
result = llm.invoke({
"messages": [
{"role": "user", "content": "Find me information about LangChain."}
],
"tools": tools
})🧠 Memoria
La memoria en LangChain ahora incluye soporte para:
- BufferMemory
- ConversationSummaryMemory
- Memoria respaldada por SQL / Redis
- Memoria basada en graph state (LangGraph)
Ejemplo:
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
memory.save_context(
{"input": "Hello"},
{"output": "Hi, how can I help?"}
)
memory.load_memory_variables({})📄 Carga de Datos, Text Splitters y Retrieval (RAG Moderno)
Ejemplo actualizado usando FAISS + embeddings de OpenAI:
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
loader = TextLoader("./state_of_the_union.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
chunks = splitter.split_documents(docs)
emb = OpenAIEmbeddings()
db = FAISS.from_documents(chunks, emb)
query = "What policies did the president highlight?"
results = db.similarity_search(query)🚀 Ejemplo de Extremo a Extremo
A continuación se muestra un pipeline completo y ejecutable de LangChain usando LCEL, la API actualizada de OpenAI y retrieval.
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import TextLoader
from langchain_community.vectorstores import FAISS
# 1. Load LLM
llm = ChatOpenAI(model="gpt-4.1", temperature=0)
# 2. Load + split documents
loader = TextLoader("./state_of_the_union.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=800)
chunks = splitter.split_documents(docs)
# 3. Build vectorstore
db = FAISS.from_documents(chunks, OpenAIEmbeddings())
# 4. Retrieval chain
prompt = ChatPromptTemplate.from_messages([
("system", "Answer based on the provided context."),
("user", "{question}\n\nContext: {context}")
])
def retriever(q):
results = db.similarity_search(q, k=3)
return "\n".join([r.page_content for r in results])
chain = (
{
"question": lambda x: x,
"context": lambda x: retriever(x)
}
| prompt
| llm
)
# 5. Run end-to-end
response = chain.invoke("What economic topics were mentioned?")
print(response.content)Conclusión
LangChain en 2025 ya no es solo una caja de herramientas: es un framework completo para aplicaciones de IA orientado a:
- agentes
- workflows
- sistemas de retrieval
- integraciones con herramientas
- aplicaciones conversacionales ricas en memoria
Con LCEL, Runnables y LangGraph, ahora puedes construir apps de IA de nivel de producción con una arquitectura limpia, mantenible y escalable.
Usa esta guía como base actualizada para crear aplicaciones de IA potentes y competitivas.