Creación de agentes con LangChain

LangChain es un framework para construir aplicaciones LLM que eleva las llamadas a modelos a sistemas de aplicación componibles, controlables y extensibles.

LangChain no resuelve cómo llamar al modelo, sino:

Cómo organizar el razonamiento de múltiples pasos
Cómo integrar datos externos
Cómo los modelos pueden llamar herramientas de forma segura
Cómo gestionar el contexto a largo plazo

Dirección del código abierto:https://github.com/langchain-ai/langchain。

Tutorial de LangChain:https://www.example.com/langchain/langchain-tutorial.html

Imagina que estás construyendo un asistente robótico inteligente. Este asistente necesita poder entender tus preguntas, buscar información en diversas fuentes, realizar razonamiento lógico y, finalmente, responderte en lenguaje natural. Usar un modelo de lenguaje como GPT por sí solo es como darle al robot solo un cerebro inteligente, pero le faltan manos y ojos: no sabe cómo obtener datos externos ni cómo ejecutar tareas concretas.

LangChainEs un framework que actúa como conector y coordinador.

LangChainConecta hábilmente poderosos modelos de lenguaje (como GPT-4, DeepSeek) con fuentes de datos externas, herramientas de cálculo y sistemas de memoria, construyendo aplicaciones de IA potentes y prácticas.

En pocas palabras, el valor principal de LangChain es:Hacer que los modelos de lenguaje sean útilesresolviendo varias limitaciones clave de los grandes modelos de lenguaje (LLM):

Actualidad del conocimiento: Los datos de entrenamiento de los LLM tienen una fecha límite y no pueden obtener información actualizada.
Especialización en dominios: Los LLM generales carecen del conocimiento privado de industrias o empresas específicas.
Capacidad de acción: Los LLM por sí mismos no pueden ejecutar acciones como cálculos, consultas a bases de datos o llamadas a API.
Coherencia conversacional: En diálogos de múltiples turnos, los LLM necesitan recordar el historial de chat anterior.

LangChain organiza estas funciones mediante una serie de cadenas (Chains) y componentes (Components) estandarizados, lo que permite a los desarrolladores construir rápidamente aplicaciones complejas de IA como si ensamblaran bloques.

Resumen de los módulos de LangChain:

LLMs / ChatModels: Interfaz de modelos
Prompt Templates: Prompts estructurados
Chains: Orquestación de flujos
Memory: Gestión de contexto
Retrievers / VectorStores: Recuperación de conocimiento
Agents & Tools: Decisión y ejecución automáticas

Preparación del entorno

Usando un espejo nacional para instalar:

pip install langchain langchain-openai langchain-community python-dotenv -i https://mirrors.aliyun.com/pypi/simple/

Si usas OpenAI, puedes configurar las variables de entorno:

export OPENAI_API_KEY=你的key

Luego prueba con el siguiente código:

Ejemplo

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

resp = llm.invoke("Explica en una frase qué es LangChain")
print(resp.content)

En China, podemos usar el modelo grande DeepSeek para probar. Si aún no lo tienes, primero debeshttps://platform.deepseek.com/api_keyscrear una clave API.

Referencia de la documentación de API de DeepSeek:https://api-docs.deepseek.com/zh-cn/。

Si necesitas gestionar múltiples modelos de terceros de forma unificada, puedes optar por instalar LiteLLM como puerta de enlace de modelos:

pip install -U litellm

Sin embargo, los ejemplos de este artículo usan directamenteChatOpenAIjunto conopenai_api_baseel parámetro para conectarse a DeepSeek, sin necesidad de instalar LiteLLM adicional.

Ejemplo

import os
from langchain_openai import ChatOpenAI

Se recomienda colocar la API Key en variables de entorno, o asignarla directamente aquí (no la incruste en el código en producción).
# os.environ["DEEPSEEK_API_KEY"] = "sk-tu clave de DeepSeek"

