# Métacognition chez les Agents IA

## Introduction

Bienvenue dans la leçon sur la métacognition chez les agents IA ! Ce chapitre est conçu pour les débutants curieux de savoir comment les agents IA peuvent réfléchir à leurs propres processus de réflexion. À la fin de cette leçon, vous comprendrez les concepts clés et disposerez d'exemples pratiques pour appliquer la métacognition dans la conception d'agents IA.

## Objectifs d'apprentissage

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

1. Comprendre les implications des boucles de raisonnement dans les définitions d'agents.
2. Utiliser des techniques de planification et d'évaluation pour aider les agents à s'auto-corriger.
3. Créer vos propres agents capables de manipuler du code pour accomplir des tâches.

## Introduction à la métacognition

La métacognition fait référence aux processus cognitifs de haut niveau qui impliquent de penser à sa propre pensée. Pour les agents IA, cela signifie être capable d'évaluer et d'ajuster leurs actions en fonction de leur conscience de soi et de leurs expériences passées.

### Qu'est-ce que la métacognition ?

La métacognition, ou "penser à penser", est un processus cognitif de haut niveau qui implique la conscience de soi et l'autorégulation de ses propres processus cognitifs. Dans le domaine de l'IA, la métacognition permet aux agents d'évaluer et d'adapter leurs stratégies et actions, ce qui conduit à une amélioration des capacités de résolution de problèmes et de prise de décision. En comprenant la métacognition, vous pouvez concevoir des agents IA non seulement plus intelligents, mais aussi plus adaptables et efficaces.

### Importance de la métacognition chez les agents IA

La métacognition joue un rôle crucial dans la conception des agents IA pour plusieurs raisons :

![Importance de la Métacognition](../../../translated_images/importance-of-metacognition.e351a5983bb745d60a1a60185391a39a6751d033c8c1948ceb6ad04eff7dbeac.fr.png?WT.mc_id=academic-105485-koreyst)

- **Auto-réflexion** : Les agents peuvent évaluer leur propre performance et identifier les domaines à améliorer.
- **Adaptabilité** : Les agents peuvent modifier leurs stratégies en fonction des expériences passées et des environnements changeants.
- **Correction d'erreurs** : Les agents peuvent détecter et corriger des erreurs de manière autonome, ce qui conduit à des résultats plus précis.
- **Gestion des ressources** : Les agents peuvent optimiser l'utilisation des ressources, comme le temps et la puissance de calcul, en planifiant et en évaluant leurs actions.

## Composantes d'un agent IA

Avant d'aborder les processus métacognitifs, il est essentiel de comprendre les composantes de base d'un agent IA. Un agent IA se compose généralement de :

- **Persona** : La personnalité et les caractéristiques de l'agent, qui définissent comment il interagit avec les utilisateurs.
- **Outils** : Les capacités et fonctions que l'agent peut effectuer.
- **Compétences** : Les connaissances et l'expertise que possède l'agent.

Ces composantes travaillent ensemble pour créer une "unité d'expertise" capable d'effectuer des tâches spécifiques.

**Exemple** : Considérez un agent de voyage, un service qui non seulement planifie vos vacances mais ajuste également son parcours en fonction des données en temps réel et des expériences passées des clients.

### Exemple : Métacognition dans un service d'agent de voyage

Imaginez que vous concevez un service d'agent de voyage alimenté par l'IA. Cet agent, appelé "Agent de Voyage", aide les utilisateurs à planifier leurs vacances. Pour intégrer la métacognition, l'Agent de Voyage doit évaluer et ajuster ses actions en fonction de sa conscience de soi et de ses expériences passées.

#### Tâche actuelle

La tâche actuelle est d'aider un utilisateur à planifier un voyage à Paris.

#### Étapes pour accomplir la tâche

1. **Collecter les préférences de l'utilisateur** : Demander à l'utilisateur ses dates de voyage, son budget, ses centres d'intérêt (par exemple, musées, cuisine, shopping) et toute exigence spécifique.
2. **Récupérer des informations** : Rechercher des options de vol, des hébergements, des attractions et des restaurants correspondant aux préférences de l'utilisateur.
3. **Générer des recommandations** : Fournir un itinéraire personnalisé avec des détails sur les vols, les réservations d'hôtel et les activités suggérées.
4. **Ajuster en fonction des retours** : Demander à l'utilisateur des retours sur les recommandations et apporter les ajustements nécessaires.

#### Ressources nécessaires

- Accès aux bases de données de réservation de vols et d'hôtels.
- Informations sur les attractions et restaurants parisiens.
- Données de retour des utilisateurs des interactions précédentes.

#### Expérience et auto-réflexion

L'Agent de Voyage utilise la métacognition pour évaluer ses performances et apprendre de ses expériences passées. Par exemple :

1. **Analyse des retours des utilisateurs** : L'Agent de Voyage examine les retours des utilisateurs pour déterminer quelles recommandations ont été bien accueillies et lesquelles ne l'ont pas été. Il ajuste ses suggestions futures en conséquence.
2. **Adaptabilité** : Si un utilisateur a précédemment mentionné qu'il n'aime pas les endroits bondés, l'Agent de Voyage évitera de recommander des lieux touristiques populaires aux heures de pointe à l'avenir.
3. **Correction d'erreurs** : Si l'Agent de Voyage a commis une erreur dans une réservation passée, comme suggérer un hôtel complet, il apprend à vérifier plus rigoureusement la disponibilité avant de faire des recommandations.

#### Exemple pratique pour les développeurs

Voici un exemple simplifié de code que pourrait utiliser l'Agent de Voyage pour intégrer la métacognition :

```python
class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # Search for flights, hotels, and attractions based on preferences
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # Analyze feedback and adjust future recommendations
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)
```

#### Pourquoi la métacognition est importante

- **Auto-réflexion** : Les agents peuvent analyser leur performance et identifier les domaines à améliorer.
- **Adaptabilité** : Les agents peuvent modifier leurs stratégies en fonction des retours et des conditions changeantes.
- **Correction d'erreurs** : Les agents peuvent détecter et corriger les erreurs de manière autonome.
- **Gestion des ressources** : Les agents peuvent optimiser l'utilisation des ressources, comme le temps et la puissance de calcul.

En intégrant la métacognition, l'Agent de Voyage peut fournir des recommandations de voyage plus personnalisées et précises, améliorant ainsi l'expérience utilisateur globale.

---

## 2. Planification chez les agents

La planification est une composante essentielle du comportement des agents IA. Elle consiste à définir les étapes nécessaires pour atteindre un objectif, en tenant compte de l'état actuel, des ressources disponibles et des obstacles possibles.

### Éléments de la planification

- **Tâche actuelle** : Définir clairement la tâche.
- **Étapes pour accomplir la tâche** : Décomposer la tâche en étapes gérables.
- **Ressources nécessaires** : Identifier les ressources nécessaires.
- **Expérience** : Utiliser les expériences passées pour informer la planification.

**Exemple** : Voici les étapes que l'Agent de Voyage doit suivre pour aider un utilisateur à planifier son voyage efficacement :

### Étapes pour l'Agent de Voyage

1. **Collecter les préférences de l'utilisateur**
   - Demander à l'utilisateur des détails sur ses dates de voyage, son budget, ses centres d'intérêt et toute exigence spécifique.
   - Exemples : "Quand prévoyez-vous de voyager ?" "Quelle est votre fourchette de budget ?" "Quelles activités aimez-vous pendant vos vacances ?"

2. **Récupérer des informations**
   - Rechercher des options de voyage pertinentes en fonction des préférences de l'utilisateur.
   - **Vols** : Rechercher des vols disponibles dans le budget et les dates de voyage préférés de l'utilisateur.
   - **Hébergements** : Trouver des hôtels ou des locations correspondant aux préférences de l'utilisateur en matière d'emplacement, de prix et de commodités.
   - **Attractions et restaurants** : Identifier des attractions populaires, des activités et des options de restauration alignées sur les centres d'intérêt de l'utilisateur.

3. **Générer des recommandations**
   - Compiler les informations récupérées dans un itinéraire personnalisé.
   - Fournir des détails tels que les options de vol, les réservations d'hôtel et les activités suggérées, en veillant à adapter les recommandations aux préférences de l'utilisateur.

4. **Présenter l'itinéraire à l'utilisateur**
   - Partager l'itinéraire proposé avec l'utilisateur pour qu'il l'examine.
   - Exemple : "Voici un itinéraire suggéré pour votre voyage à Paris. Il inclut les détails des vols, des réservations d'hôtel et une liste d'activités et de restaurants recommandés. Dites-moi ce que vous en pensez !"

5. **Collecter des retours**
   - Demander à l'utilisateur des retours sur l'itinéraire proposé.
   - Exemples : "Aimez-vous les options de vol ?" "L'hôtel convient-il à vos besoins ?" "Y a-t-il des activités que vous souhaitez ajouter ou supprimer ?"

6. **Ajuster en fonction des retours**
   - Modifier l'itinéraire en fonction des retours de l'utilisateur.
   - Apporter les changements nécessaires aux recommandations de vol, d'hébergement et d'activités pour mieux répondre aux préférences de l'utilisateur.

7. **Confirmation finale**
   - Présenter l'itinéraire mis à jour à l'utilisateur pour confirmation finale.
   - Exemple : "J'ai apporté les ajustements en fonction de vos retours. Voici l'itinéraire mis à jour. Tout vous convient-il ?"

8. **Réserver et confirmer les réservations**
   - Une fois l'itinéraire approuvé par l'utilisateur, procéder à la réservation des vols, des hébergements et des activités pré-planifiées.
   - Envoyer les détails de confirmation à l'utilisateur.

9. **Fournir un support continu**
   - Rester disponible pour aider l'utilisateur avec des modifications ou des demandes supplémentaires avant et pendant son voyage.
   - Exemple : "Si vous avez besoin d'une assistance supplémentaire pendant votre voyage, n'hésitez pas à me contacter à tout moment !"

### Exemple d'interaction

```python
class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage within a booing request
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)
```
```
```markdown
L'agent de voyage formule de nouvelles requêtes de recherche en fonction des retours des utilisateurs.
- Exemple : ```python
       if "disliked" in feedback:
           preferences["avoid"] = feedback["disliked"]
       ```
- **Outil** : L'agent de voyage utilise des algorithmes pour classer et filtrer les nouveaux résultats de recherche, en mettant l'accent sur la pertinence basée sur les retours des utilisateurs.
- Exemple : ```python
       new_attractions = search_attractions(preferences)
       new_itinerary = create_itinerary(flights, hotels, new_attractions)
       print("Updated Itinerary:", new_itinerary)
       ```
- **Évaluation** : L'agent de voyage évalue en continu la pertinence et l'exactitude de ses recommandations en analysant les retours des utilisateurs et en effectuant les ajustements nécessaires.
- Exemple : ```python
       def adjust_preferences(preferences, feedback):
           if "liked" in feedback:
               preferences["favorites"] = feedback["liked"]
           if "disliked" in feedback:
               preferences["avoid"] = feedback["disliked"]
           return preferences

       preferences = adjust_preferences(preferences, feedback)
       ```

#### Exemple pratique
Voici un exemple simplifié de code Python intégrant l'approche Corrective RAG dans un agent de voyage :
```python
class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)
```

