OpenAI Swarm - Introducción Detallada al Marco de Orquestación Multiagente

Resumen del Proyecto

OpenAI Swarm es un marco educativo para explorar la orquestación multiagente ligera y ergonómica. Este proyecto, gestionado por el equipo de soluciones de OpenAI, tiene como objetivo proporcionar a los desarrolladores una herramienta sencilla, flexible y controlable para construir sistemas multiagente.

Actualización Importante: Swarm ha sido reemplazado por el SDK de Agentes de OpenAI, que es una versión lista para producción de Swarm. El equipo de OpenAI recomienda migrar todos los casos de uso de producción al SDK de Agentes.

Características Principales

1. Filosofía de Diseño

• Ligero: Centrado en la simplicidad y la facilidad de uso.
• Altamente Controlable: Proporciona mecanismos de control precisos para los agentes.
• Fácil de Probar: Admite procesos sencillos de prueba y depuración.
• Orientado a la Educación: Sirve como recurso educativo para aprender sobre la orquestación multiagente.

2. Conceptos Abstractos Centrales

Swarm implementa la coordinación de agentes a través de dos abstracciones centrales:

Agente (Agent)

• Contiene instrucciones (instructions) y herramientas (tools).
• Puede transferir la conversación a otro agente en cualquier momento.
• Admite instrucciones dinámicas y variables de contexto.

Transferencias (Handoffs)

• Mecanismo de transición fluida entre agentes.
• Admite redes y flujos de trabajo complejos de agentes.
• Mantiene la continuidad de la conversación.

Instalación y Uso Básico

Requisitos del Sistema

• Python 3.10+

Método de Instalación

pip install git+ssh://git@github.com/openai/swarm.git
# O
pip install git+https://github.com/openai/swarm.git

Ejemplo Básico

from swarm import Swarm, Agent

client = Swarm()

def transfer_to_agent_b():
    return agent_b

agent_a = Agent(
    name="Agente A",
    instructions="Eres un agente útil.",
    functions=[transfer_to_agent_b],
)

agent_b = Agent(
    name="Agente B",
    instructions="Solo habla en Haikus.",
)

response = client.run(
    agent=agent_a,
    messages=[{"role": "user", "content": "Quiero hablar con el agente B."}],
)

print(response.messages[-1]["content"])

Ejemplo de Salida:

La esperanza brilla,
Nuevos caminos convergen bien,
¿En qué puedo ayudar?

Arquitectura Técnica

Mecanismo de Ejecución del Cliente

La función client.run() de Swarm implementa el siguiente bucle:

1. Obtiene la respuesta completa del agente actual.
2. Ejecuta las llamadas a herramientas y agrega los resultados.
3. Cambia de agente si es necesario.
4. Actualiza las variables de contexto.
5. Si no hay nuevas llamadas a funciones, devuelve el resultado.

Configuración de Parámetros

Parámetro	Tipo	Descripción	Valor Predeterminado
agent	Agent	El agente (inicial) a llamar	(Requerido)
messages	List	Lista de objetos de mensaje	(Requerido)
context_variables	dict	Variables de contexto	{}
max_turns	int	Número máximo de turnos	float("inf")
model_override	str	Anulación del modelo	None
execute_tools	bool	Si se deben ejecutar las herramientas	True
stream	bool	Si se debe habilitar la respuesta de flujo	False
debug	bool	Si se deben habilitar los registros de depuración	False

Configuración del Agente

Campos de la Clase Agent

Campo	Tipo	Descripción	Valor Predeterminado
name	str	Nombre del agente	"Agente"
model	str	Modelo a utilizar	"gpt-4o"
instructions	str o función	Instrucciones del agente	"Eres un agente útil."
functions	List	Lista de funciones invocables	[]
tool_choice	str	Estrategia de selección de herramientas	None

Ejemplo de Instrucciones Dinámicas

def instructions(context_variables):
    user_name = context_variables["user_name"]
    return f"Ayuda al usuario, {user_name}, a hacer lo que quiera."

agent = Agent(instructions=instructions)

response = client.run(
    agent=agent,
    messages=[{"role":"user", "content": "¡Hola!"}],
    context_variables={"user_name":"John"}
)

Mecanismo de Llamada a Funciones