Inicializar el modelo
llm = ChatOpenAI(
model="deepseek-v4-pro", # Nombre del modelo DeepSeek V4
openai_api_key="sk-tuKey", # Ingresa tu API Key de DeepSeek.
openai_api_base="https://api.deepseek.com", # Dirección de la API de DeepSeek.
temperature=0.7,
max_tokens=1024
)

# Probar
response = llm.invoke("¡Hola, DeepSeek! Por favor, haz una breve presentación de ti mismo.")
print(response.content)

Al ejecutar el código anterior, se mostrará el siguiente contenido:

你好！很高兴认识你！

我是DeepSeek，由深度求索公司创造的AI助手。我的特点包括：
。。。

Construcción de cadenas LCEL (LangChain Expression Language)

Solo llamar al modelo no es suficiente; necesitamos construir un flujo de procesamiento estándar:

Prompt -> LLM -> OutputParser

El código completo es el siguiente:

Ejemplo

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# 1. Definir el modelo (Model)
llm = ChatOpenAI(
model="deepseek-v4-pro",
openai_api_key="tu_DEEPSEEK_API_KEY",
openai_api_base="https://api.deepseek.com"
)

# 2. Definir la plantilla de prompt (Prompt)
# system: establecer el rol de la IA
# user: la entrada específica del usuario
prompt = ChatPromptTemplate.from_messages([
("system", Eres un experto técnico senior, con habilidad para explicar conceptos tecnológicos complejos con un 'lenguaje sencillo' fácil de entender. Tu explicación debe incluir una metáfora vívida.),
("user", "{concept}")
])

# 3. Definir el analizador de salida (Output Parser)
# Convertir el objeto Message del modelo directamente a una cadena simple
parser = StrOutputParser()

# 4. Construir una cadena (Chain) - conectar usando el operador pipe |
# Flujo: ingresar diccionario -> completar Prompt -> enviar a LLM -> analizar la salida
chain = prompt | llm | parser

# 5. Cadena de llamadas
concept_to_explain = "Entrelazamiento cuántico"
print(fExplicando el concepto: {concept_to_explain}...\n")

result = chain.invoke({"concept": concept_to_explain})

print("--- Respuesta de DeepSeek ---")
print(result)

Salida en streaming (Streaming)

En aplicaciones reales (como los chatbots), necesitamos mostrar el texto palabra por palabra, como ChatGPT, en lugar de esperar a que se genere todo y mostrarlo de una sola vez.

LangChain ofrece soporte muy sencillo para esto: usa.stream()en lugar de.invoke()：

Ejemplo

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# 1. Definir el modelo (Model)
llm = ChatOpenAI(
model="deepseek-v4-pro",
openai_api_key="tu_DEEPSEEK_API_KEY",
openai_api_base="https://api.deepseek.com"
)

# 2. Definir la plantilla de prompt (Prompt)
# system: establecer el rol de la IA
# user: la entrada específica del usuario
prompt = ChatPromptTemplate.from_messages([
("system", Eres un experto técnico senior, experto en explicar conceptos tecnológicos complejos con un "lenguaje sencillo" fácil de entender. Tu explicación debe incluir una metáfora vívida.),
("user", "{concept}")
])

# 3. Definir el analizador de salida (Output Parser)
# Convertir el objeto Message del modelo directamente a una cadena de texto pura
parser = StrOutputParser()

# 4. Construir la cadena (Chain) - usar el operador pipe | para conectar
# Flujo: diccionario de entrada -> completar el Prompt -> enviar a LLM -> analizar la salida
chain = prompt | llm | parser

# 5. Invocar la cadena
concept_to_explain = "Entrelazamiento cuántico"
print(f"Explicando el concepto: {concept_to_explain} (salida en streaming)...\n")

# Aquí chunk es el fragmento generado en cada paso
for chunk in chain.stream({"concept": "Red neuronal recurrente"}):
print(chunk, end="", flush=True)

Estructura del código

Prompt

ChatPromptTemplateDistinción clarasystem / user
El Prompt esfunción de entrada estructurada, no una cadena de texto

LLM

ChatOpenAIsolo una interfaz unificada
LangChain no mejora las capacidades del modelo, solo mejora lacontrolabilidad

OutputParser

La salida del modelo siempre esMessage
StrOutputParserSíConversión explícita de tipos
Sin Parser, la ingeniería no es controlable

Explicación detallada de los componentes principales

1. Modelos (Models)

LangChain proporciona una interfaz de abstracción unificada; ahora se recomienda principalmente usarChat Models, porque los modelos actuales (como DeepSeek, GPT-4) están optimizados principalmente para el diálogo.

Chat Models: la entrada y la salida son mensajes estructurados.
SystemMessage: define el rol de la IA.
HumanMessage: mensaje enviado por el usuario.
AIMessage: mensaje devuelto por la IA.

2. Prompts (Prompts)

En la nueva versión, se recomienda usarChatPromptTemplatepara construir prompts conversacionales, ya que se ajusta mejor a los hábitos de invocación de los LLM actuales.

from langchain_core.prompts import ChatPromptTemplate

# 使用 from_messages 构建结构化模板
prompt_template = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的{role}。"),
    ("user", "{content}")
])

