Microsoft Intro to AI Agent : Explorer le cadre de l'agent d'intelligence artificielle

Les cadres d'agents d'intelligence artificielle sont des plateformes logicielles conçues pour simplifier la création, le déploiement et la gestion des agents d'intelligence artificielle. Ces cadres fournissent aux développeurs des composants, des abstractions et des outils préconstruits pour simplifier le développement de systèmes d'IA complexes.

Ces cadres aident les développeurs à se concentrer sur les aspects uniques de leurs applications en fournissant une approche standardisée des défis communs du développement d'agents d'intelligence artificielle. Ils améliorent l'évolutivité, l'accessibilité et l'efficacité de la construction des systèmes d'IA.

bref

Ce cours couvre les points suivants

• Que sont les cadres d'agents d'intelligence artificielle et que permettent-ils aux développeurs de faire ?
• Comment les équipes peuvent-elles utiliser ces cadres pour réaliser rapidement des prototypes, des itérations et améliorer les capacités de l'agent ?
• Quelle est la différence entre les cadres et les outils créés par Microsoft AutoGen, Semantic Kernel et Azure AI Agent ?
• Est-il possible d'intégrer directement les outils existants de l'écosystème Azure ou ai-je besoin d'une solution autonome ?
• Qu'est-ce que le service Azure AI Agents et comment peut-il être utile ?

objectif d'apprentissage

L'objectif de ce cours est de vous aider à comprendre :

• Le rôle des cadres d'agents d'IA dans le développement de l'IA.
• Comment construire des agents intelligents avec le AI Agent Framework.
• Principales caractéristiques mises en œuvre par le cadre de l'agent d'intelligence artificielle.
• Différences entre AutoGen, Semantic Kernel et Azure AI Agent Service.

Que sont les cadres d'agents d'intelligence artificielle et que permettent-ils aux développeurs de faire ?

Les frameworks d'IA traditionnels peuvent vous aider à intégrer l'IA dans vos applications et à améliorer ces dernières :

• personnaliséL'IA peut analyser le comportement et les préférences des utilisateurs afin de leur proposer des recommandations, des contenus et des expériences personnalisés. Par exemple, des services de streaming comme Netflix utilisent l'IA pour recommander des films et des émissions en fonction de l'historique de visionnage afin d'accroître l'engagement et la satisfaction des utilisateurs.
• Automatisation et efficacitéL'IA permet d'automatiser les tâches répétitives, de rationaliser les flux de travail et d'améliorer l'efficacité opérationnelle. Par exemple, les applications de service client utilisent des chatbots pilotés par l'IA pour traiter les demandes courantes, ce qui réduit les temps de réponse et permet aux agents humains de traiter des questions plus complexes.
• Une expérience utilisateur amélioréeL'IA peut améliorer l'expérience globale de l'utilisateur en offrant des fonctions intelligentes telles que la reconnaissance vocale, le traitement du langage naturel et le texte prédictif. Par exemple, les assistants virtuels comme Siri et Google Assistant utilisent l'IA pour comprendre et répondre aux commandes vocales, facilitant ainsi l'interaction des utilisateurs avec leurs appareils.

Tout cela semble très bien, n'est-ce pas ? Alors pourquoi avons-nous besoin d'un cadre de travail pour les agents d'intelligence artificielle ?

Les cadres d'agents d'IA sont plus que de simples cadres d'IA. Ils sont conçus pour créer des agents intelligents capables d'interagir avec des utilisateurs, d'autres agents et l'environnement afin d'atteindre des objectifs spécifiques, et qui peuvent adopter un comportement autonome, prendre des décisions et s'adapter à des conditions changeantes. Examinons quelques-unes des principales caractéristiques mises en œuvre par les frameworks d'agents d'intelligence artificielle :

• Collaboration et coordination des agentsLe système de gestion de l'information de l'UE : Il permet la création de plusieurs agents d'intelligence artificielle qui peuvent travailler ensemble, communiquer et se coordonner pour résoudre des tâches complexes.
• Automatisation et gestion des tâchesLe système de gestion des tâches : il fournit des mécanismes d'automatisation des flux de travail à plusieurs étapes, de délégation des tâches et de gestion dynamique des tâches entre les agents.
• Compréhension du contexte et adaptationL'agent est capable de comprendre le contexte, de s'adapter à des environnements changeants et de prendre des décisions sur la base d'informations en temps réel.

