Crear tu Primer Agente de IA: Tutorial para Principiantes

Los agentes de IA son probablemente el concepto más interesante que ha salido del mundo de la inteligencia artificial en los últimos dos años. Y también el más malinterpretado.

No estamos hablando de Terminator ni de asistentes que te sustituyen en el trabajo. Un agente de IA es, en esencia, un programa que puede tomar decisiones, usar herramientas y ejecutar tareas de forma autónoma para conseguir un objetivo que tú le defines.

En este tutorial vas a crear tu primer agente de IA funcional. De verdad. Sin necesidad de saber programar (aunque también te enseño cómo hacerlo con código si quieres).

Qué es un Agente de IA (Explicado de Verdad)

Antes de construir nada, necesitas entender qué hace un agente diferente de un simple chatbot.

Un chatbot normal funciona así:

• Tú le preguntas algo
• Él te responde
• Fin

Un agente funciona así:

• Tú le das un objetivo
• Él piensa qué pasos necesita dar
• Usa herramientas (buscar en Google, consultar una base de datos, enviar un email)
• Evalúa el resultado
• Decide si necesita hacer más cosas o si ha terminado
• Te da el resultado final

La diferencia clave es la autonomía. El agente decide qué hacer, en qué orden, y cuándo ha terminado.

Los 4 componentes de un agente

Todo agente de IA tiene estos componentes:

Componente	Qué hace	Ejemplo
LLM (Cerebro)	Razona y toma decisiones	GPT-4, Claude, Llama
Herramientas	Acciones que puede ejecutar	Buscar en web, leer archivos, enviar emails
Memoria	Recuerda contexto e historial	Conversaciones previas, datos obtenidos
Planificación	Descompone tareas en pasos	"Para responder esto, primero necesito buscar X, luego Y"

Sin alguno de estos componentes, no tienes un agente completo. Tienes un chatbot con extras.

Opción A: Crear un Agente con n8n (Sin Código)

n8n es una herramienta de automatización open source que en el último año ha añadido soporte nativo para agentes de IA. Es la forma más fácil de crear tu primer agente sin escribir una línea de código.

Paso 1: Instalar n8n

Tienes dos opciones:

Opción rápida (cloud):

1. Ve a n8n.io
2. Regístrate para una cuenta gratuita
3. Ya tienes n8n funcionando en la nube

Opción local (Docker):

1. Asegúrate de tener Docker instalado
2. Abre tu terminal y ejecuta:

docker run -it --rm --name n8n -p 5678:5678 -v n8n_data:/home/node/.n8n n8nio/n8n

3. Abre http://localhost:5678 en tu navegador
4. Crea tu cuenta de administrador

Pro tip: Si vas en serio con n8n, usa la versión Docker con volumen persistente. La versión cloud tiene limitaciones en el plan gratuito.

Paso 2: Configurar las credenciales de OpenAI

1. Ve a Settings > Credentials en n8n
2. Haz clic en Add Credential
3. Busca OpenAI y selecciónalo
4. Pega tu API Key de OpenAI (la consigues en platform.openai.com)
5. Guarda

Paso 3: Crear el flujo del agente

Ahora viene lo interesante. Vamos a crear un agente que pueda buscar información en internet y responder preguntas con datos actualizados.

1. Crea un nuevo workflow (botón + en la esquina)

2. Añade un nodo "When chat message is received" (es el trigger que activa el agente cuando le hablas)

3. Añade un nodo "AI Agent" y conéctalo al trigger

4. Configura el nodo AI Agent:

   • Agent Type: Tools Agent
   • Model: GPT-4 (o GPT-4o-mini si quieres ahorrar)
   • System Message: "Eres un asistente de investigación. Cuando el usuario te hace una pregunta, buscas información actualizada en internet antes de responder. Siempre citas tus fuentes."

5. Añade herramientas al agente:

   • Haz clic en "Add Tool" dentro del nodo Agent
   • Añade SerpAPI (para buscar en Google) - necesitas una API key gratuita de serpapi.com
   • Añade Wikipedia (para datos enciclopédicos)
   • Añade Calculator (para hacer cálculos)

