Cours d'introduction à Microsoft AI Agent : Planification et conception

bref

Cet article aborde les points suivants :

• Définir des objectifs globaux clairs et décomposer les tâches complexes en sous-tâches gérables.
• Obtenez des réponses plus fiables et plus lisibles par les machines grâce à des sorties structurées.
• Appliquer une approche événementielle aux tâches dynamiques et aux entrées inattendues.

objectif d'apprentissage

À l'issue de cet article, vous comprendrez ce qui suit :

• Identifier et fixer des objectifs généraux pour l'agent d'intelligence artificielle afin de s'assurer qu'il a une idée claire de ce qu'il doit accomplir.
• Décomposer les tâches complexes en sous-tâches gérables et les organiser dans un ordre logique.
• Doter l'agent des bons outils (par exemple, des outils de recherche ou d'analyse de données), décider quand et comment les utiliser, et gérer les situations inattendues au fur et à mesure qu'elles se présentent.
• Évaluer les résultats des sous-tâches, mesurer les performances et répéter les opérations pour améliorer le résultat final.

Définition des objectifs généraux et répartition des tâches

La plupart des tâches du monde réel sont trop complexes pour être accomplies en une seule étape. L'agent d'IA a besoin d'un objectif concis pour guider sa planification et ses actions. Par exemple, considérons l'objectif suivant :

“生成一个 3 天的旅行行程。”

Bien que l'énoncé soit simple, il doit encore être amélioré. Plus l'objectif est clair, plus l'agent (et tout collaborateur humain) peut se concentrer sur l'obtention du bon résultat, comme la création d'un itinéraire complet avec des options de vol, des recommandations d'hôtels et des suggestions d'activités.

Répartition des tâches

Les tâches importantes ou complexes deviennent plus faciles à gérer lorsqu'elles sont divisées en sous-tâches plus petites, orientées vers un objectif. Dans l'exemple de l'itinéraire de voyage, l'objectif peut être décomposé en plusieurs tâches :

• Réservation de vols
• Réservation d'hôtel
• location de voitures
• personnalisé

Chaque sous-tâche peut alors être gérée par un agent ou un processus dédié. Un agent peut se spécialiser dans la recherche des meilleures offres de vols, un autre dans les réservations d'hôtels, etc. L'agent coordinateur ou l'agent "en aval" peut alors compiler ces résultats en un itinéraire cohérent qui est présenté à l'utilisateur final.

Cette approche modulaire permet également des améliorations progressives. Par exemple, des agents spécialisés peuvent être ajoutés pour fournir des recommandations sur les repas ou des suggestions d'activités locales et affiner l'itinéraire au fil du temps.

Sortie structurée

Les grands modèles de langage (LLM) peuvent générer des résultats structurés (par exemple JSON), ce qui facilite l'analyse et le traitement par les agents ou les services en aval. Ceci est particulièrement utile dans les environnements multi-agents où nous pouvons effectuer ces tâches après avoir reçu le résultat de la planification. Voir iciArticles de blogpour un aperçu rapide.

L'extrait de code Python suivant montre un agent de planification simple qui décompose les objectifs en sous-tâches et génère un plan structuré :

Agent de planification avec orchestration multi-agents

Dans cet exemple, l'agent de routage sémantique reçoit une demande de l'utilisateur (par exemple, "J'ai besoin d'un plan d'hébergement pour mon voyage"). .

Ensuite, le planificateur :

• Recevoir un plan d'hébergement : le planificateur reçoit les messages de l'utilisateur et génère un plan de voyage structuré basé sur les invites du système, y compris les détails des agents disponibles.
• Liste des agents et de leurs outils : le registre des agents contient une liste d'agents (par exemple, pour les vols, les hôtels, la location de voitures et les événements) et les fonctions ou outils qu'ils fournissent.
• Acheminer le plan vers l'agent approprié : en fonction du nombre de sous-tâches, le planificateur envoie le message directement à l'agent concerné (pour les scénarios à tâche unique) ou le coordonne par l'intermédiaire du gestionnaire de chat de groupe pour une collaboration multi-agents.
• Résumer les résultats : enfin, le planificateur résume le plan généré pour plus de clarté. L'exemple de code Python suivant illustre ces étapes :

