Étape 7 : Héberger votre agent

Pour comparer les agents hébergés Foundry gérés par Microsoft, l’auto-hébergement et l’exécution durable avec l’extension Durable, consultez Hébergement des applications Agent Framework.

Hébergement dans ASP.NET Core

Agent Framework fournit des bibliothèques d’hébergement qui vous permettent d’intégrer des agents IA dans des applications ASP.NET Core. Ces bibliothèques simplifient l’inscription, la configuration et l’exposition d’agents via différents protocoles.

Comme décrit dans Agents, AIAgent est l’abstraction d’agent fondamentale dans Agent Framework. Il définit un wrapper « LLM » qui traite les entrées utilisateur, prend des décisions, appelle des outils et effectue des tâches supplémentaires pour exécuter des actions et générer des réponses. L’exposition d’agents IA à partir de votre application ASP.NET Core n’est pas triviale. Les bibliothèques d’hébergement résolvent ce problème en inscrivant des agents IA dans un conteneur d’injection de dépendances, ce qui vous permet de les résoudre et de les utiliser dans vos services d’application. Ils vous permettent également de gérer les dépendances de l’agent, telles que les outils et le stockage de session, à partir du même conteneur. Les agents peuvent être hébergés en même temps que votre infrastructure d’application, indépendamment des protocoles qu’ils utilisent. De même, les workflows peuvent être hébergés et tirer parti de l’infrastructure commune de votre application.

Bibliothèque d’hébergement principale

La Microsoft.Agents.AI.Hosting bibliothèque est la base de l’hébergement d’agents IA dans ASP.NET Core. Il fournit des extensions pour IHostApplicationBuilder afin d'inscrire et de configurer des agents et des flux de travail IA. Dans ASP.NET Core, IHostApplicationBuilder est le type fondamental qui représente le générateur pour les applications et services hébergés, la gestion de la configuration, de la journalisation, de la durée de vie, etc.

Avant de configurer des agents ou des flux de travail, enregistrez un IChatClient dans le conteneur d’injection de dépendances. Dans les exemples ci-dessous, il est enregistré en tant que singleton associé à une clé sous le nom 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);

Avertissement

DefaultAzureCredential est pratique pour le développement, mais nécessite une considération minutieuse en production. En production, envisagez d’utiliser des informations d’identification spécifiques (par exemple ManagedIdentityCredential) pour éviter les problèmes de latence, la détection involontaire des informations d’identification et les risques de sécurité potentiels liés aux mécanismes de secours.

AddAIAgent

Inscrivez un agent IA avec l’injection de dépendances :

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

La méthode AddAIAgent() retourne un IHostedAgentBuilder, qui fournit des méthodes d’extension pour la configuration de l’agent. Par exemple, vous pouvez ajouter des outils à l’agent :

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

Vous pouvez également configurer le stockage des sessions (pour les données de conversation) :

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

AddWorkflow

Inscrivez des flux de travail qui coordonnent plusieurs agents. Un flux de travail est essentiellement un « graphe » où chaque nœud est un AIAgent, et les agents communiquent entre eux.

Dans cet exemple, deux agents fonctionnent de manière séquentielle. L’entrée utilisateur est d’abord envoyée à agent-1, ce qui produit une réponse et l’envoie à agent-2. Le flux de travail génère ensuite la réponse finale. Il existe également une BuildConcurrent méthode qui crée un flux de travail d’agent simultané.

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

Exposer le flux de travail en tant qu’AIAgent

Pour utiliser des intégrations de protocole (telles que A2A ou OpenAI) avec un flux de travail, convertissez-la en agent autonome. Actuellement, les flux de travail ne fournissent pas de fonctionnalités d’intégration similaires, de sorte que cette étape de conversion est requise :

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

Détails de l’implémentation

Les bibliothèques d’hébergement agissent en tant qu’adaptateurs de protocole qui pontent les protocoles de communication externes et l’implémentation interne AIAgent de l’Agent Framework. Lorsque vous utilisez une bibliothèque d'intégration d'hébergement, la bibliothèque récupère le registre de AIAgent à partir de l’injection de dépendances, l'encapsule avec un middleware spécifique au protocole pour traduire les requêtes entrantes et les réponses sortantes, et invoque le AIAgent pour traiter les requêtes. Cette architecture maintient votre implémentation d'agent indépendante du protocole.

Par exemple, à l’aide de la bibliothèque d’hébergement ASP.NET Core avec l’adaptateur de protocole 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();

Microsoft Foundry Hosted Agents constitue la principale option d’hébergement managé. Remplissez les prérequis de Foundry Hosted Agents, y compris l’extension d’agent IA Azure Developer CLI et la connexion à Azure CLI.

L’exemple de démarrage crée un agent avec le stockage de modèle côté serveur désactivé et démarre un 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()

Remplacez le point de terminaison de projet codé en dur et le nom du déploiement de modèle, puis exécutez l’exemple PEP 723 localement à partir de la racine du référentiel Agent Framework :

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

Pour déployer un projet d’agent hébergé complet, initialisez-le à partir de l’exemple maintenu azure.yaml :

mkdir my-hosted-agent && cd my-hosted-agent
azd ai agent init -t https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/01-basic/azure.yaml --src .

Exécutez l’hôte de l’agent :

azd ai agent run

Dans un autre terminal, appelez l’agent local :

azd ai agent invoke --local "Hello!"

Tip

Consultez l’exemple de prise en main complète et l’exemple de déploiement complet. Pour obtenir des conseils de déploiement, consultez Foundry Hosted Agents.

Hébergement avec le protocole A2A

L’implémentation Go permet l’hébergement A2A via a2aprovider, qui encapsule un agent dans un gestionnaire HTTP compatible avec le protocole Agent-to-Agent.

Note

L’hébergement d’extension durable n’est actuellement pas disponible pour Go. Pour obtenir la dernière version de l’état du Kit de développement logiciel (SDK) Go Go, consultez le référentiel Agent Framework Go.

Créez un 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{
    },
})

Exposez l’agent 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)

Tip

Consultez l’exemple complet de serveur client A2A pour obtenir un exemple exécutable complet.

Étapes suivantes

Agents

Aller plus loin :

Voir aussi

  • Dernière mise à jour :