En bref, les agents vous permettent d'en faire plus, de porter l'automatisation à un niveau supérieur et de créer des systèmes plus intelligents capables de s'adapter à leur environnement et d'en tirer des enseignements.

Comment puis-je réaliser rapidement des prototypes, des itérations et améliorer les capacités de l'agent ?

C'est un domaine qui évolue rapidement, mais la plupart des frameworks d'agents d'IA ont quelques points communs qui peuvent vous aider à créer des prototypes et à itérer rapidement, à savoir des composants modulaires, des outils de collaboration et l'apprentissage en temps réel. Nous allons nous pencher sur ces points :

• Utilisation de composants modulairesLe cadre de l'IA fournit des composants préconstruits tels que les indices, les analyseurs et la gestion de la mémoire.
• Utilisation d'outils de collaborationLes agents de conception ont des rôles et des tâches spécifiques qui leur permettent de tester et d'améliorer les flux de travail collaboratifs.
• Apprentissage en temps réelL'agent apprend de l'interaction et adapte dynamiquement son comportement.

Utilisation de composants modulaires

Des cadres tels que LangChain et Microsoft Semantic Kernel fournissent des composants prédéfinis tels que des indices, des analyseurs et la gestion de la mémoire.

Comment les équipes utilisent-elles cesLes équipes peuvent rapidement assembler ces composants pour créer un prototype fonctionnel sans avoir à partir de zéro, ce qui permet une expérimentation et une itération rapides.

Comment cela fonctionne-t-il en pratique ?Vous pouvez utiliser des analyseurs prédéfinis pour extraire des informations des entrées utilisateur, des modules en mémoire pour stocker et récupérer des données, et des générateurs d'invites pour interagir avec les utilisateurs, le tout sans avoir à construire ces composants à partir de zéro.

exemple de code (informatique). Voyons un exemple d'extraction d'informations à partir d'une entrée utilisateur à l'aide d'un analyseur prédéfini :

// Semantic Kernel 示例
ChatHistory chatHistory = [];
chatHistory.AddUserMessage("I'd like to go To New York");
// 定义一个包含预订旅行功能的插件
public class BookTravelPlugin(
IPizzaService pizzaService,
IUserContext userContext,
IPaymentService paymentService)
{
[KernelFunction("book_flight")]
[Description("Book travel given location and date")]
public async Task<Booking> BookFlight(
DateTime date,
string location,
)
{
// 根据日期、地点预订旅行
}
}
IKernelBuilder kernelBuilder = new KernelBuilder();
kernelBuilder..AddAzureOpenAIChatCompletion(
deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
apiKey: "YOUR_API_KEY",
endpoint: "YOUR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType<BookTravelPlugin>("BookTravel");
Kernel kernel = kernelBuilder.Build();
/*
在后台，它识别要调用的工具、它已经具有的参数 (location) 和它需要的参数 (date)
{
"tool_calls": [
{
"id": "call_abc123",
"type": "function",
"function": {
"name": "BookTravelPlugin-book_flight",
"arguments": "{\n\"location\": \"New York\",\n\"date\": \"\"\n}"
}
}
]
*/
ChatResponse response = await chatCompletion.GetChatMessageContentAsync(
chatHistory,
executionSettings: openAIPromptExecutionSettings,
kernel: kernel)
Console.WriteLine(response);
chatHistory.AddAssistantMessage(response);
// AI 响应："Before I can book your flight, I need to know your departure date. When are you planning to travel?"
// 也就是说，在前面的代码中，它找出了要调用的工具，它已经拥有的参数 (location) 以及它从用户输入中需要的参数 (date)，此时它最终会向用户询问缺失的信息

Cet exemple montre comment un analyseur préconstruit peut être utilisé pour extraire des informations clés de l'entrée de l'utilisateur, telles que l'origine, la destination et la date d'une demande de réservation de vol. Cette approche modulaire vous permet de vous concentrer sur la logique de haut niveau.

Utilisation d'outils de collaboration

CrewAI et Microsoft AutoGen Les cadres tels que celui-ci facilitent la création de plusieurs agents qui peuvent travailler ensemble.

Comment les équipes utilisent-elles cesLes équipes peuvent concevoir des agents avec des rôles et des tâches spécifiques, ce qui leur permet de tester et d'améliorer les flux de travail collaboratifs et d'accroître l'efficacité globale du système.

Comment cela fonctionne-t-il en pratique ?Les agents : Vous pouvez créer une équipe d'agents, chacun ayant une fonction spécialisée, telle que la recherche de données, l'analyse ou la prise de décision. Ces agents peuvent communiquer et partager des informations pour atteindre des objectifs communs, tels que répondre aux questions des utilisateurs ou accomplir des tâches.

Exemple de code (AutoGen): :

# 创建 Agent，然后创建一个循环调度，让他们可以协同工作，在本例中是按顺序
# 数据检索 Agent
# 数据分析 Agent
# 决策 Agent
agent_retrieve = AssistantAgent(
name="dataretrieval",
model_client=model_client,
tools=[retrieve_tool],
system_message="Use tools to solve tasks."
)
agent_analyze = AssistantAgent(
name="dataanalysis",
model_client=model_client,
tools=[analyze_tool],
system_message="Use tools to solve tasks."
)
# 当用户说 "APPROVE" 时，对话结束
termination = TextMentionTermination("APPROVE")
user_proxy = UserProxyAgent("user_proxy", input_func=input)
team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)
stream = team.run_stream(task="Analyze data", max_turns=10)
# 在脚本中运行时使用 asyncio.run(...)。
await Console(stream)

