Schritt 7: Hosten Ihres Agents

Hosten in ASP.NET Core

Das Agent Framework bietet Hostingbibliotheken, mit denen Sie KI-Agents in ASP.NET Core-Anwendungen integrieren können. Diese Bibliotheken vereinfachen das Registrieren, Konfigurieren und Verfügbarmachen von Agents über verschiedene Protokolle.

Wie in Agents beschrieben, AIAgent ist die grundlegende Agent-Abstraktion im Agent Framework. Es definiert einen "LLM-Wrapper", der Benutzereingaben verarbeitet, Entscheidungen trifft, Tools aufruft und zusätzliche Aufgaben ausführt, um Aktionen auszuführen und Antworten zu generieren. Das Exposieren von KI-Agents aus Ihrer ASP.NET Core-Anwendung ist nicht trivial. Die Hostingbibliotheken lösen dies durch das Registrieren von KI-Agenten in einen Dependency Injection-Container, sodass Sie sie in Ihren Anwendungsdiensten auflösen und anwenden können. Außerdem können Sie Agentabhängigkeiten wie Tools und Sitzungsspeicher aus demselben Container verwalten. Agents können zusammen mit Ihrer Anwendungsinfrastruktur gehostet werden, unabhängig von den verwendeten Protokollen. Ebenso können Workflows gehostet werden und die gemeinsame Infrastruktur Ihrer Anwendung nutzen.

Kernhostingbibliothek

Die Microsoft.Agents.AI.Hosting Bibliothek ist die Grundlage für das Hosten von KI-Agents in ASP.NET Core. Es bietet Erweiterungen für IHostApplicationBuilder zur Registrierung und Konfiguration von KI-Agenten und Workflows. In ASP.NET Core ist der grundlegende Typ IHostApplicationBuilder, der den Builder für gehostete Anwendungen und Dienste darstellt, der Konfiguration, Protokollierung, Lebensdauer und mehr verwaltet.

Registrieren Sie einen IChatClient im Abhängigkeitsinjektionscontainer, bevor Sie Agents oder Workflows konfigurieren. In den folgenden Beispielen wird es als Keyed Singleton unter dem Namen chat-modelregistriert:

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

AddAIAgent

Registrieren eines KI-Agents mit Abhängigkeitsinjektion:

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

Die AddAIAgent() Methode gibt eine IHostedAgentBuilder, die Erweiterungsmethoden zum Konfigurieren des Agents bereitstellt. Sie können dem Agent z. B. Tools hinzufügen:

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

Den Sitzungsspeicher (Speicher für Gesprächsdaten) können Sie auch konfigurieren.

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

AddWorkflow

Registrieren Sie Workflows, die mehrere Agents koordinieren. Ein Workflow ist im Wesentlichen ein "Diagramm", in dem jeder Knoten ein AIAgentist, und die Agents kommunizieren miteinander.

In diesem Beispiel arbeiten zwei Agents sequenziell. Die Benutzereingabe wird zuerst an agent-1 gesendet, welches eine Antwort erzeugt und an agent-2 sendet. Der Workflow gibt dann die endgültige Antwort aus. Es gibt auch eine BuildConcurrent Methode, mit der ein gleichzeitiger Agent-Workflow erstellt wird.

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

Workflow als AIAgent verfügbar machen

Um Protokollintegrationen (z. B. A2A oder OpenAI) mit einem Workflow zu verwenden, konvertieren Sie sie in einen eigenständigen Agent. Derzeit stellen Workflows keine ähnlichen Integrationsfunktionen selbst bereit, daher ist dieser Konvertierungsschritt erforderlich:

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

Implementierungsdetails

Die Hostingbibliotheken fungieren als Protokolladapter, die externe Kommunikationsprotokolle und die interne AIAgent Implementierung des Agent-Frameworks überbrücken. Wenn Sie eine Hostintegrationsbibliothek verwenden, ruft die Bibliothek die registrierte AIAgent aus der Abhängigkeitsinjektion ab, umschließt sie mit protokollspezifischer Middleware, um eingehende Anforderungen und ausgehende Antworten zu übersetzen, und ruft AIAgent zur Verarbeitung der Anforderungen auf. Diese Architektur sorgt dafür, dass Ihre Agentenimplementierung protokollunabhängig bleibt.

Verwenden Sie beispielsweise die ASP.NET Core-Hostingbibliothek mit dem A2A-Protokolladapter:

// 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();

Microsoft Foundry Hosted Agents ist die primäre verwaltete Hostingoption. Schließen Sie die Voraussetzungen für foundry Hosted Agents ab, einschließlich der Azure Entwickler-CLI AI-Agent-Erweiterung und Azure CLI Anmeldung.

Das Erste-Schritte-Beispiel erstellt einen Agent mit deaktiviertem serverseitigem Modellspeicher und startet einen ResponsesHostServer:

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient, ResponsesHostServer
from azure.identity import DefaultAzureCredential


def main() -> None:
    agent = Agent(
        client=FoundryChatClient(
            project_endpoint="https://your-account.services.ai.azure.com/api/projects/your-project",
            model="gpt-6-luna",
            credential=DefaultAzureCredential(),
        ),
        instructions="You are a friendly assistant. Keep your answers brief.",
        default_options={"store": False},
    )
    ResponsesHostServer(agent=agent, history_source="agent_server").run()


if __name__ == "__main__":
    main()

Ersetzen Sie den hartcodierten Projektendpunkt und den Modellbereitstellungsnamen, und führen Sie dann das PEP 723-Beispiel lokal aus dem Agent Framework-Repositorystamm aus:

uv run python/samples/01-get-started/07_hosting.py

Um ein vollständiges gehostetes Agent-Projekt bereitzustellen, initialisieren Sie es aus dem verwalteten Hostingmanifest:

mkdir my-hosted-agent && cd my-hosted-agent
azd ai agent init -m https://github.com/microsoft/agent-framework/blob/main/python/samples/04-hosting/foundry-hosted-agents/responses/basic/agent.manifest.yaml

Führen Sie den Agenthost aus:

azd ai agent run

Rufen Sie in einem anderen Terminal den lokalen Agent auf:

azd ai agent invoke --local "Hello!"

Hosting mit A2A-Protokoll

Der Go-Port ermöglicht A2A-Hosting über a2aprovider, das einen Agenten in einen HTTP-Handler kapselt, der mit dem Agent-to-Agent-Protokoll kompatibel ist.

Erstellen eines Agents:

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{
    },
})

Machen Sie den Agent über A2A verfügbar:

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)