Cómo Crear Tu Primer Agente de IA: Tutorial Paso a Paso [2026]

1Usuario pide algo
2      ↓
3Agente PIENSA: ¿Qué necesito hacer?
4      ↓
5Agente DECIDE: Usar herramienta X
6      ↓
7Herramienta EJECUTA y devuelve resultado
8      ↓
9Agente EVALÚA: ¿Tengo lo que necesito?
10      ↓
11Si no → Vuelve a PENSAR
12Si sí → RESPONDE al usuario

1# Crear proyecto
2mkdir mi-primer-agente
3cd mi-primer-agente
4 
5# Entorno virtual
6python -m venv venv
7source venv/bin/activate  # Linux/Mac
8# venv\Scripts\activate   # Windows
9 
10# Instalar dependencias
11pip install langchain langchain-openai langchain-community
12pip install duckduckgo-search python-dotenv

1mi-primer-agente/
2├── .env              # API keys
3├── agent.py          # Código principal
4├── tools.py          # Herramientas custom
5└── requirements.txt

1# .env
2OPENAI_API_KEY=sk-tu-api-key-aqui

1"""
2tools.py - Herramientas que el agente puede usar
3"""
4from langchain.tools import tool
5from langchain_community.tools import DuckDuckGoSearchRun
6import math
7 
8# Herramienta 1: Búsqueda en internet
9search = DuckDuckGoSearchRun()
10 
11@tool
12def search_web(query: str) -> str:
13    """
14    Busca información en internet. 
15    Útil para obtener datos actuales, noticias, precios, etc.
16    
17    Args:
18        query: La búsqueda a realizar
19    """
20    return search.run(query)
21 
22@tool
23def calculator(expression: str) -> str:
24    """
25    Realiza cálculos matemáticos.
26    Soporta: +, -, *, /, **, sqrt(), sin(), cos(), etc.
27    
28    Args:
29        expression: La expresión matemática a evaluar (ej: "2 + 2", "sqrt(16)")
30    """
31    try:
32        # Hacer disponibles funciones matemáticas
33        allowed_names = {
34            "sqrt": math.sqrt,
35            "sin": math.sin,
36            "cos": math.cos,
37            "tan": math.tan,
38            "log": math.log,
39            "pi": math.pi,
40            "e": math.e,
41            "abs": abs,
42            "round": round,
43        }
44        result = eval(expression, {"__builtins__": {}}, allowed_names)
45        return f"Resultado: {result}"
46    except Exception as e:
47        return f"Error en el cálculo: {str(e)}"
48 
49@tool
50def run_python(code: str) -> str:
51    """
52    Ejecuta código Python simple.
53    Útil para procesamiento de datos, manipulación de strings, etc.
54    ⚠️ Solo para código seguro y simple.
55    
56    Args:
57        code: Código Python a ejecutar
58    """
59    try:
60        # Entorno restringido para seguridad
61        local_vars = {}
62        exec(code, {"__builtins__": {"print": print, "len": len, "range": range, "str": str, "int": int, "float": float, "list": list, "dict": dict}}, local_vars)
63        
64        # Capturar resultado si hay variable 'result'
65        if 'result' in local_vars:
66            return f"Resultado: {local_vars['result']}"
67        return "Código ejecutado correctamente"
68    except Exception as e:
69        return f"Error: {str(e)}"
70 
71@tool
72def get_current_datetime() -> str:
73    """
74    Obtiene la fecha y hora actual.
75    Útil para saber qué día es, calcular plazos, etc.
76    """
77    from datetime import datetime
78    now = datetime.now()
79    return f"Fecha y hora actual: {now.strftime('%d/%m/%Y %H:%M:%S')}"
80 
81# Lista de todas las herramientas
82all_tools = [search_web, calculator, run_python, get_current_datetime]

1"""
2agent.py - Tu primer agente de IA
3"""
4import os
5from dotenv import load_dotenv
6from langchain_openai import ChatOpenAI
7from langchain.agents import AgentExecutor, create_openai_tools_agent
8from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
9from langchain.memory import ConversationBufferMemory
10 
11from tools import all_tools
12 
13load_dotenv()
14 
15def create_agent():
16    """Crea y configura el agente"""
17    
18    # 1. Configurar el LLM
19    llm = ChatOpenAI(
20        model="gpt-4o-mini",  # Buena relación calidad/precio
21        temperature=0         # Respuestas consistentes
22    )
23    
24    # 2. Definir el prompt del agente
25    prompt = ChatPromptTemplate.from_messages([
26        ("system", """Eres un asistente inteligente con acceso a herramientas.
27 
28REGLAS:
29- Siempre explica brevemente qué vas a hacer antes de usar una herramienta
30- Si no necesitas herramientas, responde directamente
31- Para cálculos, usa la calculadora
32- Para información actual (precios, noticias, datos), busca en internet
33- Sé conciso pero útil
34 
35IMPORTANTE: Piensa paso a paso antes de actuar."""),
36        
37        MessagesPlaceholder(variable_name="chat_history"),
38        ("human", "{input}"),
39        MessagesPlaceholder(variable_name="agent_scratchpad"),
40    ])
41    
42    # 3. Crear el agente
43    agent = create_openai_tools_agent(llm, all_tools, prompt)
44    
45    # 4. Configurar memoria para conversación
46    memory = ConversationBufferMemory(
47        memory_key="chat_history",
48        return_messages=True
49    )
50    
51    # 5. Crear el executor
52    agent_executor = AgentExecutor(
53        agent=agent,
54        tools=all_tools,
55        memory=memory,
56        verbose=True,  # Ver el razonamiento del agente
57        handle_parsing_errors=True,
58        max_iterations=5  # Límite de pasos para evitar loops
59    )
60    
61    return agent_executor
62 
63def chat():
64    """Loop de conversación con el agente"""
65    print("🤖 Agente de IA iniciado. Escribe 'salir' para terminar.\n")
66    print("Puedo buscar en internet, hacer cálculos y ejecutar código Python.\n")
67    
68    agent = create_agent()
69    
70    while True:
71        user_input = input("Tú: ").strip()
72        
73        if user_input.lower() in ['salir', 'exit', 'quit']:
74            print("👋 ¡Hasta luego!")
75            break
76            
77        if not user_input:
78            continue
79        
80        try:
81            response = agent.invoke({"input": user_input})
82            print(f"\n🤖 Agente: {response['output']}\n")
83        except Exception as e:
84            print(f"❌ Error: {str(e)}\n")
85 
86if __name__ == "__main__":
87    chat()