Ce que vous avez vu dans le code précédent est la façon de créer une tâche qui implique plusieurs agents travaillant ensemble pour analyser des données. Chaque agent remplit une fonction spécifique et coordonne l'exécution de la tâche par les autres agents afin d'obtenir les résultats souhaités. En créant des agents dédiés avec des rôles spécialisés, vous pouvez améliorer l'efficacité et la performance de la tâche.

Apprentissage en temps réel

Le cadre avancé permet de comprendre et d'adapter le contexte en temps réel.

Comment les équipes utilisent-elles ces cadres ?Les équipes peuvent mettre en place des boucles de rétroaction qui permettent aux agents de tirer des enseignements des interactions et d'ajuster dynamiquement leurs comportements, ce qui conduit à une amélioration et à un perfectionnement continus des capacités.

application pratiqueLes agents peuvent analyser les réactions des utilisateurs, les données environnementales et les résultats des tâches pour mettre à jour leur base de connaissances, adapter leurs algorithmes de prise de décision et améliorer leurs performances au fil du temps. Ce processus d'apprentissage itératif permet aux agents de s'adapter aux conditions changeantes et aux préférences des utilisateurs, améliorant ainsi l'efficacité globale du système.

Quelle est la différence entre AutoGen, Semantic Kernel et le cadre Azure AI Agent Service ?

Il existe de nombreuses façons de comparer ces frameworks, mais examinons quelques différences clés en termes de conception, de fonctionnalités et de cas d'utilisation cibles :

AutoGen

Cadre open source développé par le laboratoire AI Frontiers de Microsoft Research. Il se concentre sur les systèmes distribués et pilotés par les événements. agentique Applications prenant en charge de multiples modèles de langage (LLM) et SLM, outils et modèles de conception multi-agents avancés.

Le concept central d'AutoGen est celui des agents, qui sont des entités autonomes capables de percevoir leur environnement, de prendre des décisions et d'agir pour atteindre des objectifs spécifiques. Les agents communiquent par messagerie asynchrone, ce qui leur permet de travailler indépendamment et en parallèle, augmentant ainsi l'évolutivité et la réactivité du système.

Les agents sont basés sur des modèles d'acteurs. Selon Wikipédia, l'acteur est Les éléments de base de l'informatique simultanée. En réponse à un message entrant, un acteur peut : prendre des décisions locales, créer d'autres acteurs, envoyer d'autres messages et déterminer comment répondre au prochain message entrant..

