Crear IA multiagente lista para la producción en Azure AI Foundry

Arquitectura, componentes e implementación con Azure AI Foundry.

Este artículo le muestra cómo diseñar, construir e implementar una solución multiagente lista para producción en Azure utilizando Azure AI Foundry Agent Service y agentes conectados .

Recrearemos un sistema de priorización de tickets en el que un agente principal delega en tres especialistas: prioridad , asignación de equipo y estimación de esfuerzo. Luego, lo adaptaremos a una arquitectura de referencia y analizaremos las opciones de implementación para que pueda ponerlo en marcha con cargas de trabajo reales.

Referencia de arquitectura

User/App  →  Primary “Triage” Agent
               │  uses ConnectedAgentTools
               ├── Priority Agent       (assesses urgency)
               ├── Team Agent           (routes to owning team)
               └── Effort Agent         (estimates size)
               
Azure AI Foundry Agent Service
   • Threads, messages, runs
   • Tool execution + safety filters
   • Identity + observability hooks
   • Model deployment (e.g., GPT-4o)

Recommended hosting for prod:
   • App/API in Azure Container Apps
   • Private networking, Key Vault, Monitor
   • Optional orchestration patterns via SK

Este patrón se alinea con los patrones de diseño de automatización de flujos de trabajo con múltiples agentes y orquestación de agentes de Microsoft en el Centro de arquitectura de Azure. Utilice estas referencias al adaptar el ejemplo a su dominio (soporte, investigación, finanzas, cumplimiento).

Componentes clave que utilizarás

• Azure AI Foundry Project & Agent Service : el entorno de ejecución administrado que gestiona subprocesos, llamadas a herramientas, seguridad, identidad y observabilidad para sus agentes.
• Agentes conectados : permiten que un agente principal llame a subagentes especializados sin necesidad de crear un enrutador personalizado. Ideal para flujos de trabajo modulares y una mayor claridad en la responsabilidad por habilidad.
• Implementación del modelo — por ejemplo, una implementación de GPT-4o adjunta a su proyecto; las cuotas pueden variar según la región.
• SDK de agentes : AgentsClientademás de objetos como ConnectedAgentTool, threads, messages, y runspara el flujo de control. (Se muestra Python; también se admiten .NET/JS/Java).

Práctica: construir el sistema de clasificación de tickets multiagente

Lo que construirás: Un agente de triaje primario que consulta a tres agentes especialistas para: (1) establecer la prioridad , (2) elegir el equipo y (3) estimar el esfuerzo .

1) Crea tu proyecto y modelo de Azure AI Foundry.

1. Ve a ai.azure.com y crea un proyecto (centro y proyecto según se te solicite).

Anota el punto de conexión y las claves de tu proyecto:

2. Luego, implemente un modelo GPT .

2) Prepara el espacio de trabajo de tu cliente

Puedes usar Azure Cloud Shell (PowerShell, editor clásico):

• Utilizando Azure Portal, abra una instancia de Cloud Shell, clone el repositorio y abra la carpeta de ejercicios:

rm -r ai-agents -f 
git clone https://github.com/MicrosoftLearning/mslearn-ai-agents ai-agents 
cd ai-agents/Labfiles/03b-build-multi-agent-solution/Python

Crea un entorno virtual e instala las dependencias:

python -m venv labenv 
./labenv/bin/Activate.ps1 
pip install -r requirements.txt azure-ai-projects

o bien: source ./labenv/bin/activate

Configúrelo .envcon el punto de conexión de su proyecto y el nombre de implementación del modelo .

Introduzca el siguiente comando para editar el archivo de configuración:

código .env

En el archivo de código, reemplace el marcador de posición your_project_endpoint con el punto de conexión de su proyecto (copiado de la página de información general del proyecto en el portal de Azure AI Foundry) y el marcador de posición your_model_deployment con el nombre que asignó a la implementación de su modelo GPT.

3) Definir agentes y conectarlos

Ahora estamos listos para crear los agentes para la solución multiagente. ¡Comencemos!