### Chargement de contexte préventif
Le chargement de contexte préventif consiste à charger des informations contextuelles ou de fond pertinentes dans le modèle avant le traitement d'une requête. Cela permet au modèle d'accéder à ces informations dès le départ, ce qui peut l'aider à générer des réponses plus éclairées sans avoir besoin de récupérer des données supplémentaires pendant le processus.

Voici un exemple simplifié de ce à quoi pourrait ressembler un chargement de contexte préventif pour une application d'agent de voyage en Python :
```python
class TravelAgent:
    def __init__(self):
        # Pre-load popular destinations and their information
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # Fetch destination information from pre-loaded context
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# Example usage
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))
```

#### Explication
1. **Initialisation (`__init__` method)**: The `TravelAgent` class pre-loads a dictionary containing information about popular destinations such as Paris, Tokyo, New York, and Sydney. This dictionary includes details like the country, currency, language, and major attractions for each destination.

2. **Retrieving Information (`get_destination_info` method)**: When a user queries about a specific destination, the `get_destination_info` méthode)** : Cette méthode récupère les informations pertinentes à partir du dictionnaire de contexte préchargé. En préchargeant le contexte, l'application d'agent de voyage peut répondre rapidement aux requêtes des utilisateurs sans avoir à récupérer ces informations à partir d'une source externe en temps réel. Cela rend l'application plus efficace et réactive.

### Amorçage d'un plan avec un objectif avant itération
L'amorçage d'un plan avec un objectif consiste à commencer avec un objectif clair ou un résultat cible en tête. En définissant cet objectif dès le départ, le modèle peut l'utiliser comme principe directeur tout au long du processus itératif. Cela permet de s'assurer que chaque itération se rapproche de l'atteinte du résultat souhaité, rendant le processus plus efficace et ciblé.

Voici un exemple de la façon dont vous pourriez amorcer un plan de voyage avec un objectif avant d'itérer pour un agent de voyage en Python :

### Scénario
Un agent de voyage souhaite planifier des vacances personnalisées pour un client. L'objectif est de créer un itinéraire de voyage qui maximise la satisfaction du client en fonction de ses préférences et de son budget.

### Étapes
1. Définir les préférences et le budget du client.
2. Amorcer le plan initial en fonction de ces préférences.
3. Itérer pour affiner le plan, en optimisant la satisfaction du client.

#### Code Python
```python
class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# Example usage
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)
```

#### Explication du code
1. **Initialisation (`__init__` method)**: The `TravelAgent` class is initialized with a list of potential destinations, each having attributes like name, cost, and activity type.

2. **Bootstrapping the Plan (`bootstrap_plan` method)**: This method creates an initial travel plan based on the client's preferences and budget. It iterates through the list of destinations and adds them to the plan if they match the client's preferences and fit within the budget.

3. **Matching Preferences (`match_preferences` method)**: This method checks if a destination matches the client's preferences.

4. **Iterating the Plan (`iterate_plan` method)**: This method refines the initial plan by trying to replace each destination in the plan with a better match, considering the client's preferences and budget constraints.

5. **Calculating Cost (`calculate_cost` méthode)** : Cette méthode calcule le coût total du plan actuel, y compris une éventuelle nouvelle destination.

#### Exemple d'utilisation
- **Plan initial** : L'agent de voyage crée un plan initial basé sur les préférences du client pour les visites touristiques et un budget de 2000 $.
- **Plan affiné** : L'agent de voyage itère le plan, en l'optimisant en fonction des préférences et du budget du client.

En amorçant le plan avec un objectif clair (par exemple, maximiser la satisfaction du client) et en itérant pour affiner le plan, l'agent de voyage peut créer un itinéraire de voyage personnalisé et optimisé pour le client. Cette approche garantit que le plan de voyage est aligné sur les préférences et le budget du client dès le départ et s'améliore à chaque itération.

### Exploiter les LLM pour le reclassement et le scoring
Les modèles de langage de grande taille (LLM) peuvent être utilisés pour le reclassement et le scoring en évaluant la pertinence et la qualité des documents récupérés ou des réponses générées. Voici comment cela fonctionne :

**Récupération :** La première étape de récupération extrait un ensemble de documents ou de réponses candidats en fonction de la requête.
**Reclassement :** Le LLM évalue ces candidats et les reclasse en fonction de leur pertinence et de leur qualité. Cette étape garantit que les informations les plus pertinentes et de haute qualité sont présentées en premier.
**Scoring :** Le LLM attribue des scores à chaque candidat, reflétant leur pertinence et leur qualité. Cela aide à sélectionner la meilleure réponse ou le meilleur document pour l'utilisateur.

En exploitant les LLM pour le reclassement et le scoring, le système peut fournir des informations plus précises et contextuellement pertinentes, améliorant ainsi l'expérience utilisateur globale.

Voici un exemple de la façon dont un agent de voyage pourrait utiliser un modèle de langage de grande taille (LLM) pour le reclassement et le scoring des destinations de voyage en fonction des préférences des utilisateurs en Python :

#### Scénario - Voyage basé sur les préférences
Un agent de voyage souhaite recommander les meilleures destinations de voyage à un client en fonction de ses préférences. Le LLM aidera à reclasser et à noter les destinations pour s'assurer que les options les plus pertinentes sont présentées.

#### Étapes :
1. Recueillir les préférences de l'utilisateur.
2. Récupérer une liste de destinations de voyage potentielles.
3. Utiliser le LLM pour reclasser et noter les destinations en fonction des préférences de l'utilisateur.

Voici comment vous pouvez mettre à jour l'exemple précédent pour utiliser les services Azure OpenAI :

#### Prérequis
1. Vous devez avoir un abonnement Azure.
2. Créez une ressource Azure OpenAI et obtenez votre clé API.

#### Exemple de code Python
```python
import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generate a prompt for the Azure OpenAI
        prompt = self.generate_prompt(preferences)

        # Define headers and payload for the request
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }

        # Call the Azure OpenAI API to get the re-ranked and scored destinations
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()

        # Extract and return the recommendations
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# Example usage
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)
```

#### Explication du code - Preference Booker
1. **Initialisation** : Remplacez `TravelAgent` class is initialized with a list of potential travel destinations, each having attributes like name and description.

2. **Getting Recommendations (`get_recommendations` method)**: This method generates a prompt for the Azure OpenAI service based on the user's preferences and makes an HTTP POST request to the Azure OpenAI API to get re-ranked and scored destinations.

3. **Generating Prompt (`generate_prompt` method)**: This method constructs a prompt for the Azure OpenAI, including the user's preferences and the list of destinations. The prompt guides the model to re-rank and score the destinations based on the provided preferences.

4. **API Call**: The `requests` library is used to make an HTTP POST request to the Azure OpenAI API endpoint. The response contains the re-ranked and scored destinations.

5. **Example Usage**: The travel agent collects user preferences (e.g., interest in sightseeing and diverse culture) and uses the Azure OpenAI service to get re-ranked and scored recommendations for travel destinations.

Make sure to replace `your_azure_openai_api_key` with your actual Azure OpenAI API key and `https://your-endpoint.com/...` par l'URL de point de terminaison réelle de votre déploiement Azure OpenAI.

