Orquestador multiagente de AWS: Una guía con ejemplos

¿Qué es AWS Multi-Agent Orchestrator?

La página orquestador multiagente de AWS es un marco flexible y repleto de herramientas diseñado para administrar agentes de IA y facilitar conversaciones complejas de varios turnos. Sus componentes preconstruidos permiten un desarrollo y despliegue rápidos, por lo que podemos centrarnos en nuestra aplicación sin necesidad de reconstruir estos componentes desde cero.

El Orquestador multiagente de AWS ofrece las siguientes características:

• Encaminamiento inteligente: Identifica dinámicamente el mejor agente para cada consulta.
• Respuestas fluidas y no fluidas: Admite los dos formatos de respuesta del agente.
• Gestión del contexto: Gestiona la coherencia y la historia en conversaciones de varios turnos.
• Extensibilidad: Crea nuevos agentes o modifica los existentes.
• Despliegue universal: Funciona en AWS Lambdaentornos locales y plataformas en la nube.

El marco está implementado para soportar tanto Python como TypeScript.

Una visión general del funcionamiento del Orquestador Multiagente. (Fuente)

En el diagrama anterior, vemos que el clasificador tiene en cuenta los agentes disponibles, la indicación del usuario y el historial de conversaciones anteriores para seleccionar el agente óptimo para la entrada del usuario. A continuación, el agente procesa la solicitud. El flujo de trabajo es sencillo pero eficaz.

Configuración de AWS Multi-Agent Orchestrator

Para una configuración rápida del entorno, puedes seguir las instrucciones de la documentación.

En primer lugar, creamos una nueva carpeta y un nuevo entorno Python para instalar las bibliotecas necesarias.

mkdir test_multi_agent_orchestrator
cd test_multi_agent_orchestrator
python -m venv venv
source venv/bin/activate  # On Windows use venv\\Scripts\\activate

Con el nuevo entorno virtual activado, instala la biblioteca

pip install multi-agent-orchestrator

A continuación, tenemos que configurar nuestra cuenta de AWS. Si no tienes una cuenta de AWS, regístrate gratis en una cuenta de capa gratuita. Después de registrarte, descarga la CLI de AWS.

También hay que configurar la CLI de AWS. Para obtener instrucciones detalladas, sigue Configuración de la CLI de AWSpero puedes adoptar un enfoque más sencillo utilizando el comando aws configure y proporcionando el ID de la clave de acceso de AWS y la clave de acceso secreta. Puedes obtener estas claves tras crear un nuevo usuario en tu panel de control.

Claves de acceso proporcionadas al crear un nuevo usuario.

Con las claves de acceso a mano, ejecuta aws configure y proporciona las claves, selecciona el nombre de la región (se proporciona una lista completa aquí) más cercana a ti, y establece el formato de salida por defecto en json.

Si tu CLI está configurada correctamente, al ejecutar el comando aws sts get-caller-identity debería aparecer el ID de tu cuenta de AWS, el ID de usuario y el ARN.

Ahora que tenemos la CLI de AWS lista para funcionar, tenemos que configurar AWS Bedrock para dar acceso a los LLM que necesitaremos. Amazon Bedrock es un servicio que te permite probar y llamar a modelos fundacionales (como Llama 3.2 o Claude 3.5 Sonnet) a través de una API. El Orquestador multiagente utiliza este servicio para llamar a dos modelos por defecto:

1. Claude 3.5 El soneto como clasificador
2. Claude 3 Haiku como agente

Por supuesto, estos modelos pueden cambiarse, pero sigamos con la opción por defecto.

Para dar acceso a estos dos modelos, ve a Amazon Bedrock > Acceso a modelos y selecciona "Modificar acceso al modelo". Selecciona los dos modelos (y otros si quieres) y rellena la información necesaria. Esta parte tendrá el siguiente aspecto:

Tras finalizar la solicitud, los modelos estarán disponibles en 1-2 minutos. Cuando se conceda el acceso a los modelos solicitados, deberás ver "Acceso concedido" delante de ellos.

Nota: Puede que tengas que asignar una política al usuario que has creado. Puedes probarlo si tienes problemas en la siguiente subsección de nuestro artículo (Prueba tu configuración). Si es así, consulta esta página. En resumen, tendrías que dar al usuario que has definido acceso a AmazonBedrockFullAccess.

Prueba tu configuración

Para comprobar si todos los pasos anteriores están bien configurados, utiliza este código:

import uuid
import asyncio
import json
import sys
from typing import Optional, List, Dict, Any
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator, OrchestratorConfig
from multi_agent_orchestrator.agents import (
    BedrockLLMAgent,
    BedrockLLMAgentOptions,
    AgentResponse,
    AgentCallbacks,
)
from multi_agent_orchestrator.types import ConversationMessage, ParticipantRole

orchestrator = MultiAgentOrchestrator(
    options=OrchestratorConfig(
        LOG_AGENT_CHAT=True,
        LOG_CLASSIFIER_CHAT=True,
        LOG_CLASSIFIER_RAW_OUTPUT=True,
        LOG_CLASSIFIER_OUTPUT=True,
        LOG_EXECUTION_TIMES=True,
        MAX_RETRIES=3,
        USE_DEFAULT_AGENT_IF_NONE_IDENTIFIED=True,
        MAX_MESSAGE_PAIRS_PER_AGENT=10,
    )
)


class BedrockLLMAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        # handle response streaming here
        print(token, end="", flush=True)


tech_agent = BedrockLLMAgent(
    BedrockLLMAgentOptions(
        name="Tech Agent",
        streaming=True,
        description=(
            "Specializes in technology areas including software development, hardware, AI, "
            "cybersecurity, blockchain, cloud computing, emerging tech innovations, and pricing/costs "
            "related to technology products and services."
        ),
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        callbacks=BedrockLLMAgentCallbacks(),
    )
)

orchestrator.add_agent(tech_agent)


async def handle_request(
    _orchestrator: MultiAgentOrchestrator, _user_input: str, _user_id: str, _session_id: str
):
    response: AgentResponse = await _orchestrator.route_request(
        _user_input, _user_id, _session_id
    )
    # Print metadata
    print("\nMetadata:")
    print(f"Selected Agent: {response.metadata.agent_name}")
    if response.streaming:
        print("Response:", response.output.content[0]["text"])
    else:
        print("Response:", response.output.content[0]["text"])


if __name__ == "__main__":
    USER_ID = "user123"
    SESSION_ID = str(uuid.uuid4())
    print("Welcome to the interactive Multi-Agent system. Type 'quit' to exit.")
    while True:
        # Get user input
        user_input = input("\nYou: ").strip()
        if user_input.lower() == "quit":
            print("Exiting the program. Goodbye!")
            sys.exit()
        # Run the async function
        asyncio.run(handle_request(orchestrator, user_input, USER_ID, SESSION_ID))

Si puedes solicitar y recibir una respuesta, todo funciona bien.

Proyecto de demostración con AWS Multi-Agent Orchestrator

El repositorio de AWS Multi-Agent Orchestrator proporciona varios proyectos de ejemplo en TypeScript y Python. A continuación escribiremos una aplicación Python simplificada que consta de dos agentes: Agente Desarrollador Python y Agente Experto ML.

También utilizaremos Chainlit, un paquete de Python de código abierto, para implementar una interfaz de usuario sencilla para la aplicación. Para empezar, instala las bibliotecas necesarias:

chainlit==1.2.0
multi_agent_orchestrator==0.0.18

Utilizaremos el código siguiente para nuestra aplicación de demostración, pero primero vamos a explicarlo:

1. Comenzamos importando las bibliotecas necesarias.
2. Utilizamos “anthropic.claude-3-haiku-20240307-v1:0” como modelo para nuestro clasificador. Este clasificador elegirá qué agente utilizar cuando llegue una nueva entrada de usuario.
3. Pasamos el clasificador creado a un MultiAgentOrchestrator y definimos algunas configuraciones.
4. La clase BedrockLLMAgent se utiliza para crear nuestros agentes. Se proporciona un name y un description para cada agente. Para un agente, puedes elegir cualquiera de los modelos accesibles o incluso utilizar Ollama para ejecutarlos localmente. Si configuras streaming=True y pasas ChainlitAgentCallbacks() como callback, los agentes devolverán respuestas en flujo en lugar de completas. Por último, añadimos cada agente al orquestador.
5. Se establece la dirección user_session y se define la sección principal para gestionar los mensajes del usuario y del agente.

### 1
import uuid
import chainlit as cl
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator, OrchestratorConfig
from multi_agent_orchestrator.classifiers import BedrockClassifier, BedrockClassifierOptions
from multi_agent_orchestrator.agents import AgentResponse
from multi_agent_orchestrator.agents import BedrockLLMAgent, BedrockLLMAgentOptions, AgentCallbacks
from multi_agent_orchestrator.orchestrator import MultiAgentOrchestrator
from multi_agent_orchestrator.types import ConversationMessage
import asyncio
import chainlit as cl