# 动态填充变量
prompt = prompt_template.invoke({"role": "美食评论家", "content": "评价一下这碗炸酱面"})
# 输出：包含 SystemMessage 和 HumanMessage 的列表

3. Cadenas (Chains) y LCEL

Actualización importante: LLMChainHa quedado en desuso. Ahora se usaLCEL (operador pipe|)) es la sintaxis. Esta forma es más flexible, admite asincronía y salida en streaming.

# 现代写法：Prompt | Model | OutputParser
from langchain_core.output_parsers import StrOutputParser

# 这里的 llm 是 ChatOpenAI(model="deepseek-v4-pro") 的实例
chain = prompt_template | llm | StrOutputParser()

# 调用链
result = chain.invoke({"role": "导游", "content": "介绍一下故宫"})
print(result) # 直接输出字符串

4. Índices y recuperación (Indexes & Retrieval)

Este es elRAG (Generación Aumentada por Recuperación)núcleo. La nueva versión enfatiza el proceso de transformar documentos en "recuperadores".

Proceso: DocumentLoaders(carga) ->TextSplitter(división en fragmentos) ->Embeddings(vectorización) ->VectorStore(almacenamiento).
Retriever: ya no es solo una búsqueda en base de datos, es un componente que se puede integrar en la cadena.

# 将向量库转为检索器
retriever = vectorstore.as_retriever()
# 在新版链中引用
# chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm

Ejemplo práctico completo de RAG

A continuación, implementemos una aplicación RAG completa. Primero necesitamos instalar dependencias adicionales:

pip install langchain-community faiss-cpu sentence-transformers -i https://mirrors.aliyun.com/pypi/simple/

Ejemplo

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Cargar variables de entorno
load_dotenv()

# Inicializar el modelo y el Embedding
llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# Usar el modelo Embedding local gratuito (se descargará automáticamente la primera vez que se ejecute)
embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2"
)

# --- 1. Preparar los documentos de conocimiento ---
# En un proyecto real, estos documentos se pueden cargar desde archivos, páginas web, bases de datos, etc.
documents = [
"LangChain es un marco de código abierto para construir aplicaciones de modelos de lenguaje grandes, creado por Harrison Chase en 2022.",
"Los componentes principales de LangChain incluyen: interfaz de modelos, plantillas de prompts, cadenas, memoria, recuperación y agentes.",
"LCEL (Lenguaje de Expresión de LangChain) es la nueva sintaxis de construcción de cadenas de LangChain, que utiliza el operador pipe | para conectar los componentes.",
"RAG (Generación Aumentada por Recuperación) permite al LLM responder preguntas fuera de sus datos de entrenamiento al recuperar documentos relevantes antes de la generación.",
"LangGraph es un nuevo marco lanzado por el equipo de LangChain, especializado en construir flujos de trabajo complejos de agentes de IA de múltiples pasos.",
"LangSmith es la plataforma de observabilidad de LangChain, utilizada para depurar, probar y monitorear aplicaciones de LLM.",
]