En exploitant le LLM pour le reclassement et le scoring, l'agent de voyage peut fournir des recommandations de voyage plus personnalisées et pertinentes aux clients, améliorant ainsi leur expérience globale.
```
```markdown
les meilleurs musées à Paris ?"). - **Intention de navigation** : L'utilisateur souhaite naviguer vers un site ou une page spécifique (par exemple, "Site officiel du musée du Louvre"). - **Intention transactionnelle** : L'utilisateur vise à effectuer une transaction, comme réserver un vol ou effectuer un achat (par exemple, "Réserver un vol pour Paris"). 2. **Conscience du contexte** : - L'analyse du contexte de la requête de l'utilisateur aide à identifier avec précision son intention. Cela inclut la prise en compte des interactions précédentes, des préférences de l'utilisateur et des détails spécifiques de la requête actuelle. 3. **Traitement du langage naturel (NLP)** : - Les techniques de NLP sont utilisées pour comprendre et interpréter les requêtes en langage naturel fournies par les utilisateurs. Cela inclut des tâches telles que la reconnaissance d'entités, l'analyse de sentiment et le traitement des requêtes. 4. **Personnalisation** : - Personnaliser les résultats de recherche en fonction de l'historique, des préférences et des retours de l'utilisateur améliore la pertinence des informations récupérées. #### Exemple pratique : Recherche avec intention dans Travel Agent Prenons Travel Agent comme exemple pour voir comment la recherche avec intention peut être mise en œuvre. 1. **Collecte des préférences de l'utilisateur** ```python
   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}

       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   ``` 2. **Compréhension de l'intention de l'utilisateur** ```python
   def identify_intent(query):
       if "book" in query or "purchase" in query:
           return "transactional"
       elif "website" in query or "official" in query:
           return "navigational"
       else:
           return "informational"
   ``` 3. **Conscience du contexte** ```python
   def analyze_context(query, user_history):
       # Combine current query with user history to understand context
       context = {
           "current_query": query,
           "user_history": user_history
       }
       return context
   ``` 4. **Recherche et personnalisation des résultats** ```python
   def search_with_intent(query, preferences, user_history):
       intent = identify_intent(query)
       context = analyze_context(query, user_history)
       if intent == "informational":
           search_results = search_information(query, preferences)
       elif intent == "navigational":
           search_results = search_navigation(query)
       elif intent == "transactional":
           search_results = search_transaction(query, preferences)
       personalized_results = personalize_results(search_results, user_history)
       return personalized_results

   def search_information(query, preferences):
       # Example search logic for informational intent
       results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
       return results

   def search_navigation(query):
       # Example search logic for navigational intent
       results = search_web(query)
       return results

   def search_transaction(query, preferences):
       # Example search logic for transactional intent
       results = search_web(f"book {query} to {preferences['destination']}")
       return results

   def personalize_results(results, user_history):
       # Example personalization logic
       personalized = [result for result in results if result not in user_history]
       return personalized[:10]  # Return top 10 personalized results
   ``` 5. **Exemple d'utilisation** ```python
   travel_agent = Travel_Agent()
   preferences = {
       "destination": "Paris",
       "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)
   user_history = ["Louvre Museum website", "Book flight to Paris"]
   query = "best museums in Paris"
   results = search_with_intent(query, preferences, user_history)
   print("Search Results:", results)
   ``` --- ## 4. Génération de code comme outil Les agents générateurs de code utilisent des modèles d'IA pour écrire et exécuter du code, résoudre des problèmes complexes et automatiser des tâches. ### Agents générateurs de code Les agents générateurs de code utilisent des modèles d'IA générative pour écrire et exécuter du code. Ces agents peuvent résoudre des problèmes complexes, automatiser des tâches et fournir des informations précieuses en générant et en exécutant du code dans divers langages de programmation. #### Applications pratiques 1. **Génération automatique de code** : Générer des extraits de code pour des tâches spécifiques, comme l'analyse de données, le scraping web ou l'apprentissage automatique. 2. **SQL en tant que RAG** : Utiliser des requêtes SQL pour récupérer et manipuler des données issues de bases de données. 3. **Résolution de problèmes** : Créer et exécuter du code pour résoudre des problèmes spécifiques, comme l'optimisation d'algorithmes ou l'analyse de données. #### Exemple : Agent générateur de code pour l'analyse de données Imaginons que vous conceviez un agent générateur de code. Voici comment il pourrait fonctionner : 1. **Tâche** : Analyser un jeu de données pour identifier des tendances et des modèles. 2. **Étapes** : - Charger le jeu de données dans un outil d'analyse de données. - Générer des requêtes SQL pour filtrer et agréger les données. - Exécuter les requêtes et récupérer les résultats. - Utiliser les résultats pour générer des visualisations et des insights. 3. **Ressources nécessaires** : Accès au jeu de données, outils d'analyse de données et capacités SQL. 4. **Expérience** : Utiliser les résultats d'analyses passées pour améliorer la précision et la pertinence des analyses futures. ### Exemple : Agent générateur de code pour Travel Agent Dans cet exemple, nous concevrons un agent générateur de code, Travel Agent, pour aider les utilisateurs à planifier leurs voyages en générant et en exécutant du code. Cet agent peut gérer des tâches telles que la récupération d'options de voyage, le filtrage des résultats et la compilation d'un itinéraire à l'aide de l'IA générative. #### Aperçu de l'agent générateur de code 1. **Collecte des préférences de l'utilisateur** : Collecte les entrées de l'utilisateur telles que la destination, les dates de voyage, le budget et les centres d'intérêt. 2. **Génération de code pour récupérer des données** : Génère des extraits de code pour récupérer des données sur les vols, les hôtels et les attractions. 3. **Exécution du code généré** : Exécute le code généré pour récupérer des informations en temps réel. 4. **Génération d'un itinéraire** : Compile les données récupérées dans un plan de voyage personnalisé. 5. **Ajustement en fonction des retours** : Reçoit les retours de l'utilisateur et régénère le code si nécessaire pour affiner les résultats. #### Mise en œuvre étape par étape 1. **Collecte des préférences de l'utilisateur** ```python
   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}

       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   ``` 2. **Génération de code pour récupérer des données** ```python
   def generate_code_to_fetch_data(preferences):
       # Example: Generate code to search for flights based on user preferences
       code = f"""
       def search_flights():
           import requests
           response = requests.get('https://api.example.com/flights', params={preferences})
           return response.json()
       """
       return code

   def generate_code_to_fetch_hotels(preferences):
       # Example: Generate code to search for hotels
       code = f"""
       def search_hotels():
           import requests
           response = requests.get('https://api.example.com/hotels', params={preferences})
           return response.json()
       """
       return code
   ``` 3. **Exécution du code généré** ```python
   def execute_code(code):
       # Execute the generated code using exec
       exec(code)
       result = locals()
       return result

   travel_agent = Travel_Agent()
   preferences = {
       "destination": "Paris",
       "dates": "2025-04-01 to 2025-04-10",
       "budget": "moderate",
       "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)

   flight_code = generate_code_to_fetch_data(preferences)
   hotel_code = generate_code_to_fetch_hotels(preferences)

   flights = execute_code(flight_code)
   hotels = execute_code(hotel_code)

   print("Flight Options:", flights)
   print("Hotel Options:", hotels)
   ``` 4. **Génération d'un itinéraire** ```python
   def generate_itinerary(flights, hotels, attractions):
       itinerary = {
           "flights": flights,
           "hotels": hotels,
           "attractions": attractions
       }
       return itinerary

   attractions = search_attractions(preferences)
   itinerary = generate_itinerary(flights, hotels, attractions)
   print("Suggested Itinerary:", itinerary)
   ``` 5. **Ajustement en fonction des retours** ```python
   def adjust_based_on_feedback(feedback, preferences):
       # Adjust preferences based on user feedback
       if "liked" in feedback:
           preferences["favorites"] = feedback["liked"]
       if "disliked" in feedback:
           preferences["avoid"] = feedback["disliked"]
       return preferences

   feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
   updated_preferences = adjust_based_on_feedback(feedback, preferences)

   # Regenerate and execute code with updated preferences
   updated_flight_code = generate_code_to_fetch_data(updated_preferences)
   updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

   updated_flights = execute_code(updated_flight_code)
   updated_hotels = execute_code(updated_hotel_code)

   updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
   print("Updated Itinerary:", updated_itinerary)
   ``` ### Exploitation de la conscience de l'environnement et du raisonnement Basée sur le schéma de la table, elle peut effectivement améliorer le processus de génération de requêtes en tirant parti de la conscience de l'environnement et du raisonnement. Voici un exemple de la façon dont cela peut être fait : 1. **Compréhension du schéma** : Le système comprendra le schéma de la table et utilisera cette information pour ancrer la génération de requêtes. 2. **Ajustement en fonction des retours** : Le système ajustera les préférences de l'utilisateur en fonction des retours et réfléchira aux champs du schéma qui doivent être mis à jour. 3. **Génération et exécution des requêtes** : Le système générera et exécutera des requêtes pour récupérer des données mises à jour sur les vols et les hôtels en fonction des nouvelles préférences. Voici un exemple de code Python mis à jour qui intègre ces concepts : ```python
def adjust_based_on_feedback(feedback, preferences, schema):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Reasoning based on schema to adjust other related preferences
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # Custom logic to adjust preferences based on schema and feedback
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # Generate code to fetch flight data based on updated preferences
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generate code to fetch hotel data based on updated preferences
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simulate execution of code and return mock data
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generate itinerary based on flights, hotels, and attractions
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Example schema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Example usage
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Regenerate and execute code with updated preferences
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)
``` #### Explication - Réservation basée sur les retours 1. **Conscience du schéma** : La méthode `schema` dictionary defines how preferences should be adjusted based on feedback. It includes fields like `favorites` and `avoid`, with corresponding adjustments.
2. **Adjusting Preferences (`adjust_based_on_feedback` method)**: This method adjusts preferences based on user feedback and the schema.
3. **Environment-Based Adjustments (`adjust_based_on_environment` personnalise les ajustements en fonction du schéma et des retours. 4. **Génération et exécution des requêtes** : Le système génère du code pour récupérer des données mises à jour sur les vols et les hôtels en fonction des préférences ajustées et simule l'exécution de ces requêtes. 5. **Génération d'un itinéraire** : Le système crée un itinéraire mis à jour en fonction des nouvelles données sur les vols, les hôtels et les attractions. En rendant le système conscient de l'environnement et en raisonnant en fonction du schéma, il peut générer des requêtes plus précises et pertinentes, conduisant à de meilleures recommandations de voyage et à une expérience utilisateur plus personnalisée. ### Utilisation de SQL comme technique de génération augmentée par récupération (RAG) SQL (Structured Query Language) est un outil puissant pour interagir avec des bases de données. Lorsqu'il est utilisé dans le cadre d'une approche de génération augmentée par récupération (RAG), SQL peut récupérer des données pertinentes à partir de bases de données pour informer et générer des réponses ou des actions dans les agents d'IA. Explorons comment SQL peut être utilisé comme technique RAG dans le contexte de Travel Agent. #### Concepts clés 1. **Interaction avec la base de données** : - SQL est utilisé pour interroger des bases de données, récupérer des informations pertinentes et manipuler des données. - Exemple : Récupérer des détails sur les vols, les hôtels et les attractions à partir d'une base de données de voyage. 2. **Intégration avec RAG** : - Les requêtes SQL sont générées en fonction des entrées et préférences de l'utilisateur. - Les données récupérées sont ensuite utilisées pour générer des recommandations ou des actions personnalisées. 3. **Génération dynamique de requêtes** : - L'agent d'IA génère des requêtes SQL dynamiques en fonction du contexte et des besoins de l'utilisateur. - Exemple : Personnaliser les requêtes SQL pour filtrer les résultats en fonction du budget, des dates et des centres d'intérêt. #### Applications - **Génération automatique de code** : Générer des extraits de code pour des tâches spécifiques. - **SQL en tant que RAG** : Utiliser des requêtes SQL pour manipuler des données. - **Résolution de problèmes** : Créer et exécuter du code pour résoudre des problèmes. **Exemple** : Un agent d'analyse de données : 1. **Tâche** : Analyser un jeu de données pour trouver des tendances. 2. **Étapes** : - Charger le jeu de données. - Générer des requêtes SQL pour filtrer les données. - Exécuter les requêtes et récupérer les résultats. - Générer des visualisations et des insights. 3. **Ressources** : Accès au jeu de données, capacités SQL. 4. **Expérience** : Utiliser les résultats passés pour améliorer les analyses futures. #### Exemple pratique : Utilisation de SQL dans Travel Agent 1. **Collecte des préférences de l'utilisateur** ```python
   class Travel_Agent:
       def __init__(self):
           self.user_preferences = {}

       def gather_preferences(self, preferences):
           self.user_preferences = preferences
   ``` 2. **Génération de requêtes SQL** ```python
   def generate_sql_query(table, preferences):
       query = f"SELECT * FROM {table} WHERE "
       conditions = []
       for key, value in preferences.items():
           conditions.append(f"{key}='{value}'")
       query += " AND ".join(conditions)
       return query
   ``` 3. **Exécution des requêtes SQL** ```python
   import sqlite3

   def execute_sql_query(query, database="travel.db"):
       connection = sqlite3.connect(database)
       cursor = connection.cursor()
       cursor.execute(query)
       results = cursor.fetchall()
       connection.close()
       return results
   ``` 4. **Génération de recommandations** ```python
   def generate_recommendations(preferences):
       flight_query = generate_sql_query("flights", preferences)
       hotel_query = generate_sql_query("hotels", preferences)
       attraction_query = generate_sql_query("attractions", preferences)

       flights = execute_sql_query(flight_query)
       hotels = execute_sql_query(hotel_query)
       attractions = execute_sql_query(attraction_query)

       itinerary = {
           "flights": flights,
           "hotels": hotels,
           "attractions": attractions
       }
       return itinerary

   travel_agent = Travel_Agent()
   preferences = {
       "destination": "Paris",
       "dates": "2025-04-01 to 2025-04-10",
       "budget": "moderate",
       "interests": ["museums", "cuisine"]
   }
   travel_agent.gather_preferences(preferences)
   itinerary = generate_recommendations(preferences)
   print("Suggested Itinerary:", itinerary)
   ``` #### Exemples de requêtes SQL 1. **Requête pour les vols** ```sql
   SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';
   ``` 2. **Requête pour les hôtels** ```sql
   SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';
   ``` 3. **Requête pour les attractions** ```sql
   SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';
   ``` En utilisant SQL dans le cadre de la technique de génération augmentée par récupération (RAG), les agents d'IA comme Travel Agent peuvent récupérer et utiliser dynamiquement des données pertinentes pour fournir des recommandations précises et personnalisées. ### Conclusion La métacognition est un outil puissant qui peut améliorer considérablement les capacités des agents d'IA. En incorporant des processus métacognitifs, vous pouvez concevoir des agents plus intelligents, adaptables et efficaces. Utilisez les ressources supplémentaires pour explorer davantage le monde fascinant de la métacognition dans les agents d'IA.
```

**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 faire appel à 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.


# Agents d'IA en Production

## Introduction

Cette leçon couvrira :

- Comment planifier efficacement le déploiement de votre agent d'IA en production.
- Les erreurs courantes et les problèmes que vous pourriez rencontrer lors du déploiement de votre agent d'IA en production.
- Comment gérer les coûts tout en maintenant les performances de votre agent d'IA.

## Objectifs d'apprentissage

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

- Utiliser des techniques pour améliorer les performances, les coûts et l'efficacité d'un système d'agent d'IA en production.
- Évaluer vos agents d'IA et ce qu'il faut examiner.
- Contrôler les coûts lors du déploiement des agents d'IA en production.

