Cómo construir un agente de IA con LangChain: Guía paso a paso

Crea un directorio de trabajo temporal seguro

Cómo construir un agente de IA con LangChain: Tutorial paso a paso

El cambio de los modelos de lenguaje grandes (LLM) que simplemente generan texto a agentes de IA que pueden tomar acciones es uno de los avances más significativos en la ingeniería de software moderna. Un sistema agéntico percibe su entorno, toma decisiones y utiliza herramientas para alcanzar objetivos específicos, yendo más allá de los chatbots simples de preguntas y respuestas. LangChain, un framework de código abierto, se ha convertido en el estándar para construir estas aplicaciones sofisticadas al conectar LLM con datos externos, herramientas y otros LLM.

Este tutorial proporciona una guía completa y paso a paso sobre cómo construir un agente de IA con LangChain. Aprenderás los conceptos fundamentales y recorrerás una implementación práctica, lo que te permitirá crear tus propios agentes autónomos capaces de realizar tareas del mundo real.

Qué aprenderás

Al finalizar este tutorial, comprenderás los principios básicos de la IA agéntica y el framework LangChain. Podrás configurar un entorno de desarrollo, conectarte a un LLM, definir herramientas personalizadas y construir un agente funcional utilizando la API moderna create_agent. Construirás y ejecutarás un agente de IA completo que puede interactuar con un sistema de archivos local basado en comandos de lenguaje natural, brindándote una base práctica para crear automatizaciones más complejas.

1. Fundamentos de LangChain y conceptos clave

Antes de sumergirnos en el código, es esencial entender qué es un agente de IA y cómo LangChain facilita su creación. En esencia, un agente es un sistema que utiliza un LLM como motor de razonamiento. El agente recibe una solicitud del usuario, solicita al LLM que decida una acción, ejecuta esa acción (a menudo llamando a una herramienta) y luego procesa el resultado para formular una respuesta. Este ciclo continúa hasta que la tarea se completa.

LangChain proporciona un framework estándar para implementar este bucle de razonamiento, especialmente a través de su soporte para el framework ReAct (Razonar + Actuar). LangChain es una herramienta de alto nivel construida sobre LangGraph, un framework de orquestación de bajo nivel que te brinda control granular sobre el flujo de trabajo y el estado del agente.

Para construir un agente con LangChain, necesitas cuatro componentes principales:

1. Un LLM: El motor de razonamiento de tu agente.
2. Herramientas: Funciones que permiten al agente interactuar con el mundo exterior, como API, bases de datos o un sistema de archivos.
3. El bucle del agente: La capa de orquestación "cerebral" que gestiona el LLM, las herramientas y el estado.
4. Memoria (puntos de control): La capacidad de persistir el estado del agente, permitiéndole recordar interacciones pasadas dentro de un hilo de conversación.

2. Configuración de tu entorno de desarrollo

Para comenzar, necesitas instalar LangChain y sus dependencias principales. Este tutorial demuestra el proceso en Python, pero los conceptos y patrones de alto nivel son similares para usuarios de TypeScript.

Primero, asegúrate de tener Python 3 y Pip instalados en tu sistema. Para sistemas basados en Debian/Ubuntu, puedes usar los siguientes comandos. Para otros sistemas operativos, sigue el método de instalación adecuado.

sudo apt update
sudo apt install python3 python3-pip

A continuación, instala los paquetes principales de LangChain. El paquete langchain es el framework central. langchain-community contiene herramientas mantenidas por la comunidad, y langgraph es necesario para la API moderna de creación de agentes.

pip install langchain langgraph langchain-community

3. Integración de un modelo de lenguaje grande

El primer paso para construir tu agente es conectarlo a un LLM. LangChain admite docenas de proveedores de modelos, incluidos Google Gemini, OpenAI, Anthropic y más. Para este tutorial, usaremos el modelo Gemini de Google.

