Desarrollo de agentes de IA personalizados utilizando Gemini 3 Pro

Por ahora, a principios de 2026, la industria ha superado definitivamente la fase del "chatbot". Ya no estamos pidiendo a los Grandes Modelos de Lenguaje (LLMs) que simplemente conversar; en cambio, les estamos pidiendo que hacer. Para los directores técnicos y ingenieros senior, el enfoque se ha desplazado del diseño de prompts al desarrollo de "agentes de IA personalizados" —crear sistemas deterministas y fiables donde modelos como Gemini 3 Pro actúan como el motor de razonamiento detrás de complejas operaciones comerciales.Desarrollo de agentes de IA personalizados—crear sistemas deterministas y fiables en los que modelos como Gemini 3 Pro actúen como el motor de razonamiento detrás de flujos de trabajo empresariales complejos.

El lanzamiento de Gemini 3 Pro ha simplificado esto significativamente. A diferencia de las versiones anteriores que requerían una importante infraestructura intermedia para gestionar los esquemas de herramientas (las definiciones JSON de lo que un modelo puede hacer), el SDK moderno google-genai combinado con las capacidades de razonamiento nativas de Gemini 3 permite una toma de decisiones con "casi cero latencia".

En este artículo, construiremos un agente autónomo totalmente funcional que pueda interactuar con una base de datos local y realizar acciones externas (simuladas como el envío de correos electrónicos), demostrando los patrones arquitectónicos necesarios para sistemas de agentes a nivel empresarial.

La Arquitectura de un Agente Moderno

Antes de escribir código, debemos comprender el concepto de "Bucle" que distingue una llamada estándar de la API de un Agente.

En una configuración tradicional de RAG (Generación con Augmentación de Recuperación), el flujo es lineal: Entrada -> Recuperar -> Respuesta.

En una configuración con agentes, el flujo es circular y tiene estado:

1. Observación: El usuario proporciona la entrada ("Encontrar las facturas pendientes y enviar correos electrónicos a los clientes").
2. Razonamiento (El Cerebro): Gemini 3 Pro analiza la intención y selecciona una herramienta de su conjunto de herramientas registrado.Ejecución (El Cuerpo):
3. La aplicación ejecuta la función de Python (por ejemplo, query_database).Reflexión:
4. La salida de la herramienta se devuelve al modelo.Finalización:
5. El modelo decide si la tarea está completa o requiere pasos adicionales.El modelo determina si la tarea está completa o requiere pasos adicionales.

Implementación técnica

Utilizaremos Python 3.12+ y la biblioteca google-genaibiblioteca. Mientras que las versiones anteriores requerían definiciones detalladas del esquema JSON, el SDK moderno nos permite pasar funciones de Python directamente: Gemini se encarga de la inferencia de tipos y la generación del esquema.

1. Configuración e Inicialización

Primero, asegúrese de que su entorno esté configurado.

pip install -q -U google-genai

Inicializamos el cliente utilizando el patrón estándar. Tenga en cuenta la configuración de llamada a función automáticaauto_function_calling

import os
from google import genai
from google.genai import types

# Initialize the client (assumes GEMINI_API_KEY is set in environment)
client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])

# Model Configuration
MODEL_ID = "gemini-3.0-pro" # Or gemini-2.0-flash-exp for current testing

2. Definir las herramientas esenciales

El poder de un agente reside en sus herramientas. Definiremos dos funciones: una para obtener datos (leer) y otra para realizar una acción (escribir).

Nota Importante: Las cadenas de documentación no son comentarios; forman parte de la instrucción. Gemini las utiliza para entender cuándo y cómo utilizar la herramienta.

# Mock Database
INVOICE_DB = {
    "INV-001": {"client": "Acme Corp", "amount": 5000, "status": "overdue", "contact": "finance@acme.com"},
    "INV-002": {"client": "Globex", "amount": 12000, "status": "paid", "contact": "billing@globex.com"},
    "INV-003": {"client": "Soylent Corp", "amount": 3400, "status": "overdue", "contact": "pay@soylent.com"},
}

def search_invoices(status: str) -> dict:
    """
    Searches the internal invoice database by status.
    
    Args:
        status: The status to filter by (e.g., 'overdue', 'paid').
        
    Returns:
        A dictionary of invoice details matching the criteria.
    """
    print(f"\n[System] Searching database for status: {status}...")
    results = {k: v for k, v in INVOICE_DB.items() if v["status"] == status}
    return results

def send_email_reminder(invoice_id: str, email_address: str) -> str:
    """
    Sends a payment reminder email to a client.
    
    Args:
        invoice_id: The ID of the invoice (e.g., 'INV-001').
        email_address: The recipient's email address.
        
    Returns:
        Confirmation string of the action.
    """
    print(f"\n[System] Sending email for {invoice_id} to {email_address}...")
    # In a real scenario, this would integrate with SendGrid or SES
    return f"Email successfully queued for {invoice_id}."

# Create the toolbox
toolbox = [search_invoices, send_email_reminder]

