Créer des systèmes d'IA multi-agents avec le framework d'agents de Microsoft

· 14 min de lecture
AI .NET Agent Framework Semantic Kernel
Available in: Français · English · Español · Deutsch · Português · 한국어 · 日本語 · Русский · 中文 · العربية · हिन्दी · Polski · Türkçe · Bahasa Indonesia · Nederlands

##Présentation

Nous sommes entrés dans l’ère des systèmes d’IA multi-agents. Au lieu d’une seule IA monolithique gérant tout, l’industrie s’oriente vers des agents spécialisés qui collaborent pour résoudre des problèmes complexes – un peu comme une équipe d’experts bien organisée. Un agent fait des recherches, un autre analyse, un troisième écrit et un coordinateur maintient tout le monde sur la bonne voie.

Si vous avez travaillé avec de grands modèles de langage, vous avez probablement atteint le plafond de ce qu’une seule invite peut faire. Les fenêtres contextuelles se remplissent, les instructions s’emmêlent et la qualité se dégrade. Les architectures multi-agents résolvent ce problème en décomposant les tâches complexes en responsabilités ciblées, où chaque agent est un expert dans un domaine particulier.

L’Agent Framework de Microsoft, qui fait partie de l’écosystème plus large du noyau sémantique, offre aux développeurs .NET une boîte à outils de premier ordre pour créer exactement ce type de systèmes. Dans cet article, nous passerons de zéro à un pipeline multi-agent pleinement fonctionnel, couvrant les concepts de base, les modèles d’orchestration et le code pratique dont vous avez besoin pour commencer.

Qu’est-ce que l’Agent Framework de Microsoft ?

L’Agent Framework est la réponse de Microsoft à la création, à l’orchestration et au déploiement d’agents IA et de systèmes multi-agents dans .NET. Il s’associe – et s’intègre profondément – au noyau sémantique, qui est le SDK open source de Microsoft pour l’orchestration de l’IA depuis 2023.

Pensez-y de cette façon : Semantic Kernel vous fournit les primitives (noyaux, plugins, mémoire, planificateurs), tandis que Agent Framework vous propose des abstractions de niveau supérieur spécialement conçues pour la communication et la coordination d’agent à agent.

Le framework prend en charge plusieurs fournisseurs de modèles, notamment Azure OpenAI, OpenAI et les modèles hébergés sur Azure AI Foundry. Sa conception est indépendante du modèle mais profondément intégrée à l’écosystème Azure, ce qui la rend particulièrement intéressante pour les scénarios d’entreprise.

Les fonctionnalités clés incluent :

  • Plusieurs types d’agents : ChatCompletionAgent, OpenAIAssistantAgent et AzureAIAgent pour différents backends
  • Modèles d’orchestration : workflows séquentiels, simultanés, de transfert et de discussion de groupe
  • Écosystème de plugins : étendez les agents avec des fonctions C# natives, des spécifications OpenAPI et des outils Model Context Protocol (MCP).
  • Gestion des conversations : stratégies intégrées de threading, de gestion de l’historique et de terminaison
  • Observabilité : Intégration avec OpenTelemetry pour le traçage des interactions des agents

Concepts clés

Avant d’écrire du code, établissons le vocabulaire. L’Agent Framework s’articule autour de quelques abstractions principales.

###Agents

Un agent est une entité soutenue par un modèle d’IA, configurée avec des instructions spécifiques (une invite système), un nom et éventuellement un ensemble de plugins ou d’outils. Chaque agent est un spécialiste : vous définissez ce qu’il sait, ce qu’il peut faire et comment il doit se comporter.

ChatCompletionAgentLe type d’agent le plus simple. Il enveloppe un point de terminaison de discussion (Azure OpenAI, OpenAI, etc.) et maintient une conversation. Il est sans état entre les invocations : vous fournissez l’historique et il répond. Cela le rend léger et facile à raisonner.

ChatCompletionAgent agent = new()
{
    Name = "Reviewer",
    Instructions = "You are a senior code reviewer. Analyze the provided code for bugs, security issues, and style violations. Be concise and actionable.",
    Kernel = kernel
};

OuvrirAIAssistantAgent

Ce type d’agent exploite l’API OpenAI Assistants, qui fournit l’état de conversation côté serveur, la gestion des fichiers et l’interprétation du code. Il est plus lourd mais vous offre des threads persistants et des outils intégrés tels que l’interpréteur de code et la recherche de fichiers.

