Crear un agente de IA con código: tutorial con Python, LangChain y MCP

Un agente de IA es un programa que recibe un objetivo, decide por sí mismo qué pasos dar, usa herramientas (buscar en internet, consultar una base de datos, enviar un email) y repite el ciclo hasta considerar la tarea terminada. La diferencia con un chatbot es la autonomía: al chatbot le preguntas, el agente actúa.

En este tutorial vas a crear tu primer agente funcional. De verdad, hoy, en menos de una hora. Te enseño las dos vías: sin escribir código con n8n, y con Python y LangChain si prefieres control total.

No estamos hablando de Terminator ni de asistentes que te sustituyen en el trabajo. Estamos hablando de un patrón de software muy concreto que puedes montar esta tarde.

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.

Chatbot, asistente, automatización y agente: la tabla que aclara la confusión

Estos cuatro términos se usan como sinónimos en las notas de prensa y no lo son. Esta es la diferencia real:

	Chatbot	Asistente	Automatización clásica	Agente
Quién decide los pasos	Nadie: responde y ya	El humano, en cada mensaje	El humano, al diseñar el flujo	El propio modelo, en tiempo real
Usa herramientas	No, o muy limitado	A veces, si se lo pides	Sí, pero fijas y en orden fijo	Sí, y elige cuáles y cuándo
Se adapta a lo imprevisto	No	Poco	No: si cambia algo, se rompe	Sí, replanifica
Ejemplo	El chat de una web con FAQs	ChatGPT respondiéndote	Un flujo de Zapier	Claude Code arreglando un fallo
Riesgo	Bajo	Bajo	Bajo	Alto: puede hacer cosas que no esperabas

Esa última fila es la que nadie pone y la más importante. La autonomía es potencia y es riesgo a partes iguales: un agente con permisos de escritura puede borrar, enviar o publicar cosas que no querías. Volveré sobre esto.

Si quieres el panorama completo del concepto antes de programar, lo tengo en agentes de IA.

Los 4 componentes de un agente

Todo agente de IA tiene estos componentes:

Componente	Qué hace	Ejemplo
LLM (Cerebro)	Razona y toma decisiones	GPT-5.6, Claude Opus 5 o Sonnet 5, Gemini 3.x
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 con 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 y usa la prueba 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. Es gratuita para uso interno de tu negocio y no tiene límite de ejecuciones.

Paso 2: configurar las credenciales del modelo

1. Ve a Settings > Credentials en n8n
2. Haz clic en Add Credential
3. Busca el proveedor que vayas a usar (OpenAI, Anthropic o Google) y selecciónalo
4. Pega tu API key
5. Guarda

Si nunca has sacado una clave de API, el proceso está explicado paso a paso en el tutorial de la API de OpenAI. Y pon un límite de gasto mensual desde el primer día: un agente en bucle puede consumir bastante más de lo que esperas.

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: el modelo de gama media o económica de tu proveedor. Para agentes, no bajes al modelo más barato de todos: elegir herramientas es justo donde peor rinden
   • 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 una herramienta de búsqueda web (SerpAPI, Tavily o Brave Search; todas tienen plan gratuito para empezar)
   • 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
   • 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 sigue siendo el framework más extendido 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

Aviso de versiones: LangChain reorganiza su API cada pocos meses y mueve clases entre paquetes. Si al ejecutar ves avisos de deprecación o errores de importación, consulta la documentación de la versión que tengas instalada: la estructura conceptual del agente no cambia, los nombres sí.

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

load_dotenv()

MODELO = "PON-AQUI-EL-MODELO-VIGENTE"  # ver documentación del proveedor

#1. Definir el LLM (cerebro del agente)
llm = ChatOpenAI(model=MODELO, 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,
    max_iterations=10,       # nunca lo dejes sin límite
)

#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,
    max_iterations=10,
)

#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.

La vía moderna: conectar herramientas con MCP

Desde 2025 existe una forma estándar de darle herramientas a un agente sin programar cada integración: el Model Context Protocol. En lugar de escribir una función para cada sistema, conectas un servidor MCP —los hay oficiales para GitHub, Slack, bases de datos, Google Drive, Stripe, Notion y cientos más— y el agente descubre solo qué puede hacer con él.

Es el cambio más relevante de los dos últimos años en este terreno, y ya no es una apuesta: el protocolo lo gobierna la Linux Foundation y lo soportan OpenAI, Google y Microsoft. Tanto n8n como los frameworks de Python tienen nodos y clientes MCP. Lo explico entero en qué es MCP.

Mi recomendación práctica: si la herramienta que necesitas ya tiene servidor MCP oficial, úsalo y no escribas código. Reserva las herramientas a medida para tu lógica de negocio propia.

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, y cada vuelta te cuesta dinero. Siempre pon un límite de iteraciones (max_iterations en LangChain, timeout en n8n) y un tope de gasto en la cuenta del proveedor.

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 demasiado barato. La elección de herramientas es exactamente donde peor rinden los modelos pequeños: se lían, llaman a la herramienta equivocada o entran en bucle. Para agentes usa gama media como mínimo, y reserva el modelo tope para las tareas que de verdad razonan.