Primero, editemos el agent_triage.pyarchivo con el siguiente comando:

código agent_triage.py

Modifiquemos este archivo para crear los agentes para nuestra solución multiagente:

import os
from dotenv import load_dotenv

# Add references
from azure.ai.agents import AgentsClient
from azure.ai.agents.models import ConnectedAgentTool, MessageRole, ListSortOrder, ToolSet, FunctionTool
from azure.identity import DefaultAzureCredential



# Clear the console
os.system('cls' if os.name=='nt' else 'clear')

# Load environment variables from .env file
load_dotenv()
project_endpoint = os.getenv("PROJECT_ENDPOINT")
model_deployment = os.getenv("MODEL_DEPLOYMENT_NAME")


# Connect to the agents client
agents_client = AgentsClient(
     endpoint=project_endpoint,
     credential=DefaultAzureCredential(
         exclude_environment_credential=True, 
         exclude_managed_identity_credential=True
     ),
)

with agents_client:


    # Create an agent to prioritize support tickets
    priority_agent_name = "priority_agent"
    priority_agent_instructions = """
    Assess how urgent a ticket is based on its description.

    Respond with one of the following levels:
    - High: User-facing or blocking issues
    - Medium: Time-sensitive but not breaking anything
    - Low: Cosmetic or non-urgent tasks

    Only output the urgency level and a very brief explanation.
    """

    priority_agent = agents_client.create_agent(
        model=model_deployment,
        name=priority_agent_name,
        instructions=priority_agent_instructions
    )



    # Create an agent to assign tickets to the appropriate team
    team_agent_name = "team_agent"
    team_agent_instructions = """
    Decide which team should own each ticket.

    Choose from the following teams:
    - Frontend
    - Backend
    - Infrastructure
    - Marketing

    Base your answer on the content of the ticket. Respond with the team name and a very brief explanation.
    """

    team_agent = agents_client.create_agent(
        model=model_deployment,
        name=team_agent_name,
        instructions=team_agent_instructions
    )


    # Create an agent to estimate effort for a support ticket
    effort_agent_name = "effort_agent"
    effort_agent_instructions = """
    Estimate how much work each ticket will require.

    Use the following scale:
    - Small: Can be completed in a day
    - Medium: 2-3 days of work
    - Large: Multi-day or cross-team effort

    Base your estimate on the complexity implied by the ticket. Respond with the effort level and a brief justification.
    """

    effort_agent = agents_client.create_agent(
        model=model_deployment,
        name=effort_agent_name,
        instructions=effort_agent_instructions
    )


    # Create connected agent tools for the support agents
    priority_agent_tool = ConnectedAgentTool(
        id=priority_agent.id, 
        name=priority_agent_name, 
        description="Assess the priority of a ticket"
    )
        
    team_agent_tool = ConnectedAgentTool(
        id=team_agent.id, 
        name=team_agent_name, 
        description="Determines which team should take the ticket"
    )
        
    effort_agent_tool = ConnectedAgentTool(
        id=effort_agent.id, 
        name=effort_agent_name, 
        description="Determines the effort required to complete the ticket"
    )

    # Create an agent to triage support ticket processing by using connected agents
    triage_agent_name = "triage-agent"
    triage_agent_instructions = """
    Triage the given ticket. Use the connected tools to determine the ticket's priority, 
    which team it should be assigned to, and how much effort it may take.
    """

    triage_agent = agents_client.create_agent(
        model=model_deployment,
        name=triage_agent_name,
        instructions=triage_agent_instructions,
        tools=[
            priority_agent_tool.definitions[0],
            team_agent_tool.definitions[0],
            effort_agent_tool.definitions[0]
        ]
    )

    # Use the agents to triage a support issue
    print("Creating agent thread.")
    thread = agents_client.threads.create()  

    # Create the ticket prompt
    prompt = input("\nWhat's the support problem you need to resolve?: ")
        
    # Send a prompt to the agent
    message = agents_client.messages.create(
        thread_id=thread.id,
        role=MessageRole.USER,
        content=prompt,
    )   
        
    # Run the thread usng the primary agent
    print("\nProcessing agent thread. Please wait.")
    run = agents_client.runs.create_and_process(thread_id=thread.id, agent_id=triage_agent.id)
            
    if run.status == "failed":
        print(f"Run failed: {run.last_error}")

    # Fetch and display messages
    messages = agents_client.messages.list(thread_id=thread.id, order=ListSortOrder.ASCENDING)
    for message in messages:
        if message.text_messages:
            last_msg = message.text_messages[-1]
            print(f"{message.role}:\n{last_msg.text.value}\n")


    # Clean up
    print("Cleaning up agents:")
    agents_client.delete_agent(triage_agent.id)
    print("Deleted triage agent.")
    agents_client.delete_agent(priority_agent.id)
    print("Deleted priority agent.")
    agents_client.delete_agent(team_agent.id)
    print("Deleted team agent.")
    agents_client.delete_agent(effort_agent.id)
    print("Deleted effort agent.")
    