Il est essentiel de déployer des agents d'IA fiables. Consultez également la leçon "Construire des agents d'IA dignes de confiance".

## Évaluation des agents d'IA

Avant, pendant et après le déploiement des agents d'IA, il est crucial de mettre en place un système adéquat pour évaluer vos agents. Cela garantit que votre système est aligné sur vos objectifs et ceux de vos utilisateurs.

Pour évaluer un agent d'IA, il est important de pouvoir évaluer non seulement les résultats de l'agent, mais également l'ensemble du système dans lequel il opère. Cela inclut, sans s'y limiter :

- La requête initiale au modèle.
- La capacité de l'agent à identifier l'intention de l'utilisateur.
- La capacité de l'agent à choisir le bon outil pour accomplir la tâche.
- La réponse de l'outil à la requête de l'agent.
- La capacité de l'agent à interpréter la réponse de l'outil.
- Le retour d'information de l'utilisateur sur la réponse de l'agent.

Cela vous permet d'identifier les domaines à améliorer de manière plus modulaire. Vous pourrez ensuite surveiller l'effet des changements sur les modèles, les invites, les outils et d'autres composants avec une meilleure efficacité.

## Problèmes courants et solutions potentielles avec les agents d'IA

| **Problème**                                   | **Solution potentielle**                                                                                |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| L'agent d'IA n'exécute pas les tâches de manière cohérente | - Affinez l'invite donnée à l'agent d'IA ; soyez clair sur les objectifs.
- Identifiez si diviser les tâches en sous-tâches et les confier à plusieurs agents peut être utile.                                                 |
| L'agent d'IA entre dans des boucles continues  | - Assurez-vous d'avoir des termes et conditions de terminaison clairs pour que l'agent sache quand arrêter le processus.
- Pour les tâches complexes nécessitant du raisonnement et de la planification, utilisez un modèle plus grand spécialisé dans ces tâches. |
| Les appels aux outils par l'agent d'IA ne sont pas performants | - Testez et validez les résultats des outils en dehors du système de l'agent.
- Affinez les paramètres définis, les invites et les noms des outils.                                                                           |
| Le système multi-agents manque de cohérence    | - Affinez les invites données à chaque agent pour qu'elles soient spécifiques et distinctes les unes des autres.
- Construisez un système hiérarchique en utilisant un agent "routeur" ou contrôleur pour déterminer quel agent est le plus adapté.                  |

## Gestion des coûts

Voici quelques stratégies pour gérer les coûts du déploiement des agents d'IA en production :

- **Mise en cache des réponses** - Identifier les requêtes et tâches courantes et fournir les réponses avant qu'elles ne passent par votre système d'agents est une bonne façon de réduire le volume de requêtes similaires. Vous pouvez même implémenter un flux pour identifier à quel point une requête est similaire à vos requêtes mises en cache en utilisant des modèles d'IA plus basiques.

- **Utilisation de modèles plus petits** - Les Small Language Models (SLMs) peuvent être efficaces pour certains cas d'utilisation d'agents et réduiront considérablement les coûts. Comme mentionné précédemment, construire un système d'évaluation pour déterminer et comparer les performances par rapport à des modèles plus grands est la meilleure façon de comprendre dans quelle mesure un SLM peut convenir à votre cas d'utilisation.

- **Utilisation d'un modèle routeur** - Une stratégie similaire consiste à utiliser une diversité de modèles et de tailles. Vous pouvez utiliser un LLM/SLM ou une fonction sans serveur pour router les requêtes en fonction de leur complexité vers les modèles les plus adaptés. Cela aidera également à réduire les coûts tout en assurant de bonnes performances pour les tâches appropriées.

## Félicitations

Ceci est actuellement la dernière leçon de "Agents d'IA pour Débutants".

Nous prévoyons d'ajouter des leçons en fonction des retours et des évolutions dans cette industrie en pleine croissance, alors revenez nous voir prochainement.

Si vous souhaitez continuer à apprendre et à développer avec des agents d'IA, rejoignez le [Azure AI Community Discord](https://discord.gg/kzRShWzttr).

Nous y organisons des ateliers, des tables rondes communautaires et des sessions "ask me anything".

Nous avons également une collection de ressources d'apprentissage supplémentaires qui peuvent vous aider à commencer à déployer des agents d'IA en production.
```

**Avertissement** :
Ce document a été traduit à l'aide de services de traduction automatique 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 faire appel à 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.

10 Lessons to Get Started Building AI Agents


# 課程設定

## 簡介

呢堂會教你點樣運行呢個課程嘅代碼示例。

## 必備條件

- 一個 GitHub 帳戶
- Python 3.12 或以上版本

## 複製或分叉呢個 Repo

首先，請複製（clone）或者分叉（fork）GitHub 嘅 Repository。咁樣你就可以擁有課程材料嘅自己版本，方便運行、測試同埋調整代碼！

可以點擊呢個連結 [fork the repo](https://github.com/microsoft/ai-agents-for-beginners/fork) 去操作。

完成後，你應該會有一個好似以下圖示嘅分叉版本：

![Forked Repo](../../../translated_images/forked-repo.eea246a73044cc984a1e462349e36e7336204f00785e3187b7399905feeada07.hk.png)

## 獲取你嘅 GitHub Personal Access Token (PAT)

目前呢個課程使用 GitHub Models Marketplace 提供免費嘅大型語言模型（LLMs）服務，用嚟創建 AI Agents。

要使用呢個服務，你需要創建一個 GitHub 嘅 Personal Access Token。

你可以去你嘅 GitHub 帳戶嘅 [Personal Access Tokens settings](https://github.com/settings/personal-access-tokens) 頁面創建。

揀選屏幕左邊嘅 `Fine-grained tokens` 選項。

然後揀選 `Generate new token`。

![Generate Token](../../../translated_images/generate-token.361ec40abe59b84ac68d63c23e2b6854d6fad82bd4e41feb98fc0e6f030e8ef7.hk.png)

複製你啱啱創建嘅新 Token。之後，你需要將呢個 Token 加到課程中提供嘅 `.env` 文件內。

## 將 Token 加到環境變數

要創建你嘅 `.env` 文件，可以喺終端運行以下命令：

```bash
cp .env.example .env
```

呢條命令會複製示例文件，並喺你嘅目錄內創建一個 `.env` 文件。

打開呢個文件，然後將你創建嘅 Token 貼到 `.env` 文件中 `GITHUB_TOKEN=` 呢一行。

## 安裝所需嘅套件

為咗確保你有齊所有運行代碼所需嘅 Python 套件，請喺終端運行以下命令。

我哋建議你創建一個 Python 虛擬環境，避免發生衝突同埋問題。

```bash
pip install -r requirements.txt
```

呢條命令應該會安裝所有所需嘅 Python 套件。

而家你已經準備好運行課程嘅代碼，祝你學習 AI Agents 嘅世界愉快！

如果喺設定過程中遇到任何問題，可以加入我哋嘅 [Azure AI Community Discord](https://discord.gg/kzRShWzttr) 或者 [create an issue](https://github.com/microsoft/ai-agents-for-beginners/issues?WT.mc_id=academic-105485-koreyst)。

**免責聲明**:
本文件經由機器翻譯人工智能服務進行翻譯。儘管我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文作為權威來源。如涉及重要資訊，建議尋求專業人工翻譯。我們對因使用本翻譯而引起的任何誤解或錯誤解釋概不負責。


# 人工智能代理簡介及應用場景

歡迎來到「人工智能代理入門」課程！這門課程將為你提供構建人工智能代理的基礎知識和實際範例。

加入 [Azure AI Discord 社群](https://discord.gg/kzRShWzttr)，與其他學習者和人工智能代理開發者互動，並隨時提問有關本課程的問題。

在課程開始前，我們將首先了解什麼是人工智能代理，以及如何在我們構建的應用程式和工作流程中使用它們。

## 課程介紹

本課程將涵蓋：

- 什麼是人工智能代理？有哪些不同類型的代理？
- 哪些應用場景最適合人工智能代理？它們如何幫助我們？
- 設計代理解決方案時的一些基本組件有哪些？

## 學習目標

完成本課程後，你應該能夠：

- 理解人工智能代理的概念，以及它們與其他 AI 解決方案的區別。
- 高效應用人工智能代理。
- 為用戶和客戶設計具有生產力的代理解決方案。

## 定義人工智能代理及其類型

### 什麼是人工智能代理？

人工智能代理是**系統**，通過為**大型語言模型（LLMs）**提供**工具**和**知識**的訪問權限，來擴展其能力並讓它們**執行操作**。

讓我們將這個定義分解為幾個部分來理解：

- **系統** - 代理不是單一組件，而是一個由多個組件組成的系統。在基礎層面，人工智能代理的組件包括：
  - **環境** - 定義代理運行的空間。例如，如果我們有一個旅行預訂代理，環境可能是代理用來完成任務的旅行預訂系統。
  - **感測器** - 環境提供信息和反饋。代理使用感測器來收集並解釋這些信息，了解環境的當前狀態。在旅行預訂代理的例子中，感測器可能從系統中獲取酒店空房信息或機票價格。
  - **執行器** - 當代理接收到環境的當前狀態後，會決定採取哪些行動來改變環境。例如，旅行預訂代理可能會為用戶預訂一間可用的房間。

![什麼是人工智能代理？](../../../translated_images/what-are-ai-agents.125520f55950b252a429b04a9f41e0152d4dafa1f1bd9081f4f574631acb759e.hk.png?WT.mc_id=academic-105485-koreyst)

**大型語言模型** - 在 LLM 出現之前，代理的概念已經存在。使用 LLM 構建代理的優勢在於其能夠解釋人類語言和數據的能力。這種能力讓 LLM 可以解釋環境信息並制定改變環境的計劃。

**執行操作** - 在代理系統之外，LLM 的行動僅限於根據用戶的提示生成內容或信息。而在代理系統內，LLM 能夠通過解釋用戶請求並使用環境中的工具來完成任務。

**工具訪問** - LLM 可使用的工具取決於 1) 它運行的環境，以及 2) 開發者的設計。例如，在旅行代理的例子中，代理的工具可能僅限於預訂系統提供的操作，或者開發者可以限制代理只能訪問航班的相關工具。

**知識** - 除了環境提供的信息，代理還可以從其他系統、服務、工具甚至其他代理中檢索知識。在旅行代理的例子中，這些知識可能包括客戶數據庫中用戶的旅行偏好信息。

### 不同類型的代理

現在我們已經了解了人工智能代理的基本定義，讓我們看看一些具體的代理類型，以及它們如何應用於旅行預訂代理。

| **代理類型**                 | **描述**                                                                                | **範例**                                                                                |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **簡單反射代理**             | 基於預定義規則執行即時行動。                                                                                | 旅行代理解讀電子郵件內容，並將旅行投訴轉發給客戶服務部門。                                                                                |
| **基於模型的反射代理**       | 基於對世界的模型及其變化執行行動。                                                                                | 旅行代理根據歷史價格數據的訪問權限，優先處理價格變動較大的路線。                                                                                |
| **目標導向代理**             | 通過解釋目標並確定達成目標的行動來制定計劃。                                                                                | 旅行代理通過確定從當前位置到目的地所需的旅行安排（如汽車、公車、航班）來完成行程預訂。                                                                                |
| **效用導向代理**             | 考慮偏好並通過數值權衡取捨來確定如何達成目標。                                                                                | 旅行代理在預訂行程時通過權衡便利性與成本來最大化效用。                                                                                |
| **學習型代理**               | 通過響應反饋並相應調整行動來隨時間改進。                                                                                | 旅行代理通過使用客戶在行程後的調查反饋，對未來的預訂進行調整以改進服務。                                                                                |
| **分層代理**                 | 包含多個層級代理，高層代理將任務分解為子任務，交由低層代理完成。                                                                | 旅行代理取消行程時，將任務分解為子任務（例如取消具體的預訂），並由低層代理完成，然後向高層代理匯報。                                                                                |
| **多代理系統（MAS）**        | 代理以協作或競爭的方式獨立完成任務。                                                                                | 協作：多個代理分別預訂特定的旅行服務，如酒店、航班和娛樂活動。競爭：多個代理管理並競爭共享的酒店預訂日曆，為客戶預訂房間。                                                                                |

## 何時使用人工智能代理

在上一節中，我們使用旅行代理的應用場景來解釋不同類型代理在旅行預訂中的使用方式。在本課程中，我們將繼續使用這個應用場景。

讓我們看看人工智能代理最適合的應用場景類型：

![何時使用人工智能代理？](../../../translated_images/when-to-use-ai-agents.912b9a02e9e0e2af45a3e24faa4e912e334ec23f21f0cf5cb040b7e899b09cd0.hk.png?WT.mc_id=academic-105485-koreyst)

- **開放性問題** - 當任務所需的步驟無法總是硬編碼進工作流程時，允許 LLM 自行決定完成任務所需的步驟。
- **多步驟流程** - 當任務需要一定的複雜性，代理需要通過多次互動使用工具或信息，而非一次性檢索時。
- **隨時間改進** - 當任務需要通過接收來自環境或用戶的反饋來改進，以提供更好的效用時。

我們會在「構建可信賴的人工智能代理」課程中詳細討論使用代理的更多考量。

## 代理解決方案的基礎

### 代理開發

設計人工智能代理系統的第一步是定義工具、行動和行為。在本課程中，我們專注於使用 **Azure AI Agent Service** 來定義代理。它提供以下功能：

- 選擇開放模型，例如 OpenAI、Mistral 和 Llama
- 通過 Tripadvisor 等供應商使用授權數據
- 使用標準化的 OpenAPI 3.0 工具

### 代理模式

與 LLM 的溝通是通過提示完成的。由於人工智能代理具有半自動化的特性，並非總是需要在環境變化後手動重新提示 LLM。我們使用 **代理模式**，以更具規模化的方式在多步驟中提示 LLM。

本課程分為一些當前流行的代理模式進行學習。

### 代理框架

代理框架允許開發者通過程式碼實現代理模式。這些框架提供模板、插件和工具，增強人工智能代理的協作能力。這些優勢使得人工智能代理系統的可觀察性和故障排除能力更強。

在本課程中，我們將探索基於研究的 AutoGen 框架，以及來自 Semantic Kernel 的生產級代理框架。
```