class ChainlitAgentCallbacks(AgentCallbacks):
    def on_llm_new_token(self, token: str) -> None:
        asyncio.run(cl.user_session.get("current_msg").stream_token(token))

### 2
# Initialize the orchestrator & classifier
custom_bedrock_classifier = BedrockClassifier(BedrockClassifierOptions(
    model_id='anthropic.claude-3-haiku-20240307-v1:0',
    inference_config={
        'maxTokens': 500,
        'temperature': 0.7,
        'topP': 0.9
    }
))

### 3
orchestrator = MultiAgentOrchestrator(options=OrchestratorConfig(
        LOG_AGENT_CHAT=True,
        LOG_CLASSIFIER_CHAT=True,
        LOG_CLASSIFIER_RAW_OUTPUT=True,
        LOG_CLASSIFIER_OUTPUT=True,
        LOG_EXECUTION_TIMES=True,
        MAX_RETRIES=3,
        USE_DEFAULT_AGENT_IF_NONE_IDENTIFIED=False,
        MAX_MESSAGE_PAIRS_PER_AGENT=10,
    ),
    classifier=custom_bedrock_classifier
)

### 4
def create_python_dev():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Python Developer Agent",
        streaming=True,
        description="Experienced Python developer specialized in writing, debugging, and evaluating only Python code.",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))

def create_ml_expert():
    return BedrockLLMAgent(BedrockLLMAgentOptions(
        name="Machine Learning Expert",
        streaming=True,
        description="Expert in areas related to machine learning including deep learning, pytorch, tensorflow, scikit-learn, and large language models.",
        model_id="anthropic.claude-3-sonnet-20240229-v1:0",
        callbacks=ChainlitAgentCallbacks()
    ))

# Add agents to the orchestrator
orchestrator.add_agent(create_python_dev())
orchestrator.add_agent(create_ml_expert())

### 5
@cl.on_chat_start
async def start():
    cl.user_session.set("user_id", str(uuid.uuid4()))
    cl.user_session.set("session_id", str(uuid.uuid4()))
    cl.user_session.set("chat_history", [])

@cl.on_message
async def main(message: cl.Message):
    user_id = cl.user_session.get("user_id")
    session_id = cl.user_session.get("session_id")
    msg = cl.Message(content="")
    await msg.send()  # Send the message immediately to start streaming
    cl.user_session.set("current_msg", msg)
    response:AgentResponse = await orchestrator.route_request(message.content, user_id, session_id, {})
    # Handle non-streaming or problematic responses
    if isinstance(response, AgentResponse) and response.streaming is False:
        # Handle regular response
        if isinstance(response.output, str):
            await msg.stream_token(response.output)
        elif isinstance(response.output, ConversationMessage):
                await msg.stream_token(response.output.content[0].get('text'))
    await msg.update()

if __name__ == "__main__":
    cl.run()

Ahora es el momento de ejecutar la aplicación. Para ello, ejecuta primero chainlit run [app.py](<http://app.py/>) -w. Ahora puedes probar tu aplicación en la nueva pestaña abierta en tu navegador.

Como puedes ver en la captura de pantalla, ahora disponemos de una interfaz de usuario para probar nuestra aplicación y chatear con los agentes.

Observa que como la primera pregunta "¿Cuál es la capital de Francia?" no está relacionada con ninguno de nuestros agentes, el sistema no proporciona una respuesta. Esto es clave para mantener la relevancia de los chats y evitar gastar créditos innecesarios al utilizar estos modelos. Sin embargo, cuando se le plantea una pregunta relacionada, nuestroagente Experto en Aprendizaje Automático entra en juego para dar una respuesta, gracias al enrutamiento inteligente del Orquestador Multiagente.

Conclusión

En este blog, hemos presentado el reciente marco AWS Multi-Agent Orchestrator, destacado algunas de sus características únicas, esbozado los pasos para configurar el entorno, explorado los modelos fundacionales a los que sirve Amazon Bedrock e implementado un proyecto de demostración.

En el momento de escribir este artículo, el marco carece de documentación completa y detallada. Para beneficiarte de otras funciones, como el uso de memoria y herramientas, debes leer el código base y echar un vistazo a los proyectos de ejemplo proporcionados.

Mantener una mirada curiosa sobre los marcos de la IA agéntica es una sabia elección para mantenerse al día en este campo tan rápido. El Orquestador Multiagente de AWS es una opción prometedora construida sobre las infraestructuras de los servicios de AWS, y merece la pena seguir de cerca su desarrollo.