Necesitarás una clave API de la consola de Gemini. Una vez que la tengas, puedes instalar el paquete de integración Google GenAI y configurar tu entorno.

pip install -qU "langchain[google-genai]"

Ahora, puedes escribir el código Python para inicializar el modelo. El módulo getpass se utiliza para solicitar de forma segura tu clave API.

import getpass
import os
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage, SystemMessage

if not os.environ.get("GOOGLE_API_KEY"):
    os.environ["GOOGLE_API_KEY"] = getpass.getpass("Ingresa la clave API para Google Gemini: ")

model = init_chat_model("gemini-2.0-flash", model_provider="google_genai")

Puedes probar la configuración invocando el modelo con una consulta simple.

response = model.invoke("¿Cuándo comenzó la Revolución Francesa?")
print(response.content)

4. Definición de herramientas para tu agente

Las herramientas son lo que hace poderosos a los agentes. Permiten que el LLM realice acciones más allá de generar texto. En este tutorial, construiremos un agente que puede gestionar archivos en tu computadora local utilizando el FileManagementToolkit de LangChain.

El FileManagementToolkit es parte del paquete langchain-community, que ya has instalado. Este kit de herramientas te permite especificar qué operaciones de archivos puede realizar el agente, como leer, escribir y listar archivos.

Importa los módulos necesarios y define las herramientas. Es una práctica de seguridad crítica restringir al agente a un directorio temporal en lugar de darle libre acceso a todo tu sistema de archivos.

from langchain_community.agent_toolkits import FileManagementToolkit
from tempfile import TemporaryDirectory

working_directory = TemporaryDirectory()

# Inicializa el kit de herramientas con herramientas seleccionadas y un directorio raíz
tools = FileManagementToolkit(
    root_dir=str(working_directory.name),
    selected_tools=["read_file", "write_file", "list_directory"],
).get_tools()

5. Construcción del agente con create_agent

Con el LLM y las herramientas listos, ahora puedes construir el agente. La forma moderna y recomendada de construir agentes en LangChain es utilizando la función create_agent.

Esta función toma tu modelo y una lista de herramientas y crea un ejecutor de agente que gestiona el bucle de razonamiento. Simplifica el proceso, eliminando la necesidad de crear manualmente un agente ReAct y un ejecutor.

from langchain.agents import create_agent

# Las variables "model" y "tools" son de los pasos anteriores.
agent = create_agent(
    model=model,
    tools=tools
)

Esta única línea de código crea un agente sofisticado. El agente utiliza el modelo para decidir qué herramienta llamar según la entrada del usuario. Puede manejar el encadenamiento de múltiples llamadas a herramientas para lograr una tarea compleja.

⚠️ Importante: Aunque LangChain se puede usar con métodos de creación de agentes más antiguos como create_react_agent, la API create_agent es el enfoque moderno y recomendado, y debería ser tu opción predeterminada para construir nuevos agentes.

6. Ejecución de tu primer agente

Ahora que el agente está construido, puedes ejecutarlo invocándolo con un mensaje de usuario. Los siguientes comandos demostrarán la capacidad del agente para interactuar con el sistema de archivos.

Comienza pidiendo al agente que liste los archivos en el directorio de trabajo actual. En este punto, el directorio está vacío.

