Partager via

Étape 6 : Héberger votre agent

Une fois que vous avez créé votre agent, vous devez l’héberger afin que les utilisateurs et d’autres agents puissent interagir avec celui-ci.

Options d’hébergement

Choix Descriptif Idéal pour
Protocole A2A Exposer des agents via le protocole Agent-à-Agent Systèmes multi-agents
Points de terminaison compatibles avec OpenAI Exposer des agents via des API de complétion de conversation ou de réponses Clients compatibles OpenAI
Azure Functions (Durable) Exécuter des agents en tant que fonctions Azure durables Tâches serverless et longues
protocole AG-UI Créer des applications d’agent IA basées sur le web Frontaux web

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 la vue d’ensemble des agents, AIAgent il s’agit du concept fondamental de l’infrastructure de l’agent. 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 inscrire et 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 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);

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

Conseil / Astuce

Consultez les exemples de Fonctions Azure Durables pour des exemples d’hébergement sans serveur.

Installez le package d’hébergement Azure Functions :

pip install agent-framework-azurefunctions --pre

Créez un agent :

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

Inscrivez l’agent auprès de 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)

Exécutez localement avec Azure Functions Core Tools :

func start

Appelez ensuite :

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

Conseil / Astuce

Consultez l’exemple complet pour le fichier exécutable complet et les exemples d’hébergement Azure Functions pour plus de modèles.

Prochaines étapes

Vue d’ensemble des agents

Aller plus loin :

Voir aussi

  • Last updated on