Curso para Crear Agentes de AI con LangGraph — Nivel Básico: Primeros Pasos 2026

¿Qué es LangGraph y por qué aprenderlo?

LangGraph es una librería de código abierto desarrollado por LangChain que permite construir agentes de inteligencia artificial con flujos de trabajo complejos , usando gráficos de estado. A diferencia de las cadenas lineales, LangGraph te permite crear agentes que toman decisiones, iteran y manejan múltiples pasos de forma controlada.

Es ideal para construir chatbots avanzados, asistentes autónomos, pipelines de automatización con IA, y mucho más.

---

¿Qué aprenderás en este curso?

• Qué es un agente de IA y cómo funciona
• Conceptos clave de LangGraph: nodos, aristas y estado
• Cómo instalar y configurar el entorno de trabajo
• Crear tu primer agente paso a paso
• Conectar el agente a un modelo de lenguaje (LLM)
• Agregar herramientas al agente
• Ejecutar y probar tu agente

---

Requisitos previos

• Conocimientos básicos de Python (variables, funciones, listas)
• Tener instalado Python 3.10 o superior
• Cuenta en OpenAI o accede a otro LLM compatible
• Ganas de aprender IA aplicada 🚀

---

Módulo 1: Conceptos Fundamentales

¿Qué es un Agente de IA?

Un agente de IA es un sistema que percibe su entorno, toma decisiones y ejecuta acciones para alcanzar un objetivo. A diferencia de un simple chatbot, un agente puede:

• Usar herramientas externas (buscar en internet, ejecutar código, consultar bases de datos)
• Tomar decisiones basadas en el contexto
• Iterar hasta completar una tarea
• Mantener memoria de conversaciones anteriores

¿Qué es un Grafo de Estado?

LangGraph organiza la lógica del agente como un gráfico dirigido , donde:

• Nodos (Nodes): son funciones que procesan información o ejecutan acciones
• Aristas (Edges): son las conexiones entre nodos que definen el flujo
• Estado (State): es el objeto compartido que viaja entre nodos y contiene toda la información del agente

---

Módulo 2: Instalación y Configuración del Entorno

📌 ¿Dónde hago todo esto? Vas a trabajar en la Terminal (también llamada Consola o Línea de Comandos) de tu computador:

• Windows: Presiona Windows + R, escribe cmd y presiona Enter. También puedes buscar "Símbolo del sistema" o instalar Windows Terminal desde la Microsoft Store.
• Mac: Presiona Command + Espacio, escribe Terminal y presiona Enter.
• Linux: Presiona Ctrl + Alt + T para abrir la terminal.

Una vez abierta la terminal, sigue estos pasos en orden:

Paso 1: Crear un entorno virtual

Un entorno virtual es una carpeta aislada donde instalarás las librerías del proyecto sin afectar el resto de tu ordenador. En la terminal, escribe exactamente esto y presiona Enter:

python -m venv agente-env

Luego activa el entorno virtual con este comando según tu sistema operativo:

# En Mac o Linux:
source agente-env/bin/activate

# En Windows:
agente-env\Scripts\activate

✅ Sabrás que está activado porque verás (agente-env) al inicio de la línea en tu terminal.

Paso 2 — Instalar las dependencias

Con el entorno virtual activado, instala todas las librerías necesarias ejecutando este comando en la terminal:

pip install langgraph langchain langchain-openai python-dotenv

Espera a que termine la instalación. Verás mensajes de descarga e instalación: es normal, puede tardar entre 1 y 2 minutos.

Paso 3 — Crea tu carpeta de proyecto y el archivo .env

Ahora abre tu editor de código. Si no tienes uno, descarga Visual Studio Code gratis desde code.visualstudio.com . Luego:

1. Crea una carpeta nueva llamada mi-agente-ia
2. Abre esa carpeta en VS Code
3. Crea un archivo nuevo llamado .env (con el punto al inicio)
4. Dentro del archivo .env escribe esto, reemplazando con tu clave real de OpenAI:

OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxx

📌 ¿Dónde tengo mi API Key de OpenAI? Ingresa a platform.openai.com/api-keys , inicia sesión y crea una nueva clave.