input_message = {"role": "user", "content": "Lista los archivos en el directorio de trabajo actual"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

A continuación, instruye al agente para que cree un archivo llamado sample-file.txt.

input_message = {"role": "user", "content": "Crea un archivo llamado sample-file.txt"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Finalmente, pide al agente que liste los archivos nuevamente. Ahora mostrará que sample-file.txt existe.

input_message = {"role": "user", "content": "Lista los archivos en el directorio de trabajo actual"}
response = agent.invoke({"messages": [input_message]})

for message in response["messages"]:
    message.pretty_print()

Como puedes ver, el agente interpretó exitosamente los comandos en lenguaje natural, llamó a las herramientas apropiadas (list_directory, write_file) y proporcionó retroalimentación sobre las acciones realizadas. Esta es una demostración básica pero poderosa de cómo construir un agente de IA con LangChain.

7. Adición de memoria a tu agente

Una de las limitaciones clave de un agente sin estado es que olvida todo el contexto después de que se completa una invocación. Para crear un agente conversacional que pueda recordar interacciones pasadas, necesitas agregar memoria. Esto se logra a través de un "punto de control" que guarda el estado del agente.

LangGraph proporciona una clase MemorySaver, que es un punto de control simple en memoria. En un entorno de producción, usarías una opción más robusta como PostgresSaver o el punto de control basado en MongoDB, pero MemorySaver es perfecto para pruebas y desarrollo.

Primero, importa e inicializa el punto de control.

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

A continuación, vuelve a crear tu agente, pasando el checkpointer como argumento.

agent_with_memory = create_agent(
    model=model,
    tools=tools,
    checkpointer=checkpointer
)

Para usar la memoria, debes especificar un thread_id en la configuración. Este thread_id actúa como un ID de conversación, permitiendo al agente mantener memoria separada para cada conversación distinta.

config = {"configurable": {"thread_id": "user-123"}}

agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "Mi nombre es Alicia"}]},
    config=config
)

result = agent_with_memory.invoke(
    {"messages": [{"role": "user", "content": "¿Cuál es mi nombre?"}]},
    config=config
)
# El agente responde: "Tu nombre es Alicia."
print(result["messages"][-1].content)

Esta simple adición permite que tu agente mantenga conversaciones con contexto, haciéndolo sentir mucho más inteligente y útil.

8. Más allá de lo básico: Sistemas multiagente

A medida que avances, es posible que te encuentres con tareas demasiado complejas para un solo agente. LangChain admite la construcción de sistemas multiagente sofisticados, donde agentes especializados colaboran para resolver problemas. Este es un patrón arquitectónico poderoso para flujos de trabajo complejos.

Subagentes es un patrón multiagente central donde un agente supervisor principal coordina varios subagentes especializados, llamándolos como herramientas. Por ejemplo, un subagente podría ser responsable de la investigación, otro de la creación de contenido y un tercero de la revisión del trabajo.

Patrón	Cómo funciona
Subagentes	Un agente principal coordina subagentes como herramientas. Todo el enrutamiento pasa a través del agente principal, que decide cuándo invocar a cada subagente.
Transferencias	El comportamiento cambia dinámicamente según el estado, donde una llamada a una herramienta desencadena un cambio a un agente o configuración diferente.
Habilidades	Se cargan indicaciones y conocimientos especializados bajo demanda en el contexto de un solo agente.
Enrutador	Un paso de enrutamiento clasifica la entrada y la dirige a uno o más agentes especializados para su procesamiento.

Elegir el patrón correcto es crucial. Por ejemplo, una arquitectura de subagentes es excelente para la ejecución en paralelo y el desarrollo distribuido, mientras que un patrón de transferencia es más eficiente para solicitudes de usuario repetitivas en una sola conversación. Usar el patrón de subagentes en una aplicación de asistente personal permite el aislamiento del contexto: cada subagente trabaja en una tarea en una ventana de contexto limpia, evitando que la memoria del agente principal se sature.

Fuentes

1. Chris Tozzi. "Build an AI agent with LangChain in this beginner tutorial." TechTarget, Sep 2025.
2. "Quickstart" Documentación oficial de LangChain.
3. "Multi-agent" Documentación oficial de LangChain.
4. "Workflows and agents" Documentación oficial de LangChain.
5. "langchain-fundamentals" Documentación de habilidades de LangChain, GitHub.
6. "How to Build an AI Agent with LangChain and LangGraph: Build an Autonomous Starbucks Agent." freeCodeCamp, Dic 2025.
7. "Subagents" Documentación oficial de LangChain.
8. "LangChain Python Tutorial: A Complete Guide for 2026." The JetBrains Blog, Mar 2026.

— Editorial Team