OpenAIAssistantAgent agent = await OpenAIAssistantAgent.CreateAsync(
    clientProvider: clientProvider,
    definition: new OpenAIAssistantDefinition("gpt-4o")
    {
        Name = "DataAnalyst",
        Instructions = "You analyze datasets and produce statistical summaries."
    }
);

AgentGroupChat

C’est l’orchestrateur. AgentGroupChat gère les conversations à plusieurs tours entre plusieurs agents, en contrôlant qui parle ensuite, quand la conversation se termine et comment l’historique est partagé. C’est là que la magie de la collaboration multi-agents opère.

Modèles d’orchestration

Le framework prend en charge quatre modèles d’orchestration principaux, chacun adapté à différents problèmes.

Séquentiel

Les agents s’exécutent les uns après les autres dans un ordre défini. La sortie de l’agent A alimente l’agent B, dont la sortie alimente l’agent C. Ceci est idéal pour les pipelines : brouillon → révision → édition → publication.

// Conceptual flow
var draft = await writerAgent.InvokeAsync("Write a blog post about .NET 9");
var reviewed = await reviewerAgent.InvokeAsync($"Review this: {draft}");
var edited = await editorAgent.InvokeAsync($"Edit based on feedback: {reviewed}");

Concurrent

Plusieurs agents travaillent simultanément sur la même entrée. Vous répartissez le travail, puis regroupez les résultats. Idéal pour obtenir des perspectives diverses, par exemple si trois évaluateurs examinent la même pull request.

Transfert

Un agent décide de transférer le contrôle à un autre agent en fonction du contexte de la conversation. Cela imite le fonctionnement d’une équipe de service client : l’agent de première ligne traite les requêtes de base et les transmet aux spécialistes en cas de besoin.

Discussion de groupe

Plusieurs agents participent à une conversation ouverte, à tour de rôle en fonction d’une stratégie de sélection. La classe AgentGroupChat implémente ce modèle avec une logique de tour de rôle et de terminaison configurable.

Créer votre premier agent

Soyons pratiques. Voici comment créer votre premier agent étape par étape.

Prérequis

Vous aurez besoin de :

  • SDK .NET 9
  • Une ressource Azure OpenAI avec un modèle déployé (par exemple, gpt-4o)
  • Visual Studio ou VS Code

Configuration du projet

Créez une nouvelle application console et installez les packages requis :

dotnet new console -n AgentDemo
cd AgentDemo
dotnet add package Microsoft.SemanticKernel --prerelease
dotnet add package Microsoft.SemanticKernel.Agents.Core --prerelease
dotnet add package Azure.AI.OpenAI
dotnet add package Azure.Identity

Création d’un agent simple

Tout d’abord, configurez le noyau avec votre configuration Azure OpenAI :

using Azure.Identity;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.ChatCompletion;

var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: "https://your-resource.openai.azure.com/",
    credentials: new DefaultAzureCredential()
);

Kernel kernel = builder.Build();

Créez maintenant un agent et invoquez-le :

ChatCompletionAgent agent = new()
{
    Name = "TechWriter",
    Instructions = """
        You are a technical writer specializing in software documentation.
        Write clear, concise content aimed at experienced developers.
        Use code examples when appropriate.
        Always structure your output with headings and bullet points.
        """,
    Kernel = kernel
};

ChatHistory history = new();
history.AddUserMessage("Explain dependency injection in .NET in 200 words.");

await foreach (ChatMessageContent response in agent.InvokeAsync(history))
{
    Console.WriteLine(response.Content);
}

C’est tout. Vous avez un agent qui travaille. Mais le véritable pouvoir vient lorsque les agents travaillent ensemble.

Orchestration multi-agents avec AgentGroupChat

Créons quelque chose de plus intéressant : une discussion de groupe où plusieurs agents collaborent. La classe AgentGroupChat gère le flux de la conversation, y compris qui parle ensuite et quand s’arrêter.

Définir les agents

Nous allons créer trois agents : un rédacteur, un réviseur et un éditeur.

ChatCompletionAgent writer = new()
{
    Name = "Writer",
    Instructions = """
        You are a content writer. When given a topic, produce a well-structured
        draft. Focus on clarity and technical accuracy.
        When you receive feedback from the Reviewer, incorporate it into a
        revised draft.
        """,
    Kernel = kernel
};