Darle permisos de escritura sin confirmación humana. Este es el error caro. Leer es barato de equivocarse; enviar, borrar, publicar o pagar no lo es. En 2026 los reguladores europeos ya han investigado casos de modelos ejecutando acciones no autorizadas al operar con autonomía. Pon una confirmación humana en todo lo irreversible y registra cada acción del agente.

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. Y comprueba antes si existe un servidor MCP oficial que te ahorre el trabajo.

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: el paso a paso está en cómo crear una base de conocimiento con IA.

4. Implementa logging. Registra todas las decisiones y acciones del agente para poder depurar cuando algo no funcione como esperas. En cuanto el agente toque sistemas reales, esto deja de ser opcional.

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

Si lo que quieres es llevarlo a producción en una empresa —con permisos, control de costes y responsables definidos—, el enfoque de negocio lo desarrollo en cómo crear un agente de IA.

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í.

Preguntas frecuentes

¿Cómo se crea un agente de IA paso a paso?

Necesitas cuatro piezas: un modelo de lenguaje que razona, un conjunto de herramientas que puede ejecutar, memoria para recordar el hilo y un límite de iteraciones. En n8n se monta con el nodo AI Agent, un modelo, dos o tres herramientas y memoria de ventana. En Python, con LangChain son unas treinta líneas.

¿Cuánto cuesta crear un agente de IA?

El montaje puede costarte cero: n8n autoalojado es gratis y las librerías de Python también. Lo que se paga es el consumo de la API, del orden de céntimos por tarea con modelos de gama media. Un agente de uso interno moderado se mueve en decenas de euros al mes; un agente en bucle sin límite de iteraciones puede ponerse en cientos en una noche.

¿Qué diferencia hay entre un agente de IA y un chatbot?

El chatbot responde a lo que le preguntas y ahí acaba su trabajo. El agente recibe un objetivo, decide qué pasos dar, ejecuta acciones con herramientas reales, comprueba el resultado y sigue hasta terminar. Dicho corto: el chatbot habla, el agente hace.

¿Se puede crear un agente de IA sin saber programar?

Sí. Con n8n arrastras un nodo de agente, le enchufas un modelo, le añades herramientas de una lista y tienes un agente funcional en menos de una hora. También sirven Dify, Flowise o las funciones de agente de las plataformas de chatbot. El código solo hace falta cuando necesitas lógica de negocio propia.

¿Qué modelo es mejor para un agente de IA?

Los que mejor eligen herramientas hoy son la familia Claude de Anthropic, GPT-5.x de OpenAI y Gemini 3.x de Google, en su gama media o alta. El error clásico es tirar del modelo más barato para ahorrar: en tareas de agente se confunden de herramienta y acaban costando más en reintentos de lo que ahorran por token.

¿Qué herramientas le puedo dar a un agente?

Búsqueda web, Wikipedia, calculadora, lectura y escritura de archivos, consultas SQL, envío de correos, APIs de tu CRM o de tu tienda, y cualquier función propia que programes. Desde 2025 la vía estándar es conectar servidores MCP, que ya existen para GitHub, Slack, Drive, Stripe, Notion y cientos de servicios más.

¿Es seguro dejar que un agente actúe solo?

Depende de qué le dejes tocar. Leer información es de bajo riesgo; enviar, borrar, publicar o pagar no lo es. Las tres medidas mínimas: permisos de solo lectura por defecto, confirmación humana obligatoria en todo lo irreversible y registro completo de cada acción para poder revisarla después.

¿Cuánto se tarda en montar un agente de IA?

Un agente de investigación que busca en internet y responde, media hora. Un agente conectado a tus sistemas con permisos y control de errores, entre uno y cinco días según lo enredada que esté tu infraestructura. Lo que más tiempo consume no es el agente: son las integraciones.

¿Por qué mi agente entra en bucle o llama a la herramienta equivocada?

Casi siempre por una de tres razones: le has dado demasiadas herramientas y no distingue entre ellas, las descripciones de las herramientas son vagas, o el modelo es demasiado pequeño para la tarea. Empieza reduciendo a dos o tres herramientas con descripciones muy explícitas y sube de modelo antes de tocar nada más.

¿Los agentes de IA sirven para una pyme?

Sí, en casos acotados y con supervisión. Los que mejor funcionan: cualificar leads que entran por la web, preparar informes recurrentes cruzando datos de varios sistemas y resolver consultas internas sobre documentación. Lo que no recomiendo todavía es dejarlos ejecutar acciones sobre clientes o dinero sin que alguien confirme.