1Usuario: "Investiga las últimas noticias sobre OpenAI y
2         escribe un resumen de 3 párrafos"
3 
4Agente piensa: "Necesito buscar noticias recientes"
5    ↓
6Agente usa: Tool "web_search" con query "OpenAI news 2026"
7    ↓
8Agente recibe: [Resultados de búsqueda]
9    ↓
10Agente piensa: "Tengo info, ahora debo resumir"
11    ↓
12Agente escribe: [Resumen de 3 párrafos]

1┌─────────────────────────────────────────────────┐
2│                    AGENTE                        │
3├─────────────────────────────────────────────────┤
4│                                                  │
5│  ┌──────────┐    ┌──────────┐    ┌──────────┐  │
6│  │   LLM    │    │  Tools   │    │  Memory  │  │
7│  │ (cerebro)│    │(acciones)│    │(contexto)│  │
8│  └────┬─────┘    └────┬─────┘    └────┬─────┘  │
9│       │               │               │         │
10│       └───────────────┴───────────────┘         │
11│                       │                         │
12│               ┌───────┴───────┐                 │
13│               │ Agent Loop    │                 │
14│               │ (ReAct/LCEL)  │                 │
15│               └───────────────┘                 │
16└─────────────────────────────────────────────────┘

11. THOUGHT: Pensar qué hacer
22. ACTION: Elegir tool y parámetros
33. OBSERVATION: Ver resultado del tool
44. Repetir hasta: tener respuesta final
55. FINAL ANSWER: Responder al usuario

1pip install langchain langchain-openai langchain-community

1from langchain_openai import ChatOpenAI
2from langchain.agents import AgentExecutor, create_react_agent
3from langchain_community.tools import DuckDuckGoSearchRun
4from langchain import hub
5 
6# 1. Configurar LLM
7llm = ChatOpenAI(model="gpt-4o", temperature=0)
8 
9# 2. Definir tools
10search = DuckDuckGoSearchRun()
11tools = [search]
12 
13# 3. Cargar prompt de agente ReAct
14prompt = hub.pull("hwchase17/react")
15 
16# 4. Crear agente
17agent = create_react_agent(llm, tools, prompt)
18 
19# 5. Crear executor
20agent_executor = AgentExecutor(
21    agent=agent,
22    tools=tools,
23    verbose=True,  # Ver el razonamiento
24    max_iterations=5
25)
26 
27# 6. Ejecutar
28response = agent_executor.invoke({
29    "input": "¿Cuáles son las últimas noticias sobre IA en España?"
30})
31 
32print(response["output"])

1> Entering new AgentExecutor chain...
2Thought: Necesito buscar noticias recientes sobre IA en España.
3Action: duckduckgo_search
4Action Input: "noticias inteligencia artificial España 2026"
5Observation: [Resultados de búsqueda...]
6 
7Thought: Tengo información relevante. Voy a resumir los puntos principales.
8Final Answer: Las últimas noticias sobre IA en España incluyen:
91. [Noticia 1]
102. [Noticia 2]
113. [Noticia 3]
12 
13> Finished chain.

1from langchain.tools import tool
2 
3@tool
4def calcular_precio(cantidad: int, precio_unitario: float) -> float:
5    """
6    Calcula el precio total de una compra.
7    Args:
8        cantidad: Número de unidades
9        precio_unitario: Precio por unidad
10    Returns:
11        Precio total
12    """
13    return cantidad * precio_unitario
14 
15# Usar en agente
16tools = [calcular_precio, search]

1import requests
2from langchain.tools import tool
3 
4@tool
5def obtener_clima(ciudad: str) -> str:
6    """
7    Obtiene el clima actual de una ciudad.
8    Args:
9        ciudad: Nombre de la ciudad
10    Returns:
11        Descripción del clima actual
12    """
13    api_key = "tu-api-key"
14    url = f"https://api.weatherapi.com/v1/current.json?key={api_key}&q={ciudad}"
15 
16    response = requests.get(url)
17    data = response.json()
18 
19    return f"En {ciudad}: {data['current']['condition']['text']}, {data['current']['temp_c']}°C"