ChatCompletionAgent reviewer = new()
{
    Name = "Reviewer",
    Instructions = """
        You are a content reviewer. Analyze drafts for technical accuracy,
        clarity, and completeness. Provide specific, actionable feedback.
        Do NOT rewrite the content — only provide feedback.
        When the content meets your standards, respond with: APPROVED
        """,
    Kernel = kernel
};

ChatCompletionAgent editor = new()
{
    Name = "Editor",
    Instructions = """
        You are an editor. Once content is approved by the Reviewer,
        polish it for grammar, tone, and formatting.
        Output only the final polished version.
        When you have produced the final version, respond with: COMPLETE
        """,
    Kernel = kernel
};

Configuration de la discussion de groupe

Le AgentGroupChat nécessite deux configurations clés : une stratégie de sélection (qui parle ensuite) et une stratégie de terminaison (quand s’arrêter).

AgentGroupChat chat = new(writer, reviewer, editor)
{
    ExecutionSettings = new()
    {
        SelectionStrategy = new SequentialSelectionStrategy(),
        TerminationStrategy = new ApprovalTerminationStrategy()
        {
            Agents = [editor],
            MaximumIterations = 12
        }
    }
};

Stratégie de résiliation personnaliséeLa stratégie de terminaison définit le moment où la conversation se termine. En voici un personnalisé qui recherche le mot-clé « COMPLETE » :

class ApprovalTerminationStrategy : TerminationStrategy
{
    protected override Task<bool> ShouldAgentTerminateAsync(
        Agent agent,
        IReadOnlyList<ChatMessageContent> history,
        CancellationToken cancellationToken = default)
    {
        bool isComplete = history
            .Last()
            .Content?
            .Contains("COMPLETE", StringComparison.OrdinalIgnoreCase) ?? false;

        return Task.FromResult(isComplete);
    }
}

Exécuter la conversation

Lancez la conversation avec un message utilisateur et laissez les agents collaborer :

chat.AddChatMessage(
    new ChatMessageContent(AuthorRole.User,
        "Write a 300-word technical overview of gRPC vs REST for microservices.")
);

await foreach (ChatMessageContent message in chat.InvokeAsync())
{
    Console.WriteLine($"[{message.AuthorName}]: {message.Content}");
    Console.WriteLine("---");
}

Le flux ressemblera à ceci :

  1. Writer produit un brouillon
  2. Le réviseur fournit des commentaires
  3. Writer révise en fonction des commentaires
  4. Le réviseur dit « APPROUVÉ »
  5. Éditeur peaufine et dit “COMPLET”
  6. La conversation se termine

Ce va-et-vient se poursuit automatiquement jusqu’à ce que la condition de terminaison soit remplie ou que MaximumIterations soit atteint.

Plugins et outils

Les agents deviennent véritablement puissants lorsqu’ils peuvent interagir avec des systèmes externes. Agent Framework prend en charge trois mécanismes d’extension principaux.

Fonctions natives (plugins du noyau)

Vous pouvez donner aux agents l’accès aux méthodes C# en tant qu’outils. L’agent appellera ces fonctions lorsqu’il déterminera qu’elles sont nécessaires :

public class ContentToolsPlugin
{
    [KernelFunction("word_count")]
    [Description("Counts the number of words in the provided text.")]
    public int WordCount([Description("The text to count words in")] string text)
    {
        return text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
    }

    [KernelFunction("check_readability")]
    [Description("Calculates a readability score for the given text.")]
    public string CheckReadability([Description("The text to analyze")] string text)
    {
        var words = text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
        var sentences = text.Split(['.', '!', '?'], StringSplitOptions.RemoveEmptyEntries).Length;

        if (sentences == 0) return "Unable to calculate — no sentences found.";

        double avgWordsPerSentence = (double)words / sentences;

        return avgWordsPerSentence switch
        {
            < 15 => $"Easy to read (avg {avgWordsPerSentence:F1} words/sentence)",
            < 25 => $"Moderate difficulty (avg {avgWordsPerSentence:F1} words/sentence)",
            _ => $"Difficult to read (avg {avgWordsPerSentence:F1} words/sentence). Consider shorter sentences."
        };
    }
}

Enregistrez le plugin sur le noyau avant de créer l’agent :

kernel.Plugins.AddFromType<ContentToolsPlugin>();

