Cómo crear Agentes de IA para producción utilizando OpenAI AgentKit

En el panorama en rápida evolución de la Inteligencia Artificial, el paradigma está cambiando de las interfaces de chat pasivas a agentes autónomos capaces de ejecutar flujos de trabajo complejos. Para los directores de tecnología y ingenieros senior, el desafío no solo radica en la optimización de prompts, sino también en la coordinación de estados, herramientas y entornos de ejecución para crear sistemas fiables.

Este artículo explora la arquitectura y la implementación de agentes listos para producción utilizando el ecosistema de OpenAI'OpenAI'—específicamente aprovechando la API de Asistentes y las capacidades de llamada a funciones—para ofrecer soluciones robustas de desarrollo de agentes de IA personalizados.

La Arquitectura Agente: Más allá del chatbot

Un agente listo para su uso difiere fundamentalmente de un chatbot. Mientras que un chatbot recupera e integra información, un agente percibe, razona, actúa e itera. Para construir sistemas de agentes escalables, debemos ir más allá de simples ciclos de solicitud-respuesta e implementar una arquitectura cognitiva que apoye:

1. Interfaz de herramientas: Una forma estructurada para que el modelo interactúe con entornos externos (bases de datos, APIs, sistemas de archivos).
2. Gestión del estado: Hilos persistentes que mantienen el contexto a través de bucles de ejecución multi-paso.
3. Bucle de razonamiento: La capacidad de evaluar resultados intermedios y determinar la siguiente acción sin intervención del usuario.

La API de Asistentes de OpenAI encapsula estos requisitos en un conjunto "completo" que incluye Threads, Runs y Herramientas.

Equipo de Ingeniería de Software Compartido bajo Demanda, mediante Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda mediante una suscripción mensual predecible. Expertos desarrolladores, diseñadores, ingenieros de control de calidad y un gerente de proyectos gratuito le ayudan a crear MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

Paso 1: Definir el esquema y las herramientas del Agente

El núcleo de cualquier agente es su capacidad para interactuar con sistemas externos. Definimos esta capacidad utilizando Llamada a funciones. A diferencia de simples descripciones de prompts, la llamada a funciones requiere definiciones estrictas de JSON Schema, que aseguran que el modelo de lenguaje grande (LLM) genere payloads estructurados y ejecutables.

Aquí hay una implementación en Python que utiliza el SDK de openai para definir un agente de análisis financiero con herramientas específicas:

import os
from openai import OpenAI
from typing import Dict, Any

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

# Define the tool (function) schema
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_fundamentals",
            "description": "Retrieves fundamental data for a given stock symbol.",
            "parameters": {
                "type": "object",
                "properties": {
                    "symbol": {
                        "type": "string",
                        "description": "The stock ticker symbol, e.g., AAPL for Apple Inc."
                    },
                    "metrics": {
                        "type": "array",
                        "items": {"type": "string", "enum": ["PE_Ratio", "EPS", "Market_Cap"]},
                        "description": "List of specific metrics to retrieve."
                    }
                },
                "required": ["symbol"]
            }
        }
    }
]

# Initialize the Agent (Assistant)
assistant = client.beta.assistants.create(
    name="Financial Analyst Agent",
    instructions="You are a financial analyst. Use the available tools to analyze stock data. Always cite the metric values explicitly.",
    model="gpt-4-turbo",
    tools=tools
)

print(f"Agent Initialized: {assistant.id}")

Paso 2: Coordinar el ciclo de ejecución

En un entorno de producción, la latencia y la fiabilidad son fundamentales. El bucle de ejecución debe gestionar la decisión del modelo para llamar a una herramienta, la ejecución real de esa herramienta (que se realiza en el servidor dentro de su infraestructura) y la presentación de los resultados de vuelta al modelo.

Este proceso implica la consulta o el flujo de eventos. A continuación se muestra un patrón robusto para manejar el estado requiere acciónrequires_actionDesarrollo de agentes de IA personalizadosel desarrollo de agentes de IA personalizados

Equipo de Ingeniería de Software Compartido Bajo Demanda, Por Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda a través de una suscripción mensual predecible. Desarrolladores, diseñadores, ingenieros de control de calidad y un gestor de proyectos gratuitos le ayudan a crear MVPs, escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

import time
import json

def get_stock_fundamentals(symbol: str, metrics: list = None) -> str:
    # Mocking an external API call to a financial data provider
    # In production, this would connect to Bloomberg, AlphaVantage, or internal DBs
    mock_db = {
        "AAPL": {"PE_Ratio": "28.5", "EPS": "6.43", "Market_Cap": "2.8T"},
        "GOOGL": {"PE_Ratio": "24.1", "EPS": "5.80", "Market_Cap": "1.9T"}
    }
    data = mock_db.get(symbol, {})
    return json.dumps(data)