cas d'utilisationLes agents : Automatiser la génération de codes, les tâches d'analyse de données et créer des intelligences personnalisées (agents) pour les fonctions de planification et de recherche.

Voici quelques-uns des principaux concepts d'AutoGen :

• Agents. Un organisme intelligent (agent) est une entité logicielle qui :
  • Communiquer par messagesCes messages peuvent être synchrones ou asynchrones.
  • Maintenir son statutCet état peut être modifié par des messages entrants.
  • opération exécutable en réponse à un message reçu ou à un changement d'état. Ces actions peuvent modifier l'état de l'agent et avoir des effets externes, tels que la mise à jour du journal des messages, l'envoi de nouveaux messages, l'exécution de code ou l'appel d'API.

  Vous trouverez ci-dessous un court extrait de code qui vous permettra de créer un agent doté d'une fonctionnalité de chat :

  from autogen_agentchat.agents import AssistantAgent
  from autogen_agentchat.messages import TextMessage
  from autogen_ext.models.openai import OpenAIChatCompletionClient
  class MyAssistant(RoutedAgent):
  def __init__(self, name: str) -> None:
  super().__init__(name)
  model_client = OpenAIChatCompletionClient(model="gpt-4o")
  self._delegate = AssistantAgent(name, model_client=model_client)
      @message_handler
  async def handle_my_message_type(self, message: MyMessageType, ctx: MessageContext) -> None:
  print(f"{self.id.type} received message: {message.content}")
  response = await self._delegate.on_messages(
  [TextMessage(content=message.content, source="user")], ctx.cancellation_token
  )
  print(f"{self.id.type} responded: {response.chat_message.content}")
  

  Dans le code précédent, leMyAssistant a été créé et hérité de RoutedAgent. Il possède un gestionnaire de message qui imprime le contenu du message et utilise ensuite la fonction AssistantAgent Déléguer l'envoi de la réponse. Prêtez une attention particulière à la manière dont nous déléguons la fonction AssistantAgent L'instance du self._delegate(math.) genreAssistantAgent est une intelligence pré-construite (Agent) qui peut gérer la complémentation du chat.
  Ensuite, indiquez à AutoGen le type d'agent et démarrez le programme :

  # main.py
  runtime = SingleThreadedAgentRuntime()
  await MyAgent.register(runtime, "my_agent", lambda: MyAgent())
  runtime.start()  # Start processing messages in the background.
  await runtime.send_message(MyMessageType("Hello, World!"), AgentId("my_agent", "default"))
  

  Dans le code précédent, les agents sont enregistrés auprès du moteur d'exécution, puis des messages sont envoyés à l'agent, ce qui produit la sortie suivante :

  # Output from the console:
  my_agent received message: Hello, World!
  my_assistant received message: Hello, World!
  my_assistant responded: Hello! How can I assist you today?
  

• Agents multiplesAutoGen permet de créer plusieurs agents qui peuvent travailler ensemble pour accomplir des tâches complexes. Les agents peuvent communiquer, partager des informations et coordonner leurs actions afin de résoudre les problèmes plus efficacement. Pour créer un système multi-agents, vous devez définir différents types d'agents dotés de fonctions et de rôles spécialisés, tels que la recherche de données, l'analyse, la prise de décision et l'interaction avec l'utilisateur. Voyons à quoi ressemble une telle création pour mieux la comprendre :

editor_description = "Editor for planning and reviewing the content."
# Example of declaring an Agent
editor_agent_type = await EditorAgent.register(
runtime,
editor_topic_type,  # Using topic type as the agent type.
lambda: EditorAgent(
description=editor_description,
group_chat_topic_type=group_chat_topic_type,
model_client=OpenAIChatCompletionClient(
model="gpt-4o-2024-08-06",
# api_key="YOUR_API_KEY",
),
),
)
# remaining declarations shortened for brevity
# Group chat
group_chat_manager_type = await GroupChatManager.register(
runtime,
"group_chat_manager",
lambda: GroupChatManager(
participant_topic_types=[writer_topic_type, illustrator_topic_type, editor_topic_type, user_topic_type],
model_client=OpenAIChatCompletionClient(
model="gpt-4o-2024-08-06",
# api_key="YOUR_API_KEY",
),
participant_descriptions=[
writer_description, 
illustrator_description, 
editor_description, 
user_description
],
),
)