6. Añade memoria:

   • Dentro del nodo Agent, en la sección Memory
   • Selecciona Window Buffer Memory
   • Configura Context Window Length: 10 (recordará las últimas 10 interacciones)

7. Guarda y activa el workflow

Paso 4: Probar tu agente

1. Haz clic en el botón "Chat" que aparece en la esquina inferior derecha
2. Escribe: "¿Cuántos habitantes tiene Madrid en 2026?"
3. Observa cómo el agente:
   • Decide que necesita buscar en internet
   • Ejecuta una búsqueda en Google
   • Lee los resultados
   • Formula una respuesta con la información encontrada

Felicidades. Acabas de crear tu primer agente de IA. En serio, eso es un agente: un LLM que decide de forma autónoma qué herramientas usar para resolver tu petición.

Opción B: Crear un Agente con LangChain (Python)

Si prefieres código, LangChain es el framework más popular para crear agentes. Más control, más flexibilidad, pero necesitas saber algo de Python.

Paso 1: Preparar el entorno

1. Crea una carpeta para tu proyecto:

mkdir mi-primer-agente
cd mi-primer-agente

2. Crea un entorno virtual:

python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

3. Instala las dependencias:

pip install langchain langchain-openai langchain-community python-dotenv

4. Crea un archivo .env con tu API key:

OPENAI_API_KEY=tu-api-key-aqui

Paso 2: Código del agente básico

Crea un archivo agente.py:

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.tools import DuckDuckGoSearchRun, WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

# Cargar variables de entorno
load_dotenv()

# 1. Definir el LLM (cerebro del agente)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 2. Definir las herramientas
search = DuckDuckGoSearchRun()
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper(lang="es"))
tools = [search, wikipedia]

# 3. Definir el prompt del agente
prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente de investigación útil. "
               "Usa las herramientas disponibles para buscar información "
               "antes de responder. Responde siempre en español."),
    MessagesPlaceholder(variable_name="chat_history", optional=True),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# 4. Crear el agente
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 5. Ejecutar
result = agent_executor.invoke({
    "input": "¿Qué es la fusión nuclear y cuáles son los últimos avances?"
})

print(result["output"])

Paso 3: Ejecutar y observar

python agente.py

Con verbose=True, verás en la consola todo el proceso de razonamiento del agente:

• Qué herramienta decide usar
• Qué búsqueda hace
• Qué resultados obtiene
• Cómo formula la respuesta

Eso es un agente de IA en 30 líneas de código.

Paso 4: Añadir memoria

Para que el agente recuerde conversaciones anteriores:

from langchain.memory import ConversationBufferWindowMemory

# Añadir memoria (recuerda las últimas 5 interacciones)
memory = ConversationBufferWindowMemory(
    memory_key="chat_history",
    return_messages=True,
    k=5
)

# Modificar el executor para usar memoria
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True
)

# Ahora puedes hacer varias preguntas y recordará el contexto
agent_executor.invoke({"input": "Háblame de la IA generativa"})
agent_executor.invoke({"input": "¿Y qué empresas lideran en ese campo?"})

Añadiendo Herramientas Personalizadas

Lo realmente potente de los agentes es que puedes darles herramientas a medida. Veamos cómo crear una herramienta personalizada.

En n8n

1. Crea un nuevo workflow que haga algo específico (por ejemplo, consultar tu base de datos de clientes)
2. Añade un nodo Webhook al inicio
3. Configura la lógica que necesites (consulta SQL, API externa, etc.)
4. En tu agente, añade la herramienta "HTTP Request" apuntando al webhook de tu workflow
5. Describe la herramienta en el campo "Description" para que el agente sepa cuándo usarla

En LangChain

from langchain.tools import tool

@tool
def consultar_stock(producto: str) -> str:
    """Consulta el stock disponible de un producto en el inventario.
    Úsala cuando el usuario pregunte por disponibilidad de productos."""
    # Aquí irías a tu base de datos real
    inventario = {
        "laptop pro": 15,
        "teclado mecánico": 42,
        "monitor 4k": 8
    }
    stock = inventario.get(producto.lower(), None)
    if stock is not None:
        return f"Hay {stock} unidades de '{producto}' en stock."
    return f"No se encontró el producto '{producto}' en el inventario."