def execute_run_loop(thread_id: str, assistant_id: str):
    run = client.beta.threads.runs.create(
        thread_id=thread_id,
        assistant_id=assistant_id
    )

    while True:
        # Check run status
        run_status = client.beta.threads.runs.retrieve(
            thread_id=thread_id,
            run_id=run.id
        )
        print(f"Current Status: {run_status.status}")

        if run_status.status == 'completed':
            messages = client.beta.threads.messages.list(thread_id=thread_id)
            return messages.data[0].content[0].text.value
        
        elif run_status.status == 'requires_action':
            # The agent wants to execute a tool
            tool_calls = run_status.required_action.submit_tool_outputs.tool_calls
            tool_outputs = []
            
            for tool_call in tool_calls:
                func_name = tool_call.function.name
                args = json.loads(tool_call.function.arguments)
                
                print(f"Agent invoking: {func_name} with {args}")
                
                if func_name == "get_stock_fundamentals":
                    output = get_stock_fundamentals(
                        symbol=args.get("symbol"),
                        metrics=args.get("metrics")
                    )
                    tool_outputs.append({
                        "tool_call_id": tool_call.id,
                        "output": output
                    })
            
            # Submit results back to the thread to continue execution
            client.beta.threads.runs.submit_tool_outputs(
                thread_id=thread_id,
                run_id=run.id,
                tool_outputs=tool_outputs
            )
            
        elif run_status.status in ['failed', 'cancelled', 'expired']:
            raise Exception(f"Run failed with error: {run_status.last_error}")
            
        time.sleep(1) # Polling interval

# Example Usage
thread = client.beta.threads.create()
client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Analyze the PE Ratio and Market Cap for Apple and Google."
)

response = execute_run_loop(thread.id, assistant.id)
print(f"Final Response: {response}")

Paso 3: Gestión del estado y la persistencia

Para aplicaciones empresariales, la gestión del estado se extiende más allá de una sola sesión. El objeto HiloThreadestrategia de desarrollo de agentes de IA personalizados sea viable, debe mapear estos hilos a sus identificadores de usuario internos o claves de sesión.

Mejor práctica: Almacene el thread_id en su base de datos relacional (PostgreSQL o MySQL) junto al perfil del usuario. Esto permite que el agente recuerde interacciones anteriores, incluso días o semanas después, brindando una continuidad verdaderamente personalizada.

Paso 4: Manejo del determinismo y la seguridad

Uno de los principales riesgos al implementar agentes de IA generativa es el comportamiento no determinista. Para mitigar esto en un entorno de producción:

1. Establezca la temperatura en 0: Para los agentes que ejecutan lógica o recuperación de datos, es esencial un bajo nivel de aleatoriedad.
2. Refuerzo del prompt del sistema: Defina explícitamente lo que el agente no puede hacer. Utilice restricciones negativas en las instrucciones del sistema.
3. Validación de la salida: Antes de mostrar la respuesta final del agente al usuario, pásela a través de una capa de validación o un modelo más ligero para asegurarse de que cumple con las directrices de seguridad.

Conclusión

Desarrollar agentes con las herramientas de OpenAI desplaza la complejidad del entendimiento del lenguaje natural a la ingeniería de sistemas. El enfoque se centra en definir interfaces API limpias, gestionar los bucles de ejecución asíncronas y garantizar un manejo robusto de errores. Al aprovechar la API Assistants, los ingenieros pueden abstraer la gestión de la ventana de contexto y centrarse en la lógica empresarial que hace que el agente sea valioso.

Para organizaciones que buscan ampliar sus capacidades de IA, asociarse con una empresa de ingeniería especializada suele ser el factor clave para pasar del concepto a la implementación.4Geeks, una empresa global especializada en productos, crecimiento y IA, se especializa enel desarrollo de agentes de IA personalizados, ayudando a las empresas a diseñar e implementar sistemas inteligentes seguros y de alto rendimiento.

Equipo de Ingeniería de Software Compartido bajo Demanda, por Suscripción.

Acceda a un equipo flexible y compartido de ingeniería de software bajo demanda mediante una suscripción mensual predecible. Desarrolladores expertos, diseñadores, ingenieros de control de calidad y un gerente de proyectos gratuito le ayudan a crear MVPs (Producto Mínimo Viable), escalar productos e innovar con tecnologías modernas como React, Node.js y más.

Try 4Geeks Teams

Preguntas frecuentes