Krok 7. Hostowanie agenta

Hosting w ASP.NET Core

Struktura agentów udostępnia biblioteki hostingu, które umożliwiają integrowanie agentów sztucznej inteligencji z aplikacjami ASP.NET Core. Te biblioteki upraszczają rejestrowanie, konfigurowanie i udostępnianie agentów za pomocą różnych protokołów.

Zgodnie z opisem w Omówienie agentów, AIAgent jest podstawową koncepcją Agent Framework. Definiuje "otokę LLM", która przetwarza dane wejściowe użytkownika, podejmuje decyzje, wywołuje narzędzia i wykonuje dodatkową pracę w celu wykonywania akcji i generowania odpowiedzi. Uwidacznianie agentów sztucznej inteligencji z aplikacji ASP.NET Core nie jest proste. Biblioteki hostingu rozwiążą ten problem, rejestrując agentów sztucznej inteligencji w kontenerze iniekcji zależności, umożliwiając rozpoznawanie i używanie ich w usługach aplikacji. Umożliwiają one również zarządzanie zależnościami agenta, takimi jak narzędzia i magazyn sesji, z tego samego kontenera. Agenci mogą być hostowani obok infrastruktury aplikacji niezależnie od używanych protokołów. Podobnie przepływy pracy mogą być hostowane i korzystać ze wspólnej infrastruktury aplikacji.

Podstawowa biblioteka hostingu

Biblioteka Microsoft.Agents.AI.Hosting jest podstawą hostowania agentów sztucznej inteligencji w ASP.NET Core. Udostępnia rozszerzenia IHostApplicationBuilder do rejestrowania i konfigurowania agentów i przepływów pracy AI. W ASP.NET Core IHostApplicationBuilder jest podstawowym typem reprezentującym konstruktora hostowanych aplikacji i usług, zarządzanie konfiguracją, rejestrowaniem, okresem istnienia i nie tylko.

Przed skonfigurowaniem agentów lub przepływów pracy zarejestruj IChatClient w kontenerze wstrzykiwania zależności. W poniższych przykładach jest on zarejestrowany jako kluczowy singleton pod nazwą chat-model:

// endpoint is your Microsoft Foundry project endpoint
// deploymentName is 'gpt-4o-mini' for example

IChatClient chatClient = new AIProjectClient(
        new Uri(endpoint),
        new DefaultAzureCredential())
    .GetProjectOpenAIClient()
    .GetProjectResponsesClient()
    .AsIChatClient(deploymentName);
builder.Services.AddSingleton(chatClient);

Dodaj agenta AI

Zarejestruj agenta sztucznej inteligencji za pomocą iniekcji zależności:

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

Metoda AddAIAgent() zwraca metodę IHostedAgentBuilder, która udostępnia metody rozszerzenia do konfigurowania agenta. Na przykład, możesz dodać narzędzia do agenta:

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

Możesz również skonfigurować magazyn sesji (magazyn danych konwersacji):

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

AddWorkflow

Rejestrowanie przepływów pracy, które koordynują wielu agentów. Przepływ pracy to zasadniczo "graf", w którym każdy węzeł jest elementem AIAgent, a agenci komunikują się ze sobą.

W tym przykładzie dwóch agentów działa sekwencyjnie. Dane wejściowe użytkownika są najpierw wysyłane do agent-1elementu , który generuje odpowiedź i wysyła ją do elementu agent-2. Następnie przepływ pracy zwraca ostateczną odpowiedź. Istnieje również BuildConcurrent metoda, która tworzy współbieżny przepływ pracy agenta.

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]);
});

Uwidaczniaj przepływ pracy jako AIAgent

Aby używać integracji protokołów (takich jak A2A lub OpenAI) z przepływem pracy, przekonwertuj go na autonomicznego agenta. Obecnie przepływy pracy nie zapewniają samodzielnie podobnych możliwości integracji, więc ten krok konwersji jest wymagany:

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

Szczegóły implementacji

Biblioteki hostingu działają jako adaptery protokołów, które łączą zewnętrzne protokoły komunikacyjne i wewnętrzną AIAgent implementację ramy działania agenta. W przypadku korzystania z biblioteki integracji hostingu, biblioteka pobiera zarejestrowane AIAgent z iniekcji zależności, opakowuje je za pomocą oprogramowania middleware specyficznego dla protokołu w celu tłumaczenia przychodzących żądań i odpowiedzi wychodzących, a następnie wywołuje AIAgent w celu przetworzenia żądań. Ta architektura utrzymuje implementację agenta niezależną od protokołu.

Na przykład przy użyciu biblioteki hostingu ASP.NET Core z adapterem protokołu 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();

Zainstaluj pakiet hostingowy Azure Functions, klienta usługi Foundry i pakiet uwierzytelniania Azure:

pip install agent-framework-azurefunctions agent-framework-foundry azure-identity

Utwórz agenta:

# 1. Instantiate the agent with the chosen deployment and instructions.
def _create_agent() -> Any:
    """Create the Joker agent."""
    return Agent(
        client=FoundryChatClient(
            project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
            model=os.environ["FOUNDRY_MODEL"],
            credential=AzureCliCredential(),
        ),
        name="Joker",
        instructions="You are good at telling jokes.",
    )

Zarejestruj agenta przy użyciu polecenia 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)

Uruchom lokalnie za pomocą narzędzi Azure Functions Core Tools:

az login
pip install -r requirements.txt
# Start Azurite and copy local.settings.json.template to local.settings.json first.
func start

Następnie wywołaj:

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

Hosting przy użyciu protokołu A2A

Implementacja w Go zapewnia hostowanie A2A za pomocą a2aprovider, które opakowuje agenta w moduł obsługi HTTP zgodny z protokołem Agent-to-Agent.

Utwórz agenta:

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/a2aprovider"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"

    "github.com/a2aproject/a2a-go/v2/a2a"
    "github.com/a2aproject/a2a-go/v2/a2asrv"
)

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
    },
})

Uwidaczniaj agenta za pośrednictwem usługi A2A:

url := "http://localhost:5000"
card := &a2a.AgentCard{
    Name:               "MyAgent",
    Description:        "A helpful assistant.",
    Version:            "1.0.0",
    DefaultInputModes:  []string{"text"},
    DefaultOutputModes: []string{"text"},
    Capabilities:       a2a.AgentCapabilities{Streaming: false},
    SupportedInterfaces: []*a2a.AgentInterface{
        a2a.NewAgentInterface(url, a2a.TransportProtocolJSONRPC),
    },
}

mux := http.NewServeMux()
requestHandler := a2asrv.NewHandler(
    a2aprovider.NewExecutor(a, a2aprovider.ExecutorConfig{}),
    a2asrv.WithExtendedAgentCard(card),
)
mux.Handle("/", a2asrv.NewJSONRPCHandler(requestHandler))
mux.Handle(a2asrv.WellKnownAgentCardPath, a2asrv.NewStaticAgentCardHandler(card))

log.Println("A2A server listening on :5000")
http.ListenAndServe(":5000", mux)