Construir un agente de IA con LangChain y Python es mucho más accesible de lo que parece: con un modelo de lenguaje, un par de herramientas y unas 40 líneas de código ya tenés un agente que razona, decide y ejecuta acciones por su cuenta. Esta guía te lleva paso a paso desde la instalación hasta tu primer agente funcional con memoria.

La diferencia entre un chatbot y un agente es simple: el chatbot responde, el agente actúa. Un agente recibe un objetivo, decide qué herramientas necesita, las ejecuta, evalúa el resultado y repite el ciclo hasta cumplir la tarea. LangChain se convirtió en el framework más usado para orquestar esa lógica en Python, y su capa de orquestación LangGraph ya es la base de sistemas en producción en empresas como Klarna, LinkedIn, Uber y Replit, según la guía técnica publicada por JetBrains.

Si estás empezando y todavía no tenés claro qué es un agente ni cómo se diferencia de una automatización tradicional, te conviene arrancar por esta guía práctica sobre agentes de IA para automatizar tareas sin programar y después volver a este tutorial.

Qué es un agente de IA y cómo funciona por dentro

Un agente de IA es un programa que usa un modelo de lenguaje como "cerebro" para decidir qué hacer a continuación. En lugar de seguir un flujo fijo escrito por vos, el modelo elige entre un conjunto de herramientas disponibles.

El ciclo básico tiene cuatro pasos:

• Percepción: el agente recibe una instrucción del usuario o un evento externo.

• Razonamiento: el modelo analiza el objetivo y decide si puede responder directo o necesita una herramienta.

• Acción: ejecuta la herramienta elegida (una búsqueda, una consulta a base de datos, un cálculo, una llamada a API).

• Observación: lee el resultado y decide si terminó o si necesita otra iteración.

Ese bucle es lo que LangChain te ahorra implementar a mano. Vos definís las herramientas y el objetivo; el framework se encarga del parsing de respuestas, el manejo de errores y el control del ciclo.

LangChain vs LangGraph: cuál usar

LangChain es la capa de abstracción sobre modelos, herramientas y memoria. LangGraph es la capa de orquestación construida encima, pensada para flujos con estado, ciclos y lógica condicional.

Para empezar, LangChain alcanza. Cuando el agente necesite recordar contexto entre ejecuciones o ramificar decisiones, migrás a LangGraph sin reescribir la lógica de herramientas. La documentación oficial de LangChain para Python mantiene actualizada la referencia de ambas capas, que cambian con frecuencia.

Paso 1: preparar el entorno

Necesitás Python 3.10 o superior. Creá un entorno virtual para aislar las dependencias:

• python -m venv .venv

• source .venv/bin/activate (en Windows: .venv\Scripts\activate)

• pip install langchain langchain-openai langgraph python-dotenv

Después creá un archivo .env con tu clave de API del proveedor de modelos que uses y nunca lo subas a un repositorio público. Este es el error más común de quienes recién arrancan: exponer credenciales en GitHub.

Paso 2: conectar el modelo

El primer bloque es la conexión al modelo de lenguaje. LangChain abstrae el proveedor, así que podés cambiar de modelo sin tocar el resto del código.

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
respuesta = llm.invoke("Explicá qué es un agente de IA en dos frases.")
print(respuesta.content)

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
respuesta = llm.invoke("Explicá qué es un agente de IA en dos frases.")
print(respuesta.content)

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
respuesta = llm.invoke("Explicá qué es un agente de IA en dos frases.")
print(respuesta.content)

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
respuesta = llm.invoke("Explicá qué es un agente de IA en dos frases.")
print(respuesta.content)

Usá temperature=0 mientras desarrollás: hace las respuestas más determinísticas y te permite depurar el comportamiento del agente sin ruido aleatorio.

Paso 3: definir las herramientas

Las herramientas son funciones de Python que el agente puede invocar. Lo único que necesita LangChain es el decorador @tool y un docstring claro: el modelo lee ese docstring para decidir cuándo usar la función.

from langchain_core.tools import tool

@tool
def calcular_descuento(precio: float, porcentaje: float) -> float:
    """Calcula el precio final aplicando un porcentaje de descuento.
    Usar cuando el usuario pida el precio con descuento aplicado."""
    return round(precio * (1 - porcentaje / 100), 2)

@tool
def buscar_stock(producto: str) -> str:
    """Consulta el stock disponible de un producto por nombre."""
    inventario = {"notebook": 12, "monitor": 3, "teclado": 0}
    cantidad = inventario.get(producto.lower(), 0)
    return f"Stock de {producto}: {cantidad} unidades"

from langchain_core.tools import tool

@tool
def calcular_descuento(precio: float, porcentaje: float) -> float:
    """Calcula el precio final aplicando un porcentaje de descuento.
    Usar cuando el usuario pida el precio con descuento aplicado."""
    return round(precio * (1 - porcentaje / 100), 2)