Dans le code précédent, nous avons un GroupChatManagerIl est enregistré auprès du moteur d'exécution. Ce gestionnaire est chargé de coordonner les interactions entre les différents types d'agents, tels que les rédacteurs, les illustrateurs, les éditeurs et les utilisateurs.

• Durée d'exécution de l'agentLe cadre fournit un environnement d'exécution qui prend en charge la communication entre les agents et applique des limites en matière de sécurité et de respect de la vie privée. Le cadre fournit un environnement d'exécution qui prend en charge la communication entre les agents, gère leur identité et leur cycle de vie, et applique des limites de sécurité et de confidentialité. Cela signifie que vous pouvez faire fonctionner vos agents dans un environnement sécurisé et contrôlé, en veillant à ce qu'ils puissent interagir de manière sûre et efficace. Il existe deux environnements d'exécution intéressants :
  • Durée d'exécution autonome. C'est un bon choix pour les applications mono-processus où tous les agents sont implémentés dans le même langage de programmation et s'exécutent dans le même processus. Voici un schéma de fonctionnement :
    Durée d'exécution autonome
    pile d'applications
    Les agents communiquent par l'intermédiaire de messages via le runtime, qui gère le cycle de vie des agents.
  • Exécution d'un agent distribuéCela s'applique aux applications multiprocessus dans lesquelles les agents peuvent être mis en œuvre dans différents langages de programmation et exécutés sur différentes machines. Voici une illustration de son fonctionnement :
    Exécution distribuée

Noyau sémantique + cadre d'agents

Le noyau sémantique se compose de deux parties : le cadre d'agent du noyau sémantique et le noyau sémantique lui-même.

Parlons un peu du noyau sémantique, qui repose sur les concepts fondamentaux suivants :

• ConnexionsIl s'agit de l'interface avec les services d'intelligence artificielle et les sources de données externes.

using Microsoft.SemanticKernel;
// Create kernel
var builder = Kernel.CreateBuilder();
// Add a chat completion service:
builder.Services.AddAzureOpenAIChatCompletion(
"your-resource-name",
"your-endpoint",
"your-resource-key",
"deployment-model");
var kernel = builder.Build();

Le Semantic Kernel crée une connexion avec un service d'IA externe, dans ce cas Azure OpenAI Chat Completion.

• PluginsLes plug-ins : ils encapsulent des fonctions qu'une application peut utiliser. Il existe à la fois des plug-ins prêts à l'emploi et des plug-ins que vous pouvez créer vous-même. Il existe un concept appelé fonctions sémantiques. La raison pour laquelle elles sont sémantiques est que vous leur fournissez des informations sémantiques pour aider le Semantic Kernel à déterminer qu'il a besoin d'appeler la fonction. Voici un exemple :

var userInput = Console.ReadLine();
// Define semantic function inline.
string skPrompt = @"Summarize the provided unstructured text in a sentence that is easy to understand.
Text to summarize: {{$userInput}}";
// Register the function
kernel.CreateSemanticFunction(
promptTemplate: skPrompt,
functionName: "SummarizeText",
pluginName: "SemanticFunctions"
);

Ici, vous commencez par un modèle de conseil skPromptIl laisse à l'utilisateur le soin de saisir le texte $userInput du plugin. Vous utilisez ensuite le plugin SemanticFunctions fonction enregistrée SummarizeText. Notez le nom de la fonction, qui aide le Semantic Kernel à comprendre ce que fait la fonction et quand elle doit être appelée.

• Fonction nativeIl existe également des fonctions natives que le cadre peut appeler directement pour effectuer des tâches. Voici un exemple de ces fonctions qui permettent de récupérer le contenu d'un fichier :