1python agent.py

1🤖 Agente de IA iniciado. Escribe 'salir' para terminar.
2Puedo buscar en internet, hacer cálculos y ejecutar código Python.
3 
4Tú: ¿Cuál es el precio actual del Bitcoin y cuánto sería 0.5 BTC en euros?
5 
6> Entering new AgentExecutor chain...
7Voy a buscar el precio actual del Bitcoin y luego calcular el valor.
8 
9Invoking: `search_web` with `precio Bitcoin EUR hoy`
10 
11Bitcoin price today is $98,234 USD (approximately €91,500 EUR)...
12 
13Ahora calcularé cuánto serían 0.5 BTC:
14 
15Invoking: `calculator` with `91500 * 0.5`
16 
17Resultado: 45750.0
18 
19> Finished chain.
20 
21🤖 Agente: El precio actual de Bitcoin es aproximadamente €91,500 EUR.
220.5 BTC equivaldrían a **€45,750**.
23 
24Tú: Genera una lista de los primeros 10 números de Fibonacci
25 
26> Entering new AgentExecutor chain...
27Voy a usar Python para generar la secuencia de Fibonacci:
28 
29Invoking: `run_python` with `
30def fibonacci(n):
31    fib = [0, 1]
32    for i in range(2, n):
33        fib.append(fib[i-1] + fib[i-2])
34    return fib[:n]
35 
36result = fibonacci(10)
37`
38 
39Resultado: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
40 
41> Finished chain.
42 
43🤖 Agente: Los primeros 10 números de Fibonacci son:
44**0, 1, 1, 2, 3, 5, 8, 13, 21, 34**

1@tool
2def send_email(to: str, subject: str, body: str) -> str:
3    """
4    Envía un email.
5    
6    Args:
7        to: Dirección de email del destinatario
8        subject: Asunto del email
9        body: Contenido del email
10    """
11    # Aquí iría la integración real con Gmail/SMTP
12    # Por seguridad, solo simulamos
13    return f"✅ Email enviado a {to} con asunto: {subject}"

1@tool
2def query_database(query: str) -> str:
3    """
4    Ejecuta una consulta SQL en la base de datos.
5    Tablas disponibles: users, orders, products
6    
7    Args:
8        query: Consulta SQL a ejecutar
9    """
10    # Conexión a tu DB real
11    import sqlite3
12    conn = sqlite3.connect('database.db')
13    cursor = conn.cursor()
14    cursor.execute(query)
15    results = cursor.fetchall()
16    conn.close()
17    return str(results)

1@tool
2def create_file(filename: str, content: str) -> str:
3    """
4    Crea un archivo con el contenido especificado.
5    
6    Args:
7        filename: Nombre del archivo a crear
8        content: Contenido del archivo
9    """
10    with open(f"outputs/{filename}", "w") as f:
11        f.write(content)
12    return f"✅ Archivo {filename} creado correctamente"

1from langgraph.graph import StateGraph, END
2from typing import TypedDict, Annotated
3import operator
4 
5class AgentState(TypedDict):
6    messages: Annotated[list, operator.add]
7    next_action: str
8 
9def research_node(state):
10    """Nodo de investigación"""
11    # Busca información
12    return {"messages": [{"role": "assistant", "content": "Info encontrada..."}]}
13 
14def analyze_node(state):
15    """Nodo de análisis"""
16    # Analiza la información
17    return {"messages": [{"role": "assistant", "content": "Análisis completado..."}]}
18 
19def write_node(state):
20    """Nodo de escritura"""
21    # Genera el output final
22    return {"messages": [{"role": "assistant", "content": "Reporte generado..."}]}
23 
24# Crear grafo
25workflow = StateGraph(AgentState)
26 
27# Añadir nodos
28workflow.add_node("research", research_node)
29workflow.add_node("analyze", analyze_node)
30workflow.add_node("write", write_node)
31 
32# Definir flujo
33workflow.set_entry_point("research")
34workflow.add_edge("research", "analyze")
35workflow.add_edge("analyze", "write")
36workflow.add_edge("write", END)
37 
38# Compilar
39app = workflow.compile()

1agent_executor = AgentExecutor(
2    ...
3    max_iterations=5,  # Límite de iteraciones
4    early_stopping_method="force"  # Forzar parada
5)

1@tool
2def calculator(expression: str) -> str:
3    """
4    SOLO para operaciones matemáticas: suma, resta, multiplicación, división.
5    NO usar para buscar información o datos externos.
6    
7    Ejemplos válidos: "2+2", "100*0.21", "sqrt(16)"
8    """

1("system", """...
2ESTILO DE RESPUESTA:
3- Máximo 3 párrafos
4- Ve al grano
5- Sin introducciones innecesarias
6...""")