@tool
def buscar_stock(producto: str) -> str:
    """Consulta el stock disponible de un producto por nombre."""
    inventario = {"notebook": 12, "monitor": 3, "teclado": 0}
    cantidad = inventario.get(producto.lower(), 0)
    return f"Stock de {producto}: {cantidad} unidades"

from langchain_core.tools import tool

@tool
def calcular_descuento(precio: float, porcentaje: float) -> float:
    """Calcula el precio final aplicando un porcentaje de descuento.
    Usar cuando el usuario pida el precio con descuento aplicado."""
    return round(precio * (1 - porcentaje / 100), 2)

@tool
def buscar_stock(producto: str) -> str:
    """Consulta el stock disponible de un producto por nombre."""
    inventario = {"notebook": 12, "monitor": 3, "teclado": 0}
    cantidad = inventario.get(producto.lower(), 0)
    return f"Stock de {producto}: {cantidad} unidades"

from langchain_core.tools import tool

@tool
def calcular_descuento(precio: float, porcentaje: float) -> float:
    """Calcula el precio final aplicando un porcentaje de descuento.
    Usar cuando el usuario pida el precio con descuento aplicado."""
    return round(precio * (1 - porcentaje / 100), 2)

@tool
def buscar_stock(producto: str) -> str:
    """Consulta el stock disponible de un producto por nombre."""
    inventario = {"notebook": 12, "monitor": 3, "teclado": 0}
    cantidad = inventario.get(producto.lower(), 0)
    return f"Stock de {producto}: {cantidad} unidades"

La calidad del docstring define la calidad del agente. Si el modelo elige mal la herramienta, casi siempre el problema está ahí y no en el prompt del sistema. Escribí docstrings que expliquen qué hace la función y en qué situación conviene usarla.

Paso 4: armar el agente

Con el modelo y las herramientas listos, el agente se arma en pocas líneas:

from langgraph.prebuilt import create_react_agent

herramientas = [calcular_descuento, buscar_stock]

agente = create_react_agent(
    model=llm,
    tools=herramientas,
    prompt="Sos un asistente de e-commerce. Respondé en español, "
           "de forma breve y usando las herramientas disponibles."
)

resultado = agente.invoke({
    "messages": [("user", "¿Hay stock de monitor? Si hay, decime "
                          "el precio con 15% off sobre $450000.")]
})

print(resultado["messages"][-1].content)

from langgraph.prebuilt import create_react_agent

herramientas = [calcular_descuento, buscar_stock]

agente = create_react_agent(
    model=llm,
    tools=herramientas,
    prompt="Sos un asistente de e-commerce. Respondé en español, "
           "de forma breve y usando las herramientas disponibles."
)

resultado = agente.invoke({
    "messages": [("user", "¿Hay stock de monitor? Si hay, decime "
                          "el precio con 15% off sobre $450000.")]
})

print(resultado["messages"][-1].content)

from langgraph.prebuilt import create_react_agent

herramientas = [calcular_descuento, buscar_stock]

agente = create_react_agent(
    model=llm,
    tools=herramientas,
    prompt="Sos un asistente de e-commerce. Respondé en español, "
           "de forma breve y usando las herramientas disponibles."
)

resultado = agente.invoke({
    "messages": [("user", "¿Hay stock de monitor? Si hay, decime "
                          "el precio con 15% off sobre $450000.")]
})

print(resultado["messages"][-1].content)

from langgraph.prebuilt import create_react_agent

herramientas = [calcular_descuento, buscar_stock]

agente = create_react_agent(
    model=llm,
    tools=herramientas,
    prompt="Sos un asistente de e-commerce. Respondé en español, "
           "de forma breve y usando las herramientas disponibles."
)

resultado = agente.invoke({
    "messages": [("user", "¿Hay stock de monitor? Si hay, decime "
                          "el precio con 15% off sobre $450000.")]
})

print(resultado["messages"][-1].content)

Ese agente resuelve una consulta que requiere dos herramientas encadenadas: primero verifica stock, después calcula el descuento. No escribiste ninguna lógica de decisión — el modelo la infiere.

Paso 5: agregar memoria

Sin memoria, cada llamada al agente arranca de cero. LangGraph resuelve esto con un checkpointer y un identificador de conversación:

from langgraph.checkpoint.memory import MemorySaver

memoria = MemorySaver()
agente = create_react_agent(
    model=llm, tools=herramientas, checkpointer=memoria
)

config = {"configurable": {"thread_id": "usuario-42"}}

agente.invoke({"messages": [("user", "Me llamo Ana")]}, config)
r = agente.invoke({"messages": [("user", "¿Cómo me llamo?")]}, config)
print(r["messages"][-1].content)  # recuerda "Ana"

from langgraph.checkpoint.memory import MemorySaver

memoria = MemorySaver()
agente = create_react_agent(
    model=llm, tools=herramientas, checkpointer=memoria
)

config = {"configurable": {"thread_id": "usuario-42"}}