**免責聲明**:
本文件經由機器翻譯人工智能服務翻譯而成。雖然我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。如涉及關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。


# 探索 AI Agent 框架

AI Agent 框架係一啲專門設計嘅軟件平台，目標係簡化 AI agent 嘅開發、部署同管理。呢啲框架為開發者提供預設嘅組件、抽象層同工具，令到開發複雜嘅 AI 系統變得更加簡單。

呢啲框架幫助開發者專注於應用程式嘅獨特部分，通過為 AI agent 開發中常見嘅挑戰提供標準化嘅解決方案。佢哋提升咗構建 AI 系統嘅可擴展性、可用性同效率。

## 簡介

呢堂課會涵蓋：

- 乜嘢係 AI Agent 框架？佢哋可以幫開發者做到啲乜？
- 團隊可以點樣利用呢啲框架快速原型設計、反覆改良同提升 agent 嘅能力？
- 微軟開發嘅框架同工具（[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)）有乜唔同？
- 我可以直接整合現有嘅 Azure 生態系統工具，定係需要獨立嘅解決方案？
- 乜嘢係 Azure AI Agents Service？佢可以點樣幫到我？

## 學習目標

呢堂課嘅目標係幫你了解：

- AI Agent 框架喺 AI 開發中嘅角色。
- 點樣利用 AI Agent 框架構建智能 agent。
- AI Agent 框架提供嘅關鍵功能。
- Autogen、Semantic Kernel 同 Azure AI Agent Service 嘅分別。

## 乜嘢係 AI Agent 框架？佢哋可以幫開發者做到啲乜？

傳統嘅 AI 框架可以幫你將 AI 整合到應用程式入面，並令呢啲應用更好，方式如下：

- **個性化**：AI 可以分析用戶行為同喜好，提供個人化推薦、內容同體驗。
例子：Netflix 呢類串流服務用 AI 根據用戶嘅觀看歷史推薦電影同節目，提升用戶參與度同滿意度。

- **自動化同效率**：AI 可以自動化重複性任務、簡化工作流程，提升運營效率。
例子：客戶服務應用利用 AI 驅動嘅聊天機械人處理常見查詢，縮短回應時間，令人工客服可以專注於更複雜嘅問題。

- **提升用戶體驗**：AI 可以提供智能功能，例如語音識別、自然語言處理同預測文本，改善整體用戶體驗。
例子：虛擬助手例如 Siri 同 Google Assistant 利用 AI 理解同回應語音指令，令用戶更容易操作設備。

### 咁聽起嚟好正，但點解仲需要 AI Agent 框架？

AI Agent 框架唔止係 AI 框架咁簡單。佢哋設計出嚟係為咗創建智能 agent，呢啲 agent 可以同用戶、其他 agent 同環境互動，達到特定目標。呢啲 agent 可以表現出自主行為、作決策，並適應不斷變化嘅條件。以下係 AI Agent 框架提供嘅幾個關鍵功能：

- **Agent 合作同協調**：支持創建多個 AI agent，佢哋可以合作、溝通同協調，解決複雜任務。
- **任務自動化同管理**：提供機制，自動化多步工作流程、任務分配同動態任務管理。
- **上下文理解同適應**：賦予 agent 理解上下文、適應環境變化嘅能力，並根據實時信息作出決策。

總結嚟講，agent 令你做到更多，可以將自動化提升到新層次，創建能夠適應同學習環境嘅更智能系統。

## 點樣快速原型設計、反覆改良同提升 agent 嘅能力？

呢個領域發展得好快，但大多數 AI Agent 框架都有啲共通點，可以幫你快速原型設計同反覆改良，包括模塊化組件、協作工具同實時學習。讓我哋逐一探討：

- **使用模塊化組件**：AI 框架提供預設嘅組件，例如 prompts、parsers 同記憶管理。
- **利用協作工具**：設計擁有特定角色同任務嘅 agent，測試同改良協作工作流程。
- **實時學習**：實現反饋循環，令 agent 從互動中學習，並動態調整行為。

### 使用模塊化組件

框架例如 LangChain 同 Microsoft Semantic Kernel 提供預設嘅組件，例如 prompts、parsers 同記憶管理。

**團隊點樣用呢啲**：團隊可以快速組裝呢啲組件，創建一個可用嘅原型，而唔需要從零開始，從而快速進行實驗同反覆改良。

**實際操作係點**：你可以使用預設嘅 parser 從用戶輸入中提取信息，用記憶模塊存取數據，並用 prompt 生成器同用戶互動，呢啲都唔需要你自己從頭開發。

**範例代碼**：以下係一個例子，展示點樣用預設嘅 parser 從用戶輸入中提取信息：

```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'}
```

由呢個例子你可以睇到，點樣利用預設嘅 parser 提取用戶輸入嘅關鍵信息，例如航班預訂請求嘅出發地、目的地同日期。呢種模塊化方法可以令你專注於高層次邏輯。

### 利用協作工具

框架例如 CrewAI 同 Microsoft Autogen 幫助創建多個可以合作嘅 agent。

**團隊點樣用呢啲**：團隊可以設計擁有特定角色同任務嘅 agent，測試同改良協作工作流程，從而提升整體系統效率。

**實際操作係點**：你可以創建一組 agent，每個 agent 都有專門功能，例如數據檢索、分析或決策。呢啲 agent 可以溝通同分享信息，以完成共同目標，例如回答用戶查詢或完成任務。

