Cómo crear un agente de IA con Python desde cero

Un agente de IA no es un chatbot con mejor tono: es un programa que decide qué hacer para completar una tarea. La diferencia práctica está en el bucle: el modelo recibe una petición, decide si necesita llamar una herramienta (consultar una base, calcular, buscar), ejecuta esa llamada, recibe el resultado y vuelve a razonar hasta terminar. Esa mecánica se puede escribir en Python con unas cuantas líneas, sin frameworks. Esta guía te lleva desde pip install hasta un agente con tool calling, memoria simple y criterios claros para saber cuándo conviene pasar a un framework.

Qué es un agente (y qué no es)

Un chatbot responde: recibe un mensaje y devuelve texto. Un agente actúa: tiene herramientas, las elige según la tarea y encadena pasos hasta producir un resultado. La pieza central es el agente loop: enviar el mensaje, inspeccionar la respuesta, ejecutar las herramientas que el modelo pidió y repetir hasta que el modelo decida terminar.

Sin ese bucle tienes un chat bonito. Con el bucle tienes algo que resuelve tareas: responder con datos reales de tu base, enviar correos, generar reportes. La buena noticia: el bucle son unas veinte líneas.

Paso 1: entorno y dependencias

Usa un entorno virtual para no contaminar tu Python del sistema y una API que soporte tool calling (OpenAI, Anthropic, Gemini; este ejemplo usa OpenAI).

python3 -m venv .venv
source .venv/bin/activate
pip install openai

Guarda tu clave como variable de entorno, nunca en el código:

export OPENAI_API_KEY="tu-clave"

Paso 2: la primera llamada

from openai import OpenAI

client = OpenAI()

respuesta = client.responses.create(
    model="gpt-4.1-mini",
    input="Escribe una frase de bienvenida para un agente de soporte.",
)
print(respuesta.output_text)

Si esto corre, tienes el 30% del camino. El resto es darle al modelo la capacidad de hacer cosas, no solo de hablar.

Paso 3: el bucle del agente con tool calling

Defines una función de Python y se la describes al modelo con un schema JSON: nombre, descripción y argumentos. Cuando la tarea lo requiera, el modelo devuelve una llamada estructurada a esa herramienta en lugar de texto; tu código la ejecuta y devuelve el resultado al modelo.

import json
from openai import OpenAI

client = OpenAI()

def consultar_stock(sku: str) -> str:
    # En producción esto consulta tu base o tu ERP
    stock = {"A-100": 23, "B-200": 4, "C-300": 0}
    return json.dumps({"sku": sku, "stock": stock.get(sku, 0)})

tools = [{
    "type": "function",
    "name": "consultar_stock",
    "description": "Consulta el stock disponible de un producto por su SKU",
    "parameters": {
        "type": "object",
        "properties": {"sku": {"type": "string"}},
        "required": ["sku"],
    },
}]

mensajes = [{"role": "user", "content": "¿Cuántas unidades hay del A-100?"}]

while True:
    respuesta = client.responses.create(
        model="gpt-4.1-mini",
        input=mensajes,
        tools=tools,
    )
    if respuesta.output:
        llamadas = [o for o in respuesta.output if o.type == "function_call"]
        if llamadas:
            for llamada in llamadas:
                argumentos = json.loads(llamada.arguments)
                resultado = consultar_stock(argumentos["sku"])
                mensajes.append({
                    "role": "user",
                    "content": [
                        {
                            "type": "function_call_output",
                            "call_id": llamada.call_id,
                            "output": resultado,
                        }
                    ],
                })
            continue
        print(respuesta.output_text)
        break

Eso es el agente. Observa el patrón: el modelo no ejecuta nada, solo pide; tu código ejecuta y devuelve. Por eso las herramientas son seguras: tú controlas qué se ejecuta, con qué permisos y qué se registra.

Paso 4: memoria simple

La memoria mínima es el historial de mensajes: cada turno envía todo lo anterior para que el modelo tenga contexto. Funciona hasta que el historial crece y el costo y la latencia suben. Dos técnicas para controlarlo:

• Poda: conservar los últimos N mensajes y resumir los antiguos en un párrafo que se reinyecta como contexto.
• Memoria por tarea: guardar en un archivo o base los hechos relevantes (preferencias, IDs, decisiones) y cargarlos solo cuando la tarea los necesita, en lugar de arrastrar toda la conversación.

Para un primer agente, la poda simple es suficiente: si el historial supera un límite, resumir con el mismo modelo y seguir. Más adelante puedes migrar a memoria vectorial o a una base real cuando el volumen lo justifique.

Cuándo pasar a un framework

Tu bucle manual está bien para aprender y para agentes simples. Cuando empieces a necesitar paralelismo, herramientas que se llaman entre sí, reintentos, guardado de estado o supervisión, un framework te ahorra reescribir lo que ya está resuelto:

• OpenAI Agents SDK: el mismo stack de OpenAI con agentes declarativos, handoffs y guardrails; natural si ya usas la API de OpenAI.
• LangChain/LangGraph: ecosistema amplio de integraciones y grafos de agentes.
• n8n o Make: si no quieres mantener código, el agente vive en un flujo visual con el mismo concepto de herramientas.

La regla práctica: empieza manual para entender el bucle, migra al framework cuando el segundo agente del proyecto llegue, no antes. El curso gratuito de instalación te deja el primer agente funcionando con el framework de OpenAI para comparar ambos estilos, y la guía de function calling para agentes confiables cubre los errores de diseño de herramientas que debes evitar desde el día uno.

Verificación de tu agente

1. El agente responde con datos reales de la herramienta, no inventados.
2. El bucle termina: el modelo deja de llamar herramientas cuando la tarea está completa.
3. Los errores de la herramienta se devuelven al modelo como texto (así puede corregirse o pedir datos faltantes).
4. El historial no crece sin límite: poda o resumen funcionando.
5. La clave de API vive en el entorno, nunca en el repositorio.

Con eso tienes un agente real en Python, sin magia ni frameworks ocultos. El siguiente paso natural es conectarle más herramientas vía MCP: la guía de MCP con Python para conectar APIs y bases de datos muestra cómo exponer tus sistemas existentes como herramientas sin reescribirlos. Y para el resto del camino hacia producción, el hub de guías de construcción de agentes reúne arquitectura, memoria, RAG y despliegue en un solo lugar.