# --- 2. División del texto ---
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=100,
chunk_overlap=20
)
# Aquí el documento ya es corto; en escenarios reales, los documentos largos se dividen en varios fragmentos
texts = text_splitter.create_documents(documents)

# --- 3. Vectorizar y almacenar en FAISS ---
vectorstore = FAISS.from_documents(texts, embeddings)

# --- 4. Crear el recuperador ---
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# --- 5. Construir la cadena RAG ---
rag_prompt = ChatPromptTemplate.from_messages([
("system", "Eres un asistente de conocimiento. Responde la pregunta según el contexto recuperado a continuación. Si la respuesta no está en el contexto, di que no lo sabes.\n\nContexto: {context}"),
("human", "{question}")
])

# Función auxiliar: concatenar los documentos recuperados en una cadena de texto
def format_docs(docs):
return "\n".join(doc.page_content for doc in docs)

rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| rag_prompt
| llm
| StrOutputParser()
)

# --- 6. Probar RAG ---
question = "¿Cuáles son los componentes principales de LangChain?"
print(f"Pregunta: {question}")
print(f"Respuesta: {rag_chain.invoke(question)}")

Explicación de los puntos técnicos clave de RAG:

FAISSes una biblioteca de búsqueda de similitud vectorial de código abierto de Facebook, adecuada para desarrollo y pruebas locales, los datos se almacenan en memoria.
Entorno de producciónse recomienda usar bases de datos vectoriales profesionales como Pinecone, Milvus, Chroma, Weaviate, que admiten persistencia y distribución.
Modelo de Embedding: este ejemplo utiliza el modelo de HuggingFaceall-MiniLM-L6-v2, que se descargará automáticamente la primera vez que se ejecute (aprox. 80MB)
Si tienes una API Key de OpenAI, también puedes usarOpenAIEmbeddingspara obtener mejores resultados en chino
Para el ámbito doméstico con escenarios en chino, se recomienda usarBAAI/bge-small-zh-v1.5y otros modelos de Embedding en chino.
chunk_sizeychunk_overlapSe debe ajustar según las características del documento real; si es demasiado grande puede perder precisión, si es demasiado pequeño puede perder contexto.

5. Memoria (Memory)

Actualización importante:los tradicionalesConversationBufferMemoryson difíciles de integrar en cadenas LCEL complejas. La recomendación más reciente es usarChatMessageHistoryjunto conRunnableWithMessageHistory。

Lógica principal: la memoria ya no es un atributo de la cadena, sino un repositorio de mensajes independiente, que mediantesession_iddistingue a diferentes usuarios.
Persistencia: admite almacenamiento en Redis, PostgreSQL o memoria.

6. Agentes (Agents)

El agente (Agent) es una de las funciones más potentes de LangChain. A diferencia de la cadena (Chain), el agente puede, según la entrada del usuario,tomar decisiones autónomassobre qué herramientas invocar y en qué orden ejecutarlas; es un verdadero "agente inteligente".

El ciclo principal del agente: recibir tarea -> pensar (elegir herramienta) -> ejecutar herramienta -> observar resultado -> continuar pensando o dar la respuesta final.

Usando el@tooldecorador se puede convertir cualquier función de Python en una herramienta invocable por LLM. LangChain pasa automáticamente el nombre de la función y el docstring al modelo, para que el modelo sepa cuándo y cómo usar esta herramienta.

A continuación se muestra un ejemplo práctico completo de Agent, que incluye tres herramientas: consulta del clima, cálculo matemático y búsqueda de conocimiento:

Ejemplo

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain.agents import AgentExecutor, create_tool_calling_agent

# Cargar variables de entorno
load_dotenv()

# Inicializar el modelo DeepSeek
llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# --- Definir herramientas ---
# Usando el decorador @tool, LangChain informa automáticamente al modelo del nombre de la función y del docstring