https://gist.github.com/daveRendon/35649bded514daf2819e9b7102cca547

4) Ejecutar un hilo e inspeccionar los resultados

1. Inicie sesión mediante la CLI en Cloud Shell ( az login), luego:

python agent_triage.py

• Proporcione un problema real (por ejemplo, “Los usuarios no pueden restablecer su contraseña en la aplicación móvil”).

Lea el resultado combinado (prioridad, equipo, esfuerzo).

Cada agente realiza una tarea de forma óptima. El agente principal coordina y su funcionamiento se mantiene transparente; las transferencias de agentes son visibles en los registros y facilitan las pruebas y observaciones de extremo a extremo.

Del laboratorio a la producción: qué cambiar

1) Alojamiento y empaquetado

• Utiliza Azure Container Apps (o Kubernetes) para alojar tu API que controla los agentes. Combínalo con Dapr si necesitas publicación/suscripción, enlaces o estado.

2) Identidad y secretos

• Utilice la identidad administrada en lugar de la autenticación de usuario; coloque la configuración en Key Vault ; confíe en el orden de resolución de DefaultAzureCredential en producción.

3) Redes y seguridad

• Integración de puntos de conexión privados/VNet para el servicio de agente y fuentes de datos; habilite filtros de seguridad y políticas de contenido adecuadas para su dominio.

4) Observabilidad

• Analiza los subprocesos , las llamadas a herramientas, las transferencias y los modos de error . Emite registros/métricas estructurados a Azure Monitor/Application Insights y registra los intervalos de transferencia de agentes para garantizar la trazabilidad.

5) Pruebas y control de versiones

• Escriba pruebas unitarias específicas para las instrucciones/mensajes de cada agente; agregue pruebas de integración para flujos de trabajo entre agentes; defina los nombres de implementación del modelo y mantenga .envlos valores con ámbito de entorno por etapa.

6) Escala y coste

• Mantenga las instrucciones del agente concisas; almacene en caché el contexto estable; prefiera herramientas especializadas a mensajes extensos; supervise la latencia por agente y la distribución para evitar efectos de vecinos ruidosos.

Consideraciones finales y preguntas frecuentes

P: ¿Por qué agentes conectados en lugar de una sola solicitud?
R: Separación de responsabilidades. Se obtienen solicitudes modulares, evaluación específica y registros más claros, lo cual es fundamental para la depuración y el cumplimiento normativo.

P: ¿Puedo usar .NET o JavaScript en lugar de Python?
R: Sí. El artículo muestra Python, pero el SDK de Azure AI Foundry también incluye clientes para .NET, JavaScript y Java . Elija la tecnología que mejor se adapte a su infraestructura.

P: ¿Cuál es un buen siguiente paso después del triaje?
R: Agregar herramientas de datos (búsqueda/base de datos), herramientas MCP externas o hacer que el agente de triaje invoque enlaces de flujo de trabajo (tickets, paginación).

Gracias por leer Código en Casa.