Steg 7: Var värd för din agent

Hosting i ASP.NET Core

Agent Framework tillhandahåller värdbibliotek som gör att du kan integrera AI-agenter i ASP.NET Core-program. De här biblioteken förenklar registreringen, konfigurationen och avslöjandet av agenter via olika protokoll.

Som beskrivs i AgenterAIAgent är den grundläggande agentabstraktionen i Agent Framework. Den definierar en "LLM-wrapper" som bearbetar användarindata, fattar beslut, anropar verktyg och utför ytterligare arbete för att genomföra åtgärder och generera svar. Att exponera AI-agenter från ditt ASP.NET Core-program är inte trivialt. Värdbiblioteken löser detta genom att registrera AI-agenter i en container för beroendeinmatning, så att du kan lösa och använda dem i dina programtjänster. De gör också att du kan hantera agentberoenden, till exempel verktyg och sessionslagring, från samma container. Agenter kan finnas tillsammans med din programinfrastruktur, oberoende av de protokoll som de använder. På samma sätt kan arbetsflöden hanteras och utnyttja programmets gemensamma infrastruktur.

Kärnvärdbibliotek

Biblioteket Microsoft.Agents.AI.Hosting är grunden för att hosta AI-agenter i ASP.NET Core. Den innehåller tillägg för IHostApplicationBuilder att registrera och konfigurera AI-agenter och arbetsflöden. I ASP.NET Core IHostApplicationBuilder är den grundläggande typen som representerar byggare för värdbaserade program och tjänster, hantering av konfiguration, loggning, livslängd med mera.

Innan du konfigurerar agenter eller arbetsflöden registrerar du en IChatClient i containern för beroendeinmatning. I exemplen nedan registreras den som en nyckelad singleton under namnet 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);

AddAIAgent

Registrera en AI-agent med beroendeinmatning:

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

Metoden AddAIAgent() returnerar en IHostedAgentBuilder, som innehåller tilläggsmetoder för att konfigurera agenten. Du kan till exempel lägga till verktyg i agenten:

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

Du kan också konfigurera sessionsarkivet (lagring för konversationsdata):

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

AddWorkflow

Registrera arbetsflöden som samordnar flera agenter. Ett arbetsflöde är i princip ett "diagram" där varje nod är en AIAgent, och agenterna kommunicerar med varandra.

I det här exemplet fungerar två agenter sekventiellt. Användarens indata skickas först till agent-1, vilket genererar ett svar och skickar det till agent-2. Arbetsflödet matar sedan ut det slutliga svaret. Det finns också en BuildConcurrent metod som skapar ett arbetsflöde för samtidig agent.

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

Exponera arbetsflöde som AIAgent

Om du vill använda protokollintegreringar (till exempel A2A eller OpenAI) med ett arbetsflöde konverterar du det till en fristående agent. För närvarande tillhandahåller arbetsflöden inte liknande integreringsfunktioner på egen hand, så det här konverteringssteget krävs:

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

Implementeringsinformation

Värdbiblioteken fungerar som protokolladapterar som överbryggar externa kommunikationsprotokoll och Agent Frameworks interna AIAgent implementation. När du använder ett värdintegreringsbibliotek hämtar biblioteket den registrerade AIAgent från beroendeinmatningen, omsluter den med protokollspecifikt mellanprogram för att översätta inkommande begäranden och utgående svar och anropar AIAgent för att bearbeta begäranden. Den här arkitekturen håller din agentimplementering protokoll-agnostisk.

Till exempel kan du använda ASP.NET Core-värdbiblioteket med A2A-protokolladaptern.

// 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 är det primära hanterade värdalternativet. Slutför kraven för Foundry Hosted Agents, inklusive Azure DEVELOPER CLI AI-agenttillägget och Azure CLI inloggning.

Kom igång-exemplet skapar en agent med modelllagring på serversidan inaktiverad och startar en 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()

Ersätt den hårdkodade projektets slutpunkt och namnet på modelldistributionen och kör sedan PEP 723-exemplet lokalt från Agent Framework-lagringsplatsens rot:

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

Om du vill distribuera ett fullständigt projekt med värdhanterad agent initierar du det från det underhållna värdmanifestet:

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

Kör agentvärden:

azd ai agent run

Anropa den lokala agenten i en annan terminal:

azd ai agent invoke --local "Hello!"

Hosting med A2A-protokoll

Go-portningen ger stöd för A2A-värdskap genom a2aprovider, som kapslar in en agent i en HTTP-hanterare som är kompatibel med Agent-to-Agent-protokollet.

Skapa en agent:

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

Exponera agenten via 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)