from pydantic import BaseModel
from enum import Enum
from typing import List, Optional, Union
class AgentEnum(str, Enum):
FlightBooking = "flight_booking"
HotelBooking = "hotel_booking"
CarRental = "car_rental"
ActivitiesBooking = "activities_booking"
DestinationInfo = "destination_info"
DefaultAgent = "default_agent"
GroupChatManager = "group_chat_manager"
# Travel SubTask Model
class TravelSubTask(BaseModel):
task_details: str
assigned_agent: AgentEnum # we want to assign the task to the agent
class TravelPlan(BaseModel):
main_task: str
subtasks: List[TravelSubTask]
is_greeting: bool
import json
import os
from typing import Optional
from autogen_core.models import UserMessage, SystemMessage, AssistantMessage
from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
# Create the client with type-checked environment variables
client = AzureOpenAIChatCompletionClient(
azure_deployment=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
model=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
)
from pprint import pprint
# Define the user message
messages = [
SystemMessage(content="""你是一个规划 Agent。
你的工作是根据用户的请求决定运行哪些 Agent。
以下是专门负责不同任务的可用 Agent：
- FlightBooking: 用于预订航班和提供航班信息
- HotelBooking: 用于预订酒店和提供酒店信息
- CarRental: 用于预订汽车和提供汽车租赁信息
- ActivitiesBooking: 用于预订活动和提供活动信息
- DestinationInfo: 用于提供有关目的地的信息
- DefaultAgent: 用于处理一般请求""", source="system"),
UserMessage(content="为一个有两个孩子的家庭创建一个从新加坡到墨尔本的旅行计划", source="user"),
]
response = await client.create(messages=messages, extra_create_args={"response_format": TravelPlan})
# Ensure the response content is a valid JSON string before loading it
response_content: Optional[str] = response.content if isinstance(response.content, str) else None
if response_content is None:
raise ValueError("Response content is not a valid JSON string")
# Print the response content after loading it as JSON
pprint(json.loads(response_content))

Voici le résultat du code précédent, et ce résultat structuré peut être utilisé pour acheminer les données vers l'application assigned_agent et résumer les plans de voyage à l'utilisateur final.

{
"is_greeting": "False",
"main_task": "Plan a family trip from Singapore to Melbourne.",
"subtasks": [
{
"assigned_agent": "flight_booking",
"task_details": "Book round-trip flights from Singapore to Melbourne."
},
{
"assigned_agent": "hotel_booking",
"task_details": "Find family-friendly hotels in Melbourne."
},
{
"assigned_agent": "car_rental",
"task_details": "Arrange a car rental suitable for a family of four in Melbourne."
},
{
"assigned_agent": "activities_booking",
"task_details": "List family-friendly activities in Melbourne."
},
{
"assigned_agent": "destination_info",
"task_details": "Provide information about Melbourne as a travel destination."
}
]
}

Un exemple de carnet de notes contenant l'exemple de code précédent se trouve dans la sectionici (littéraire)Trouver.

Planification itérative

Certaines tâches nécessitent une itération ou une replanification, où le résultat d'une sous-tâche affecte la suivante. Par exemple, si un agent découvre un format de données inattendu lors de la réservation d'un vol, il devra peut-être ajuster sa stratégie avant de poursuivre la réservation d'un hôtel.

En outre, le retour d'information de l'utilisateur (par exemple, un utilisateur décide qu'il préfère un vol plus tôt) peut déclencher une replanification partielle. Cette approche dynamique et itérative garantit que la solution finale est alignée sur les contraintes du monde réel et les préférences changeantes de l'utilisateur.

Par exemple, l'exemple de code

```python
from autogen_core.models import UserMessage, SystemMessage, AssistantMessage
#.. same as previous code and pass on the user history, current plan 
messages = [
SystemMessage(content="""你是一个规划 Agent，负责优化旅行计划。
你的工作是根据用户的请求决定运行哪些 Agent。
以下是专门负责不同任务的可用 Agent：
- FlightBooking: 用于预订航班和提供航班信息
- HotelBooking: 用于预订酒店和提供酒店信息
- CarRental: 用于预订汽车和提供汽车租赁信息
- ActivitiesBooking: 用于预订活动和提供活动信息
- DestinationInfo: 用于提供有关目的地的信息
- DefaultAgent: 用于处理一般请求""", source="system"),
UserMessage(content="为一个有两个孩子的家庭创建一个从新加坡到墨尔本的旅行计划", source="user"),
AssistantMessage(content=f"先前的旅行计划 - {TravelPlan}", source="assistant")
]
# .. re-plan and send the tasks to respective agents

要获得更全面的规划，请查看 Magnetic One [博客文章](https://www.microsoft.com/research/articles/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks)，了解如何解决复杂任务。
## 总结
[](https://github.com/microsoft/ai-agents-for-beginners/blob/main/07-planning-design/README.md#summary)
在本文中，我们研究了一个示例，说明了如何创建一个规划器，该规划器可以动态选择定义的可用 Agent。规划器的输出分解任务并分配 Agent，以便执行它们。假设 Agent 可以访问执行任务所需的功能/工具。除了 Agent 之外，你还可以包括其他模式，如反思、摘要器和循环聊天以进行进一步定制。
## 其他资源
[](https://github.com/microsoft/ai-agents-for-beginners/blob/main/07-planning-design/README.md#additional-resources)
*   AutoGen Magentic One - 一个通用的多 Agent 系统，用于解决复杂的任务，并在多个具有挑战性的 Agent 基准测试中取得了令人印象深刻的结果。参考：[autogen-magentic-one](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-magentic-one)。在此实现中，编排器创建特定于任务的计划并将这些任务委派给可用的 Agent。除了规划之外，编排器还采用跟踪机制来监控任务的进度并根据需要重新规划。