public class NativeFunctions {
[SKFunction, Description("Retrieve content from local file")]
public async Task<string> RetrieveLocalFile(string fileName, int maxSize = 5000)
{
string content = await File.ReadAllTextAsync(fileName);
if (content.Length <= maxSize) return content;
return content.Substring(0, maxSize);
}
}
//Import native function
string plugInName = "NativeFunction";
string functionName = "RetrieveLocalFile";
var nativeFunctions = new NativeFunctions();
kernel.ImportFunctions(nativeFunctions, plugInName);

• PlanificateurLe planificateur orchestre les plans d'exécution et les politiques sur la base des données fournies par l'utilisateur. L'idée est d'exprimer comment l'exécution doit se faire et d'en faire une instruction que le noyau sémantique doit suivre. Ce dernier appelle alors les fonctions nécessaires à l'exécution des tâches. Voici un exemple d'un tel plan :

string planDefinition = "Read content from a local file and summarize the content.";
SequentialPlanner sequentialPlanner = new SequentialPlanner(kernel);
string assetsFolder = @"../../assets";
string fileName = Path.Combine(assetsFolder,"docs","06_SemanticKernel", "aci_documentation.txt");
ContextVariables contextVariables = new ContextVariables();
contextVariables.Add("fileName", fileName);
var customPlan = await sequentialPlanner.CreatePlanAsync(planDefinition);
// Execute the plan
KernelResult kernelResult = await kernel.RunAsync(contextVariables, customPlan);
Console.WriteLine($"Summarization: {kernelResult.GetValue<string>()}");

attention particulière planDefinitionqui est l'instruction simple suivie par le planificateur. La fonction appropriée est alors appelée en fonction de ce plan, dans ce cas notre fonction sémantique SummarizeText et les fonctions natives RetrieveLocalFile.

• MémoireMémoire : abstraire et simplifier la gestion du contexte pour les applications d'intelligence artificielle. L'idée de la mémoire est que c'est quelque chose que le Grand Modèle de Langage (LLM) devrait connaître. Vous pouvez stocker ces informations dans un magasin de vecteurs, qui devient par la suite une base de données en mémoire ou une base de données vectorielle ou quelque chose de similaire. Voici un exemple très simplifié d'un scénario dans lequel le Les faits est ajouté à la mémoire :

var facts = new Dictionary<string,string>();
facts.Add(
"Azure Machine Learning; https://learn.microsoft.com/azure/machine-learning/",
@"Azure Machine Learning is a cloud service for accelerating and
managing the machine learning project lifecycle. Machine learning professionals,
data scientists, and engineers can use it in their day-to-day workflows"
);
facts.Add(
"Azure SQL Service; https://learn.microsoft.com/azure/azure-sql/",
@"Azure SQL is a family of managed, secure, and intelligent products
that use the SQL Server database engine in the Azure cloud."
);
string memoryCollectionName = "SummarizedAzureDocs";
foreach (var fact in facts) {
await memoryBuilder.SaveReferenceAsync(
collection: memoryCollectionName,
description: fact.Key.Split(";")[1].Trim(),
text: fact.Value,
externalId: fact.Key.Split(";")[2].Trim(),
externalSourceName: "Azure Documentation"
);
}

Ces faits sont ensuite stockés dans la collection de mémoire SummarizedAzureDocs en mémoire. Il s'agit d'un exemple très simplifié, mais vous pouvez voir comment des informations peuvent être stockées en mémoire pour être utilisées dans le Grand Modèle de Langage (LLM).

Voilà pour les bases du Semantic Kernel, qu'en est-il de l'Agent Framework ?

Azure AI Agent Service

Le service Azure AI Agent Service est un membre plus récent, présenté lors de la conférence Microsoft Ignite 2024. Il permet le développement et le déploiement d'agents d'IA avec des modèles plus flexibles, tels que l'invocation directe de grands modèles de langage (LLM) open source comme Llama 3, Mistral et Cohere.

Azure AI Agent Service offre des mécanismes de sécurité d'entreprise et des méthodes de stockage des données plus solides qui le rendent adapté aux applications d'entreprise.

Il fonctionne dès le départ avec des cadres d'orchestration multi-agents tels qu'AutoGen et Semantic Kernel.

Ce service est actuellement en avant-première publique et prend en charge Python et C# pour la création d'agents.

Concepts de base

Le service Azure AI Agent Service repose sur les concepts fondamentaux suivants :