Llamada a Funciones Básica

def greet(context_variables, language):
    user_name = context_variables["user_name"]
    greeting = "Hola" if language.lower() == "spanish" else "Hello"
    print(f"{greeting}, {user_name}!")
    return "Hecho"

agent = Agent(functions=[greet])

Transferencia de Agente

sales_agent = Agent(name="Agente de Ventas")

def transfer_to_sales():
    return sales_agent

agent = Agent(functions=[transfer_to_sales])

Retorno de Resultados Complejos

def talk_to_sales():
    print("¡Hola, Mundo!")
    return Result(
        value="Hecho",
        agent=sales_agent,
        context_variables={"department": "sales"}
    )

Proyectos de Ejemplo

Swarm proporciona varios proyectos de ejemplo que muestran diferentes escenarios de aplicación:

1. basic - Ejemplo Básico

Demuestra el uso básico de la configuración, la llamada a funciones, la transferencia y las variables de contexto.

2. triage_agent - Agente de Triaje

Configuración de triaje simple que reenvía las solicitudes al agente apropiado.

3. weather_agent - Agente del Tiempo

Muestra un ejemplo simple de llamada a funciones.

4. airline - Atención al Cliente de Aerolínea

Configuración multiagente que maneja diferentes tipos de solicitudes de servicio al cliente de una aerolínea.

5. support_bot - Bot de Soporte

Incluye un agente de interfaz de usuario y un agente de centro de ayuda con varias herramientas.

6. personal_shopper - Asistente de Compras Personal

Asistente de compras personal que ayuda con el procesamiento de pedidos de ventas y reembolsos.

Procesamiento de Flujo (Streaming)

Swarm admite respuestas de flujo, utilizando los mismos eventos que la API de Chat Completions:

stream = client.run(agent, messages, stream=True)
for chunk in stream:
    print(chunk)

Nuevos tipos de eventos:

• {"delim":"start"} y {"delim":"end"} - Marcan el inicio y el final del procesamiento de un solo mensaje por parte del agente.
• {"response": Response} - Devuelve el objeto Response completo al final del flujo.

Pruebas y Evaluación

Pruebas de Desarrollo

Utilice run_demo_loop para pruebas de línea de comandos:

from swarm.repl import run_demo_loop

run_demo_loop(agent, stream=True)

Sugerencias de Evaluación

• Se anima a los desarrolladores a traer sus propios conjuntos de evaluación.
• Se proporcionan referencias de evaluación en los ejemplos de airline, weather_agent y triage_agent.
• Admite métricas de prueba de rendimiento personalizadas.

Diferencias con Otros Productos de OpenAI

Comparación con la API de Assistants

• API de Assistants: Proporciona hilos totalmente gestionados y gestión de memoria integrada.
• Swarm: Se ejecuta completamente en el cliente, con un diseño sin estado, más adecuado para el aprendizaje y la experimentación.

Características Técnicas

• Construido sobre la API de Chat Completions.
• No guarda el estado entre llamadas.
• Implementación de cliente ligera.
• Centrado en fines educativos y de aprendizaje.

Escenarios de Aplicación

Swarm es especialmente adecuado para las siguientes situaciones:

• Escenarios que requieren el manejo de una gran cantidad de funciones e instrucciones independientes.
• Tareas complejas que son difíciles de codificar en un solo prompt.
• Aprender conceptos de orquestación multiagente.
• Desarrollo rápido de prototipos y experimentación.

Estado del Proyecto

Nota: Aunque Swarm ha sido reemplazado por el SDK de Agentes de OpenAI, sigue siendo un excelente recurso educativo para ayudar a los desarrolladores a comprender los conceptos básicos y la implementación de sistemas multiagente. Para entornos de producción, se recomienda migrar al SDK de Agentes oficial.

Resumen

OpenAI Swarm proporciona un marco simple y potente para el aprendizaje y el desarrollo de sistemas multiagente. A través de los dos conceptos centrales de agentes y transferencias, los desarrolladores pueden construir flujos de trabajo de IA complejos, manteniendo al mismo tiempo la legibilidad y la mantenibilidad del código. Aunque ha sido reemplazado por un nuevo SDK, su filosofía de diseño y su valor educativo siguen siendo importantes.