Creación de agentes autónomos utilizando la funcionalidad de llamada a herramientas de Gemini 3 Pro

Ahora, a principios de 2026, la industria ya ha superado la fase de los "chatbots". Ya no le pedimos a los Modelos de Lenguaje Grandes (LLMs) que simplemente conversaciónhablen; ahora les pedimos que hagan. Para los directores técnicos y ingenieros senior, el enfoque se ha desplazado de la ingeniería de prompts a el desarrollo de agentes de IA personalizados

El lanzamiento de Gemini 3 Pro ha simplificado este proceso significativamente. A diferencia de las versiones anteriores que requerían un middleware pesado 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 completamente funcional que pueda interactuar con una base de datos local y realizar acciones externas (simuladas como la entrega de correos electrónicos), demostrando los patrones arquitectónicos necesarios para sistemas de agentes de nivel empresarial.

La Arquitectura de un Agente Moderno

Antes de escribir código, debemos comprender el "bucle" que diferencia una llamada API estándar de una llamada realizada por un Agente.

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

En una configuración orientada al agente, el flujo es circular y de 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..
3. Ejecución (El Cuerpo): La aplicación ejecuta la función de Python (por ejemplo, query_database).
4. Reflexión: La salida de la herramienta se alimenta de nuevo al modelo.
5. Finalización: El modelo decide 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 de esquemas JSON, el SDK moderno nos permite pasar funciones de Python directamente: Gemini se encarga de la inferencia de tipos y la generación de esquemas.

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 para llamada de función automática, lo que simplifica el bucle de ejecución en casos de uso sencillos, aunque crearemos un bucle manual aquí para tener el máximo control, lo cual es un requisito para la lógica empresarial compleja.

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; son 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 el trabajo de ingeniería. No simplemente llamamos generate_content una vez; iniciamos 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 gestiona la razón en múltiples pasos (por ejemplo, encontrar la factura primero, luego extraer la dirección de correo electrónico, luego enviarla).

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 ejecutes el código anterior, observarás al agente realizando un razonamiento de tipo "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 quién está con vencimiento.
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. Ve 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 a 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 asesoramos en el desarrollo de agentes de IA personalizadosDesarrollo de agentes de IA personalizados), los bucles simples no son suficientes. Necesitarás:

• Uso de herramientas en paralelo: Gemini 3 Pro puede generar múltiples llamadas a funciones en una sola ronda. Si el agente necesita verificar el precio de las acciones de Apple, Google y Microsoft, debería realizar tres get_stock_price llamadas simultáneamente, no de forma secuencial. La lista function_calls en el objeto de respuesta admite esto de forma nativa.
• Directrices: Nunca permita que un agente ejecute operaciones de "escritura" (como delete_database o refund_payment), sin una verificación "Humano en el bucle". 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 ronda.

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

Un error común es pedirle al LLM que realice cálculos o transformaciones de datos complejas.

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

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

Conclusión

El lanzamiento de Gemini 3 Pro ha confirmado el cambio arquitectónico hacia flujos de trabajo basados en agentes. Al aprovechar las llamadas a herramientas nativas, podemos crear sistemas lo suficientemente flexibles para manejar el lenguaje natural, pero lo suficientemente rígidos como para ejecutar la lógica empresarial crítica de forma fiable.

Para las organizaciones que buscan escalar estas arquitecturas, el desafío a menudo no radica en la integración de la API, sino en la infraestructura circundante: bases de datos vectoriales para la memoria, pipelines de evaluación para prevenir el sesgo, y despliegue seguro. Si está explorando el desarrollo de agentes de IA personalizados de nivel empresarial, asociarse con una empresa de ingeniería especializada suele ser el camino más rápido para la producción.custom ai agents development, partnering with a specialized engineering firm is often the fastest path to production.

Preguntas frecuentes