Compartir a través de

Paso 6: Hospedar el agente

Una vez compilado el agente, debe hospedarlo para que los usuarios y otros agentes puedan interactuar con él.

Opciones de hospedaje

Opción Description Mejor para
Protocolo A2A Exponer agentes mediante el protocolo Agent-to-Agent Sistemas multiagente
Puntos de conexión compatibles con OpenAI Exponer agentes a través de finalizaciones de chat o API de respuestas Clientes compatibles con OpenAI
Azure Functions (Durable) Ejecutar agentes como funciones duraderas de Azure Functions Tareas sin servidor y de larga duración
El Protocolo AG-UI Desarrollo de aplicaciones de agentes de IA basadas en web Interfaces web

Hospedaje en ASP.NET Core

Agent Framework proporciona bibliotecas de hospedaje que permiten integrar agentes de inteligencia artificial en aplicaciones ASP.NET Core. Estas bibliotecas simplifican el registro, la configuración y la exposición de agentes a través de varios protocolos.

Como se describe en Información general de agentes, AIAgent es el concepto fundamental de Agent Framework. Define un "contenedor LLM" que procesa las entradas del usuario, toma decisiones, llama a herramientas y realiza un trabajo adicional para ejecutar acciones y generar respuestas. La exposición de agentes de IA desde la aplicación ASP.NET Core no es trivial. Las bibliotecas de hospedaje resuelven esto mediante el registro de agentes de INTELIGENCIA ARTIFICIAL en un contenedor de inserción de dependencias, lo que le permite resolverlos y usarlos en los servicios de aplicación. También le permiten administrar dependencias del agente, como herramientas y almacenamiento de sesión, desde el mismo contenedor. Los agentes se pueden hospedar junto con la infraestructura de la aplicación, independientemente de los protocolos que usan. Del mismo modo, los flujos de trabajo se pueden hospedar y aprovechar la infraestructura común de la aplicación.

Biblioteca de hospedaje principal

La Microsoft.Agents.AI.Hosting biblioteca es la base para hospedar agentes de inteligencia artificial en ASP.NET Core. Proporciona extensiones para IHostApplicationBuilder registrar y configurar agentes y flujos de trabajo de IA. En ASP.NET Core, IHostApplicationBuilder es el tipo fundamental que representa el generador de aplicaciones y servicios hospedados, la administración de la configuración, el registro, la duración, etc.

Antes de configurar agentes o flujos de trabajo, registre un IChatClient en el contenedor de inserción de dependencias. En los ejemplos siguientes, se registra como singleton con clave bajo el nombre chat-model:

// endpoint is of 'https://<your-own-foundry-endpoint>.openai.azure.com/' format
// deploymentName is 'gpt-4o-mini' for example

IChatClient chatClient = new AzureOpenAIClient(
        new Uri(endpoint),
        new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();
builder.Services.AddSingleton(chatClient);

AddAIAgent

Registro de un agente de IA con inserción de dependencias:

var pirateAgent = builder.AddAIAgent(
    "pirate",
    instructions: "You are a pirate. Speak like a pirate",
    description: "An agent that speaks like a pirate.",
    chatClientServiceKey: "chat-model");

El AddAIAgent() método devuelve un IHostedAgentBuilder, que proporciona métodos de extensión para configurar el agente. Por ejemplo, puede agregar herramientas al agente:

var pirateAgent = builder.AddAIAgent("pirate", instructions: "You are a pirate. Speak like a pirate")
    .WithAITool(new MyTool()); // MyTool is a custom type derived from AITool

También puede configurar el almacén de sesiones (almacenamiento para datos de conversación):

var pirateAgent = builder.AddAIAgent("pirate", instructions: "You are a pirate. Speak like a pirate")
    .WithInMemorySessionStore();

AddWorkflow

Registre flujos de trabajo que coordinan varios agentes. Un flujo de trabajo es básicamente un "grafo" donde cada nodo es un AIAgenty los agentes se comunican entre sí.

En este ejemplo, dos agentes funcionan secuencialmente. La entrada del usuario se envía primero a agent-1, que genera una respuesta y la envía a agent-2. A continuación, el flujo de trabajo genera la respuesta final. También hay un BuildConcurrent método que crea un flujo de trabajo de agente simultáneo.

builder.AddAIAgent("agent-1", instructions: "you are agent 1!");
builder.AddAIAgent("agent-2", instructions: "you are agent 2!");

var workflow = builder.AddWorkflow("my-workflow", (sp, key) =>
{
    var agent1 = sp.GetRequiredKeyedService<AIAgent>("agent-1");
    var agent2 = sp.GetRequiredKeyedService<AIAgent>("agent-2");
    return AgentWorkflowBuilder.BuildSequential(key, [agent1, agent2]);
});

Exposición del flujo de trabajo como AIAgent

Para usar integraciones de protocolo (como A2A o OpenAI) con un flujo de trabajo, conviértalo en un agente independiente. Actualmente, los flujos de trabajo no proporcionan funcionalidades de integración similares por sí mismas, por lo que se requiere este paso de conversión:

var workflowAsAgent = builder
    .AddWorkflow("science-workflow", (sp, key) => { ... })
    .AddAsAIAgent();  // Now the workflow can be used as an agent

Detalles de implementación

Las bibliotecas de hospedaje actúan como adaptadores de protocolo que puenten protocolos de comunicación externos y la implementación interna AIAgent de Agent Framework. Cuando se usa una biblioteca de integración de hospedaje, la biblioteca recupera el registro AIAgent de la inserción de dependencias, lo encapsula con middleware específico de protocolo para traducir las solicitudes entrantes y las respuestas salientes e invoca AIAgent para procesar las solicitudes. Esta arquitectura mantiene la implementación del agente independiente de cualquier protocolo.

Por ejemplo, con la biblioteca de hospedaje de ASP.NET Core con el adaptador de protocolo A2A:

// Register the agent
var pirateAgent = builder.AddAIAgent("pirate",
    instructions: "You are a pirate. Speak like a pirate",
    description: "An agent that speaks like a pirate.");

// Expose via a protocol (e.g. A2A)
builder.Services.AddA2AServer();
var app = builder.Build();
app.MapA2AServer();
app.Run();

Sugerencia

Consulte los ejemplos de Durable Azure Functions para obtener ejemplos de hospedaje sin servidor.

Instale el paquete de hospedaje de Azure Functions:

pip install agent-framework-azurefunctions --pre

Cree un agente:

from agent_framework.azure import AgentFunctionApp, AzureOpenAIChatClient
from azure.identity import AzureCliCredential


# 1. Instantiate the agent with the chosen deployment and instructions.
def _create_agent() -> Any:
    """Create the Joker agent."""

    return AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
        name="Joker",
        instructions="You are good at telling jokes.",
    )

Registre el agente con AgentFunctionApp:

# 2. Register the agent with AgentFunctionApp so Azure Functions exposes the required triggers.
app = AgentFunctionApp(agents=[_create_agent()], enable_health_check=True, max_poll_retries=50)

Ejecute localmente con Azure Functions Core Tools:

func start

A continuación, invoque:

curl -X POST http://localhost:7071/api/agents/Joker/run \
  -H "Content-Type: text/plain" \
  -d "Tell me a short joke about cloud computing."

Sugerencia

Consulte el ejemplo completo del archivo ejecutable completo y los ejemplos de hospedaje de Azure Functions para obtener más patrones.

Pasos siguientes

Introducción a los agentes

Vaya más profundamente:

Consulte también

  • Last updated on