• AgentLe service Azure AI Agent s'intègre à Azure AI Foundry. Dans AI Foundry, les intelligences d'IA (agents) agissent comme des microservices "intelligents" qui peuvent être utilisés pour répondre à des questions (RAG), d'effectuer des opérations ou d'automatiser complètement les flux de travail. Pour ce faire, il combine les capacités des modèles d'IA générative avec des outils qui leur permettent d'accéder à des sources de données du monde réel et d'interagir avec elles. Voici un exemple d'agent :

agent = project_client.agents.create_agent(
model="gpt-4o-mini",
name="my-agent",
instructions="You are helpful agent",
tools=code_interpreter.definitions,
tool_resources=code_interpreter.resources,
)

Dans cet exemple, un modèle est créé avec le modèle gpt-4o-miniNom my-agent et des directives You are helpful agent L'agent est équipé d'outils et de ressources pour effectuer des tâches d'interprétation de codes. L'agent est équipé d'outils et de ressources pour effectuer des tâches d'interprétation de codes.

• Fil et messages. Le fil conducteur est un autre concept important. Il représente un dialogue ou une interaction entre un agent et un utilisateur. Les threads peuvent être utilisés pour suivre la progression d'un dialogue, stocker des informations contextuelles et gérer l'état d'une interaction. Voici un exemple de fil de discussion :

thread = project_client.agents.create_thread()
message = project_client.agents.create_message(
thread_id=thread.id,
role="user",
content="Could you please create a bar chart for the operating profit using the following data and provide the file to me? Company A: $1.2 million, Company B: $2.5 million, Company C: $3.0 million, Company D: $1.8 million",
)
# Ask the agent to perform work on the thread
run = project_client.agents.create_and_process_run(thread_id=thread.id, agent_id=agent.id)
# Fetch and log all messages to see the agent's response
messages = project_client.agents.list_messages(thread_id=thread.id)
print(f"Messages: {messages}")

Dans le code précédent, un fil de discussion a été créé. Ensuite, un message est envoyé à la discussion. Le message est envoyé au thread en appelant la fonction create_and_process_runIl est ensuite demandé à l'agent d'effectuer un travail sur le fil de discussion. Enfin, les messages sont capturés et enregistrés pour voir la réponse de l'agent. Les messages indiquent la progression du dialogue entre l'utilisateur et l'agent. Il est également important de comprendre que les messages peuvent être de différents types, tels que du texte, des images ou des fichiers, où le travail des agents se traduit, par exemple, par une réponse sous forme d'image ou de texte. En tant que développeur, vous pouvez utiliser ces informations pour traiter la réponse ou la présenter à l'utilisateur.

• Intégration avec d'autres frameworks d'IAAzure AI Agent Service peut interagir avec d'autres frameworks, tels qu'AutoGen et Semantic Kernel, ce qui signifie que vous pouvez créer une partie de votre application dans l'un de ces frameworks, par exemple en utilisant le service d'agent comme orchestrateur, ou vous pouvez tout créer dans le service d'agent.

cas d'utilisationAzure AI Agent Service : Azure AI Agent Service est conçu pour les applications d'entreprise qui nécessitent un déploiement sécurisé, évolutif et flexible d'intelligences IA (agents).

Quelle est la différence entre ces cadres ?

Il semble qu'il y ait beaucoup de chevauchements entre ces cadres, mais il existe des différences essentielles dans leur conception, leurs fonctionnalités et les cas d'utilisation visés :

• AutoGenIl est axé sur les applications agentiques distribuées et pilotées par les événements, avec une prise en charge de plusieurs grands modèles de langage (LLM) et SLM, d'outils et de modèles de conception multi-agents avancés.
• Noyau sémantiqueLe logiciel d'analyse de textes : Il se concentre sur la compréhension et la génération de contenus textuels de type humain en capturant une signification sémantique plus profonde. Il est conçu pour automatiser des flux de travail complexes et lancer des tâches en fonction des objectifs du projet.
• Azure AI Agent ServiceIl fournit des modèles plus flexibles, tels que des appels directs à des modèles de langage à grande échelle (LLM) open-source comme Llama 3, Mistral et Cohere. Il fournit des mécanismes de sécurité d'entreprise et des méthodes de stockage de données plus robustes, ce qui le rend approprié pour les applications d'entreprise.