3. El bucle de ejecución

Aquí es donde se realiza la ingeniería. No simplemente llamamos a generate_content una vez; introducimos un bucle while que gestiona las solicitudes del modelo para invocar funciones. Este patrón es esencial para el desarrollo de agentes de IA personalizados, ya que permite la razonamiento en múltiples pasos (por ejemplo, encontrar la factura primero, luego extraer el correo electrónico, luego enviarlo).

def run_agent(user_query: str):
    print(f"--- Agent Task: {user_query} ---")
    
    # Initialize chat history with the user's request
    chat = client.chats.create(
        model=MODEL_ID,
        config=types.GenerateContentConfig(
            tools=toolbox,
            temperature=0.0 # Deterministic behavior for tool use
        )
    )

    response = chat.send_message(user_query)
    
    # The SDK handles the recursive loop of:
    # 1. Model predicts function call
    # 2. SDK executes function
    # 3. SDK feeds result back to model
    # 4. Model generates final answer
    # Note: If using 'automatic_function_calling=True' isn't desired (e.g. for async),
    # you would manually parse 'response.function_calls'. 
    # Here, we demonstrate the manual parsing for clarity on what happens under the hood.

    while response.function_calls:
        for tool_call in response.function_calls:
            name = tool_call.name
            args = tool_call.args
            
            # Dynamic dispatch
            if name == "search_invoices":
                result = search_invoices(**args)
            elif name == "send_email_reminder":
                result = send_email_reminder(**args)
            else:
                result = "Error: Tool not found."
            
            # Feed the result back to Gemini
            # The model needs the result to continue its train of thought
            response = chat.send_message(
                types.Part.from_function_response(
                    name=name,
                    response={"result": result}
                )
            )

    print(f"\n[Agent Final Answer]: {response.text}")

# --- Execution ---
run_agent("Find all overdue invoices and send an email reminder to their contacts.")

Análisis de resultados

Cuando ejecute el código anterior, observará que el agente realiza la razón por "Chain of Thought" sin instrucciones explícitas:

1. Paso 1: El agente reconoce que aún no puede "enviar correos electrónicos" porque no sabe a quién le corresponde el pago pendiente.
2. Paso 2: Llama a search_invoices(status='overdue').
3. Paso 3: Recibe los datos (INV-001 y INV-003).
4. Paso 4: Realiza la iteración interna. Observa dos resultados. Activa send_email_reminder para INV-001.
5. Paso 5: Activa send_email_reminder para INV-003.
6. Paso 6: Resume las acciones para el usuario.

Esta autonomía es lo que diferencia un script de un agente.

Patrones Avanzados: Ejecución Paralela y Manejo de Errores

En un entorno de producción (como los que vemos cuando se realiza consultoría en el desarrollo de agentes de inteligencia artificial personalizados) , las simples iteraciones no son suficientes. Necesitas:), los bucles simples no son suficientes. Necesitas:

• Uso de herramientas paralelas: Gemini 3 Pro puede generar múltiples llamadas a funciones en una sola vez. Si el agente necesita consultar el precio de acciones de Apple, Google y Microsoft, debe realizar tres get_stock_price llamadas simultáneamente, no secuencialmente. La lista function_calls en el objeto de respuesta admite esto de forma nativa.
• Guía: Nunca permita que un agente ejecute operaciones "de escritura" (como delete_database o refund_payment), sin una verificación "con intervención humana". Puede implementar esto haciendo que la herramienta delete devuelva una solicitud de código de confirmación, que el usuario debe proporcionar en la siguiente vez.

¿Por qué la lógica debería estar en el código, no en las instrucciones?

Un error común es pedirle al modelo de lenguaje que realice operaciones aritméticas o transformaciones complejas de datos.

• Malo: Pedir a Gemini que "calcule la suma de todas las facturas pendientes."
• Bueno: Proporcionar una herramienta calculate_total(invoices) o simplemente escribir código que sume los resultados de la tool search_invoices.herramienta.

Como ingenieros de software, deberíamos considerar el LLM como un enrutador y razonador, no como una calculadora. Destaca en la transformación de datos no estructurados a estructurados (Texto del usuario -> Llamada a herramienta) y en la toma de decisiones (Si X -> Llama a Y).

Conclusión

El lanzamiento de Gemini 3 Pro ha validado el cambio arquitectónico hacia flujos de trabajo basados en agentes. Al aprovechar la llamada nativa a herramientas, podemos crear sistemas lo suficientemente flexibles para manejar lenguaje natural, pero también lo suficientemente rígidos como para ejecutar la lógica empresarial crítica de manera fiable.

Para organizaciones que buscan escalar estas arquitecturas, el desafío suele radicar no en la integración de APIs, sino en la infraestructura circundante: bases de datos vectoriales para la memoria, pipelines de evaluación para prevenir desviaciones y despliegues seguros. Si está explorando el desarrollo de agentes de IA Desarrollo de agentes de IA personalizadosa medida de nivel empresarial

Preguntas frecuentes