Paso 4 — Crea tu primer archivo Python

En VS Code, crea un archivo nuevo llamado agente.py dentro de tu carpeta. Aquí escribirás todo el código del curso. Para cargar tu clave API en el código, agrega esto al inicio del archivo:

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

---

Módulo 3: Tu Primer Agente con LangGraph

Paso 1 — Definir el Estado del Agente

El estado es el corazón del agente. Define qué información va a manejar:

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_step: str

Paso 2 — Crear los Nodos

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage

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

def agent_node(state: AgentState):
    messages = state["messages"]
    response = llm.invoke(messages)
    return {"messages": [response]}

Paso 3 — Construir el Grafo

workflow = StateGraph(AgentState)
workflow.add_node("agent", agent_node)
workflow.set_entry_point("agent")
workflow.add_edge("agent", END)
app = workflow.compile()

Paso 4 — Ejecutar el Agente

Para ejecutar tu agente, guarda el archivo agente.py y en la terminal (con el entorno virtual activado) escribe:

python agente.py

Agrega este código al final de tu archivo para probarlo:

result = app.invoke({
    "messages": [HumanMessage(content="Hola, ¿qué puedes hacer por mí?")]
})
print(result["messages"][-1].content)

✅ ¡Felicidades! Acabas de crear y ejecutar tu primer agente de IA con LangGraph.

---

Módulo 4: Agregar Herramientas (Tools) al Agente

Paso 1 — Definir una herramienta personalizada

from langchain_core.tools import tool

@tool
def calcular_suma(a: int, b: int) -> int:
    """Suma dos números enteros y retorna el resultado."""
    return a + b

tools = [calcular_suma]

Paso 2 — Vincular las herramientas al LLM

llm_with_tools = llm.bind_tools(tools)

Paso 3 — Actualizar el nodo del agente

def agent_node_with_tools(state: AgentState):
    messages = state["messages"]
    response = llm_with_tools.invoke(messages)
    return {"messages": [response]}

Paso 4 — Agregar un nodo ejecutor de herramientas

from langgraph.prebuilt import ToolNode

tool_node = ToolNode(tools)

def should_use_tools(state: AgentState):
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"
    return END

Paso 5 — Construir el gráfico con herramientas

workflow2 = StateGraph(AgentState)
workflow2.add_node("agent", agent_node_with_tools)
workflow2.add_node("tools", tool_node)
workflow2.set_entry_point("agent")
workflow2.add_conditional_edges(
    "agent",
    should_use_tools,
    {"tools": "tools", END: END}
)
workflow2.add_edge("tools", "agent")
app2 = workflow2.compile()

result2 = app2.invoke({
    "messages": [HumanMessage(content="¿Cuánto es 45 + 78?")]
})
print(result2["messages"][-1].content)

---

Módulo 5: Agregar Memoria al Agente

from langgraph.checkpoint.memory import MemorySaver

memory = MemorySaver()
app_with_memory = workflow2.compile(checkpointer=memory)

config = {"configurable": {"thread_id": "sesion-001"}}

app_with_memory.invoke(
    {"messages": [HumanMessage(content="Mi nombre es Carlos")]},
    config=config
)

result = app_with_memory.invoke(
    {"messages": [HumanMessage(content="¿Cómo me llamo?")]},
    config=config
)
print(result["messages"][-1].content)

---

Resumen del Curso

• ✅ Qué es LangGraph y para qué sirve
• ✅ Los conceptos de nodos, aristas y estado
• ✅ Cómo abrir la terminal e instalar el entorno
• ✅ Crear un agente básico paso a paso
• ✅ Agregar herramientas personalizadas al agente
• ✅ Implementar memoria para conversaciones persistentes

---

Próximos Pasos — Nivel Intermedio

• Agentes multiherramienta con búsqueda web (Tavily, SerpAPI)
• Agentes con acceso a bases de datos y API externas
• Flujos de trabajo paralelos y subgrafos
• Despliegue de agentes con LangGraph Cloud o FastAPI
• Agentes con RAG (Retrieval-Augmented Generation)

¡Sigue practicando y construyendo! La IA aplicada es una de las habilidades más demandadas en 2026. 🚀