Vous ne savez toujours pas lequel choisir ?

cas d'utilisation

Passons en revue quelques cas d'utilisation courants pour voir si nous pouvons vous aider :

Q : Mon équipe développe un projet impliquant la génération automatisée de code et des tâches d'analyse de données. Quel cadre de travail devrions-nous utiliser ?

R : AutoGen est un bon choix dans ce cas car il se concentre sur les applications agentiques distribuées et pilotées par les événements et prend en charge les modèles de conception multi-agents avancés.

Q : En quoi AutoGen est-il meilleur que Semantic Kernel et Azure AI Agent Service pour ce cas d'utilisation ?

R : AutoGen est conçu pour des applications agentiques distribuées et pilotées par des événements, ce qui le rend idéal pour automatiser la génération de code et les tâches d'analyse de données. Il fournit les outils et les fonctionnalités nécessaires pour construire efficacement des systèmes multi-agents complexes.

Q : Il semble que le service Azure AI Agent Service fonctionne ici aussi, et qu'il dispose d'outils pour la génération de code, etc.

R : Oui, Azure AI Agent Service prend également en charge la génération de code et les tâches d'analyse de données, mais il est peut-être mieux adapté aux applications d'entreprise qui nécessitent des déploiements d'agents d'IA sécurisés, évolutifs et flexibles. autoGen est davantage axé sur les applications agentiques distribuées et pilotées par les événements et sur les modèles de conception multi-agents avancés. AutoGen est davantage axé sur les applications agentiques distribuées et pilotées par les événements, ainsi que sur les modèles de conception multi-agents avancés.

Q : Vous dites donc que si je veux me lancer dans l'entreprise, je devrais opter pour Azure AI Agent Service ?

R : Oui, Azure AI Agent Service est conçu pour les applications d'entreprise qui nécessitent un déploiement sécurisé, évolutif et flexible d'intelligences IA (agents). Il fournit des mécanismes de sécurité d'entreprise et des méthodes de stockage des données plus solides qui le rendent adapté aux cas d'utilisation en entreprise.

Résumons les principales différences dans un tableau :

Quel est le cas d'utilisation idéal pour chacun de ces cadres ?

• AutoGenApplications agentiques : applications agentiques distribuées et pilotées par les événements, modèle de conception multi-agents avancé. Idéal pour la génération automatisée de code, les tâches d'analyse de données.
• Noyau sémantiqueComprendre et générer du contenu textuel de type humain, automatiser des flux de travail complexes et lancer des tâches en fonction des objectifs d'un projet. Idéal pour la compréhension du langage naturel et la génération de contenu.
• Azure AI Agent ServiceLes agents d'intelligence artificielle (IA) sont des modèles flexibles, des mécanismes de sécurité d'entreprise et des méthodes de stockage des données. Idéal pour les déploiements sécurisés, évolutifs et flexibles de l'intelligence artificielle (agent) dans les applications d'entreprise.

Puis-je intégrer directement mes outils existants de l'écosystème Azure ou ai-je besoin d'une solution autonome ?

La réponse est oui, vous pouvez intégrer vos outils existants de l'écosystème Azure directement avec Azure AI Agent Service, d'autant plus qu'il est conçu pour fonctionner de manière transparente avec d'autres services Azure. Par exemple, vous pouvez intégrer Bing, Azure AI Search et Azure Functions. Il existe également une intégration approfondie avec Azure AI Foundry.

Pour AutoGen et Semantic Kernel, vous pouvez également intégrer les services Azure, mais cela peut nécessiter d'appeler les services Azure à partir du code. Une autre méthode d'intégration consiste à utiliser le SDK Azure pour interagir avec les services Azure à partir de vos agents. En outre, comme indiqué précédemment, vous pouvez utiliser le service Azure AI Agent Service comme orchestrateur pour les agents construits dans AutoGen ou Semantic Kernel, ce qui vous permettra d'accéder facilement à l'écosystème Azure.