Compartilhar via

Etapa 6: hospedar seu agente

Depois de criar seu agente, você precisará hospedá-lo para que os usuários e outros agentes possam interagir com ele.

Opções de hospedagem

Opção DESCRIÇÃO Mais Adequado Para
Protocolo A2A Expor agentes por meio do protocolo Agente para Agente Sistemas multiagente
Endpoints compatíveis com OpenAI Expor agentes por meio das APIs "Chat Completions" ou "Responses" Clientes compatíveis com OpenAI
Azure Functions (Durable) Executar agentes como Durable Functions do Azure Tarefas sem servidor e de execução longa
Protocolo AG-UI Criar aplicativos de agente de IA baseados na Web Front-ends de Web

Hospedagem no ASP.NET Core

O Agent Framework fornece bibliotecas de hospedagem que permitem integrar agentes de IA a aplicativos ASP.NET Core. Essas bibliotecas simplificam o registro, a configuração e a exposição de agentes por meio de vários protocolos.

Conforme descrito na Visão Geral dos Agentes, AIAgent é o conceito fundamental da Estrutura do Agente. Ele define um "wrapper LLM" que processa entradas do usuário, toma decisões, chama ferramentas e executa trabalho adicional para executar ações e gerar respostas. Expor agentes de IA de seu aplicativo ASP.NET Core não é trivial. As bibliotecas de hospedagem resolvem isso registrando agentes de IA em um contêiner de injeção de dependência, permitindo que você resolva e use-as em seus serviços de aplicativo. Eles também permitem que você gerencie dependências de agente, como ferramentas e armazenamento de sessão, do mesmo contêiner. Os agentes podem ser hospedados junto com sua infraestrutura de aplicativo, independentemente dos protocolos que eles usam. Da mesma forma, os fluxos de trabalho podem ser hospedados e aproveitar a infraestrutura comum do aplicativo.

Biblioteca de hospedagem principal

A Microsoft.Agents.AI.Hosting biblioteca é a base para hospedar agentes de IA no ASP.NET Core. Ele fornece extensões para IHostApplicationBuilder registrar e configurar agentes de IA e fluxos de trabalho. No ASP.NET Core, IHostApplicationBuilder é o tipo fundamental que representa o construtor para aplicativos e serviços hospedados, gerenciando a configuração, o registro em log, o tempo de vida e muito mais.

Antes de configurar agentes ou fluxos de trabalho, registre um IChatClient no contêiner de injeção de dependência. Nos exemplos abaixo, está registrado como um singleton identificado por chave com o nome 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

Registre um agente de IA com injeção de dependência:

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");

AddAIAgent() método retorna um IHostedAgentBuilder, que fornece métodos de extensão para configurar o agente. Por exemplo, você pode adicionar ferramentas ao 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

Você também pode configurar o repositório de sessão (armazenamento para dados de conversa):

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

AddWorkflow

Registre fluxos de trabalho que coordenam vários agentes. Um fluxo de trabalho é essencialmente um "grafo" em que cada nó é um AIAgent, e os agentes se comunicam entre si.

Neste exemplo, dois agentes funcionam sequencialmente. A entrada do usuário é enviada primeiro para agent-1, o que produz uma resposta e a envia para agent-2. Em seguida, o fluxo de trabalho gera a resposta final. Há também um BuildConcurrent método que cria um fluxo de trabalho 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]);
});

Expor fluxo de trabalho como AIAgent

Para usar integrações de protocolo (como A2A ou OpenAI) com um fluxo de trabalho, converta-o em um agente autônomo. Atualmente, os fluxos de trabalho não fornecem recursos de integração semelhantes por conta própria, portanto, essa etapa de conversão é necessária:

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

Detalhes da implementação

As bibliotecas de hospedagem atuam como adaptadores de protocolo que fazem a ponte entre os protocolos de comunicação externa e a implementação interna AIAgent do Agent Framework. Quando você usa uma biblioteca de integração de hospedagem, a biblioteca recupera o registrado AIAgent da injeção de dependência, encapsula-o com middleware específico do protocolo para traduzir as solicitações recebidas e as respostas enviadas, e invoca AIAgent para processar as solicitações. Essa arquitetura mantém a implementação do agente indiferente ao protocolo.

Por exemplo, usando a biblioteca de hospedagem do ASP.NET Core com o 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();

Dica

Consulte os exemplos do Durable Azure Functions para exemplos de hospedagem sem servidor.

Instale o pacote de hospedagem do Azure Functions:

pip install agent-framework-azurefunctions --pre

Criar um 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 o agente com 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)

Execute localmente com as Ferramentas Principais do Azure Functions:

func start

Em seguida, 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."

Dica

Consulte o exemplo completo do arquivo executável completo e os exemplos de hospedagem do Azure Functions para obter mais padrões.

Próximas etapas

Visão geral dos agentes

Vá mais fundo:

Consulte também

  • Last updated on