ChatCompletionAgent analyst = new()
{
    Name = "ContentAnalyst",
    Instructions = "Analyze content using available tools. Report word count and readability.",
    Kernel = kernel,
    Arguments = new KernelArguments(
        new PromptExecutionSettings
        {
            FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
        })
};

Protocole de contexte de modèle (MCP)

MCP est un standard ouvert permettant de connecter des modèles d’IA à des outils et sources de données externes. Agent Framework prend en charge MCP, ce qui signifie que vos agents peuvent utiliser les outils exposés par n’importe quel serveur compatible MCP. Cela ouvre la porte aux systèmes de fichiers, aux bases de données, aux API et bien plus encore, le tout via une interface standardisée.

// Example: Adding an MCP server for file operations
kernel.Plugins.AddFromMcpServer("filesystem",
    new Uri("http://localhost:3000/mcp"));

C’est particulièrement intéressant car cela signifie que vos agents ne sont pas limités à ce que vous créez : ils peuvent accéder à un écosystème d’outils MCP que d’autres développent et partagent.

Exemple concret : pipeline de révision de contenu

Rassemblons le tout avec un scénario pratique. Imaginez que vous créez un outil interne qui automatise la révision du contenu pour une équipe de documentation. Le pipeline comporte quatre étapes :

  1. Chercheur — Rassemble les informations techniques pertinentes
  2. Écrivain — Produit un brouillon basé sur la recherche
  3. Examinateur — Vérifie l’exactitude et l’exhaustivité
  4. Publisher — Formate et prépare le résultat final

Voici une implémentation condensée :

using Azure.Identity;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.ChatCompletion;

// Build the kernel
var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: "https://your-resource.openai.azure.com/",
    credentials: new DefaultAzureCredential()
);
Kernel kernel = builder.Build();

// Define specialized agents
ChatCompletionAgent researcher = new()
{
    Name = "Researcher",
    Instructions = """
        You are a technical researcher. Given a topic, identify the key
        concepts, recent developments, and important details that should
        be covered. Output a structured research brief.
        """,
    Kernel = kernel
};

ChatCompletionAgent writer = new()
{
    Name = "Writer",
    Instructions = """
        You are a technical writer. Using the research brief provided,
        write a comprehensive, well-structured article. Include code
        examples where relevant. Target audience: experienced developers.
        """,
    Kernel = kernel
};

ChatCompletionAgent reviewer = new()
{
    Name = "Reviewer",
    Instructions = """
        You are a senior technical reviewer. Check the article for:
        - Technical accuracy
        - Completeness relative to the research brief
        - Code correctness
        - Clarity and structure
        If everything looks good, respond with APPROVED.
        Otherwise, provide specific feedback for revision.
        """,
    Kernel = kernel
};

ChatCompletionAgent publisher = new()
{
    Name = "Publisher",
    Instructions = """
        You are a content publisher. Once the article is approved,
        format it with proper markdown, add a summary at the top,
        and ensure consistent formatting throughout.
        End your response with COMPLETE.
        """,
    Kernel = kernel
};

// Configure the group chat
AgentGroupChat chat = new(researcher, writer, reviewer, publisher)
{
    ExecutionSettings = new()
    {
        SelectionStrategy = new SequentialSelectionStrategy(),
        TerminationStrategy = new ApprovalTerminationStrategy()
        {
            Agents = [publisher],
            MaximumIterations = 15
        }
    }
};

// Start the pipeline
chat.AddChatMessage(new ChatMessageContent(
    AuthorRole.User,
    "Create a technical article about implementing health checks in ASP.NET Core microservices."
));

await foreach (ChatMessageContent message in chat.InvokeAsync())
{
    Console.ForegroundColor = message.AuthorName switch
    {
        "Researcher" => ConsoleColor.Cyan,
        "Writer" => ConsoleColor.Green,
        "Reviewer" => ConsoleColor.Yellow,
        "Publisher" => ConsoleColor.Magenta,
        _ => ConsoleColor.White
    };

    Console.WriteLine($"\n{'='new string('=', 60)}");
    Console.WriteLine($"[{message.AuthorName}]");
    Console.WriteLine(new string('=', 60));
    Console.WriteLine(message.Content);
}

Console.ResetColor();

Ce pipeline produit un article entièrement recherché, écrit, révisé et formaté, le tout grâce à la collaboration d’agents. Chaque agent se concentre sur ce qu’il fait de mieux et le AgentGroupChat coordonne le flux de travail.

