6 pièce(s) jointe(s)
Présentation de Microsoft Agent Framework (Preview) : simplifier les agents IA pour tous les développeurs
Présentation de Microsoft Agent Framework (Preview) : simplifier les agents IA pour tous les développeurs, par Luis Quintanilla
La création d'agents IA ne devrait pas être sorcière. Pourtant, de nombreux développeurs se retrouvent confrontés à une logique d'orchestration complexe, peinent à connecter plusieurs modèles IA ou passent des semaines à créer une infrastructure d'hébergement juste pour mettre en production un simple agent.
Et si la création d'un agent IA pouvait être aussi simple que la création d'une API web ou d'une application console ?
Agents et workflows
Avant d'approfondir le sujet, définissons les deux éléments fondamentaux des systèmes d'agents : les agents et les workflows.
Agents
Sur le web, vous trouverez de nombreuses définitions des agents. Certaines sont contradictoires, d'autres se recoupent.
Pour cet article, nous allons rester simples :
Les agents sont des systèmes qui accomplissent des objectifs.
Les agents deviennent plus performants lorsqu'ils sont équipés des éléments suivants :
- Raisonnement et prise de décision : alimentés par des modèles d'IA (LLM), des algorithmes de recherche ou des systèmes de planification et de prise de décision.
- Utilisation d'outils : accès aux serveurs MCP (Model Context Protocol), exécution de code et API externes.
- Conscience du contexte : alimentée par l'historique des chats, les fils de discussion, les magasins de vecteurs, les données d'entreprise ou les graphes de connaissances.
Ces capacités permettent aux agents de fonctionner de manière plus autonome, adaptative et intelligente.
Workflows
À mesure que les objectifs gagnent en complexité, ils doivent être décomposés en étapes gérables. C'est là que les workflows entrent en jeu.
Les workflows définissent la séquence d'étapes nécessaires pour atteindre un objectif.
Imaginez que vous lanciez une nouvelle fonctionnalité sur le site web de votre entreprise. S'il s'agit d'une simple mise à jour, vous pouvez passer de l'idée à la production en quelques heures. Mais pour des initiatives plus complexes, le processus peut inclure :
- Recueil des exigences
- Conception et architecture
- Mise en œuvre
- Tests
- Déploiement
Quelques observations importantes :
- Chaque étape peut contenir des sous-tâches.
- Différents spécialistes peuvent être responsables de différentes phases.
- Les progrès ne sont pas toujours linéaires. Les bogues détectés lors des tests peuvent vous renvoyer à la phase de mise en œuvre.
- Le succès dépend de la planification, de l'orchestration et de la communication entre les parties prenantes.
Agents + Workflows
Les workflows ne nécessitent pas d'agents, mais ceux-ci peuvent les optimiser.
Lorsque les agents sont dotés de raisonnement, d'outils et de contexte, ils peuvent optimiser les workflows.
C'est le fondement des systèmes multi-agents, dans lesquels les agents collaborent au sein de workflows pour atteindre des objectifs complexes.
Découvrez Microsoft Agent Framework
Microsoft Agent Framework est un ensemble complet de bibliothèques .NET qui réduit la complexité du développement d'agents. Que vous créiez un simple chatbot ou que vous orchestriez plusieurs agents IA dans des workflows complexes, Microsoft Agent Framework vous fournit les outils dont vous avez besoin pour :
- Créer des agents avec un minimum de code standard
- Orchestrer facilement des flux de travail multi-agents
- Héberger et déployer des agents à l'aide de modèles .NET familiers
- Surveiller et observer le comportement des agents en production
Pour plus de détails, consultez l'article « Introducing Microsoft Agent Framework » (Présentation de Microsoft Agent Framework) sur le blog Foundry.
Conçu sur des bases éprouvées
Microsoft Agent Framework s'appuie sur des technologies établies pour simplifier le développement d'agents pour les développeurs .NET :
- Semantic Kernel : fournit une orchestration robuste
- AutoGen : permet une collaboration multi-agents avancée et des techniques de pointe axées sur la recherche.
- Microsoft.Extensions.AI : fournit des blocs de construction IA standardisés pour .NET.
En combinant ces technologies, Agent Framework offre fiabilité, flexibilité et une API conviviale pour les développeurs. Cela vous permet de créer et de déployer rapidement et efficacement de puissants agents IA.
Commencez simplement : créez votre premier agent en quelques minutes.
Il est facile de se lancer avec Microsoft Agent Framework. Dans l'exemple suivant, vous allez créer un agent de création littéraire qui génère des nouvelles captivantes.
Le moyen le plus rapide de l'essayer est d'ouvrir l'exemple Hello World Agents dans GitHub Codespaces :
:fleche: Ouvrir dans GitHub Codespaces
Si vous préférez, vous pouvez suivre les instructions étape par étape ci-dessous pour configurer le projet sur votre propre machine.
- Étape 0 : Configurez les prérequis
Pour commencer, vous aurez besoin des éléments suivants :
Ce projet peut utiliser des modèles hébergés par GitHub. Vous devrez donc fournir le jeton d'accès personnel GitHub (PAT) à votre application à l'aide de la variable d'environnement GITHUB_TOKEN.
Windows
Code:
1
2
| setx GITHUB_TOKEN "YOUR-GITHUB-TOKEN"
# Restart your shell to pick up the value |
Linux / Mac
Code:
export GITHUB_TOKEN="YOUR-GITHUB-TOKEN"
- Étape 1 : Configurez votre projet
- Créez une nouvelle application console C# et installez les packages Agent
Code:
1
2
3
| dotnet new console -o HelloWorldAgents
cd HelloWorldAgents
dotnet add package Microsoft.Agents.AI --prerelease |
- Vous devrez également installer les packages suivants pour utiliser les modèles de GitHub.
Code:
1
2
3
| dotnet add package OpenAI
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package Microsoft.Extensions.AI |
- Étape 2 : Écrivez votre agent
- Ajoutez ce code à votre fichier Program.cs pour créer un agent de rédaction d'histoires :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel;
IChatClient chatClient =
new ChatClient(
"gpt-4o-mini",
new ApiKeyCredential(Environment.GetEnvironmentVariable("GITHUB_TOKEN")!),
new OpenAIClientOptions { Endpoint = new Uri("https://models.github.ai/inference") })
.AsIChatClient();
AIAgent writer = new ChatClientAgent(
chatClient,
new ChatClientAgentOptions
{
Name = "Writer",
Instructions = "Write stories that are engaging and creative."
});
AgentRunResponse response = await writer.RunAsync("Write a short story about a haunted house.");
Console.WriteLine(response.Text); |
- Exécutez votre application
Et voilà ! En quelques lignes de code seulement, vous disposez d'un agent IA pleinement fonctionnel.
La puissance de l'abstraction
Microsoft Agent Framework est conçu autour d'abstractions puissantes qui simplifient le développement d'agents.
Au cœur de ce framework se trouve l'abstraction AIAgent, qui fournit une interface unifiée pour la création d'agents. La flexibilité d'utiliser n'importe quel fournisseur de modèles d'IA compatible provient de Microsoft.Extensions.AI, qui normalise l'accès aux modèles via l'interface IChatClient.
L'implémentation ChatClientAgent de AIAgent accepte n'importe quel IChatClient, ce qui vous permet de choisir facilement entre différents fournisseurs tels que :
- OpenAI
- Azure OpenAI
- Foundry Local
- Ollama
- GitHub Models
- Et bien d'autres
Cela signifie que vous pouvez changer de fournisseur ou en intégrer de nouveaux sans modifier le code de votre agent. La même interface AIAgent fonctionne de manière transparente avec :
- Azure Foundry Agents
- OpenAI Assistants
- Copilot Studio
- Et bien d'autres encore
Si vous avez créé des agents à l'aide de différents SDK ou plateformes, l'utilisation de Microsoft Agent Framework est très simple. Vous bénéficiez d'une expérience de développement cohérente et pouvez tirer parti des fonctionnalités d'orchestration, d'hébergement et de surveillance.
Évolutivité : orchestrez plusieurs agents
Les agents uniques sont puissants, mais les scénarios réels nécessitent souvent la collaboration de plusieurs agents spécialisés. Votre agent rédacteur crée peut-être un excellent contenu, mais vous avez également besoin d'un éditeur pour le peaufiner ou d'un vérificateur pour vérifier les détails.
Agent Framework rend l'orchestration multi-agents aussi simple que la connexion de blocs de construction.
Ajouter des agents spécialisés
Améliorons notre exemple en ajoutant un agent éditeur pour réviser et améliorer le travail du rédacteur :
Code:
1
2
3
4
5
6
7
8
| // Create a specialized editor agent
AIAgent editor = new ChatClientAgent(
chatClient,
new ChatClientAgentOptions
{
Name = "Editor",
Instructions = "Make the story more engaging, fix grammar, and enhance the plot."
}); |
Créer des workflows
Voici maintenant la partie magique : connecter ces agents dans un workflow.
- Installez le package NuGet Microsoft.Agents.Workflows :
Code:
dotnet add package Microsoft.Agents.AI.Workflows --prerelease
- Créez un workflow pour orchestrer vos agents :
Code:
1
2
3
4
5
6
7
8
9
10
11
| // Create a workflow that connects writer to editor
Workflow workflow =
AgentWorkflowBuilder
.BuildSequential(writer, editor);
AIAgent workflowAgent = await workflow.AsAgentAsync();
AgentRunResponse workflowResponse =
await workflowAgent.RunAsync("Write a short story about a haunted house.");
Console.WriteLine(workflowResponse.Text); |
Résultat
Désormais, lorsque vous exécutez votre application, l'auteur crée l'histoire initiale, puis l'éditeur la révise et l'améliore automatiquement. L'ensemble du workflow apparaît au monde extérieur comme un agent unique et plus performant.
Ce modèle s'adapte à n'importe quelle complexité :
- Workflows de recherche : Chercheur → Vérificateur de faits → Résumeur
- Pipelines de contenu : Rédacteur → Éditeur → Optimiseur SEO → Éditeur
- Service client : Triage des intentions → Agent spécialiste client → Contrôleur qualité
Le point essentiel à retenir ici est que les systèmes d'agents complexes sont composés d'agents simples et spécialisés.
Tous les types de flux de travail
L'exemple ci-dessus utilise un flux de travail séquentiel, dans lequel les agents traitent les tâches les uns après les autres, chacun s'appuyant sur le résultat de l'agent précédent. Cependant, Microsoft Agent Framework prend en charge divers modèles de flux de travail pour répondre à différentes exigences :
- Séquentiel : les agents exécutent les tâches dans l'ordre, en transmettant les résultats tout au long de la chaîne.
- Concurrent : plusieurs agents travaillent en parallèle, traitant simultanément différents aspects d'une tâche.
- Transfert : la responsabilité passe d'un agent à l'autre en fonction du contexte ou des résultats.
- GroupChat : les agents collaborent dans un espace de conversation partagé en temps réel.
Ces types de flux de travail flexibles permettent l'orchestration de tout, des pipelines simples à la collaboration dynamique entre plusieurs agents.
Donnez plus de moyens à vos agents grâce à des outils
Microsoft Agent Framework facilite considérablement l'accès de vos agents à des fonctions, API et services externes afin qu'ils puissent agir.
Création d'outils pour agents
Améliorons notre agent d'écriture à l'aide d'outils utiles. Dans notre exemple d'histoire, nous pourrions vouloir des agents capables d'effectuer les tâches suivantes :
Code:
1
2
3
4
5
6
| [Description("Gets the author of the story.")]
string GetAuthor() => "Jack Torrance";
[Description("Formats the story for display.")]
string FormatStory(string title, string author, string story) =>
$"Title: {title}\nAuthor: {author}\n\n{story}"; |
Connecter des outils aux agents
L'ajout de ces outils à votre agent est très simple. Voici une version modifiée de notre agent écrivain configurée pour utiliser les outils définis précédemment.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| AIAgent writer = new ChatClientAgent(
chatClient,
new ChatClientAgentOptions
{
Name = "Writer",
Instructions = "Write stories that are engaging and creative.",
ChatOptions = new ChatOptions
{
Tools = [
AIFunctionFactory.Create(GetAuthor),
AIFunctionFactory.Create(FormatStory)
],
}
}); |
L'exécution de l'application générerait une histoire formatée selon le modèle que vous avez fourni dans FormatStory.
Code:
1
2
3
4
5
| **Title: The Haunting of Blackwood Manor**
**Author: Jack Torrance**
On the outskirts of a quaint village, a grand but crumbling mansion, known as Blackwood Manor, loomed against the twilight sky. Locals spoke in hushed tones about the house, claiming it was haunted by the spirits of its former inhabitants, who had mysteriously vanished decades ago. Tales of flickering lanterns, echoing whispers, and the ghostly figure of a woman in white gliding through the halls filled the village’s atmosphere with a sense of dread
//... |
Au-delà des fonctions simples
Comme Microsoft Agent Framework s'appuie sur Microsoft.Extensions.AI, vos agents peuvent utiliser des outils plus robustes, notamment :
- Serveurs MCP (Model Context Protocol) : connectez-vous à des services externes tels que des bases de données, des API et des outils tiers.
- Outils hébergés : accédez à des outils côté serveur tels que Code Interpreter, Bing Grounding et bien d'autres encore.
Par exemple, vous pouvez vous connecter à un serveur MCP qui fournit un accès à une base de données, une recherche sur le Web ou même un contrôle matériel. Pour en savoir plus sur la création d'intégrations MCP, consultez notre guide de démarrage rapide pour les clients MCP.
Déployez en toute confiance : l'hébergement simplifié
La mise en production d'agents ne devrait pas impliquer l'apprentissage d'un nouveau modèle de déploiement. Microsoft Agent Framework s'intègre de manière transparente aux modèles d'hébergement .NET que vous utilisez déjà.
Intégration minimale de l'API Web
L'utilisation de votre agent dans une API REST ne nécessite que quelques lignes de code.
Dans une API Web minimale ASP.NET, commencez par enregistrer votre IChatClient :
Code:
1
2
| builder.AddOpenAIClient("chat")
.AddChatClient(Environment.GetEnvironmentVariable("MODEL_NAME")!); |
Utilisez le package NuGet Microsoft.Agents.AI.Hosting pour enregistrer vos agents :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| builder.AddAIAgent("Writer", (sp, key) =>
{
var chatClient = sp.GetRequiredService<IChatClient>();
return new ChatClientAgent(
chatClient,
name: key,
instructions:
"""
You are a creative writing assistant who crafts vivid,
well-structured stories with compelling characters based on user prompts,
and formats them after writing.
""",
tools: [
AIFunctionFactory.Create(GetAuthor),
AIFunctionFactory.Create(FormatStory)
]
);
});
builder.AddAIAgent(
name: "Editor",
instructions:
"""
You are an editor who improves a writer’s draft by providing 4–8 concise recommendations and
a fully revised Markdown document, focusing on clarity, coherence, accuracy, and alignment.
"""); |
Une fois enregistrés, vos agents sont disponibles partout dans votre application :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| app.MapGet("/agent/chat", async (
[FromKeyedServices("Writer")] AIAgent writer,
[FromKeyedServices("Editor")] AIAgent editor,
HttpContext context,
string prompt) =>
{
Workflow workflow =
AgentWorkflowBuilder
.CreateGroupChatBuilderWith(agents =>
new AgentWorkflowBuilder.RoundRobinGroupChatManager(agents)
{
MaximumIterationCount = 2
})
.AddParticipants(writer, editor)
.Build();
AIAgent workflowAgent = await workflow.AsAgentAsync();
AgentRunResponse response = await workflowAgent.RunAsync(prompt);
return Results.Ok(response);
}); |
Fonctionnalités prêtes pour la production
L'hébergement Microsoft Agent Framework comprend tout ce dont vous avez besoin pour la production :
- Configuration : gérez les paramètres des agents via la configuration .NET standard.
- Injection de dépendances : intégrez vos conteneurs et pratiques DI existants.
- Prise en charge des intergiciels : ajoutez l'authentification, la limitation de débit ou une logique personnalisée.
Déploiement
Microsoft Agent Framework ne réinvente pas le déploiement. Si vous savez comment déployer une application .NET, vous savez déjà comment déployer des agents.
Pas de nouveaux outils. Pas de modèle d'hébergement spécial. Il suffit d'ajouter des agents et de les déployer partout où .NET fonctionne.
Observer et améliorer : surveillance intégrée
Les agents de production ont besoin d'observabilité. Microsoft Agent Framework fournit une surveillance complète qui s'intègre à votre pile d'observabilité existante.
Intégration OpenTelemetry
Activez la télémétrie détaillée en une seule ligne :
Code:
1
2
3
| // Enhanced telemetry for all your agents
writer.WithOpenTelemetry();
editor.WithOpenTelemetry(); |
Cela permet de capturer :
- Flux de conversation : Visualisez la façon dont les messages circulent entre les agents.
- Utilisation des modèles : Suivez la consommation de jetons, la sélection des modèles et les coûts.
- Mesures de performance : Surveillez les temps de réponse et le débit.
- Suivi des erreurs : identifiez et déboguez rapidement les problèmes.
Tableaux de bord riches
Lorsque vous êtes connecté à vos plateformes d'observabilité existantes telles que :
- Aspire
- Azure Monitor
- Grafana
- Et bien d'autres
Vous obtenez des informations détaillées sur le comportement des agents, ce qui vous aide à optimiser les performances et à identifier les problèmes avant qu'ils n'affectent les utilisateurs.
OpenTelemetry avec Aspire
Pour envoyer la télémétrie des agents au tableau de bord Aspire, activez OpenTelemetry et autorisez les données sensibles pour obtenir des informations plus riches.
Définissez EnableSensitiveTelemetryData sur true lors de la configuration de votre client :
Code:
1
2
3
4
5
6
| builder
.AddAzureChatCompletionsClient("chat", settings =>
{
settings.EnableSensitiveTelemetryData = true;
})
.AddChatClient(Environment.GetEnvironmentVariable("MODEL_NAME")!); |
Ensuite, configurez Aspire pour qu'il reconnaisse les sources de télémétrie :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| public static TBuilder ConfigureOpenTelemetry<TBuilder>(this TBuilder builder) where TBuilder : IHostApplicationBuilder
{
builder.Logging.AddOpenTelemetry(logging =>
{
//...
})
.AddTraceSource("Experimental.Microsoft.Extensions.AI.*");
builder.Services.AddOpenTelemetry()
.WithMetrics(metrics =>
{
metrics.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation()
.AddRuntimeInstrumentation()
.AddMeter("Experimental.Microsoft.Extensions.AI.*");
})
.WithTracing(tracing =>
{
tracing.AddSource(builder.Environment.ApplicationName)
.AddSource("Experimental.Microsoft.Extensions.AI.*")
.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation();
});
//...
} |
Avec cette configuration, les tableaux de bord Aspire affichent des données télémétriques détaillées, notamment les flux de conversation, l'utilisation des modèles, les mesures de performances et le suivi des erreurs.
Garantir la qualité : évaluation et tests
La confiance dans les systèmes d'IA repose sur une évaluation rigoureuse. Microsoft Agent Framework s'intègre facilement à Microsoft.Extensions.AI.Evaluations pour vous aider à créer des systèmes d'agents fiables et dignes de confiance.
Cela permet :
- Tests automatisés : exécutez des suites d'évaluation dans le cadre de votre pipeline CI/CD.
- Mesures de qualité : mesurez la pertinence, la cohérence et la sécurité.
- Détection des régressions : détectez la dégradation de la qualité avant le déploiement.
- Tests A/B : comparez différentes configurations.
Découvrez comment démarrer avec les évaluations à l'aide de Microsoft.Extensions.AI.Evaluations.
Commencez à créer des agents dès aujourd'hui
Microsoft Agent Framework transforme le développement d'agents, qui était auparavant une compétence complexe et spécialisée, en une tâche à la portée de tous les développeurs .NET. Que vous créiez un chatbot ou que vous orchestriez plusieurs agents IA dans des workflows complexes, Microsoft Agent Framework vous offre une voie claire vers l'avenir.
Points clés à retenir
- Conception simple : démarrez avec seulement quelques lignes de code. Créez votre premier agent en quelques minutes, et non en plusieurs jours.
- Évolutif : commencez avec un seul agent, puis ajoutez facilement des workflows, des outils, l'hébergement et la surveillance à mesure que vos besoins évoluent.
- Basé sur une technologie éprouvée : Microsoft Agent Framework réunit le meilleur d'AutoGen et de Semantic Kernel. Il s'appuie sur Microsoft.Extensions.AI, une base unifiée pour le développement moderne de l'IA, afin d'offrir une expérience robuste et cohérente aux développeurs .NET.
- Prêt pour la production : déployez à l'aide de modèles .NET familiers avec des capacités intégrées d'observabilité, d'évaluation et d'hébergement.
Et maintenant ?
Prêt à commencer à développer ?
Exécutez l'exemple d'agent Hello World.
Ensuite, consultez la documentation Microsoft Agent Framework pour continuer à vous former.
L'avenir du développement logiciel inclut les agents IA comme composants de premier ordre dans le développement logiciel moderne. Microsoft Agent Framework garantit que cet avenir est accessible à tous les développeurs .NET.
Source : "Introducing Microsoft Agent Framework (Preview): Making AI Agents Simple for Every Developer"
Et vous ?
:fleche: Quel est votre avis sur le sujet ?
Voir aussi :
:fleche: Tout le monde parle de vibe coding : guide pour générer rapidement une application avec les modèles d'instructions génératives exacts, par Jay Gordon
:fleche: Laissez l'agent de codage Copilot se charger des tâches fastidieuses : analyser votre référentiel, planifier des tâches en plusieurs étapes, créer des tickets et des pull requests, par Bruno Capuano
:fleche: Personnaliser les réponses de l'IA à partir de GitHub Copilot : En mode Agent, l'IA peut créer des parties ou même des applications entières à partir de vos instructions écrites ou parlées, par Matt Soucoup