**範例代碼 (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)
```

上面嘅代碼展示咗點樣創建一個涉及多個 agent 協作分析數據嘅任務。每個 agent 執行特定功能，並通過協調佢哋嘅行動完成目標任務。創建專門角色嘅 agent 可以提升任務效率同性能。

### 實時學習

高級框架提供實時上下文理解同適應嘅能力。

**團隊點樣用呢啲**：團隊可以實現反饋循環，令 agent 從互動中學習，並動態調整行為，實現持續改良同能力提升。

**實際操作係點**：agent 可以分析用戶反饋、環境數據同任務結果，更新佢哋嘅知識庫，調整決策算法，並隨時間改進性能。呢種反覆學習過程令 agent 能夠適應變化嘅條件同用戶偏好，提升整體系統效能。

## Autogen、Semantic Kernel 同 Azure AI Agent Service 嘅分別係咩？

有好多方法可以比較呢啲框架，以下係從設計、功能同目標用例方面嘅主要區別：

### Autogen

一個由 Microsoft Research 嘅 AI Frontiers Lab 開發嘅開源框架，專注於事件驅動、分布式嘅 *agentic* 應用，支持多個 LLMs、SLMs、工具同高級多-agent 設計模式。

Autogen 嘅核心概念係基於 agent，呢啲係自主實體，可以感知環境、作決策同採取行動以達到特定目標。agent 通過非同步消息進行溝通，令佢哋可以獨立同並行工作，提升系統可擴展性同響應能力。

...（以下省略其餘部分，內容太長）...
根據項目目標。適用於自然語言理解、內容生成。
- **Azure AI Agent Service**：靈活的模型、企業級安全機制、數據存儲方法。適用於企業應用中安全、可擴展且靈活的 AI 代理部署。

## 我可以直接整合現有的 Azure 生態系統工具，還是需要獨立的解決方案？
答案是肯定的，您可以直接將現有的 Azure 生態系統工具與 Azure AI Agent Service 整合，特別是因為它被設計為能與其他 Azure 服務無縫協作。例如，您可以整合 Bing、Azure AI Search 和 Azure Functions。還有與 Azure AI Foundry 的深度整合。對於 Autogen 和 Semantic Kernel，您也可以與 Azure 服務整合，但可能需要從您的代碼中調用 Azure 服務。另一種整合方式是使用 Azure SDK 從您的代理與 Azure 服務進行交互。此外，如前所述，您可以將 Azure AI Agent Service 作為 Autogen 或 Semantic Kernel 構建的代理的協調器，這將使您能輕鬆訪問 Azure 生態系統。

## 參考資料
- [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)

**免責聲明**：
本文件是使用機器翻譯AI服務進行翻譯的。我們致力於追求準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件為權威來源。對於關鍵信息，建議尋求專業人工翻譯。我們對因使用本翻譯而引起的任何誤解或錯誤解釋概不負責。


# AI Agentic Design Principles

## 簡介

建立 AI Agentic 系統有好多唔同嘅方法。由於喺生成式 AI 設計中，模糊性係一個特性而唔係缺陷，所以工程師有時會唔知點開始。我哋創建咗一套以人為本嘅用戶體驗設計原則，幫助開發者建立以客戶為中心嘅 agentic 系統，從而解決業務需求。呢啲設計原則唔係一個具體嘅架構，而係一個幫助團隊定義同建立 agent 體驗嘅起點。

一般嚟講，agents 應該：

- 擴展同提升人類能力（例如：頭腦風暴、解決問題、自動化等）
- 填補知識空白（例如：讓我快速掌握知識領域、翻譯等）
- 支援並促進協作，滿足我哋每個人偏好嘅合作方式
- 幫助我哋成為更好嘅自己（例如：人生教練/任務管理，幫助學習情緒調節同正念技能，建立韌性等）

## 呢堂課會講咩

- 乜嘢係 Agentic 設計原則
- 喺實施呢啲設計原則時要遵守嘅指引
- 使用設計原則嘅例子

## 學習目標

完成呢堂課後，你將能夠：

1. 解釋乜嘢係 Agentic 設計原則
2. 解釋使用 Agentic 設計原則嘅指引
3. 明白點樣用 Agentic 設計原則建立一個 agent

## Agentic 設計原則

![Agentic Design Principles](../../../translated_images/agentic-design-principles.9f32a64bb6e2aa5a1bdffb70111aa724058bc248b1a3dd3c6661344015604cff.hk.png?WT.mc_id=academic-105485-koreyst)

### Agent（空間）

呢個係 agent 運作嘅環境。呢啲原則指導我哋點樣設計 agents，讓佢哋能夠喺實體同數碼世界中互動。

- **連結，而唔係隔絕** – 幫助人哋連結其他人、事件同可行嘅知識，促進協作同連接。
  - Agents 幫助連結事件、知識同人。
  - Agents 拉近人與人之間嘅距離，而唔係設計嚟取代或者貶低人。
- **容易接觸但偶爾隱形** – agent 大部分時間喺背景運作，只有喺相關同適當時先提醒我哋。
  - Agent 喺任何裝置或平台上都容易被授權用戶發現同使用。
  - Agent 支援多模態輸入同輸出（聲音、語音、文字等）。
  - Agent 可以喺前景同背景之間無縫切換；喺主動同被動模式之間切換，根據用戶需求進行感知。
  - Agent 可能以隱形形式運作，但其背景處理路徑同與其他 Agents 嘅協作對用戶係透明同可控嘅。

### Agent（時間）

呢個係 agent 喺時間上點樣運作。呢啲原則指導我哋點樣設計 agents 喺過去、現在同未來進行互動。

- **過去**：回顧包括狀態同上下文喺內嘅歷史。
  - Agent 基於更豐富嘅歷史數據分析提供更相關嘅結果，而唔係只係事件、人或者狀態。
  - Agent 由過去事件建立連接，並主動反思記憶以應對當前情況。
- **現在**：更多係提示，而唔係通知。
  - Agent 採用全面嘅方式與人互動。當事件發生時，Agent 唔只係靜態通知或者其他形式化提醒。Agent 可以簡化流程或者動態生成提示，喺正確嘅時刻引導用戶注意力。
  - Agent 根據上下文環境、社會同文化變化，以及用戶意圖，提供信息。
  - Agent 嘅互動可以係漸進式嘅，隨住時間增長逐步提升複雜性，從而長期賦能用戶。
- **未來**：適應同進化。
  - Agent 可以適應各種裝置、平台同模態。
  - Agent 適應用戶行為、無障礙需求，並且可以自由定制。
  - Agent 通過持續嘅用戶互動塑造同進化。

### Agent（核心）

呢啲係 agent 設計核心嘅關鍵元素。

- **接受不確定性，但建立信任**。
  - 一定程度嘅 Agent 不確定性係可以接受嘅。不確定性係 agent 設計嘅一個關鍵元素。
  - 信任同透明係 Agent 設計嘅基石。
  - 人類控制住 Agent 嘅開啟/關閉狀態，並且 Agent 狀態隨時清晰可見。

## 實施呢啲原則嘅指引

當你使用上述設計原則時，請遵守以下指引：

1. **透明性**：通知用戶 AI 嘅參與，解釋佢點樣運作（包括過往行為），以及點樣提供反饋同修改系統。
2. **控制**：讓用戶可以定制、指定偏好同個性化，並對系統同其屬性擁有控制權（包括忘記功能）。
3. **一致性**：確保喺裝置同端點之間提供一致、多模態嘅體驗。盡可能使用熟悉嘅 UI/UX 元素（例如：用麥克風圖標表示語音互動），並儘量減低用戶嘅認知負擔（例如：提供簡潔嘅回應、視覺輔助同“了解更多”內容）。

## 如何用呢啲原則同指引設計旅遊 Agent

假設你喺設計一個旅遊 Agent，可以咁樣運用設計原則同指引：

1. **透明性** – 讓用戶知道旅遊 Agent 係一個 AI 支援嘅 Agent。提供一啲基本指引，教用戶點樣開始（例如：“Hello” 信息、示例提示）。喺產品頁面清楚記錄呢啲資訊。展示用戶過去問過嘅提示列表。清楚說明點樣提供反饋（例如：讚好/踩低按鈕、發送反饋按鈕等）。明確講解 Agent 是否有使用或主題限制。
2. **控制** – 確保用戶清楚點樣喺創建 Agent 後修改，例如使用 System Prompt。讓用戶選擇 Agent 嘅詳細程度、寫作風格，以及 Agent 唔應該討論嘅內容。允許用戶查看同刪除任何相關文件或數據、提示同過去嘅對話。
3. **一致性** – 確保“分享提示”、“添加文件或圖片”同“標記某人或某物”嘅圖標係標準同易於識別嘅。用迴紋針圖標表示文件上傳/共享，用圖片圖標表示圖片上傳。

## 其他資源
- [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)

**免責聲明**：
本文件已使用機器翻譯人工智能服務進行翻譯。儘管我們努力確保準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原始語言的文件作為權威來源。對於關鍵資訊，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或誤釋不承擔責任。


# 工具使用設計模式

## 簡介

喺呢堂課，我哋會解答以下問題：

- 咩係工具使用設計模式？
- 呢個模式適用於咩場景？
- 實現呢個設計模式需要嘅元素/組成部分係咩？
- 喺建立可信賴嘅AI代理時，使用工具使用設計模式需要注意啲咩特別事項？

## 學習目標

完成呢堂課之後，你將能夠：

- 定義工具使用設計模式及其目的。
- 識別適用工具使用設計模式嘅場景。
- 理解實現呢個設計模式所需嘅關鍵元素。
- 認識使用呢個設計模式時，確保AI代理可信賴嘅考量。

## 咩係工具使用設計模式？

**工具使用設計模式**重點喺俾大型語言模型（LLMs）能夠與外部工具互動，以達到特定目標。工具係由代理執行嘅代碼，佢可以係一個簡單嘅函數，例如計算機，亦可以係第三方服務嘅API調用，例如股票價格查詢或者天氣預報。喺AI代理嘅背景下，工具係設計俾代理響應**模型生成嘅函數調用**而執行。

## 呢個模式適用於咩場景？

AI代理可以利用工具完成複雜任務、檢索信息或者做決策。工具使用設計模式通常應用喺需要動態與外部系統交互嘅場景，例如數據庫、網絡服務或者代碼解釋器。呢種能力對多種場景都好有用，包括：

- **動態信息檢索：** 代理可以查詢外部API或者數據庫，獲取最新數據（例如查詢SQLite數據庫進行數據分析、獲取股票價格或者天氣信息）。
- **代碼執行與解釋：** 代理可以執行代碼或者腳本，解決數學問題、生成報告或者進行模擬。
- **工作流自動化：** 通過集成工具（例如任務調度器、電子郵件服務或者數據管道），自動化重複或者多步驟工作流。
- **客戶支持：** 代理可以與CRM系統、工單平台或者知識庫互動，解答用戶問題。
- **內容生成與編輯：** 代理可以利用工具，例如語法檢查器、文本摘要生成器或者內容安全評估工具，協助完成內容創建任務。

## 實現工具使用設計模式需要嘅元素/組成部分係咩？

### 函數/工具調用

函數調用係俾大型語言模型（LLMs）與工具互動嘅主要方式。你可能會見到「函數」同「工具」互換使用，因為「函數」（可重用嘅代碼塊）就係代理用嚟執行任務嘅「工具」。為咗讓函數嘅代碼可以被調用，LLM需要將用戶請求同函數嘅描述進行比較。為咗做到呢點，一個包含所有可用函數描述嘅結構（schema）會被發送俾LLM。然後，LLM會選擇最適合嘅函數，返回佢嘅名稱同參數。被選中嘅函數會被執行，佢嘅回應會再返俾LLM，然後LLM利用呢啲信息回應用戶請求。

開發者想為代理實現函數調用，需要：

1. 一個支持函數調用嘅LLM模型
2. 一個包含函數描述嘅結構（schema）
3. 每個描述中提到嘅函數代碼

用一個查詢城市當前時間嘅例子嚟說明：

- **初始化支持函數調用嘅LLM：**

    唔係所有模型都支持函數調用，所以確認你用嘅LLM支持呢個功能好重要。[Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling)支持函數調用。我哋可以由初始化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"
    )
    ```

- **創建函數結構（Schema）：**

    接住，我哋會定義一個JSON結構，包含函數名稱、函數用途嘅描述，以及函數參數嘅名稱同描述。
    然後，我哋會將呢個結構同用戶請求一齊傳俾之前創建嘅客戶端，請求查詢三藩市嘅時間。需要注意嘅係，返回嘅係**工具調用**，而唔係問題嘅最終答案。如之前提到，LLM返回咗佢為任務選擇嘅函數名稱同將會傳遞俾函數嘅參數。

    ```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')])
    ```

- **執行任務所需嘅函數代碼：**

    而家LLM已經選擇咗需要運行嘅函數，接住就需要實現並執行完成任務嘅代碼。
    我哋可以用Python實現查詢當前時間嘅代碼。同時，我哋亦需要編寫代碼，從response_message中提取名稱同參數以獲取最終結果。

    ```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.
     ```

函數調用係大部分（如果唔係全部）代理工具使用設計嘅核心，但從零開始實現有時會有挑戰。
正如我哋喺[第二課](../../../02-explore-agentic-frameworks)學到，代理框架為我哋提供咗預構建嘅組件，方便實現工具使用。