## meilleures pratiques

Après avoir construit plusieurs systèmes multi-agents, voici les modèles et pratiques que j’ai trouvés les plus utiles.

Gestion des erreurs

Définissez toujours MaximumIterations sur votre stratégie de résiliation. Sans cela, les agents peuvent entrer dans des boucles infinies, en particulier lorsqu’un réviseur continue de trouver des problèmes et qu’un rédacteur continue de réviser sans amélioration.

TerminationStrategy = new ApprovalTerminationStrategy()
{
    MaximumIterations = 12 // Safety net
}

Enveloppez les invocations de vos agents dans des blocs try-catch. Les limites de débit des API, les problèmes de réseau et les erreurs de modèle sont autant de réalités des systèmes de production :

try
{
    await foreach (var message in chat.InvokeAsync(cancellationToken))
    {
        // Process messages
    }
}
catch (HttpOperationException ex) when (ex.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
{
    // Implement retry with exponential backoff
    await Task.Delay(TimeSpan.FromSeconds(30), cancellationToken);
}

ObservabilitéAgent Framework s’intègre à OpenTelemetry, ce qui signifie que vous pouvez tracer chaque interaction d’agent, appel d’outil et utilisation de jeton. Ceci est essentiel pour le débogage des flux de travail multi-agents où il n’est pas toujours évident de savoir quel agent a causé le problème.

Configurez la télémétrie de base en ajoutant les packages de télémétrie Semantic Kernel et en configurant votre exportateur préféré (Application Insights, Jaeger, etc.) :

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        tracing.AddSource("Microsoft.SemanticKernel*");
        tracing.AddOtlpExporter();
    });

Gestion des coûts

Les systèmes multi-agents multiplient vos coûts API : chaque tour d’agent est un appel API, et les discussions de groupe peuvent générer de nombreux tours. Quelques stratégies pour maîtriser les coûts :

  • Utilisez des modèles moins chers pour les agents plus simples : tous les agents n’ont pas besoin de GPT-4o. Un critique peut fonctionner correctement avec un modèle plus petit, alors que seul l’écrivain a besoin du gros frappeur.
  • Limiter l’historique : utilisez ReducedHistoryCount dans vos paramètres d’exécution pour limiter la quantité de contexte de conversation que chaque agent reçoit.
  • Définissez des limites d’itération strictes : évitez les conversations incontrôlables avec des valeurs MaximumIterations raisonnables.
  • Cache lorsque cela est possible : si un agent effectue la même recherche à plusieurs reprises, mettez les résultats en cache dans un plugin.

Conception d’agents

  • Gardez les instructions ciblées : chaque agent doit avoir une responsabilité unique et claire. Des instructions générales conduisent à des performances médiocres dans toutes les tâches.
  • Soyez explicite sur le format de sortie : indiquez aux agents exactement comment structurer leurs réponses. Cela rend l’analyse en aval fiable.
  • Utiliser des mots-clés de fin : définissez des signaux clairs (comme « APPROUVÉ » ou « COMPLET ») que les agents utilisent pour indiquer qu’ils ont terminé. Cela rend les stratégies de résiliation simples et prévisibles.

Conclusion

Les systèmes d’IA multi-agents représentent un changement fondamental dans la façon dont nous construisons des applications intelligentes. Au lieu de nous battre avec une seule invite pour tout gérer, nous pouvons décomposer les problèmes en rôles spécialisés et laisser les agents collaborer.

L’Agent Framework de Microsoft rend cela pratique pour les développeurs .NET. Les abstractions sont claires – agents, discussions de groupe, stratégies de sélection et de terminaison – et elles se composent naturellement. Combiné avec l’écosystème de plugins de Semantic Kernel et l’hébergement de modèles d’Azure, vous disposez d’une pile complète pour créer des systèmes multi-agents de niveau production.

Le framework est encore en évolution (de nombreux packages sont en avant-première), mais les modèles de base sont solides et la direction est claire. Si vous créez des applications basées sur l’IA dans .NET, le moment est venu de commencer à expérimenter des architectures multi-agents.

Commencez petit : créez deux agents qui collaborent sur une tâche simple. Une fois que vous constaterez l’amélioration de la qualité par rapport aux approches à agent unique, vous souhaiterez tout décomposer en équipes d’agents.

Bon codage !