Partilhar via

Passo 6: Aloje o seu agente

Depois de construir o seu agente, precisa de o hospedar para que os utilizadores e outros agentes possam interagir com ele.

Opções de Alojamento

Opção Description Melhor Para
Protocolo A2A Expor agentes através do protocolo Agent-to-Agent Sistemas multiagentes
Endpoints Compatíveis com OpenAI Expor agentes por meio de APIs de Conclusões de Chat ou Respostas Clientes compatíveis com OpenAI
Azure Functions (Durable) Executar agentes como Funções do Azure duráveis Tarefas de longa duração sem servidor
AG-UI Protocolo Construir aplicações de agentes de IA baseadas na web Frontends Web

Alojamento no ASP.NET Core

O Agent Framework fornece bibliotecas de alojamento que permitem integrar agentes de IA nas ASP.NET aplicações Core. Estas bibliotecas simplificam o registo, configuração e exposição de agentes através de vários protocolos.

Como descrito na Visão Geral dos Agentes, AIAgent é o conceito fundamental do Quadro do Agente. Define um "wrapper LLM" que processa as entradas do utilizador, toma decisões, chama ferramentas e realiza trabalho adicional para executar ações e gerar respostas. Expor agentes de IA da sua aplicação ASP.NET Core não é trivial. As bibliotecas de alojamento resolvem isto registando agentes de IA num contentor de injeção de dependências, permitindo-lhe resolvê-los e usá-los nos seus serviços de aplicação. Também permitem gerir dependências de agentes, como ferramentas e armazenamento de sessões, a partir do mesmo contentor. Os agentes podem ser alojados juntamente com a infraestrutura da sua aplicação, independentemente dos protocolos que utilizam. De forma semelhante, os fluxos de trabalho podem ser alojados e tirar partido da infraestrutura comum da sua aplicação.

Biblioteca Principal de Alojamento

A Microsoft.Agents.AI.Hosting biblioteca é a base para alojar agentes de IA no ASP.NET Core. Fornece extensões para IHostApplicationBuilder registar e configurar agentes e fluxos de trabalho de IA. No contexto do ASP.NET Core, IHostApplicationBuilder é o tipo fundamental que representa o construtor para aplicações e serviços alojados, gerindo configuração, registos, ciclo de vida e muito mais.

Antes de configurar agentes ou fluxos de trabalho, regista um IChatClient no contentor de injeção de dependências. Nos exemplos abaixo, está registado como um singleton chaveado sob 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);

Adicionar Agente de IA

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

O AddAIAgent() método devolve um IHostedAgentBuilder, que fornece métodos de extensão para configurar o agente. Por exemplo, 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

Também pode configurar o armazenamento de sessões (armazenamento para dados de conversa):

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

AddWorkflow

Registar fluxos de trabalho que coordenam múltiplos agentes. Um fluxo de trabalho é essencialmente um "grafo" onde cada nó é um AIAgent, e os agentes comunicam entre si.

Neste exemplo, dois agentes funcionam sequencialmente. A entrada do utilizador é enviada primeiro para agent-1, que produz uma resposta e envia-a para agent-2. O fluxo de trabalho depois gera a resposta final. Existe também um BuildConcurrent método que cria um fluxo de trabalho de agente concorrente.

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 Workflow como AIAgent

Para usar integrações de protocolos (como A2A ou OpenAI) com um fluxo de trabalho, converta-o num agente autónomo. Atualmente, os fluxos de trabalho não oferecem capacidades de integração semelhantes por si só, pelo que este passo de conversão é necessário:

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 alojamento atuam como adaptadores de protocolo que ligam protocolos de comunicação externos e a implementação interna AIAgent do Agent Framework. Quando usa uma biblioteca de integração de alojamento, a biblioteca obtém o registo AIAgent da injeção de dependências, envolve-o com middleware específico do protocolo para traduzir pedidos recebidos e respostas de saída, e invoca o AIAgent para processar pedidos. Esta arquitetura mantém a implementação do seu agente independente do protocolo.

Por exemplo, usando a biblioteca de alojamento 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();

Sugestão

Veja os exemplos de Durable Azure Functions para alojamento sem servidor.

Instale o pacote de alojamento Azure Functions:

pip install agent-framework-azurefunctions --pre

Crie 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.",
    )

Registe 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 Core do Azure Functions:

func start

Depois invoca:

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

Sugestão

Veja o exemplo completo para o ficheiro executável completo e as Funções Azure que alojam amostras para mais padrões.

Próximos passos

Visão Geral dos Agentes

Vai mais fundo:

Consulte também

  • Last updated on