# Añade la herramienta a la lista
tools = [search, wikipedia, consultar_stock]

La clave está en la docstring del decorador @tool. El agente lee esa descripción para decidir cuándo usar la herramienta. Sé claro y específico.

Patrones Comunes de Agentes

Ahora que sabes crear un agente básico, estos son los patrones más útiles que puedes implementar:

1. Agente de Investigación

• Herramientas: Búsqueda web, Wikipedia, lectura de URLs
• Uso: Investigar un tema, recopilar datos, generar un informe
• Ejemplo: "Investiga las últimas tendencias en energías renovables en España y genera un resumen ejecutivo"

2. Agente de Datos

• Herramientas: SQL, pandas, calculadora
• Uso: Analizar datos, generar estadísticas, crear informes
• Ejemplo: "Analiza las ventas del último trimestre y dime qué productos están cayendo"

3. Agente de Automatización

• Herramientas: Email, Slack, calendarios, CRM
• Uso: Ejecutar flujos de trabajo complejos
• Ejemplo: "Cuando llegue un lead nuevo, investiga la empresa, personaliza un email y envíalo"

4. Agente de Soporte

• Herramientas: Base de conocimiento (RAG), ticketing, escalado humano
• Uso: Responder consultas de clientes con información actualizada
• Ejemplo: "Responde preguntas de clientes usando nuestra documentación interna"

Patrón	Complejidad	Mejor herramienta	Tiempo de setup
Investigación	Baja	n8n o LangChain	30 min
Datos	Media	LangChain	1-2 horas
Automatización	Media	n8n	1-2 horas
Soporte	Alta	LangChain + RAG	3-5 horas

Errores Comunes al Crear Agentes

Después de crear bastantes agentes, estos son los errores que más veo:

Darle demasiadas herramientas. Un agente con 20 herramientas se confunde. Empieza con 2-3 herramientas bien definidas y ve añadiendo según necesites. Menos es más.

No limitar los loops. Un agente puede entrar en un bucle infinito si no encuentra la respuesta. Siempre pon un límite de iteraciones (max_iterations=10 en LangChain, timeout en n8n).

Descripciones vagas de herramientas. Si la descripción de la herramienta no es clara, el agente no sabrá cuándo usarla. Describe exactamente qué hace y cuándo debe usarse.

No manejar errores. Las herramientas pueden fallar (APIs caídas, timeouts). Tu agente necesita saber qué hacer cuando algo falla. Añade mensajes de error informativos.

Usar un modelo barato para tareas complejas. GPT-3.5-turbo es malo tomando decisiones de herramientas. Para agentes, usa GPT-4o-mini como mínimo, o GPT-4o si necesitas razonamiento complejo.

Pro tip: Empieza con verbose=True siempre. Ver el razonamiento del agente te ayuda a entender qué está haciendo mal y cómo mejorar tus prompts y herramientas.

Siguientes Pasos

Ya tienes tu primer agente funcionando. Ahora qué:

1. Añade herramientas específicas para tu caso de uso. ¿Tienes un ecommerce? Conecta tu inventario. ¿Una agencia? Conecta las APIs de tus clientes.

2. Experimenta con el system prompt. El comportamiento del agente cambia radicalmente según las instrucciones que le des. Sé específico sobre cuándo usar cada herramienta.

3. Añade RAG para que tu agente pueda consultar tus documentos internos. Esto convierte un agente genérico en uno que conoce tu negocio.

4. Implementa logging. Registra todas las decisiones y acciones del agente para poder depurar cuando algo no funcione como esperas.

5. Prueba con usuarios reales (aunque sea uno o dos). Los patrones de uso real siempre son diferentes a los que imaginas.

Los agentes de IA son una de las áreas con más potencial en inteligencia artificial. Y ahora ya sabes cómo construir uno. El siguiente paso es encontrar un problema real que resolver y construir un agente específico para ello.

No necesitas crear el agente perfecto a la primera. Necesitas crear uno que funcione y mejorarlo desde ahí.