1from langchain.tools import tool
2import sqlite3
3 
4@tool
5def consultar_productos(categoria: str) -> str:
6    """
7    Busca productos en la base de datos por categoría.
8    Args:
9        categoria: Categoría de productos a buscar
10    Returns:
11        Lista de productos encontrados
12    """
13    conn = sqlite3.connect("productos.db")
14    cursor = conn.cursor()
15 
16    cursor.execute(
17        "SELECT nombre, precio FROM productos WHERE categoria = ?",
18        (categoria,)
19    )
20    resultados = cursor.fetchall()
21    conn.close()
22 
23    if not resultados:
24        return f"No se encontraron productos en la categoría '{categoria}'"
25 
26    return "\n".join([f"- {nombre}: €{precio}" for nombre, precio in resultados])

1@tool
2def enviar_email(destinatario: str, asunto: str, cuerpo: str) -> str:
3    """Envía un email."""
4    # Implementación...
5    return f"Email enviado a {destinatario}"
6 
7@tool
8def crear_evento_calendario(titulo: str, fecha: str, hora: str) -> str:
9    """Crea un evento en Google Calendar."""
10    # Implementación...
11    return f"Evento '{titulo}' creado para {fecha} a las {hora}"
12 
13@tool
14def buscar_en_documentos(query: str) -> str:
15    """Busca información en los documentos internos de la empresa."""
16    # Implementación con RAG...
17    return "Resultados relevantes..."
18 
19tools = [
20    search,
21    enviar_email,
22    crear_evento_calendario,
23    buscar_en_documentos,
24    calcular_precio,
25    obtener_clima
26]

1from langchain.memory import ConversationBufferMemory
2 
3# Memoria que guarda el historial completo
4memory = ConversationBufferMemory(
5    memory_key="chat_history",
6    return_messages=True
7)
8 
9# Incluir en el executor
10agent_executor = AgentExecutor(
11    agent=agent,
12    tools=tools,
13    memory=memory,
14    verbose=True
15)
16 
17# Primera interacción
18agent_executor.invoke({"input": "Me llamo Carlos"})
19 
20# El agente recuerda
21agent_executor.invoke({"input": "¿Cómo me llamo?"})
22# Output: "Te llamas Carlos"

1from langchain.memory import ConversationBufferWindowMemory
2 
3# Solo guarda los últimos N intercambios
4memory = ConversationBufferWindowMemory(
5    k=5,  # Últimas 5 conversaciones
6    memory_key="chat_history",
7    return_messages=True
8)

1from langchain.memory import ConversationSummaryMemory
2 
3# Resume conversaciones largas automáticamente
4memory = ConversationSummaryMemory(
5    llm=llm,
6    memory_key="chat_history"
7)

1from langchain.memory import RedisChatMessageHistory
2from langchain.memory import ConversationBufferMemory
3 
4# Memoria que persiste en Redis
5message_history = RedisChatMessageHistory(
6    url="redis://localhost:6379/0",
7    session_id="user-123"
8)
9 
10memory = ConversationBufferMemory(
11    chat_memory=message_history,
12    memory_key="chat_history",
13    return_messages=True
14)

1from langchain_openai import ChatOpenAI
2from langchain.agents import AgentExecutor, create_openai_functions_agent
3from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
4 
5# Prompt personalizado
6prompt = ChatPromptTemplate.from_messages([
7    ("system", """Eres un asistente personal inteligente.
8 
9Tienes acceso a las siguientes herramientas:
10- Búsqueda web para información actualizada
11- Calendario para gestionar eventos
12- Email para enviar mensajes
13- Base de datos de documentos internos
14 
15Siempre:
161. Piensa qué herramientas necesitas
172. Ejecuta las acciones necesarias
183. Proporciona respuestas claras y útiles
19 
20Fecha actual: {current_date}
21"""),
22    MessagesPlaceholder(variable_name="chat_history"),
23    ("human", "{input}"),
24    MessagesPlaceholder(variable_name="agent_scratchpad"),
25])
26 
27# Crear agente con function calling (más preciso)
28agent = create_openai_functions_agent(llm, tools, prompt)
29 
30agent_executor = AgentExecutor(
31    agent=agent,
32    tools=tools,
33    memory=memory,
34    verbose=True,
35    handle_parsing_errors=True
36)

1# El agente puede encadenar múltiples herramientas
2response = agent_executor.invoke({
3    "input": """
4    Necesito preparar la reunión con el cliente de mañana:
5    1. Busca información sobre su empresa (TechCorp)
6    2. Revisa si tenemos documentos previos sobre ellos
7    3. Crea un evento en el calendario para mañana a las 10:00
8    4. Envía un email de confirmación a cliente@techcorp.com
9    """,
10    "current_date": "2026-02-02"
11})