@tool
def get_current_weather(city: str) -> str:
"""Obtiene la información meteorológica actual de una ciudad determinada. Usa esta herramienta cuando el usuario pregunte por el clima."""
# En una aplicación real, aquí se llamaría a una API meteorológica real
weather_data = {
"Pekín": "Despejado, temperatura 28°C, humedad 45%",
"Shanghái": "Nublado, temperatura 25°C, humedad 70%",
"Shenzhen": "Tormentas eléctricas, temperatura 30°C, humedad 85%",
}
return weather_data.get(city, f"Lo sentimos, no hay datos meteorológicos para {city}")

@tool
def calculate(expression: str) -> str:
"""Calcula expresiones matemáticas. Utiliza esta herramienta cuando el usuario necesite realizar cálculos matemáticos.
Admite operaciones aritméticas básicas, como '2 + 3 * 4'."""
import ast
import operator

# Mapeo seguro de operadores
ops = {
ast.Add: operator.add,
ast.Sub: operator.sub,
ast.Mult: operator.mul,
ast.Div: operator.truediv,
ast.Pow: operator.pow,
ast.USub: operator.neg,
}

def safe_eval(node):
if isinstance(node, ast.Expression):
return safe_eval(node.body)
elif isinstance(node, ast.Constant):
return node.value
elif isinstance(node, ast.BinOp):
left = safe_eval(node.left)
right = safe_eval(node.right)
return ops[type(node.op)](left, right)
elif isinstance(node, ast.UnaryOp):
operand = safe_eval(node.operand)
return ops[type(node.op)](operand)
else:
raise ValueError(f"Tipo de expresión no soportado: {type(node)}")

try:
tree = ast.parse(expression, mode='eval')
result = safe_eval(tree)
return f"Resultado del cálculo: {expression} = {result}"
except Exception as e:
return f"Error de cálculo: {e}"

@tool
def search_knowledge(query: str) -> str:
"""Busca en la base de conocimiento para obtener información relevante. Utiliza esta herramienta cuando el usuario haga preguntas factuales."""
# En una aplicación real, aquí se conectaría una base de datos vectorial o un motor de búsqueda
knowledge = {
"LangChain": "LangChain es un framework de código abierto para construir aplicaciones LLM, que admite llamadas encadenadas, gestión de memoria e integración de herramientas.",
"Python": "Python es un lenguaje de programación de alto nivel, conocido por su simplicidad y legibilidad, ampliamente utilizado en IA, ciencia de datos y otros campos.",
}
for key, value in knowledge.items():
if key.lower() in query.lower():
return value
return f"No se encontró información relacionada con '{query}'"

# --- Montar la lista de herramientas ---
tools = [get_current_weather, calculate, search_knowledge]