### 使用代理框架嘅工具使用例子

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

    Semantic Kernel係一個開源嘅AI框架，適合用.NET、Python同Java開發大型語言模型（LLMs）嘅開發者。佢透過一個叫做[序列化](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)嘅過程，自動將你嘅函數同參數描述傳遞俾模型，簡化咗使用函數調用嘅過程。佢仲處理模型同你代碼之間嘅雙向通信。使用代理框架例如Semantic Kernel嘅另一個好處係，你可以訪問預構建嘅工具，例如[文件搜索](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step4_assistant_tool_file_search.py)同[代碼解釋器](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py)。

    以下圖解展示咗使用Semantic Kernel進行函數調用嘅過程：

    ![函數調用](../../../translated_images/functioncalling-diagram.b5493ea5154ad8e3e4940d2e36a49101eec1398948e5d1039942203b4f5a4209.hk.png)

    喺Semantic Kernel中，函數/工具被稱為[插件](https://learn.microsoft.com/semantic-kernel/concepts/plugins/?pivots=programming-language-python)。我哋可以將`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`裝飾器，加入函數描述。當你用GetCurrentTimePlugin創建內核時，內核會自動序列化函數同佢嘅參數，喺呢個過程中創建結構發送俾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係一個較新嘅代理框架，旨喺幫助開發者安全地構建、部署同擴展高質量同可擴展嘅AI代理，而唔需要管理底層嘅計算同存儲資源。呢個框架對企業應用特別有用，因為佢係一個完全託管嘅服務，並提供企業級別嘅安全性。

    同直接用LLM API開發相比，Azure AI Agent Service提供咗以下優勢：
  - 自動工具調用——唔需要解析工具調用、調用工具同處理回應；呢啲全部都喺服務端完成
  - 安全管理數據——唔需要自行管理會話狀態，可以依賴threads存儲所需嘅所有信息
  - 預構建工具——可以用嚟與數據源交互嘅工具，例如Bing、Azure AI Search同Azure Functions。

    Azure AI Agent Service提供嘅工具可以分為兩類：

    1. 知識工具：
        - [使用Bing Search進行信息補充](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/bing-grounding?tabs=python&pivots=overview)
        - [文件搜索](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. 行動工具：
        - [函數調用](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/function-calling?tabs=python&pivots=overview)
        - [代碼解釋器](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/code-interpreter?tabs=python&pivots=overview)
        - [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)

    Agent Service允許我哋將呢啲工具作為一個`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.hk.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`，或者根據用戶請求使用預構建嘅代碼解釋器。

    ```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
    )
    ```

## 使用工具使用設計模式構建可信AI代理需要注意啲咩特別事項？

使用LLM動態生成嘅SQL通常會引起安全問題，特別係SQL注入或者惡意操作（例如刪除或者篡改數據庫）嘅風險。雖然呢啲擔憂係合理嘅，但可以通過正確配置數據庫訪問權限有效減輕呢啲風險。對於大多數數據庫，呢個過程包括將數據庫設置為只讀模式。對於例如PostgreSQL或者Azure SQL嘅數據庫服務，應該為應用程序分配只讀（SELECT）角色。

喺安全環境中運行應用程序可以進一步增強保護。喺企業場景中，數據通常會從運營系統中提取並轉換到只讀數據庫或者數據倉庫，並具有用戶友好嘅結構。呢個方法可以確保數據安全，並優化性能同可訪問性，同時限制應用程序只有只讀訪問權限。

## 其他資源

- [Azure AI Agents Service Workshop](https://microsoft.github.io/build-your-first-agent-with-azure-ai-agent-service-workshop/)
- [Contoso Creative Writer Multi-Agent Workshop](https://github.com/Azure-Samples/contoso-creative-writer/tree/main/docs/workshop)
- [Semantic Kernel Function Calling Tutorial](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)
- [Semantic Kernel Code Interpreter](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)
```

**免責聲明**:
本文件是使用機器翻譯人工智能服務進行翻譯的。我們雖然努力確保準確性，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文文件作為權威來源。對於關鍵信息，建議尋求專業人工翻譯。我們對因使用本翻譯而產生的任何誤解或錯誤解讀概不負責。


# 主動式 RAG

本課程為你提供一個全面的介紹，了解主動式檢索增強生成（Agentic RAG），這是一種新興的人工智能模式，讓大型語言模型（LLMs）能自主規劃下一步行動，同時從外部數據源獲取資訊。與傳統的靜態檢索-閱讀模式不同，主動式 RAG 涉及到多次迭代地調用 LLM，穿插使用工具或函數調用，並生成結構化的輸出。系統會評估結果，改進查詢，必要時調用額外工具，並重複這個過程，直到找到滿意的解決方案為止。

## 課程介紹

本課程將涵蓋以下內容：

- **理解主動式 RAG：** 學習這種新興的 AI 模式，讓大型語言模型（LLMs）能自主規劃下一步行動，同時從外部數據源中提取資訊。
- **掌握迭代式 Maker-Checker 模式：** 理解這種迭代調用 LLM 的循環過程，穿插工具或函數調用和結構化輸出，旨在提升正確性並處理不良查詢。
- **探索實際應用：** 確定主動式 RAG 的適用場景，例如以正確性為優先的環境、複雜的數據庫交互以及長期工作流程。

## 學習目標

完成本課程後，你將了解以下內容：

- **理解主動式 RAG：** 學習這種新興的 AI 模式，讓大型語言模型（LLMs）能自主規劃下一步行動，同時從外部數據源中提取資訊。
- **迭代式 Maker-Checker 模式：** 掌握這種迭代調用 LLM 的概念，穿插工具或函數調用和結構化輸出，旨在提升正確性並處理不良查詢。
- **掌控推理過程：** 理解系統如何自主掌控推理過程，決定如何處理問題，而不是依賴預定的路徑。
- **工作流程：** 理解主動模型如何自主決定檢索市場趨勢報告、識別競爭對手數據、關聯內部銷售數據、綜合結論並評估策略。
- **迭代循環、工具整合與記憶：** 學習系統如何依賴迴圈交互模式，跨步驟維持狀態和記憶，避免重複循環並做出更明智的決策。
- **處理失敗模式與自我糾正：** 探索系統的自我糾正機制，包括迭代與重新查詢、使用診斷工具以及在必要時依賴人工監督。
- **代理邊界：** 理解主動式 RAG 的限制，聚焦於特定領域的自主性、基礎設施依賴性以及遵守安全規範。
- **實際使用案例與價值：** 確定主動式 RAG 的適用場景，例如以正確性為優先的環境、複雜的數據庫交互以及長期工作流程。
- **治理、透明性與信任：** 學習治理與透明性的必要性，包括可解釋的推理、偏見控制以及人工監督。

## 什麼是主動式 RAG？

主動式檢索增強生成（Agentic RAG）是一種新興的 AI 模式，讓大型語言模型（LLMs）能自主規劃下一步行動，同時從外部數據源中提取資訊。與靜態的檢索-閱讀模式不同，主動式 RAG 涉及到多次迭代地調用 LLM，穿插工具或函數調用和結構化輸出。系統會評估結果，改進查詢，必要時調用額外工具，並重複這個過程，直到找到滿意的解決方案為止。

這種迭代的 “Maker-Checker” 操作方式提升了正確性，能處理結構化數據庫（例如 NL2SQL）中的不良查詢，並確保高質量的結果。系統主動掌控其推理過程，能重寫失敗的查詢，選擇不同的檢索方法，並整合多種工具，例如 Azure AI Search 的向量檢索、SQL 數據庫或自定義 API，在最終給出答案之前。主動式系統的顯著特點是它能掌控推理過程。傳統的 RAG 實現依賴於預定的路徑，而主動式系統能自主根據所獲得的資訊質量來決定步驟順序。

## 定義主動式檢索增強生成（Agentic RAG）

主動式檢索增強生成（Agentic RAG）是一種新興的 AI 開發模式，讓 LLMs 不僅能從外部數據源中提取資訊，還能自主規劃下一步行動。與靜態的檢索-閱讀模式或精心設計的提示序列不同，主動式 RAG 涉及到一個迭代循環，調用 LLM，穿插工具或函數調用和結構化輸出。每一步，系統都會評估已獲得的結果，決定是否需要改進查詢，必要時調用額外工具，並持續這個循環，直到找到滿意的解決方案。

這種迭代的 “Maker-Checker” 操作方式旨在提升正確性，處理結構化數據庫（例如 NL2SQL）中的不良查詢，並確保平衡且高質量的結果。系統不僅依賴於精心設計的提示鏈，還能主動掌控推理過程。它能重寫失敗的查詢，選擇不同的檢索方法，並整合多種工具，例如 Azure AI Search 的向量檢索、SQL 數據庫或自定義 API，在最終給出答案之前。這消除了對過於複雜的編排框架的需求。相反，一個相對簡單的循環 “LLM 調用 → 工具使用 → LLM 調用 → …” 就能產生精細且有根據的輸出。

![Agentic RAG 核心循環](../../../translated_images/agentic-rag-core-loop.2224925a913fb3439f518bda61a40096ddf6aa432a11c9b5bba8d0d625e47b79.hk.png)

## 掌控推理過程

讓系統成為 “主動式” 的關鍵特質在於它能掌控推理過程。傳統的 RAG 實現通常依賴於人類預先定義的模型路徑：一條明確的思路，指導模型應該檢索什麼以及何時檢索。但當系統真正實現主動性時，它能內部決定如何處理問題。這不僅僅是執行一個腳本，而是自主根據所找到的資訊質量決定步驟順序。

例如，如果被要求制定一個產品上市策略，主動式模型不會僅僅依賴於一個明確指出整個研究和決策流程的提示。相反，主動模型會自主決定：

1. 使用 Bing Web Grounding 檢索當前市場趨勢報告。
2. 使用 Azure AI Search 識別相關的競爭對手數據。
3. 使用 Azure SQL Database 關聯歷史內部銷售數據。
4. 通過 Azure OpenAI Service 將發現綜合成一個連貫的策略。
5. 評估該策略是否存在差距或不一致之處，必要時啟動另一輪檢索。

所有這些步驟——改進查詢、選擇來源、迭代直到對答案“滿意”——都是由模型決定的，而不是由人類預先編寫的腳本。

## 迭代循環、工具整合與記憶

![工具整合架構](../../../translated_images/tool-integration.7b05a923e3278bf1fd2972faa228fb2ac725f166ed084362b031a24bffd26287.hk.png)

主動式系統依賴於一個迴圈交互模式：

- **初始調用：** 用戶的目標（即用戶提示）被呈現給 LLM。
- **工具調用：** 如果模型發現資訊不足或指令不明確，它會選擇一個工具或檢索方法，例如向量數據庫查詢（如 Azure AI Search 的混合檢索私有數據）或結構化 SQL 調用，以獲取更多上下文。
- **評估與改進：** 在審查返回的數據後，模型會決定該資訊是否足夠。如果不夠，它會改進查詢，嘗試不同的工具或調整方法。
- **重複直到滿意：** 這個循環會持續進行，直到模型認為它有足夠的清晰度和證據來提供最終的、經過深思熟慮的回應。
- **記憶與狀態：** 系統會在各步驟間維持狀態和記憶，因此能回憶起先前的嘗試及其結果，避免重複循環並在過程中做出更明智的決策。

隨著時間的推移，這種方式會創造一種不斷演進的理解，讓模型能在沒有人工持續干預或重塑提示的情況下，完成複雜的多步驟任務。

## 處理失敗模式與自我糾正

主動式 RAG 的自主性還包含了強大的自我糾正機制。當系統遇到瓶頸（例如檢索到不相關的文件或遇到不良查詢）時，它可以：

- **迭代與重新查詢：** 與其返回低價值的回應，模型會嘗試新的搜索策略，重寫數據庫查詢或尋找替代數據集。
- **使用診斷工具：** 系統可能調用額外的功能來幫助其調試推理步驟或確認檢索數據的正確性。像 Azure AI Tracing 這樣的工具對於實現強大的可觀測性和監控至關重要。
- **依賴人工監督：** 對於高風險或持續失敗的場景，模型可能會標記不確定性並請求人工指導。一旦人類提供了糾正意見，模型可以將其納入以後的學習。

這種迭代和動態的方法讓模型能不斷改進，確保它不僅僅是一個一次性的系統，而是一個在特定會話期間從錯誤中學習的系統。

![自我糾正機制](../../../translated_images/self-correction.3d42c31baf4a476bb89313cec58efb196b0e97959c04d7439cc23d27ef1242ac.hk.png)

## 主動性邊界

儘管在任務內部具備自主性，主動式 RAG 並不等同於通用人工智能。它的“主動性”能力局限於人類開發者提供的工具、數據源和政策。它無法創建自己的工具，也無法超出設定的領域範圍。相反，它在動態協調現有資源方面表現出色。

主要與更高級 AI 形式的區別包括：

1. **領域特定的自主性：** 主動式 RAG 系統專注於在已知領域內實現用戶定義的目標，通過查詢重寫或工具選擇等策略來改善結果。
2. **依賴基礎設施：** 系統的能力取決於開發者整合的工具和數據。沒有人工干預，它無法超越這些邊界。
3. **遵守安全規範：** 道德指導方針、合規規則和商業政策仍然非常重要。代理的自由度始終受到安全措施和監督機制的約束（希望如此）。

## 實際使用案例與價值

主動式 RAG 在需要迭代改進和精準度的場景中表現出色：

1. **正確性優先的環境：** 在合規檢查、法規分析或法律研究中，主動模型可以反覆驗證事實，查閱多個來源，並重寫查詢，直到產生經過徹底驗證的答案。
2. **複雜的數據庫交互：** 在處理結構化數據時，查詢可能經常失敗或需要調整，系統可以自主使用 Azure SQL 或 Microsoft Fabric OneLake 改進查詢，確保最終檢索符合用戶意圖。
3. **長期工作流程：** 當新的資訊不斷出現時，長期會話可能會發生變化。主動式 RAG 可以持續整合新數據，隨著對問題空間的理解加深而調整策略。

## 治理、透明性與信任

隨著這些系統在推理方面變得越來越自主，治理和透明性至關重要：

- **可解釋的推理：** 模型可以提供查詢記錄、所查閱的來源以及其得出結論的推理步驟。像 Azure AI Content Safety 和 Azure AI Tracing / GenAIOps 這樣的工具可以幫助保持透明性並降低風險。
- **偏見控制與平衡檢索：** 開發者可以調整檢索策略，確保考慮到平衡且具有代表性的數據來源，並定期審核輸出以檢測偏見或不均衡模式，使用 Azure Machine Learning 為進階數據科學組織提供自定義模型。
- **人工監督與合規性：** 對於敏感任務，人工審查仍然是必要的。主動式 RAG 並不會取代高風險決策中的人類判斷，而是通過提供經過更徹底驗證的選項來輔助人類。

擁有能提供清晰行動記錄的工具至關重要。沒有這些工具，調試多步驟過程可能會非常困難。以下是 Literal AI（Chainlit 背後的公司）提供的 Agent 運行範例：

![AgentRunExample](../../../translated_images/AgentRunExample.27e2df23ad898772d1b3e7a3e3cd4615378e10dfda87ae8f06b4748bf8eea97d.hk.png)

![AgentRunExample2](../../../translated_images/AgentRunExample2.c0e8c78b1f2540a641515e60035abcc6a9c5e3688bae143eb6c559dd37cdee9f.hk.png)

## 結論

主動式 RAG 代表了 AI 系統在處理複雜且數據密集型任務方面的一種自然進化。通過採用迴圈交互模式，自主選擇工具，並改進查詢直到達成高質量結果，系統超越了靜態的提示執行，成為更具適應性和上下文感知的決策者。儘管仍受限於人類定義的基礎設施和道德指導方針，但這些主動性能力使企業和最終用戶能夠享受到更豐富、更動態、也更有用的 AI 互動。

## 其他資源

- 使用 Azure OpenAI Service 實現檢索增強生成（RAG）：學習如何使用自己的數據與 Azure OpenAI Service。[這個 Microsoft Learn 模組提供了實現 RAG 的全面指南](https://learn.microsoft.com/training/modules/use-own-data-azure-openai)
- 使用 Azure AI Foundry 評估生成式 AI 應用：本文涵蓋了基於公開數據集的模型評估與比較，包括[主動式 AI 應用和 RAG 架構](https://learn.microsoft.com/azure/ai-studio/concepts/evaluation-approach-gen-ai)
- [什麼是主動式 RAG | Weaviate](https://weaviate.io/blog/what-is-agentic-rag)
- [主動式 RAG：一份關於基於代理的檢索增強生成的完整指南 – generation RAG 的新聞](https://ragaboutit.com/agentic-rag-a-complete-guide-to-agent-based-retrieval-augmented-generation/)
- [主動式 RAG：使用查詢重構和自查詢為你的 RAG 提速！ Hugging Face 開源 AI 手冊](https://huggingface.co/learn/cookbook/agent_rag)
- [為 RAG 添加主動層](https://youtu.be/aQ4yQXeB1Ss?si=2HUqBzHoeB5tR04U)
- [知識助理的未來：Jerry Liu](https://www.youtube.com/watch?v=zeAyuLc_f3Q&t=244s)
- [如何構建主動式 RAG 系統](https://www.youtube.com/watch?v=AOSjiXP1jmQ)
- [使用 Azure AI Foundry Agent Service 擴展你的 AI 代理](https://ignite.microsoft.com/sessions/BRK102?source=sessions)

### 學術論文

- [2303.17651 Self-Refine: Iterative Refinement with Self-Feedback](https://arxiv.org/abs/2303.17651)
- [2303.11366 Reflexion: Language Agents with Verbal Reinforcement Learning](https://arxiv.org/

**免責聲明**:
此文件使用機器人工智能翻譯服務進行翻譯。雖然我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。應以原文作為權威來源。對於關鍵信息，建議尋求專業人工翻譯。我們對因使用此翻譯而引起的任何誤解或錯誤解釋概不負責。


# 建立值得信賴的人工智能代理

## 簡介

本課程將涵蓋：

- 如何構建和部署安全且有效的人工智能代理
- 開發人工智能代理時的重要安全考量
- 如何在開發人工智能代理時維護數據和用戶隱私

## 學習目標

完成本課程後，您將能夠：

- 識別並減輕創建人工智能代理時的風險
- 實施安全措施，確保數據和訪問得到妥善管理
- 創建能維護數據隱私並提供優質用戶體驗的人工智能代理

## 安全性

首先，我們來探討如何構建安全的代理應用程序。安全性意味著人工智能代理按照設計執行。作為代理應用程序的開發者，我們擁有一些方法和工具來最大化安全性：

### 構建元提示系統

如果您曾經使用大型語言模型（LLMs）構建人工智能應用程序，那麼您應該知道設計一個健全的系統提示或系統消息有多麼重要。這些提示確立了元規則、指令和指南，指導LLM如何與用戶和數據互動。

對於人工智能代理來說，系統提示更加重要，因為這些代理需要非常具體的指令來完成我們為其設計的任務。

為了創建可擴展的系統提示，我們可以使用元提示系統來構建我們應用中的一個或多個代理：

![構建元提示系統](../../../translated_images/building-a-metaprompting-system.aa7d6de2100b0ef48c3e1926dab6903026b22fc9d27fc4327162fbbb9caf960f.hk.png)

#### 第一步：創建元提示或模板提示

元提示將由LLM用於生成我們創建的代理的系統提示。我們將其設計為模板，以便在需要時能有效地創建多個代理。

以下是一個我們會給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.
```

#### 第二步：創建基本提示

下一步是創建一個基本提示來描述人工智能代理。您應該包括代理的角色、代理將完成的任務以及代理的其他職責。

以下是一個示例：

```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.
```

#### 第三步：向LLM提供基本提示

現在，我們可以將元提示作為系統提示，並提供我們的基本提示來優化這個過程。

這將生成一個更適合指導我們人工智能代理的提示：

```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.

```

#### 第四步：迭代和改進

這個元提示系統的價值在於能夠更輕鬆地擴展多個代理的提示創建，同時隨著時間推移改進您的提示。很少有提示能在第一次就完全適用於您的全部使用場景。通過更改基本提示並運行它來進行小的調整和改進，您將能夠比較和評估結果。

## 理解威脅

要構建值得信賴的人工智能代理，理解並減輕對人工智能代理的風險和威脅至關重要。我們來看看人工智能代理面臨的一些不同威脅，以及如何更好地計劃和準備應對這些威脅。

![理解威脅](../../../translated_images/understanding-threats.f8fbe6fe11e025b3085fc91e82d975937ad1d672260a2aeed40458aa41798d0e.hk.png)

### 任務和指令

**描述：** 攻擊者試圖通過提示或操縱輸入來更改人工智能代理的指令或目標。

**緩解措施：** 執行驗證檢查和輸入過濾器，以在AI代理處理之前檢測潛在的危險提示。由於這些攻擊通常需要與代理頻繁交互，限制對話輪次也是防止此類攻擊的一種方法。

### 訪問關鍵系統

**描述：** 如果人工智能代理可以訪問存儲敏感數據的系統和服務，攻擊者可能會破壞代理與這些服務之間的通信。這些可能是直接攻擊，也可能是通過代理間接獲取這些系統信息的嘗試。

**緩解措施：** 人工智能代理應僅基於需要訪問系統，以防止此類攻擊。代理與系統之間的通信也應該是安全的。實施身份驗證和訪問控制是保護這些信息的另一種方法。

### 資源和服務過載

**描述：** 人工智能代理可以訪問不同的工具和服務來完成任務。攻擊者可能利用這一能力，通過人工智能代理發送大量請求來攻擊這些服務，可能導致系統故障或高成本。

**緩解措施：** 實施策略以限制人工智能代理向服務發出的請求數量。限制與人工智能代理的對話輪次和請求次數是防止此類攻擊的另一種方法。

### 知識庫污染

**描述：** 這種攻擊不是直接針對人工智能代理，而是針對代理將使用的知識庫和其他服務。這可能涉及破壞代理將用於完成任務的數據或信息，導致對用戶的偏頗或非預期回應。

**緩解措施：** 定期驗證人工智能代理在工作流中使用的數據。確保對這些數據的訪問是安全的，並且只有受信任的人員才能更改，以避免此類攻擊。

### 錯誤傳播

**描述：** 人工智能代理訪問各種工具和服務來完成任務。攻擊者引發的錯誤可能導致與人工智能代理連接的其他系統失效，使攻擊範圍擴大且更難排查。

**緩解措施：** 一種避免此問題的方法是讓人工智能代理在受限環境中運行，例如在Docker容器中執行任務，以防止直接系統攻擊。創建回退機制和重試邏輯，當某些系統響應錯誤時，可以防止更大範圍的系統故障。

## 人工參與流程

另一種構建值得信賴的人工智能代理系統的有效方法是使用人工參與流程。這創建了一個流程，用戶可以在代理運行過程中提供反饋。用戶本質上成為多代理系統中的一個代理，通過批准或終止運行過程來進行干預。

![人工參與流程](../../../translated_images/human-in-the-loop.e9edbe8f6d42041b4213421410823250aa750fe8bdba5601d69ed46f3ff6489d.hk.png)

以下是使用AutoGen展示如何實現這一概念的代碼片段：

```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)

```

**免責聲明**:
本文件使用機器翻譯人工智能服務進行翻譯。我們致力於提供準確的翻譯，但請注意，自動翻譯可能包含錯誤或不準確之處。原始語言的文件應被視為權威來源。對於關鍵信息，建議使用專業的人手翻譯。我們對因使用本翻譯而引起的任何誤解或錯誤解釋不承擔責任。