1> Entering new AgentExecutor chain...
2 
3Invoking: search with {'query': 'TechCorp empresa información'}
4[Resultados de búsqueda...]
5 
6Invoking: buscar_en_documentos with {'query': 'TechCorp cliente'}
7"Encontré 3 documentos: propuesta_2025.pdf, contrato_2024.pdf..."
8 
9Invoking: crear_evento_calendario with {'titulo': 'Reunión TechCorp', 'fecha': '2026-02-03', 'hora': '10:00'}
10"Evento creado correctamente"
11 
12Invoking: enviar_email with {'destinatario': 'cliente@techcorp.com', 'asunto': 'Confirmación reunión mañana', 'cuerpo': '...'}
13"Email enviado"
14 
15Final Answer: He preparado todo para la reunión:
161. TechCorp es una empresa de tecnología fundada en 2015...
172. Encontré documentos previos: propuesta y contrato de años anteriores
183. Evento creado: "Reunión TechCorp" mañana a las 10:00
194. Email de confirmación enviado al cliente
20 
21> Finished chain.

1from langchain.agents import AgentExecutor
2from langgraph.graph import StateGraph
3 
4# Definir agentes especializados
5researcher_agent = create_agent(llm, [search], "Investigador")
6writer_agent = create_agent(llm, [write_file], "Escritor")
7reviewer_agent = create_agent(llm, [review_tool], "Revisor")
8 
9# Supervisor que coordina
10def supervisor_node(state):
11    """Decide qué agente debe actuar"""
12    messages = state["messages"]
13    last_message = messages[-1]
14 
15    # Lógica de routing
16    if "investigar" in last_message.lower():
17        return "researcher"
18    elif "escribir" in last_message.lower():
19        return "writer"
20    elif "revisar" in last_message.lower():
21        return "reviewer"
22    else:
23        return "end"
24 
25# Crear grafo de agentes
26workflow = StateGraph(AgentState)
27workflow.add_node("supervisor", supervisor_node)
28workflow.add_node("researcher", researcher_agent)
29workflow.add_node("writer", writer_agent)
30workflow.add_node("reviewer", reviewer_agent)
31 
32# Definir transiciones
33workflow.add_edge("supervisor", "researcher")
34workflow.add_edge("researcher", "supervisor")
35workflow.add_edge("supervisor", "writer")
36workflow.add_edge("writer", "supervisor")
37workflow.add_edge("supervisor", "reviewer")
38workflow.add_edge("reviewer", "end")
39 
40app = workflow.compile()

1result = app.invoke({
2    "messages": ["Investiga sobre IA generativa, escribe un artículo, y revísalo"]
3})
4 
5# El supervisor coordina:
6# 1. researcher investiga
7# 2. writer escribe basándose en la investigación
8# 3. reviewer revisa y sugiere mejoras

1from fastapi import FastAPI
2from pydantic import BaseModel
3 
4app = FastAPI()
5 
6class Query(BaseModel):
7    input: str
8    user_id: str
9 
10@app.post("/agent")
11async def run_agent(query: Query):
12    # Obtener memoria del usuario
13    memory = get_user_memory(query.user_id)
14 
15    executor = AgentExecutor(
16        agent=agent,
17        tools=tools,
18        memory=memory,
19        max_iterations=10,
20        early_stopping_method="generate"
21    )
22 
23    try:
24        result = executor.invoke({"input": query.input})
25        return {"response": result["output"], "success": True}
26    except Exception as e:
27        return {"error": str(e), "success": False}

1agent_executor = AgentExecutor(
2    agent=agent,
3    tools=tools,
4    verbose=True,
5    max_iterations=10,  # Evitar loops infinitos
6    max_execution_time=60,  # Timeout de 60 segundos
7    handle_parsing_errors=True,  # Recuperarse de errores de parsing
8    early_stopping_method="generate"  # Generar respuesta si se alcanza límite
9)

1from langchain.callbacks import FileCallbackHandler
2from langchain.callbacks.manager import CallbackManager
3 
4# Log a archivo
5file_handler = FileCallbackHandler("agent_logs.txt")
6callback_manager = CallbackManager([file_handler])
7 
8agent_executor = AgentExecutor(
9    agent=agent,
10    tools=tools,
11    callbacks=callback_manager
12)