# --- Crear el prompt del Agent ---
prompt = ChatPromptTemplate.from_messages([
("system", "Eres un asistente de IA potente que puede usar herramientas para ayudar a los usuarios. Según la pregunta del usuario, determina si es necesario usar herramientas y elige la más adecuada para obtener información."),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# --- Crear el Agent ---
agent = create_tool_calling_agent(llm, tools, prompt)

# --- Crear el AgentExecutor (ejecutor del agente) ---
# verbose=True permite ver el proceso de razonamiento completo del Agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# --- Probar el Agent ---
# Prueba 1: Consulta del clima
print("=" * 50)
response = agent_executor.invoke({"input": "¿Cómo está el clima hoy en Pekín?"})
print(f"\nRespuesta final: {response['output']}")

# Prueba 2: Cálculo matemático
print("\n" + "=" * 50)
response = agent_executor.invoke({"input": "Ayúdame a calcular cuánto es (15 * 37 + 228) / 3"})
print(f"\nRespuesta final: {response['output']}")

# Prueba 3: Pregunta integral (el Agent debe decidir por sí mismo qué herramienta usar)
print("\n" + "=" * 50)
response = agent_executor.invoke({"input": "¿Qué es LangChain? Además, ayúdame a calcular 2 elevado a la décima potencia"})
print(f"\nRespuesta final: {response['output']}")

Al ejecutar el código anterior, verás(Salida de la cadena de razonamiento cuando verbose=True):

==================================================

> Entering new AgentExecutor chain...
Invoking: `get_current_weather` with `{'city': '北京'}`

晴天，气温 28°C，湿度 45%

根据查询结果，北京今天的天气是晴天，气温 28°C，湿度 45%。

> Finished chain.

Respuesta final: 北京今天天气晴朗，气温 28°C，湿度 45%，适合外出活动。

==================================================

> Entering new AgentExecutor chain...
Invoking: `calculate` with `{'expression': '(15 * 37 + 228) / 3'}`

计算结果：(15 * 37 + 228) / 3 = 261.0

> Finished chain.

Respuesta final: (15 * 37 + 228) / 3 的计算结果是 261.0

==================================================

> Entering new AgentExecutor chain...
Invoking: `search_knowledge` with `{'query': 'LangChain'}`
Invoking: `calculate` with `{'expression': '2 ** 10'}`

LangChain 是一个用于构建 LLM 应用的开源框架...
计算结果：2 ** 10 = 1024

> Finished chain.

Respuesta final: LangChain 是一个用于构建 LLM 应用的开源框架，支持链式调用、记忆管理和工具集成。另外，2 的 10 次方等于 1024.

Nota de seguridad:Este ejemplo utiliza un análisis AST seguro en lugar de eval(). En proyectos reales, nunca uses eval() directamente sobre la entrada del usuario, ya que conlleva un grave riesgo de ejecución remota de código.

Entender el "proceso de razonamiento" del Agent:

verbose=TrueNos permite ver la cadena de decisión completa del Agent, facilitando la depuración y la comprensión de su comportamiento.
El Agent determina automáticamente qué herramienta debe invocar, sin necesidad de especificar manualmente el orden de llamada.
Si la pregunta no requiere herramientas (como una conversación informal), el Agent responderá directamente con su propio conocimiento.
Para problemas complejos, el Agent puede invocar herramientas varias veces, incluso en paralelo.

Inicio rápido: Construye tu primera aplicación LangChain

Veamos lo conveniente que es LangChain a través de un ejemplo sencillo.

En el desarrollo real, podemos guardar la información relacionada con la API en el directorio raíz del proyecto.enven el archivo, para facilitar su uso.

# .env 文件内容
DEEPSEEK_API_KEY=sk-xxx
DEEPSEEK_BASE_URL=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-v4-pro

Al usar ChatOpenAI de LangChain, se recomienda configurar openai_api_base como https://api.deepseek.com, sin necesidad de agregar /v1 manualmente, LangChain completará la ruta automáticamente.

Ejemplo 1: Cadena básica de preguntas y respuestas

Ejemplo

import os
from dotenv import load_dotenv
# La ruta de importación correcta
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# Cargar las variables de entorno
load_dotenv()

llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL'),
)

# Crear la plantilla de prompt
template = """
Eres un asistente amigable.
Por favor, responde la siguiente pregunta:

Pregunta: {question}
Respuesta:
"""
prompt = PromptTemplate.from_template(template)

# Crear la cadena con sintaxis LCEL (forma recomendada)
# Estructura: Prompt -> LLM -> Analizar a cadena de texto
chain = prompt | llm | StrOutputParser()

# Ejecutar la cadena
question = "¿Qué es LangChain? ¿Cuáles son sus usos principales?"

response = chain.invoke({"question": question})

print("Pregunta:", question)
print("-" * 20)
print("Respuesta:", response)

Ejemplo 2: Cadena de diálogo con memoria

Creemos un simple chatbot que pueda recordar el historial de la conversación.

Ejemplo

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# 1. Cargar la configuración
load_dotenv()

# 2. Inicializar el modelo DeepSeek
llm = ChatOpenAI(
model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# 3. Definir la plantilla de prompt
# MessagesPlaceholder se rellenará con el historial de conversación en tiempo de ejecución
prompt = ChatPromptTemplate.from_messages([
("system", "Eres un asistente de IA servicial."),
MessagesPlaceholder(variable_name="history"),
("human", "{question}"),
])

# 4. Construir la cadena
chain = prompt | llm

# 5. Gestionar la memoria: crear un diccionario para almacenar los historiales de diferentes usuarios
store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]

# 6. Envolver nuestra cadena con RunnableWithMessageHistory
# Así LangChain manejará automáticamente la lectura y actualización del historial
with_message_history = RunnableWithMessageHistory(
chain,
get_session_history,
input_messages_key="question",
history_messages_key="history",
)

# 7. Entrar en el bucle de conversación
print("--- Modo de chat DeepSeek activado (escribe 'exit' para salir) ---")
session_config = {"configurable": {"session_id": "user_001"}} # ID para distinguir diferentes sesiones

while True:
user_input = input("Tú: ")
if user_input.lower() in ["exit", "quit", "salir"]:
break

# Invocar la cadena con memoria
response = with_message_history.invoke(
{"question": user_input},
config=session_config
)

print(f"AI: {response.content}\n")

Al ejecutar el código anterior, verás：

--- 已进入 DeepSeek 聊天模式 (输入 'exit' 退出) ---
Tú: 你好
AI: 你好！很高兴见到你！ 有什么我可以帮助你的吗？无论是回答问题、聊天，还是协助解决问题，我都很乐意为你提供帮助！

Tú: 我叫小明
AI: 你好，小明！很高兴认识你！ 
如果你有任何问题、想法，或者需要帮助的地方，随时告诉我哦～

Tú: 我叫什么记得吗？
AI: 当然记得！你刚刚告诉我你叫**小明**～  
我会认真记住我们的对话内容，在之后的交流中尽量保持上下文连贯。不过如果对话过长或间隔太久，我可能需要你提醒一下哦～  
有什么想聊的或需要帮助的吗？

Resumen

Este artículo presenta los conceptos fundamentales y las aplicaciones prácticas del framework LangChain. Gracias a sus componentes estandarizados y las llamadas encadenadas, LangChain permite a los desarrolladores crear rápidamente potentes aplicaciones de IA.

La siguiente tabla resume los puntos clave tratados en este artículo:

Concepto	Descripción	Código clave
Cadena LCEL	Conecta Prompt, Model y Parser con el operador de tubería \|	`chain = prompt \| llm \| parser`
Plantilla de prompt	Prompt estructurado que distingue los roles system/user	`ChatPromptTemplate.from_messages()`
Salida en streaming	Salida carácter por carácter para mejorar la experiencia del usuario	`chain.stream()`
Memoria de conversación	Gestiona el historial de conversaciones de varios turnos mediante session_id	`RunnableWithMessageHistory`
RAG (Generación aumentada por recuperación)	Integración de conocimiento externo para superar los límites de conocimiento del LLM	`retriever \| format_docs`
Agente (Agent)	Toma de decisiones autónoma para invocar herramientas, la función avanzada más esencial	`create_tool_calling_agent()`

Ruta de aprendizaje recomendada

Otras extensiones

Herramientas de agentes

Implementación de agentes inteligentes en Python

Creación de agentes con LangChain

Preparación del entorno

Ejemplo

Ejemplo

Construcción de cadenas LCEL (LangChain Expression Language)

Ejemplo

Salida en streaming (Streaming)

Ejemplo

Estructura del código

Prompt

LLM

OutputParser

Explicación detallada de los componentes principales

1. Modelos (Models)

2. Prompts (Prompts)

3. Cadenas (Chains) y LCEL

4. Índices y recuperación (Indexes & Retrieval)

Ejemplo

5. Memoria (Memory)

6. Agentes (Agents)

Ejemplo

Inicio rápido: Construye tu primera aplicación LangChain

Ejemplo 1: Cadena básica de preguntas y respuestas

Ejemplo

Ejemplo 2: Cadena de diálogo con memoria

Ejemplo

Resumen

Ruta de aprendizaje recomendada