# Explorer les Frameworks d'Agents IA

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

Ces frameworks permettent aux développeurs de se concentrer sur les aspects uniques de leurs applications en proposant des approches standardisées pour relever les défis communs du développement d'agents IA. Ils améliorent la scalabilité, l'accessibilité et l'efficacité dans la construction de systèmes IA.

## Introduction

Cette leçon couvrira :

- Ce que sont les frameworks d'agents IA et ce qu'ils permettent aux développeurs de réaliser.
- Comment les équipes peuvent les utiliser pour prototyper rapidement, itérer et améliorer les capacités de leurs agents.
- Les différences entre les frameworks et outils créés par Microsoft ([Autogen](https://aka.ms/ai-agents/autogen) / [Semantic Kernel](https://aka.ms/ai-agents-beginners/semantic-kernel) / [Azure AI Agent Service](https://aka.ms/ai-agents-beginners/ai-agent-service)).
- Est-il possible d'intégrer directement mes outils existants de l'écosystème Azure, ou ai-je besoin de solutions autonomes ?
- Qu'est-ce que le service Azure AI Agents et comment cela m'aide-t-il ?

## Objectifs d'apprentissage

Les objectifs de cette leçon sont de vous aider à comprendre :

- Le rôle des frameworks d'agents IA dans le développement IA.
- Comment tirer parti des frameworks d'agents IA pour construire des agents intelligents.
- Les capacités clés offertes par les frameworks d'agents IA.
- Les différences entre Autogen, Semantic Kernel et Azure AI Agent Service.

## Que sont les frameworks d'agents IA et que permettent-ils aux développeurs de faire ?

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

- **Personnalisation** : L'IA peut analyser le comportement et les préférences des utilisateurs pour fournir des recommandations, contenus et expériences personnalisés.
Exemple : Les services de streaming comme Netflix utilisent l'IA pour suggérer des films et des séries en fonction de l'historique de visionnage, améliorant ainsi l'engagement et la satisfaction des utilisateurs.
- **Automatisation et efficacité** : L'IA peut automatiser les tâches répétitives, rationaliser les flux de travail et améliorer l'efficacité opérationnelle.
Exemple : Les applications de service client utilisent des chatbots alimentés par l'IA pour traiter les demandes courantes, réduisant ainsi les temps de réponse et libérant les agents humains pour des problèmes plus complexes.
- **Amélioration de l'expérience utilisateur** : L'IA peut améliorer l'expérience utilisateur globale en proposant des fonctionnalités intelligentes comme la reconnaissance vocale, le traitement du langage naturel et le texte prédictif.
Exemple : Les assistants virtuels comme Siri et Google Assistant utilisent l'IA pour comprendre et répondre aux commandes vocales, facilitant l'interaction des utilisateurs avec leurs appareils.

### Tout cela semble génial, n'est-ce pas ? Alors pourquoi avons-nous besoin de frameworks d'agents IA ?

Les frameworks d'agents IA représentent quelque chose de plus que les simples frameworks IA. Ils sont conçus pour permettre la création d'agents intelligents capables d'interagir avec les utilisateurs, d'autres agents et leur environnement pour atteindre des objectifs spécifiques. Ces agents peuvent adopter un comportement autonome, prendre des décisions et s'adapter à des conditions changeantes. Examinons quelques capacités clés offertes par les frameworks d'agents IA :

- **Collaboration et coordination entre agents** : Permettent la création de multiples agents IA capables de travailler ensemble, communiquer et se coordonner pour résoudre des tâches complexes.
- **Automatisation et gestion des tâches** : Fournissent des mécanismes pour automatiser des flux de travail en plusieurs étapes, déléguer des tâches et gérer dynamiquement les tâches entre les agents.
- **Compréhension contextuelle et adaptation** : Équipent les agents de la capacité à comprendre le contexte, s'adapter à des environnements changeants et prendre des décisions basées sur des informations en temps réel.

En résumé, les agents permettent d'aller plus loin, de pousser l'automatisation à un niveau supérieur et de créer des systèmes plus intelligents capables de s'adapter et d'apprendre de leur environnement.

## Comment prototyper, itérer et améliorer rapidement les capacités d’un agent ?

C'est un domaine en constante évolution, mais il existe des éléments communs à la plupart des frameworks d'agents IA qui peuvent vous aider à prototyper et itérer rapidement, notamment les composants modulaires, les outils collaboratifs et l'apprentissage en temps réel. Explorons ces éléments :

- **Utiliser des composants modulaires** : Les frameworks IA offrent des composants préconstruits comme des invites, des analyseurs et des gestionnaires de mémoire.
- **Exploiter des outils collaboratifs** : Concevoir des agents avec des rôles et tâches spécifiques pour tester et affiner les flux de travail collaboratifs.
- **Apprendre en temps réel** : Mettre en œuvre des boucles de rétroaction où les agents apprennent des interactions et ajustent leur comportement de manière dynamique.

### Utiliser des composants modulaires

Des frameworks comme LangChain et Microsoft Semantic Kernel offrent des composants préconstruits tels que des invites, des analyseurs et des gestionnaires de mémoire.

**Comment les équipes peuvent les utiliser** : Les équipes peuvent assembler rapidement ces composants pour créer un prototype fonctionnel sans partir de zéro, ce qui permet une expérimentation et une itération rapides.

**Comment cela fonctionne en pratique** : Vous pouvez utiliser un analyseur préconstruit pour extraire des informations des entrées utilisateur, un module de mémoire pour stocker et récupérer des données, et un générateur d'invites pour interagir avec les utilisateurs, sans avoir à construire ces composants à partir de zéro.

**Exemple de code**. Voici un exemple montrant comment utiliser un analyseur préconstruit pour extraire des informations des entrées utilisateur :

```python
from langchain import Parser

parser = Parser()
user_input = "Book a flight from New York to London on July 15th"

parsed_data = parser.parse(user_input)

print(parsed_data)
# Output: {'origin': 'New York', 'destination': 'London', 'date': 'July 15th'}
```

Ce que vous voyez dans cet exemple, c'est comment tirer parti d'un analyseur préconstruit pour extraire des informations clés des entrées utilisateur, comme 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.

### Exploiter des outils collaboratifs

Des frameworks comme CrewAI et Microsoft Autogen facilitent la création de plusieurs agents capables de travailler ensemble.

**Comment les équipes peuvent les utiliser** : Les équipes peuvent concevoir des agents avec des rôles et tâches spécifiques, leur permettant de tester et affiner les flux de travail collaboratifs et d'améliorer l'efficacité globale du système.

**Comment cela fonctionne en pratique** : Vous pouvez créer une équipe d'agents où chaque agent a une fonction spécialisée, comme la récupération de données, l'analyse ou la prise de décision. Ces agents peuvent communiquer et partager des informations pour atteindre un objectif commun, comme répondre à une requête utilisateur ou accomplir une tâche.

**Exemple de code (Autogen)** :

```python
# creating agents, then create a round robin schedule where they can work together, in this case in order

# Data Retrieval Agent
# Data Analysis Agent
# Decision Making 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."
)

# conversation ends when user says "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)
# Use asyncio.run(...) when running in a script.
await Console(stream)
```

Dans le code ci-dessus, vous voyez comment créer une tâche impliquant plusieurs agents travaillant ensemble pour analyser des données. Chaque agent remplit une fonction spécifique, et la tâche est exécutée en coordonnant les agents pour atteindre le résultat souhaité. En créant des agents dédiés avec des rôles spécialisés, vous pouvez améliorer l'efficacité et les performances des tâches.

### Apprendre en temps réel

Les frameworks avancés offrent des capacités de compréhension contextuelle et d'adaptation en temps réel.

**Comment les équipes peuvent les utiliser** : Les équipes peuvent mettre en œuvre des boucles de rétroaction où les agents apprennent des interactions et ajustent leur comportement de manière dynamique, ce qui conduit à une amélioration continue et à un affinement des capacités.

**Comment cela fonctionne en pratique** : Les agents peuvent analyser les retours des utilisateurs, les données environnementales et les résultats des tâches pour mettre à jour leur base de connaissances, ajuster 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.

## Quelles sont les différences entre les frameworks Autogen, Semantic Kernel et Azure AI Agent Service ?

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

--- (La traduction continue ici, mais suit la même logique en respectant les consignes) ---
basé sur les objectifs du projet. Idéal pour la compréhension du langage naturel, la génération de contenu. - **Azure AI Agent Service** : Modèles flexibles, mécanismes de sécurité d'entreprise, méthodes de stockage des données. Idéal pour un déploiement sécurisé, évolutif et flexible d'agents IA dans des applications d'entreprise.

## Puis-je intégrer directement mes outils existants de l'écosystème Azure, ou ai-je besoin de solutions autonomes ?
La réponse est oui, vous pouvez intégrer directement vos outils existants de l'écosystème Azure avec Azure AI Agent Service, notamment parce qu'il a été conçu pour fonctionner de manière transparente avec d'autres services Azure. Par exemple, vous pourriez 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 avec les services Azure, mais cela peut nécessiter d'appeler les services Azure depuis votre code. Une autre manière d'intégrer est d'utiliser les SDK Azure pour interagir avec les services Azure depuis vos agents. De plus, comme mentionné, vous pouvez utiliser Azure AI Agent Service comme orchestrateur pour vos agents construits dans Autogen ou Semantic Kernel, ce qui offrirait un accès facile à l'écosystème Azure.

## Références
- [1] - [Azure Agent Service](https://techcommunity.microsoft.com/blog/azure-ai-services-blog/introducing-azure-ai-agent-service/4298357)
- [2] - [Semantic Kernel and Autogen](https://devblogs.microsoft.com/semantic-kernel/microsofts-agentic-ai-frameworks-autogen-and-semantic-kernel/)
- [3] - [Semantic Kernel Agent Framework](https://learn.microsoft.com/semantic-kernel/frameworks/agent/?pivots=programming-language-csharp)
- [4] - [Azure AI Agent service](https://learn.microsoft.com/azure/ai-services/agents/overview)
- [5] - [Using Azure AI Agent Service with AutoGen / Semantic Kernel to build a multi-agent's solution](https://techcommunity.microsoft.com/blog/educatordeveloperblog/using-azure-ai-agent-service-with-autogen--semantic-kernel-to-build-a-multi-agen/4363121)

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction automatisée basés sur l'intelligence artificielle. Bien que nous fassions de notre mieux pour garantir l'exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle effectuée par un humain. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.


# Principes de Conception Agentique pour l'IA

## Introduction

Il existe de nombreuses façons d'aborder la création de systèmes d'IA agentique. Étant donné que l'ambiguïté est une caractéristique inhérente et non un défaut dans la conception de l'IA générative, il est parfois difficile pour les ingénieurs de savoir par où commencer. Nous avons élaboré un ensemble de principes de conception UX centrés sur l'humain pour permettre aux développeurs de créer des systèmes agentiques centrés sur les utilisateurs, répondant à leurs besoins professionnels. Ces principes de conception ne constituent pas une architecture prescriptive, mais plutôt un point de départ pour les équipes qui définissent et construisent des expériences d'agents.

En général, les agents devraient :

- Élargir et amplifier les capacités humaines (brainstorming, résolution de problèmes, automatisation, etc.)
- Combler les lacunes en matière de connaissances (me mettre à jour sur des domaines de connaissance, traduction, etc.)
- Faciliter et soutenir la collaboration en respectant les préférences individuelles pour travailler avec d'autres
- Nous rendre meilleurs (par exemple, coach de vie/gestionnaire de tâches, nous aider à apprendre la régulation émotionnelle et des compétences de pleine conscience, renforcer la résilience, etc.)

## Cette Leçon Couvre

- Quels sont les Principes de Conception Agentique
- Quelles sont les directives à suivre pour mettre en œuvre ces principes de conception
- Quels sont des exemples d'utilisation de ces principes de conception

## Objectifs d'Apprentissage

Après avoir terminé cette leçon, vous serez en mesure de :

1. Expliquer ce que sont les Principes de Conception Agentique
2. Expliquer les directives pour utiliser les Principes de Conception Agentique
3. Comprendre comment construire un agent en utilisant les Principes de Conception Agentique

## Les Principes de Conception Agentique

![Principes de Conception Agentique](../../../translated_images/agentic-design-principles.9f32a64bb6e2aa5a1bdffb70111aa724058bc248b1a3dd3c6661344015604cff.fr.png?WT.mc_id=academic-105485-koreyst)

### Agent (Espace)

C'est l'environnement dans lequel l'agent opère. Ces principes guident la manière dont nous concevons les agents pour interagir dans des mondes physiques et numériques.

- **Connecter, pas isoler** – aider à connecter les personnes à d'autres personnes, événements et connaissances exploitables pour favoriser la collaboration et le lien.
  - Les agents aident à relier événements, connaissances et individus.
  - Les agents rapprochent les gens. Ils ne sont pas conçus pour remplacer ou minimiser les individus.
- **Facilement accessible mais parfois invisible** – l'agent opère principalement en arrière-plan et n'intervient que lorsqu'il est pertinent et approprié.
  - L'agent est facilement accessible et repérable par les utilisateurs autorisés sur n'importe quel appareil ou plateforme.
  - L'agent prend en charge des entrées et sorties multimodales (son, voix, texte, etc.).
  - L'agent peut passer de manière fluide de l'avant-plan à l'arrière-plan ; de proactif à réactif, en fonction de son évaluation des besoins de l'utilisateur.
  - L'agent peut fonctionner de manière invisible, mais son processus en arrière-plan et sa collaboration avec d'autres agents sont transparents et contrôlables par l'utilisateur.

### Agent (Temps)

C'est ainsi que l'agent fonctionne au fil du temps. Ces principes guident la manière dont nous concevons les agents interagissant à travers le passé, le présent et le futur.

- **Passé** : Réfléchir à l'historique incluant état et contexte.
  - L'agent fournit des résultats plus pertinents grâce à l'analyse de données historiques plus riches au-delà de l'événement, des personnes ou des états.
  - L'agent établit des connexions à partir d'événements passés et réfléchit activement à sa mémoire pour interagir avec les situations actuelles.
- **Présent** : Encourager plutôt que notifier.
  - L'agent adopte une approche globale pour interagir avec les personnes. Lorsqu'un événement se produit, il va au-delà de la notification statique ou d'autres formalités statiques. Il peut simplifier les flux ou générer des indices dynamiques pour attirer l'attention de l'utilisateur au bon moment.
  - L'agent délivre des informations en fonction du contexte, des changements sociaux et culturels, et adaptées aux intentions de l'utilisateur.
  - L'interaction avec l'agent peut être progressive, évoluant en complexité pour autonomiser les utilisateurs sur le long terme.
- **Futur** : S'adapter et évoluer.
  - L'agent s'adapte à divers appareils, plateformes et modalités.
  - L'agent s'adapte au comportement de l'utilisateur, aux besoins d'accessibilité, et est librement personnalisable.
  - L'agent se façonne et évolue grâce à une interaction continue avec l'utilisateur.

### Agent (Noyau)

Ce sont les éléments clés au cœur de la conception d'un agent.

- **Accepter l'incertitude mais établir la confiance**.
  - Un certain niveau d'incertitude de l'agent est attendu. L'incertitude est un élément clé de la conception des agents.
  - La confiance et la transparence sont des couches fondamentales dans la conception des agents.
  - Les humains contrôlent quand l'agent est activé/désactivé, et le statut de l'agent est clairement visible à tout moment.

## Les Directives Pour Mettre en Œuvre Ces Principes

Lorsque vous utilisez les principes de conception ci-dessus, suivez les directives suivantes :

1. **Transparence** : Informez l'utilisateur que l'IA est impliquée, comment elle fonctionne (y compris ses actions passées), et comment donner des retours et modifier le système.
2. **Contrôle** : Permettez à l'utilisateur de personnaliser, spécifier ses préférences et personnaliser, et d'avoir le contrôle sur le système et ses attributs (y compris la possibilité d'oublier).
3. **Cohérence** : Visez des expériences cohérentes et multimodales sur tous les appareils et points d'accès. Utilisez des éléments d'interface utilisateur/UX familiers lorsque cela est possible (par exemple, une icône de microphone pour l'interaction vocale) et réduisez autant que possible la charge cognitive de l'utilisateur (par exemple, privilégiez des réponses concises, des aides visuelles et du contenu « En savoir plus »).

## Comment Concevoir un Agent de Voyage en Utilisant Ces Principes et Directives

Imaginez que vous concevez un Agent de Voyage, voici comment vous pourriez envisager d'utiliser les Principes de Conception et les Directives :

1. **Transparence** – Informez l'utilisateur que l'Agent de Voyage est un agent activé par l'IA. Fournissez des instructions de base pour démarrer (par exemple, un message de « Bonjour », des exemples de requêtes). Documentez cela clairement sur la page produit. Montrez la liste des requêtes posées par l'utilisateur dans le passé. Expliquez clairement comment donner des retours (pouce levé et baissé, bouton « Envoyer un retour », etc.). Indiquez clairement si l'agent a des restrictions d'utilisation ou de sujet.
2. **Contrôle** – Assurez-vous qu'il est clair comment l'utilisateur peut modifier l'agent après sa création, par exemple avec des invites système. Permettez à l'utilisateur de choisir le niveau de détail de l'agent, son style d'écriture, et toute restriction sur ce dont l'agent ne doit pas parler. Autorisez l'utilisateur à consulter et supprimer tout fichier ou donnée associé(e), les requêtes et les conversations passées.
3. **Cohérence** – Assurez-vous que les icônes pour Partager une Requête, ajouter un fichier ou une photo, et taguer quelqu'un ou quelque chose sont standards et reconnaissables. Utilisez l'icône de trombone pour indiquer le téléversement/partage de fichier avec l'agent, et une icône d'image pour indiquer le téléversement de graphiques.

## Ressources Supplémentaires
- [Practices for Governing Agentic AI Systems | OpenAI](https://openai.com)
- [The HAX Toolkit Project - Microsoft Research](https://microsoft.com)
- [Responsible AI Toolbox](https://responsibleaitoolbox.ai)
```

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction basés sur l'intelligence artificielle. Bien que nous fassions de notre mieux pour garantir l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées découlant de l'utilisation de cette traduction.

10 Lessons to Get Started Building AI Agents


# Modèle de Conception d'Utilisation d'Outils

## Introduction

Dans cette leçon, nous cherchons à répondre aux questions suivantes :

- Qu'est-ce que le modèle de conception d'utilisation d'outils ?
- À quels cas d'utilisation peut-il être appliqué ?
- Quels sont les éléments nécessaires pour implémenter ce modèle de conception ?
- Quelles sont les considérations particulières pour utiliser le modèle de conception d'utilisation d'outils afin de construire des agents d'IA fiables ?

## Objectifs d'Apprentissage

Après avoir complété cette leçon, vous serez capable de :

- Définir le modèle de conception d'utilisation d'outils et son objectif.
- Identifier les cas d'utilisation où ce modèle est applicable.
- Comprendre les éléments clés nécessaires pour implémenter ce modèle de conception.
- Reconnaître les considérations pour garantir la fiabilité des agents d'IA utilisant ce modèle de conception.

## Qu'est-ce que le modèle de conception d'utilisation d'outils ?

Le **modèle de conception d'utilisation d'outils** se concentre sur la capacité des LLMs (modèles de langage à grande échelle) à interagir avec des outils externes pour atteindre des objectifs spécifiques. Les outils sont des morceaux de code pouvant être exécutés par un agent pour effectuer des actions. Un outil peut être une fonction simple comme une calculatrice ou un appel API vers un service tiers, comme une recherche de prix d'actions ou une prévision météo. Dans le contexte des agents d'IA, les outils sont conçus pour être exécutés par des agents en réponse à des **appels de fonction générés par le modèle**.

## À quels cas d'utilisation peut-il être appliqué ?

Les agents d'IA peuvent utiliser des outils pour accomplir des tâches complexes, récupérer des informations ou prendre des décisions. Le modèle de conception d'utilisation d'outils est souvent utilisé dans des scénarios nécessitant une interaction dynamique avec des systèmes externes tels que des bases de données, des services web ou des interpréteurs de code. Cette capacité est utile pour de nombreux cas d'utilisation, notamment :

- **Récupération d'informations dynamiques :** Les agents peuvent interroger des API ou des bases de données externes pour obtenir des données à jour (par exemple, interroger une base SQLite pour des analyses de données, récupérer des prix d'actions ou des informations météorologiques).
- **Exécution et interprétation de code :** Les agents peuvent exécuter du code ou des scripts pour résoudre des problèmes mathématiques, générer des rapports ou réaliser des simulations.
- **Automatisation de flux de travail :** Automatiser des flux de travail répétitifs ou en plusieurs étapes en intégrant des outils tels que des planificateurs de tâches, des services d'e-mails ou des pipelines de données.
- **Support client :** Les agents peuvent interagir avec des systèmes CRM, des plateformes de gestion des tickets ou des bases de connaissances pour résoudre des demandes des utilisateurs.
- **Génération et édition de contenu :** Les agents peuvent utiliser des outils comme des correcteurs grammaticaux, des résumeurs de texte ou des évaluateurs de sécurité de contenu pour aider dans les tâches de création de contenu.

## Quels sont les éléments nécessaires pour implémenter le modèle de conception d'utilisation d'outils ?

### Appels de Fonction/Outil

L'appel de fonction est le principal moyen permettant aux LLMs d'interagir avec des outils. Vous verrez souvent les termes 'Fonction' et 'Outil' utilisés de manière interchangeable, car les 'fonctions' (blocs de code réutilisables) sont les 'outils' que les agents utilisent pour accomplir des tâches. Pour qu'une fonction soit invoquée, le LLM doit comparer la demande de l'utilisateur à la description des fonctions. Un schéma contenant les descriptions de toutes les fonctions disponibles est envoyé au LLM. Le LLM sélectionne ensuite la fonction la plus appropriée pour la tâche et retourne son nom ainsi que ses arguments. La fonction sélectionnée est exécutée, sa réponse est renvoyée au LLM, qui utilise ces informations pour répondre à la demande de l'utilisateur.

Pour que les développeurs puissent implémenter des appels de fonction pour les agents, ils auront besoin de :

1. Un modèle LLM prenant en charge les appels de fonction
2. Un schéma contenant les descriptions des fonctions
3. Le code de chaque fonction décrite

Prenons l'exemple de l'obtention de l'heure actuelle dans une ville pour illustrer :

- **Initialiser un LLM prenant en charge les appels de fonction :**

    Tous les modèles ne prennent pas en charge les appels de fonction, il est donc important de vérifier que le modèle utilisé le permet. [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling) prend en charge les appels de fonction. Nous pouvons commencer par initialiser le client Azure OpenAI.

    ```python
    # Initialize the Azure OpenAI client
    client = AzureOpenAI(
        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
        api_version="2024-05-01-preview"
    )
    ```

- **Créer un schéma de fonction :**

    Ensuite, nous définissons un schéma JSON contenant le nom de la fonction, une description de ce que fait la fonction, ainsi que les noms et descriptions des paramètres de la fonction. Nous transmettons ensuite ce schéma au client créé ci-dessus, avec la demande de l'utilisateur pour trouver l'heure à San Francisco. Il est important de noter qu'un **appel d'outil** est ce qui est retourné, **et non** la réponse finale à la question. Comme mentionné précédemment, le LLM retourne le nom de la fonction qu'il a sélectionnée pour la tâche, ainsi que les arguments qui lui seront passés.

    ```python
    # Function description for the model to read
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]
    ```

    ```python

    # Initial user message
    messages = [{"role": "user", "content": "What's the current time in San Francisco"}]

    # First API call: Ask the model to use the function
      response = client.chat.completions.create(
          model=deployment_name,
          messages=messages,
          tools=tools,
          tool_choice="auto",
      )

      # Process the model's response
      response_message = response.choices[0].message
      messages.append(response_message)

      print("Model's response:")

      print(response_message)

    ```

    ```bash
    Model's response:
    ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_pOsKdUlqvdyttYB67MOj434b', function=Function(arguments='{"location":"San Francisco"}', name='get_current_time'), type='function')])
    ```

- **Le code de la fonction nécessaire pour accomplir la tâche :**

    Maintenant que le LLM a choisi la fonction à exécuter, le code réalisant la tâche doit être implémenté et exécuté. Nous pouvons implémenter le code pour obtenir l'heure actuelle en Python. Nous devrons également écrire le code pour extraire le nom et les arguments de `response_message` afin d'obtenir le résultat final.

    ```python
      def get_current_time(location):
        """Get the current time for a given location"""
        print(f"get_current_time called with location: {location}")
        location_lower = location.lower()

        for key, timezone in TIMEZONE_DATA.items():
            if key in location_lower:
                print(f"Timezone found for {key}")
                current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
                return json.dumps({
                    "location": location,
                    "current_time": current_time
                })

        print(f"No timezone data found for {location_lower}")
        return json.dumps({"location": location, "current_time": "unknown"})
    ```

    ```python
     # Handle function calls
      if response_message.tool_calls:
          for tool_call in response_message.tool_calls:
              if tool_call.function.name == "get_current_time":

                  function_args = json.loads(tool_call.function.arguments)

                  time_response = get_current_time(
                      location=function_args.get("location")
                  )

                  messages.append({
                      "tool_call_id": tool_call.id,
                      "role": "tool",
                      "name": "get_current_time",
                      "content": time_response,
                  })
      else:
          print("No tool calls were made by the model.")

      # Second API call: Get the final response from the model
      final_response = client.chat.completions.create(
          model=deployment_name,
          messages=messages,
      )

      return final_response.choices[0].message.content
     ```

    ```bash
      get_current_time called with location: San Francisco
      Timezone found for san francisco
      The current time in San Francisco is 09:24 AM.
     ```

L'appel de fonction est au cœur de la plupart, sinon de toutes les conceptions d'utilisation d'outils par les agents, bien que l'implémenter à partir de zéro puisse parfois être complexe. Comme nous l'avons appris dans la [Leçon 2](../../../02-explore-agentic-frameworks), les frameworks agentiques nous fournissent des blocs de construction préconstruits pour implémenter l'utilisation d'outils.

### Exemples d'Utilisation d'Outils avec des Frameworks Agentiques

- ### **[Semantic Kernel](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    Semantic Kernel est un framework open-source pour les développeurs .NET, Python et Java travaillant avec des LLMs. Il simplifie le processus d'utilisation des appels de fonction en décrivant automatiquement vos fonctions et leurs paramètres au modèle via un processus appelé [sérialisation](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions). Il gère également la communication entre le modèle et votre code. Un autre avantage d'utiliser un framework agentique comme Semantic Kernel est qu'il permet d'accéder à des outils préconstruits tels que [File Search](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step4_assistant_tool_file_search.py) et [Code Interpreter](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py).

    Le diagramme suivant illustre le processus d'appel de fonction avec Semantic Kernel :

    ![function calling](../../../translated_images/functioncalling-diagram.b5493ea5154ad8e3e4940d2e36a49101eec1398948e5d1039942203b4f5a4209.fr.png)

    Dans Semantic Kernel, les fonctions/outils sont appelés [Plugins](https://learn.microsoft.com/semantic-kernel/concepts/plugins/?pivots=programming-language-python). Nous pouvons convertir la fonction `get_current_time` function we saw earlier into a plugin by turning it into a class with the function in it. We can also import the `kernel_function` en utilisant un décorateur qui prend la description de la fonction. Lorsque vous créez un kernel avec le plugin GetCurrentTimePlugin, celui-ci sérialisera automatiquement la fonction et ses paramètres, créant ainsi le schéma à envoyer au LLM.

    ```python
    from semantic_kernel.functions import kernel_function

    class GetCurrentTimePlugin:
        async def __init__(self, location):
            self.location = location

        @kernel_function(
            description="Get the current time for a given location"
        )
        def get_current_time(location: str = ""):
            ...

    ```

    ```python
    from semantic_kernel import Kernel

    # Create the kernel
    kernel = Kernel()

    # Create the plugin
    get_current_time_plugin = GetCurrentTimePlugin(location)

    # Add the plugin to the kernel
    kernel.add_plugin(get_current_time_plugin)
    ```

- ### **[Azure AI Agent Service](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    Azure AI Agent Service est un framework agentique plus récent conçu pour permettre aux développeurs de créer, déployer et faire évoluer des agents d'IA de haute qualité et extensibles, sans avoir à gérer les ressources informatiques et de stockage sous-jacentes. Il est particulièrement utile pour les applications d'entreprise, car il s'agit d'un service entièrement géré avec une sécurité de niveau entreprise.

    Comparé au développement avec l'API LLM directement, Azure AI Agent Service offre certains avantages, notamment :
  - Appels d'outils automatiques – pas besoin de parser un appel d'outil, d'invoquer l'outil et de gérer la réponse ; tout cela est désormais géré côté serveur.
  - Gestion sécurisée des données – au lieu de gérer votre propre état de conversation, vous pouvez utiliser des threads pour stocker toutes les informations nécessaires.
  - Outils prêts à l'emploi – Outils permettant d'interagir avec vos sources de données, comme Bing, Azure AI Search et Azure Functions.

    Les outils disponibles dans Azure AI Agent Service peuvent être divisés en deux catégories :

    1. Outils de Connaissance :
        - [Grounding avec Bing Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/bing-grounding?tabs=python&pivots=overview)
        - [File Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/file-search?tabs=python&pivots=overview)
        - [Azure AI Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-ai-search?tabs=azurecli%2Cpython&pivots=overview-azure-ai-search)

    2. Outils d'Action :
        - [Appels de Fonction](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/function-calling?tabs=python&pivots=overview)
        - [Code Interpreter](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/code-interpreter?tabs=python&pivots=overview)
        - [Outils définis par OpenAI](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/openapi-spec?tabs=python&pivots=overview)
        - [Azure Functions](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-functions?pivots=overview)

    Le service Agent permet d'utiliser ces outils ensemble comme un `toolset`. It also utilizes `threads` which keep track of the history of messages from a particular conversation.

    Imagine you are a sales agent at a company called Contoso. You want to develop a conversational agent that can answer questions about your sales data.

    The image below illustrates how you could use Azure AI Agent Service to analyze your sales data:

    ![Agentic Service In Action](../../../translated_images/agent-service-in-action.8c2d8aa8e9d91feeb29549b3fde529f8332b243875154d03907616a69198afbc.fr.jpg?WT.mc_id=academic-105485-koreyst)

    To use any of these tools with the service we can create a client and define a tool or toolset. To implement this practically we can use the Python code below. The LLM will be able to look at the toolset and decide whether to use the user created function, `fetch_sales_data_using_sqlite_query`, ou le Code Interpreter préconstruit selon la demande de l'utilisateur.

    ```python
    import os
    from azure.ai.projects import AIProjectClient
    from azure.identity import DefaultAzureCredential
    from fecth_sales_data_functions import fetch_sales_data_using_sqlite_query # fetch_sales_data_using_sqlite_query function which can be found in a fecth_sales_data_functions.py file.
    from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

    project_client = AIProjectClient.from_connection_string(
        credential=DefaultAzureCredential(),
        conn_str=os.environ["PROJECT_CONNECTION_STRING"],
    )

    # Initialize function calling agent with the fetch_sales_data_using_sqlite_query function and adding it to the toolset
    fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
    toolset = ToolSet()
    toolset.add(fetch_data_function)

    # Initialize Code Interpreter tool and adding it to the toolset.
    code_interpreter = code_interpreter = CodeInterpreterTool()
    toolset = ToolSet()
    toolset.add(code_interpreter)

    agent = project_client.agents.create_agent(
        model="gpt-4o-mini", name="my-agent", instructions="You are helpful agent",
        toolset=toolset
    )
    ```

## Quelles sont les considérations particulières pour utiliser le modèle de conception d'utilisation d'outils pour construire des agents d'IA fiables ?

Une préoccupation fréquente avec le SQL généré dynamiquement par les LLMs est la sécurité, en particulier le risque d'injection SQL ou d'actions malveillantes, telles que la suppression ou la manipulation de la base de données. Bien que ces préoccupations soient valides, elles peuvent être efficacement atténuées en configurant correctement les permissions d'accès à la base de données. Pour la plupart des bases de données, cela implique de configurer la base comme en lecture seule. Pour des services de bases de données comme PostgreSQL ou Azure SQL, l'application doit se voir attribuer un rôle en lecture seule (SELECT).

Exécuter l'application dans un environnement sécurisé renforce encore la protection. Dans les scénarios d'entreprise, les données sont généralement extraites et transformées à partir de systèmes opérationnels dans une base de données en lecture seule ou un entrepôt de données avec un schéma convivial. Cette approche garantit que les données sont sécurisées, optimisées pour la performance et l'accessibilité, et que l'application dispose d'un accès restreint en lecture seule.

## Ressources Supplémentaires

- [Atelier sur Azure AI Agents Service](https://microsoft.github.io/build-your-first-agent-with-azure-ai-agent-service-workshop/)
- [Atelier Contoso Creative Writer Multi-Agent](https://github.com/Azure-Samples/contoso-creative-writer/tree/main/docs/workshop)
- [Tutoriel sur l'Appel de Fonction dans Semantic Kernel](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)
- [Code Interpreter dans Semantic Kernel](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py)
- [Autogen Tools](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/components/tools.html)
```

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction automatisés basés sur l'IA. Bien que nous fassions de notre mieux pour garantir l'exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.


# Agentic RAG

Cette leçon offre une vue d'ensemble complète de l'Agentic Retrieval-Augmented Generation (Agentic RAG), un paradigme émergent de l'IA où les grands modèles de langage (LLMs) planifient de manière autonome leurs prochaines étapes tout en récupérant des informations à partir de sources externes. Contrairement aux modèles statiques de type "récupérer puis lire", l'Agentic RAG implique des appels itératifs au LLM, entrecoupés d'appels à des outils ou fonctions et de sorties structurées. Le système évalue les résultats, affine les requêtes, invoque des outils supplémentaires si nécessaire, et poursuit ce cycle jusqu'à ce qu'une solution satisfaisante soit atteinte.

## Introduction

Cette leçon couvrira :

- **Comprendre l'Agentic RAG :** Découvrez ce paradigme émergent en IA où les grands modèles de langage (LLMs) planifient de manière autonome leurs prochaines étapes tout en récupérant des informations à partir de sources de données externes.
- **Approche itérative Maker-Checker :** Apprenez à comprendre la boucle d'appels itératifs au LLM, entrecoupés d'appels à des outils ou fonctions et de sorties structurées, conçue pour améliorer la précision et gérer les requêtes mal formées.
- **Explorer des applications pratiques :** Identifiez les scénarios où l'Agentic RAG excelle, comme dans les environnements où la précision est primordiale, les interactions complexes avec des bases de données, et les flux de travail prolongés.

## Objectifs d'apprentissage

Après avoir complété cette leçon, vous serez capable de :

- **Comprendre l'Agentic RAG :** Découvrir ce paradigme émergent en IA où les grands modèles de langage (LLMs) planifient de manière autonome leurs prochaines étapes tout en récupérant des informations à partir de sources de données externes.
- **Approche itérative Maker-Checker :** Saisir le concept d'une boucle d'appels itératifs au LLM, entrecoupés d'appels à des outils ou fonctions et de sorties structurées, conçue pour améliorer la précision et gérer les requêtes mal formées.
- **Maîtriser le processus de raisonnement :** Comprendre la capacité du système à prendre en charge son propre processus de raisonnement, en décidant comment aborder les problèmes sans dépendre de chemins pré-définis.
- **Flux de travail :** Comprendre comment un modèle agentique décide de manière autonome de récupérer des rapports sur les tendances du marché, d'identifier des données sur les concurrents, de corréler des métriques de ventes internes, de synthétiser les résultats et d'évaluer la stratégie.
- **Boucles itératives, intégration d'outils et mémoire :** Apprenez comment le système s'appuie sur un modèle d'interaction en boucle, en maintenant un état et une mémoire à travers les étapes pour éviter les boucles répétitives et prendre des décisions éclairées.
- **Gérer les échecs et l'auto-correction :** Explorez les mécanismes robustes d'auto-correction du système, incluant des itérations, des réinterrogations, l'utilisation d'outils de diagnostic et le recours à une supervision humaine.
- **Limites de l'autonomie :** Comprendre les limitations de l'Agentic RAG, en se concentrant sur l'autonomie spécifique au domaine, la dépendance à l'infrastructure et le respect des garde-fous.
- **Cas d'usage pratiques et valeur ajoutée :** Identifiez les scénarios où l'Agentic RAG excelle, comme dans les environnements où la précision est primordiale, les interactions complexes avec des bases de données, et les flux de travail prolongés.
- **Gouvernance, transparence et confiance :** Apprenez l'importance de la gouvernance et de la transparence, y compris le raisonnement explicable, le contrôle des biais et la supervision humaine.

## Qu'est-ce que l'Agentic RAG ?

L'Agentic Retrieval-Augmented Generation (Agentic RAG) est un paradigme émergent en IA où les grands modèles de langage (LLMs) planifient de manière autonome leurs prochaines étapes tout en récupérant des informations à partir de sources externes. Contrairement aux modèles statiques de type "récupérer puis lire", l'Agentic RAG implique des appels itératifs au LLM, entrecoupés d'appels à des outils ou fonctions et de sorties structurées. Le système évalue les résultats, affine les requêtes, invoque des outils supplémentaires si nécessaire, et poursuit ce cycle jusqu'à ce qu'une solution satisfaisante soit atteinte. Ce style itératif "maker-checker" améliore la précision, gère les requêtes mal formées et garantit des résultats de haute qualité.

Le système prend activement en charge son processus de raisonnement, réécrit les requêtes échouées, choisit différentes méthodes de récupération et intègre plusieurs outils—tels que la recherche vectorielle dans Azure AI Search, les bases de données SQL ou des API personnalisées—avant de finaliser sa réponse. La qualité distinctive d'un système agentique est sa capacité à posséder son processus de raisonnement. Les implémentations traditionnelles de RAG s'appuient sur des chemins pré-définis, mais un système agentique détermine de manière autonome la séquence des étapes en fonction de la qualité des informations qu'il trouve.

## Définir l'Agentic Retrieval-Augmented Generation (Agentic RAG)

L'Agentic Retrieval-Augmented Generation (Agentic RAG) est un paradigme émergent dans le développement de l'IA où les LLMs non seulement récupèrent des informations à partir de sources de données externes, mais planifient également leurs prochaines étapes de manière autonome. Contrairement aux modèles statiques de type "récupérer puis lire" ou aux séquences de prompts soigneusement scriptées, l'Agentic RAG repose sur une boucle d'appels itératifs au LLM, entrecoupés d'appels à des outils ou fonctions et de sorties structurées. À chaque étape, le système évalue les résultats obtenus, décide s'il doit affiner ses requêtes, invoque des outils supplémentaires si nécessaire, et poursuit ce cycle jusqu'à ce qu'une solution satisfaisante soit atteinte.

Ce style itératif "maker-checker" est conçu pour améliorer la précision, gérer les requêtes mal formées vers des bases de données structurées (par exemple, NL2SQL) et garantir des résultats équilibrés et de haute qualité. Plutôt que de se reposer uniquement sur des chaînes de prompts soigneusement conçues, le système prend activement en charge son processus de raisonnement. Il peut réécrire des requêtes échouées, choisir différentes méthodes de récupération et intégrer plusieurs outils—tels que la recherche vectorielle dans Azure AI Search, les bases de données SQL ou des API personnalisées—avant de finaliser sa réponse. Cela élimine le besoin de cadres d'orchestration excessivement complexes. À la place, une boucle relativement simple de "Appel LLM → Utilisation d'outil → Appel LLM → …" peut produire des résultats sophistiqués et bien fondés.

![Agentic RAG Core Loop](../../../translated_images/agentic-rag-core-loop.2224925a913fb3439f518bda61a40096ddf6aa432a11c9b5bba8d0d625e47b79.fr.png?WT.mc_id=academic-105485-koreyst)

## Maîtriser le processus de raisonnement

La qualité distinctive qui rend un système "agentique" est sa capacité à maîtriser son processus de raisonnement. Les implémentations traditionnelles de RAG dépendent souvent des humains pour pré-définir un chemin pour le modèle : une chaîne de réflexion qui décrit quoi récupérer et quand.
Mais lorsqu'un système est véritablement agentique, il décide en interne de la manière d'aborder le problème. Il ne fait pas qu'exécuter un script ; il détermine de manière autonome la séquence des étapes en fonction de la qualité des informations qu'il trouve.
Par exemple, s'il est demandé de créer une stratégie de lancement de produit, il ne se repose pas uniquement sur un prompt qui décrit tout le flux de travail de recherche et de prise de décision. À la place, le modèle agentique décide indépendamment de :

1. Récupérer les rapports de tendances actuelles du marché à l'aide de Bing Web Grounding.
2. Identifier les données pertinentes sur les concurrents en utilisant Azure AI Search.
3. Corréler les métriques historiques de ventes internes en utilisant Azure SQL Database.
4. Synthétiser les résultats en une stratégie cohérente orchestrée via Azure OpenAI Service.
5. Évaluer la stratégie pour détecter des lacunes ou incohérences, initiant une nouvelle ronde de récupération si nécessaire.
Toutes ces étapes—affiner les requêtes, choisir les sources, itérer jusqu'à être "satisfait" de la réponse—sont décidées par le modèle, et non pré-scriptées par un humain.
```

*Note : La traduction est partielle en raison de la longueur du contenu. Si vous souhaitez continuer, veuillez me le faire savoir !*

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction automatique basés sur l'intelligence artificielle. Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction professionnelle humaine. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.


# Construire des Agents IA Fiables

## Introduction

Cette leçon couvrira :

- Comment construire et déployer des Agents IA sûrs et efficaces.
- Les considérations importantes en matière de sécurité lors du développement d'Agents IA.
- Comment préserver la confidentialité des données et des utilisateurs lors du développement d'Agents IA.

## Objectifs d'Apprentissage

Après avoir terminé cette leçon, vous saurez comment :

- Identifier et atténuer les risques lors de la création d'Agents IA.
- Mettre en œuvre des mesures de sécurité pour garantir que les données et les accès soient correctement gérés.
- Créer des Agents IA qui respectent la confidentialité des données et offrent une expérience utilisateur de qualité.

## Sécurité

Commençons par examiner la création d'applications agentiques sûres. La sécurité signifie que l'agent IA fonctionne comme prévu. En tant que concepteurs d'applications agentiques, nous disposons de méthodes et d'outils pour maximiser la sécurité :

### Construire un Système de Méta-Prompting

Si vous avez déjà conçu une application IA utilisant des modèles de langage de grande taille (LLMs), vous savez à quel point il est crucial de concevoir un prompt ou message système robuste. Ces prompts établissent les règles, instructions et lignes directrices pour la manière dont le LLM interagit avec l'utilisateur et les données.

Pour les Agents IA, le prompt système est encore plus important, car ces agents auront besoin d'instructions très spécifiques pour accomplir les tâches que nous leur avons assignées.

Pour créer des prompts systèmes évolutifs, nous pouvons utiliser un système de méta-prompting pour concevoir un ou plusieurs agents dans notre application :

![Construire un Système de Méta-Prompting](../../../translated_images/building-a-metaprompting-system.aa7d6de2100b0ef48c3e1926dab6903026b22fc9d27fc4327162fbbb9caf960f.fr.png)

#### Étape 1 : Créer un Méta-Prompt ou Prompt Modèle

Le méta-prompt sera utilisé par un LLM pour générer les prompts systèmes des agents que nous créons. Nous le concevons comme un modèle afin de pouvoir créer efficacement plusieurs agents si nécessaire.

Voici un exemple de méta-prompt que nous donnerions au LLM :

```plaintext
You are an expert at creating AI agent assitants.
You will be provided a company name, role, responsibilites and other
information that you will use to provide a system prompt for.
To create the system prompt, be descriptive as possible and provide a structure that a system using an LLM can better understand the role and responsibilites of the AI assistant.
```

#### Étape 2 : Créer un Prompt de Base

L'étape suivante consiste à créer un prompt de base pour décrire l'Agent IA. Vous devez inclure le rôle de l'agent, les tâches qu'il accomplira, ainsi que toute autre responsabilité qui lui incombe.

Voici un exemple :

```plaintext
You are a travel agent for Contoso Travel with that is great at booking flights for customers. To help customers you can perform the following tasks: lookup available flights, book flights, ask for preferences in seating and times for flights, cancel any previously booked flights and alert customers on any delays or cancellations of flights.
```

#### Étape 3 : Fournir le Prompt de Base au LLM

Nous pouvons maintenant optimiser ce prompt en utilisant le méta-prompt comme prompt système et notre prompt de base.

Cela produira un prompt mieux conçu pour guider nos Agents IA :

```markdown
**Company Name:** Contoso Travel
**Role:** Travel Agent Assistant

**Objective:**
You are an AI-powered travel agent assistant for Contoso Travel, specializing in booking flights and providing exceptional customer service. Your main goal is to assist customers in finding, booking, and managing their flights, all while ensuring that their preferences and needs are met efficiently.

**Key Responsibilities:**

1. **Flight Lookup:**

    - Assist customers in searching for available flights based on their specified destination, dates, and any other relevant preferences.
    - Provide a list of options, including flight times, airlines, layovers, and pricing.
2. **Flight Booking:**

    - Facilitate the booking of flights for customers, ensuring that all details are correctly entered into the system.
    - Confirm bookings and provide customers with their itinerary, including confirmation numbers and any other pertinent information.
3. **Customer Preference Inquiry:**

    - Actively ask customers for their preferences regarding seating (e.g., aisle, window, extra legroom) and preferred times for flights (e.g., morning, afternoon, evening).
    - Record these preferences for future reference and tailor suggestions accordingly.
4. **Flight Cancellation:**

    - Assist customers in canceling previously booked flights if needed, following company policies and procedures.
    - Notify customers of any necessary refunds or additional steps that may be required for cancellations.
5. **Flight Monitoring:**

    - Monitor the status of booked flights and alert customers in real-time about any delays, cancellations, or changes to their flight schedule.
    - Provide updates through preferred communication channels (e.g., email, SMS) as needed.

**Tone and Style:**

- Maintain a friendly, professional, and approachable demeanor in all interactions with customers.
- Ensure that all communication is clear, informative, and tailored to the customer's specific needs and inquiries.

**User Interaction Instructions:**

- Respond to customer queries promptly and accurately.
- Use a conversational style while ensuring professionalism.
- Prioritize customer satisfaction by being attentive, empathetic, and proactive in all assistance provided.

**Additional Notes:**

- Stay updated on any changes to airline policies, travel restrictions, and other relevant information that could impact flight bookings and customer experience.
- Use clear and concise language to explain options and processes, avoiding jargon where possible for better customer understanding.

This AI assistant is designed to streamline the flight booking process for customers of Contoso Travel, ensuring that all their travel needs are met efficiently and effectively.

```

#### Étape 4 : Itérer et Améliorer

L'avantage de ce système de méta-prompting est de faciliter la création de prompts pour plusieurs agents ainsi que d'améliorer vos prompts au fil du temps. Il est rare qu'un prompt fonctionne parfaitement dès la première tentative pour répondre à tous vos besoins. Pouvoir effectuer de petits ajustements et améliorations en modifiant le prompt de base et en le passant par le système vous permettra de comparer et d'évaluer les résultats.

## Comprendre les Menaces

Pour concevoir des agents IA fiables, il est essentiel de comprendre et d'atténuer les risques et menaces auxquels votre agent IA peut être confronté. Examinons certaines des différentes menaces pour les agents IA et comment vous pouvez mieux les anticiper et vous y préparer.

![Comprendre les Menaces](../../../translated_images/understanding-threats.f8fbe6fe11e025b3085fc91e82d975937ad1d672260a2aeed40458aa41798d0e.fr.png)

### Tâches et Instructions

**Description :** Les attaquants tentent de modifier les instructions ou les objectifs de l'agent IA en manipulant les prompts ou les entrées.

**Atténuation :** Effectuez des vérifications de validation et appliquez des filtres d'entrée pour détecter les prompts potentiellement dangereux avant qu'ils ne soient traités par l'Agent IA. Comme ces attaques nécessitent généralement des interactions fréquentes avec l'Agent, limiter le nombre de tours dans une conversation est une autre manière de prévenir ces attaques.

### Accès aux Systèmes Critiques

**Description :** Si un agent IA a accès à des systèmes et services contenant des données sensibles, des attaquants peuvent compromettre la communication entre l'agent et ces services. Cela peut inclure des attaques directes ou des tentatives indirectes pour obtenir des informations sur ces systèmes via l'agent.

**Atténuation :** Les agents IA ne devraient avoir accès aux systèmes que sur une base strictement nécessaire pour éviter ce type d'attaques. La communication entre l'agent et les systèmes doit également être sécurisée. La mise en œuvre de mécanismes d'authentification et de contrôle d'accès est une autre méthode pour protéger ces informations.

### Surcharge des Ressources et Services

**Description :** Les agents IA peuvent accéder à divers outils et services pour accomplir leurs tâches. Les attaquants peuvent exploiter cette capacité pour envoyer un grand volume de requêtes via l'Agent IA, ce qui peut entraîner des pannes de système ou des coûts élevés.

**Atténuation :** Mettez en place des politiques limitant le nombre de requêtes qu'un agent IA peut envoyer à un service. Limiter le nombre de tours de conversation et de requêtes adressées à votre agent IA est une autre méthode pour prévenir ce type d'attaques.

### Empoisonnement de la Base de Connaissances

**Description :** Ce type d'attaque ne cible pas directement l'agent IA mais vise la base de connaissances et d'autres services utilisés par l'agent IA. Cela peut inclure la corruption des données ou informations que l'agent IA utilise pour accomplir ses tâches, entraînant des réponses biaisées ou non souhaitées pour l'utilisateur.

**Atténuation :** Effectuez des vérifications régulières des données utilisées par l'agent IA dans ses flux de travail. Assurez-vous que l'accès à ces données est sécurisé et que seules des personnes de confiance peuvent les modifier pour éviter ce type d'attaque.

### Erreurs en Cascade

**Description :** Les agents IA accèdent à divers outils et services pour accomplir leurs tâches. Les erreurs causées par des attaquants peuvent entraîner des défaillances dans d'autres systèmes auxquels l'agent IA est connecté, rendant l'attaque plus étendue et plus difficile à diagnostiquer.

**Atténuation :** Une méthode pour éviter cela est de faire fonctionner l'Agent IA dans un environnement limité, tel que l'exécution des tâches dans un conteneur Docker, pour prévenir les attaques directes sur le système. La création de mécanismes de secours et de logique de reprise lorsque certains systèmes renvoient une erreur est une autre façon d'éviter des défaillances plus importantes.

## L'Humain dans la Boucle

Une autre méthode efficace pour construire des systèmes d'Agents IA fiables est d'intégrer un humain dans la boucle. Cela crée un flux où les utilisateurs peuvent fournir des retours aux Agents pendant leur exécution. Les utilisateurs agissent essentiellement comme un agent dans un système multi-agents en approuvant ou en interrompant les processus en cours.

![Humain dans la Boucle](../../../translated_images/human-in-the-loop.e9edbe8f6d42041b4213421410823250aa750fe8bdba5601d69ed46f3ff6489d.fr.png)

Voici un extrait de code utilisant AutoGen pour montrer comment ce concept est mis en œuvre :

```python

# Create the agents.
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
assistant = AssistantAgent("assistant", model_client=model_client)
user_proxy = UserProxyAgent("user_proxy", input_func=input)  # Use input() to get user input from console.

# Create the termination condition which will end the conversation when the user says "APPROVE".
termination = TextMentionTermination("APPROVE")

# Create the team.
team = RoundRobinGroupChat([assistant, user_proxy], termination_condition=termination)

# Run the conversation and stream to the console.
stream = team.run_stream(task="Write a 4-line poem about the ocean.")
# Use asyncio.run(...) when running in a script.
await Console(stream)

```
```

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction automatisés basés sur l'intelligence artificielle. Bien que nous fassions de notre mieux pour garantir l'exactitude, veuillez noter que les traductions automatiques peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.


# Conception de la Planification

## Introduction

Cette leçon couvrira :

* Définir un objectif global clair et diviser une tâche complexe en tâches gérables.
* Exploiter des sorties structurées pour des réponses plus fiables et lisibles par machine.
* Appliquer une approche orientée événements pour gérer des tâches dynamiques et des entrées inattendues.

## Objectifs d'Apprentissage

Après avoir terminé cette leçon, vous comprendrez :

* Comment identifier et définir un objectif global pour un agent IA, en veillant à ce qu'il sache précisément ce qu'il doit accomplir.
* Comment décomposer une tâche complexe en sous-tâches gérables et les organiser dans une séquence logique.
* Comment équiper les agents des bons outils (par exemple, outils de recherche ou d'analyse de données), décider quand et comment les utiliser, et gérer les situations imprévues.
* Comment évaluer les résultats des sous-tâches, mesurer les performances et itérer sur les actions pour améliorer le résultat final.

## Définir l'Objectif Global et Décomposer une Tâche

![Définir les Objectifs et les Tâches](../../../translated_images/defining-goals-tasks.dcc1181bbdb194704ae0fb3363371562949e8b03fd2fadc256218aaadf84a9f4.fr.png)

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

    "Générer un itinéraire de voyage de 3 jours."

Bien que cet objectif soit simple à énoncer, il nécessite encore d'être précisé. Plus l'objectif est clair, mieux l'agent (et les collaborateurs humains, le cas échéant) pourra se concentrer sur l'obtention du bon résultat, comme créer un itinéraire complet avec des options de vol, des recommandations d'hôtels et des suggestions d'activités.

### Décomposition des Tâches

Les tâches volumineuses ou complexes deviennent plus faciles à gérer lorsqu'elles sont divisées en sous-tâches orientées vers des objectifs spécifiques.
Pour l'exemple de l'itinéraire de voyage, vous pourriez décomposer l'objectif en :

* Réservation de Vols
* Réservation d'Hôtels
* Location de Voiture
* Personnalisation

Chaque sous-tâche peut ensuite être traitée par des agents ou des processus dédiés. Un agent pourrait se spécialiser dans la recherche des meilleures offres de vols, un autre dans les réservations d'hôtels, etc. Un agent coordinateur ou "en aval" peut ensuite compiler ces résultats en un itinéraire cohérent pour l'utilisateur final.

Cette approche modulaire permet également des améliorations progressives. Par exemple, vous pourriez ajouter des agents spécialisés pour les recommandations culinaires ou les suggestions d'activités locales, et affiner l'itinéraire au fil du temps.

### Sortie Structurée

Les modèles de langage avancés (LLMs) peuvent générer des sorties structurées (par exemple, JSON) qui sont plus faciles à analyser et à traiter par des agents ou services en aval. Cela est particulièrement utile dans un contexte multi-agent, où ces tâches peuvent être exécutées après réception de la sortie de planification. Consultez ce [blogpost](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/cookbook/structured-output-agent.html) pour un aperçu rapide.

Voici un exemple de snippet Python qui illustre un agent de planification simple décomposant un objectif en sous-tâches et générant un plan structuré :

### Agent de Planification avec Orchestration Multi-Agent

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

Le planificateur :

* Reçoit le Plan d'Hôtel : Le planificateur prend le message de l'utilisateur et, sur la base d'une invite système (y compris les détails des agents disponibles), génère un plan de voyage structuré.
* Liste les Agents et Leurs Outils : Le registre des agents contient une liste d'agents (par exemple, pour les vols, hôtels, locations de voitures et activités) ainsi que les fonctions ou outils qu'ils proposent.
* Route le Plan vers les Agents Concernés : En fonction du nombre de sous-tâches, le planificateur envoie soit directement le message à un agent dédié (pour des scénarios de tâche unique), soit coordonne via un gestionnaire de discussion de groupe pour une collaboration multi-agent.
* Résume le Résultat : Enfin, le planificateur résume le plan généré pour plus de clarté.
Voici un exemple de code Python illustrant ces étapes :

```python

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="""You are an planner agent.
    Your job is to decide which agents to run based on the user's request.
    Below are the available agents specialised in different tasks:
    - FlightBooking: For booking flights and providing flight information
    - HotelBooking: For booking hotels and providing hotel information
    - CarRental: For booking cars and providing car rental information
    - ActivitiesBooking: For booking activities and providing activity information
    - DestinationInfo: For providing information about destinations
    - DefaultAgent: For handling general requests""", source="system"),
    UserMessage(content="Create a travel plan for a family of 2 kids from Singapore to Melbourne", 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 la sortie du code ci-dessus, que vous pouvez ensuite utiliser pour router vers `assigned_agent` et résumer le plan de voyage pour l'utilisateur final :

```json
{
    "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 notebook contenant cet extrait de code est disponible [ici](../../../07-planning-design/code_samples/07-autogen.ipynb).

### Planification Itérative

Certaines tâches nécessitent des allers-retours ou une re-planification, où le résultat d'une sous-tâche influence la suivante. Par exemple, si l'agent découvre un format de données inattendu lors de la réservation de vols, il pourrait devoir adapter sa stratégie avant de passer à la réservation d'hôtels.

De plus, les retours utilisateurs (par exemple, un humain décidant de préférer un vol plus tôt) peuvent déclencher une re-planification partielle. Cette approche dynamique et itérative garantit que la solution finale s'aligne sur les contraintes du monde réel et les préférences évolutives des utilisateurs.

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="""You are a planner agent to optimize the
        Your job is to decide which agents to run based on the user's request.
        Below are the available agents specialised in different tasks:
        - FlightBooking: For booking flights and providing flight information
        - HotelBooking: For booking hotels and providing hotel information
        - CarRental: For booking cars and providing car rental information
        - ActivitiesBooking: For booking activities and providing activity information
        - DestinationInfo: For providing information about destinations
        - DefaultAgent: For handling general requests""", source="system"),
        UserMessage(content="Create a travel plan for a family of 2 kids from Singapore to Melboune", source="user"),
        AssistantMessage(content=f"Previous travel plan - {TravelPlan}", source="assistant")
    ]
    # .. re-plan and send the tasks to respective agents
    ```

Pour une planification plus complète, consultez le [Blogpost Magnetic One](https://www.microsoft.com/research/articles/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks) pour résoudre des tâches complexes.

## Résumé

Dans cet article, nous avons examiné un exemple de création d'un planificateur capable de sélectionner dynamiquement les agents disponibles définis. La sortie du planificateur décompose les tâches et attribue les agents pour qu'ils soient exécutés. On suppose que les agents ont accès aux fonctions/outils nécessaires pour effectuer la tâche. En plus des agents, vous pouvez inclure d'autres modèles comme la réflexion, le résumé, ou un chat en round-robin pour personnaliser davantage.

## Ressources Supplémentaires

* L'utilisation de modèles de raisonnement o1 a prouvé des avancées significatives dans la planification de tâches complexes - TODO : Partager un exemple ?

* Autogen Magnetic One - Un système multi-agent généraliste pour résoudre des tâches complexes, qui a obtenu des résultats impressionnants sur plusieurs benchmarks exigeants. Référence : [autogen-magentic-one](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-magentic-one). Dans cette implémentation, l'orchestrateur crée un plan spécifique à la tâche et délègue ces tâches aux agents disponibles. En plus de la planification, l'orchestrateur utilise un mécanisme de suivi pour surveiller l'avancement des tâches et re-planifier si nécessaire.
```

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction basés sur l'intelligence artificielle. Bien que nous fassions de notre mieux pour garantir l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.


# Modèles de conception multi-agents

Dès que vous commencez à travailler sur un projet impliquant plusieurs agents, vous devez prendre en compte le modèle de conception multi-agents. Cependant, il n'est pas toujours évident de savoir quand passer à un système multi-agents et quels en sont les avantages.

## Introduction

Dans cette leçon, nous cherchons à répondre aux questions suivantes :

- Quels sont les scénarios où les systèmes multi-agents sont applicables ?
- Quels sont les avantages d'utiliser des multi-agents plutôt qu'un agent unique effectuant plusieurs tâches ?
- Quels sont les éléments constitutifs pour implémenter le modèle de conception multi-agents ?
- Comment pouvons-nous avoir une visibilité sur les interactions entre plusieurs agents ?

## Objectifs d'apprentissage

Après cette leçon, vous devriez être capable de :

- Identifier les scénarios où les multi-agents sont applicables.
- Reconnaître les avantages d'utiliser des multi-agents par rapport à un agent unique.
- Comprendre les éléments constitutifs nécessaires pour implémenter le modèle de conception multi-agents.

Quelle est la vision d'ensemble ?

*Les systèmes multi-agents sont un modèle de conception qui permet à plusieurs agents de collaborer pour atteindre un objectif commun.*

Ce modèle est largement utilisé dans divers domaines, notamment la robotique, les systèmes autonomes et l'informatique distribuée.

## Scénarios où les systèmes multi-agents sont applicables

Quels sont donc les scénarios adaptés à l'utilisation de multi-agents ? La réponse est qu'il existe de nombreux cas où l'emploi de plusieurs agents est bénéfique, notamment dans les situations suivantes :

- **Charges de travail importantes** : Les charges de travail importantes peuvent être divisées en tâches plus petites et attribuées à différents agents, permettant un traitement en parallèle et une exécution plus rapide. Un exemple classique est le traitement de grandes quantités de données.
- **Tâches complexes** : Les tâches complexes, comme les charges de travail importantes, peuvent être décomposées en sous-tâches plus petites et attribuées à différents agents, chacun se spécialisant dans un aspect spécifique de la tâche. Un bon exemple est celui des véhicules autonomes où différents agents gèrent la navigation, la détection des obstacles et la communication avec d'autres véhicules.
- **Expertise variée** : Différents agents peuvent avoir des expertises variées, leur permettant de gérer différents aspects d'une tâche de manière plus efficace qu'un agent unique. Par exemple, dans le domaine de la santé, des agents peuvent gérer les diagnostics, les plans de traitement et la surveillance des patients.

## Avantages d'utiliser des multi-agents par rapport à un agent unique

Un système à agent unique peut fonctionner correctement pour des tâches simples, mais pour des tâches plus complexes, l'utilisation de plusieurs agents offre plusieurs avantages :

- **Spécialisation** : Chaque agent peut se spécialiser dans une tâche spécifique. L'absence de spécialisation dans un système à agent unique peut entraîner une confusion lorsqu'il est confronté à une tâche complexe. Par exemple, il pourrait finir par effectuer une tâche pour laquelle il n'est pas le mieux adapté.
- **Évolutivité** : Il est plus facile de faire évoluer un système en ajoutant des agents supplémentaires plutôt qu'en surchargeant un agent unique.
- **Tolérance aux pannes** : Si un agent tombe en panne, les autres peuvent continuer à fonctionner, assurant ainsi la fiabilité du système.

Prenons un exemple : réserver un voyage pour un utilisateur. Un système à agent unique devrait gérer tous les aspects du processus de réservation, de la recherche de vols à la réservation d'hôtels et de voitures de location. Cela nécessiterait que l'agent unique dispose d'outils pour gérer toutes ces tâches, ce qui pourrait conduire à un système complexe et monolithique, difficile à maintenir et à faire évoluer. Un système multi-agents, en revanche, pourrait avoir différents agents spécialisés dans la recherche de vols, la réservation d'hôtels et la location de voitures. Cela rendrait le système plus modulaire, plus facile à maintenir et évolutif.

Comparez cela à une agence de voyage gérée comme un petit commerce familial versus une agence gérée comme une franchise. Le petit commerce familial aurait un agent unique gérant tous les aspects du processus de réservation, tandis que la franchise aurait différents agents gérant différents aspects du processus.

## Éléments constitutifs pour implémenter le modèle de conception multi-agents

Avant de pouvoir implémenter le modèle de conception multi-agents, vous devez comprendre les éléments constitutifs qui le composent.

Prenons à nouveau l'exemple de la réservation d'un voyage pour un utilisateur. Dans ce cas, les éléments constitutifs incluraient :

- **Communication entre agents** : Les agents chargés de trouver des vols, de réserver des hôtels et de louer des voitures doivent communiquer et partager des informations sur les préférences et les contraintes de l'utilisateur. Vous devez décider des protocoles et des méthodes pour cette communication. Concrètement, cela signifie que l'agent chargé de trouver des vols doit communiquer avec l'agent chargé de réserver des hôtels pour s'assurer que l'hôtel est réservé pour les mêmes dates que le vol. Cela implique de décider *quels agents partagent des informations et comment ils les partagent*.
- **Mécanismes de coordination** : Les agents doivent coordonner leurs actions pour s'assurer que les préférences et les contraintes de l'utilisateur sont respectées. Par exemple, une préférence utilisateur pourrait être d'avoir un hôtel proche de l'aéroport, tandis qu'une contrainte pourrait être que les voitures de location ne sont disponibles qu'à l'aéroport. Cela signifie que vous devez décider *comment les agents coordonnent leurs actions*.
- **Architecture des agents** : Les agents doivent avoir une structure interne leur permettant de prendre des décisions et d'apprendre de leurs interactions avec l'utilisateur. Par exemple, l'agent chargé de trouver des vols doit être capable de décider quels vols recommander à l'utilisateur. Cela implique de déterminer *comment les agents prennent des décisions et apprennent de leurs interactions avec l'utilisateur*. Un exemple pourrait être qu'un agent utilise un modèle d'apprentissage automatique pour recommander des vols basés sur les préférences passées de l'utilisateur.
- **Visibilité des interactions multi-agents** : Vous devez avoir une visibilité sur la manière dont les agents interagissent entre eux. Cela nécessite des outils et des techniques pour suivre les activités et les interactions des agents. Cela peut inclure des outils de journalisation, de surveillance, de visualisation et des indicateurs de performance.
- **Modèles multi-agents** : Il existe différents modèles pour implémenter des systèmes multi-agents, comme des architectures centralisées, décentralisées ou hybrides. Vous devez choisir le modèle qui correspond le mieux à votre cas d'utilisation.
- **Humain dans la boucle** : Dans la plupart des cas, un humain interviendra dans le processus, et vous devez définir quand les agents doivent demander une intervention humaine. Cela peut inclure des demandes spécifiques, comme un utilisateur demandant un hôtel ou un vol particulier, ou des confirmations avant de finaliser une réservation.

## Visibilité des interactions multi-agents

Il est crucial d'avoir une visibilité sur la manière dont les agents interagissent entre eux. Cette visibilité est essentielle pour le débogage, l'optimisation et l'efficacité globale du système. Pour cela, vous devez disposer d'outils et de techniques permettant de suivre les activités et interactions des agents. Cela peut inclure des outils de journalisation, de surveillance, de visualisation et des indicateurs de performance.

Par exemple, dans le cas de la réservation d'un voyage, vous pourriez avoir un tableau de bord affichant le statut de chaque agent, les préférences et contraintes de l'utilisateur, ainsi que les interactions entre les agents. Ce tableau de bord pourrait montrer les dates de voyage de l'utilisateur, les vols recommandés par l'agent de vol, les hôtels recommandés par l'agent hôtelier et les voitures de location recommandées par l'agent de location. Cela vous offrirait une vue claire des interactions entre les agents et de la satisfaction des préférences et contraintes de l'utilisateur.

Voyons ces aspects plus en détail :

- **Outils de journalisation et de surveillance** : Vous souhaitez enregistrer chaque action effectuée par un agent. Une entrée de journal peut contenir des informations sur l'agent ayant effectué l'action, l'action elle-même, l'heure de l'action et son résultat. Ces informations peuvent ensuite être utilisées pour le débogage, l'optimisation, etc.
- **Outils de visualisation** : Les outils de visualisation peuvent vous aider à comprendre les interactions entre les agents de manière plus intuitive. Par exemple, vous pourriez avoir un graphique montrant le flux d'informations entre les agents, ce qui pourrait vous aider à identifier les goulets d'étranglement ou inefficacités.
- **Indicateurs de performance** : Les indicateurs de performance peuvent vous aider à mesurer l'efficacité du système multi-agents. Par exemple, vous pourriez suivre le temps nécessaire pour terminer une tâche, le nombre de tâches accomplies par unité de temps, ou encore la précision des recommandations faites par les agents.

## Modèles multi-agents

Explorons quelques modèles concrets que nous pouvons utiliser pour créer des applications multi-agents. Voici quelques modèles intéressants à considérer :

### Discussion de groupe

Ce modèle est utile lorsque vous souhaitez créer une application de discussion de groupe où plusieurs agents peuvent communiquer entre eux. Les cas d'utilisation typiques incluent la collaboration en équipe, le support client et les réseaux sociaux.

Dans ce modèle, chaque agent représente un utilisateur dans la discussion de groupe, et les messages sont échangés entre les agents via un protocole de messagerie. Les agents peuvent envoyer des messages à la discussion de groupe, recevoir des messages de celle-ci et répondre à d'autres agents.

Ce modèle peut être implémenté via une architecture centralisée où tous les messages transitent par un serveur central, ou via une architecture décentralisée où les messages sont échangés directement.

![Discussion de groupe](../../../translated_images/multi-agent-group-chat.82d537c5c8dc833abbd252033e60874bc9d00df7193888b3377f8426449a0b20.fr.png)

### Transmission de tâches

Ce modèle est utile lorsque vous souhaitez créer une application où plusieurs agents peuvent se transmettre des tâches.

Les cas d'utilisation typiques incluent le support client, la gestion des tâches et l'automatisation des flux de travail.

Dans ce modèle, chaque agent représente une tâche ou une étape d'un flux de travail, et les agents peuvent transmettre des tâches à d'autres agents en fonction de règles prédéfinies.

![Transmission de tâches](../../../translated_images/multi-agent-hand-off.ed4f0a5a58614a8a3e962fc476187e630a3ba309d066e460f017b503d0b84cfc.fr.png)

### Filtrage collaboratif

Ce modèle est utile lorsque vous souhaitez créer une application où plusieurs agents peuvent collaborer pour faire des recommandations aux utilisateurs.

L'intérêt d'avoir plusieurs agents collaborant est que chaque agent peut avoir une expertise différente et contribuer au processus de recommandation de diverses manières.

Prenons un exemple où un utilisateur souhaite une recommandation sur la meilleure action à acheter en bourse :

- **Expertise sectorielle** : Un agent pourrait être expert dans un secteur spécifique.
- **Analyse technique** : Un autre agent pourrait être spécialisé dans l'analyse technique.
- **Analyse fondamentale** : Un autre agent encore pourrait exceller dans l'analyse fondamentale. En collaborant, ces agents peuvent fournir une recommandation plus complète à l'utilisateur.

![Recommandation](../../../translated_images/multi-agent-filtering.719217d169391ddb118bbb726b19d4d89ee139f960f8749ccb2400efb4d0ce79.fr.png)

## Scénario : Processus de remboursement

Considérons un scénario où un client cherche à obtenir un remboursement pour un produit. Plusieurs agents peuvent être impliqués dans ce processus, mais distinguons les agents spécifiques à ce processus et les agents généraux pouvant être utilisés dans d'autres contextes.

**Agents spécifiques au processus de remboursement** :

Voici quelques agents qui pourraient être impliqués dans le processus de remboursement :

- **Agent client** : Représente le client et est responsable d'initier le processus de remboursement.
- **Agent vendeur** : Représente le vendeur et est chargé de traiter le remboursement.
- **Agent de paiement** : Représente le processus de paiement et est responsable de rembourser le paiement du client.
- **Agent de résolution** : Représente le processus de résolution et est chargé de résoudre les problèmes éventuels pendant le processus de remboursement.
- **Agent de conformité** : Représente le processus de conformité et veille à ce que le processus de remboursement respecte les réglementations et politiques en vigueur.

**Agents généraux** :

Ces agents peuvent être utilisés dans d'autres parties de votre entreprise.

- **Agent d'expédition** : Représente le processus d'expédition et est chargé de renvoyer le produit au vendeur. Cet agent peut être utilisé à la fois pour le processus de remboursement et pour l'expédition générale d'un produit après un achat, par exemple.
- **Agent de retour d'expérience** : Représente le processus de collecte des retours d'expérience et est chargé de recueillir les retours du client. Ces retours peuvent être collectés à tout moment, pas seulement pendant le processus de remboursement.
- **Agent d'escalade** : Représente le processus d'escalade et est chargé de transmettre les problèmes à un niveau de support supérieur. Ce type d'agent peut être utilisé dans n'importe quel processus nécessitant une escalade.
- **Agent de notification** : Représente le processus de notification et est chargé d'envoyer des notifications au client à différentes étapes du processus de remboursement.
- **Agent d'analyse** : Représente le processus d'analyse et est chargé d'analyser les données relatives au processus de remboursement.
- **Agent d'audit** : Représente le processus d'audit et est chargé de vérifier que le processus de remboursement est correctement exécuté.
- **Agent de reporting** : Représente le processus de reporting et est chargé de générer des rapports sur le processus de remboursement.
- **Agent de connaissance** : Représente le processus de gestion des connaissances et est chargé de maintenir une base de connaissances sur le processus de remboursement. Cet agent peut être informé à la fois sur les remboursements et sur d'autres aspects de votre entreprise.
- **Agent de sécurité** : Représente le processus de sécurité et est chargé de garantir la sécurité du processus de remboursement.
- **Agent de qualité** : Représente le processus de qualité et est chargé d'assurer la qualité du processus de remboursement.

Il y a beaucoup d'agents listés ci-dessus, à la fois pour le processus de remboursement spécifique et pour les agents généraux pouvant être utilisés dans d'autres parties de votre entreprise. Cela devrait vous donner une idée de la manière de décider quels agents utiliser dans votre système multi-agents.

## Exercice

Quel serait un bon exercice pour cette leçon ?

Concevez un système multi-agents pour un processus de support client. Identifiez les agents impliqués dans le processus, leurs rôles et responsabilités, et comment ils interagissent entre eux. Prenez en compte à la fois les agents spécifiques au processus de support client et les agents généraux pouvant être utilisés dans d'autres parties de votre entreprise.

> Réfléchissez avant de lire la solution ci-dessous, vous pourriez avoir besoin de plus d'agents que vous ne le pensez.

> TIP : Pensez aux différentes étapes du processus de support client et prenez également en compte les agents nécessaires à tout système.

## Solution

[Solution](./solution/solution.md)

## Questions de révision

Question : Quand devriez-vous envisager d'utiliser des multi-agents ?

- [] A1 : Lorsque vous avez une charge de travail légère et une tâche simple.
- [] A2 : Lorsque vous avez une charge de travail importante.
- [] A3 : Lorsque vous avez une tâche simple.

[Solution du quiz](./solution/solution-quiz.md)

## Résumé

Dans cette leçon, nous avons exploré le modèle de conception multi-agents, y compris les scénarios où les multi-agents sont applicables, les avantages d'utiliser des multi-agents par rapport à un agent unique, les éléments constitutifs pour implémenter le modèle de conception multi-agents, et comment avoir une visibilité sur les interactions entre les agents.

## Ressources supplémentaires

- [Autogen design patterns](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/design-patterns/intro.html)
- [Agentic design patterns](https://www.analyticsvidhya.com/blog/2024/10/agentic-design-patterns/)
```

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction automatisés basés sur l'intelligence artificielle. Bien que nous nous efforcions d'assurer l'exactitude, veuillez noter que les traductions automatisées peuvent contenir des erreurs ou des inexactitudes. Le document original dans sa langue d'origine doit être considéré comme la source faisant autorité. Pour des informations critiques, il est recommandé de recourir à une traduction humaine professionnelle. Nous déclinons toute responsabilité en cas de malentendus ou d'interprétations erronées résultant de l'utilisation de cette traduction.