agente.invoke({"messages": [("user", "Me llamo Ana")]}, config)
r = agente.invoke({"messages": [("user", "¿Cómo me llamo?")]}, config)
print(r["messages"][-1].content)  # recuerda "Ana"

from langgraph.checkpoint.memory import MemorySaver

memoria = MemorySaver()
agente = create_react_agent(
    model=llm, tools=herramientas, checkpointer=memoria
)

config = {"configurable": {"thread_id": "usuario-42"}}

agente.invoke({"messages": [("user", "Me llamo Ana")]}, config)
r = agente.invoke({"messages": [("user", "¿Cómo me llamo?")]}, config)
print(r["messages"][-1].content)  # recuerda "Ana"

from langgraph.checkpoint.memory import MemorySaver

memoria = MemorySaver()
agente = create_react_agent(
    model=llm, tools=herramientas, checkpointer=memoria
)

config = {"configurable": {"thread_id": "usuario-42"}}

agente.invoke({"messages": [("user", "Me llamo Ana")]}, config)
r = agente.invoke({"messages": [("user", "¿Cómo me llamo?")]}, config)
print(r["messages"][-1].content)  # recuerda "Ana"

MemorySaver guarda el estado en RAM, así que sirve para desarrollo. Para producción vas a querer un checkpointer persistente contra PostgreSQL o Redis, de modo que la conversación sobreviva a un reinicio del servicio.

Errores frecuentes al empezar

• Demasiadas herramientas de entrada: con más de 8 o 10 herramientas el modelo empieza a elegir mal. Arrancá con 2 o 3 y sumá de a poco.

• No limitar las iteraciones: un agente sin tope puede quedarse en loop y consumir tokens sin control. Configurá un máximo de pasos.

• Herramientas que devuelven demasiado texto: si una función retorna 5.000 caracteres, el contexto se llena rápido. Resumí o paginá los resultados.

• Falta de manejo de errores: si una API falla, la herramienta debe devolver un mensaje entendible en lugar de lanzar una excepción que corte el flujo.

• No registrar las trazas: sin logs de qué herramienta llamó el agente y con qué argumentos, depurar es adivinar.

Qué construir después de tu primer agente

Una vez que el ciclo básico funciona, los proyectos que más aprendizaje dejan son estos:

• Un agente que consulta una base de datos SQL y responde preguntas de negocio en lenguaje natural.

• Un agente de soporte que lee documentación interna y responde citando la fuente.

• Un agente que monitorea una casilla de correo, clasifica mensajes y redacta borradores de respuesta.

• Un agente investigador que busca información en la web, la sintetiza y arma un informe.

Cada uno suma una capa nueva: conexión a datos, recuperación de documentos, integración con APIs externas y evaluación de calidad de salida.

Cursos recomendados de Coderhouse

Si querés profundizar en agentes con acompañamiento y proyectos guiados, estos programas cubren distintos niveles:

• Curso de Python — el punto de partida si todavía no tenés base de programación. Sin Python sólido, LangChain se vuelve cuesta arriba.

• Curso de AI Agents — nivel intermedio, enfocado en diseñar, construir y desplegar agentes con herramientas y memoria.

• Curso de AI Engineering — nivel avanzado, para llevar agentes a producción: evaluación, observabilidad, costos y arquitectura.

• Curso de AI Automation — alternativa si te interesa más automatizar procesos que programar desde cero.

Preguntas frecuentes

¿Necesito saber machine learning para usar LangChain?

No. LangChain consume modelos ya entrenados a través de una API, así que no vas a entrenar nada. Lo que sí necesitás es Python intermedio: funciones, clases, manejo de errores y trabajo con entornos virtuales.

¿Cuánto cuesta correr un agente de IA?

Depende del modelo y de la cantidad de iteraciones. Un agente simple con un modelo económico cuesta centavos por consulta, pero un agente que hace 10 llamadas encadenadas con un modelo grande puede multiplicar ese costo por veinte. Medí el consumo de tokens desde el día uno y usá modelos chicos para las tareas rutinarias.

¿LangChain sirve para producción o es solo para prototipos?

Sirve para producción, pero conviene usar LangGraph para la orquestación y sumar observabilidad, límites de iteración y checkpointers persistentes. Muchas empresas corren sistemas de agentes sobre este stack; la diferencia con un prototipo está en el manejo de errores, los tests y el monitoreo, no en el framework.

¿Puedo usar modelos open source en lugar de APIs pagas?

Sí. LangChain integra modelos locales vía Ollama o servidores compatibles. La contra es que los modelos abiertos chicos suelen ser menos confiables eligiendo herramientas, así que vas a necesitar prompts más explícitos y más validación de salidas.

¿Qué diferencia hay entre un agente y una automatización con n8n o Zapier?

Una automatización sigue un flujo fijo que vos definís: si pasa A, hacé B. Un agente decide el camino en tiempo de ejecución según el objetivo. Los agentes ganan cuando las situaciones son variables o ambiguas; las automatizaciones ganan cuando el proceso es estable y predecible, porque son más baratas y auditables.