Implémentation en Python d'un agent IA

Avant de plonger dans le code, établissons une compréhension claire : considérez un Agent IA comme unprogramme intelligent avec un cerveau, des mains et des pieds。

  • Cerveau (noyau): aqui peut comprendre, raisonner et prendre des décisionsmodèle (par ex., grand modèle de langage LLM). Il est responsable du traitement des informations et de l'élaboration de plans.
  • Perception (entrée): L'Agent obtient des informations externes par ses sens, telles que des instructions utilisateur, des résultats de requêtes de base de données, du contenu web, des données de capteurs, etc.
  • Action (sortie): L'Agent agit sur le monde extérieur par ses mains et ses pieds, par exemple, appeler une fonction, envoyer un e-mail, afficher du texte à l'écran, contrôler un bras robotique, etc.
  • Objectif: Tous les comportements de l'Agent s'articulent autour d'unobjectifclair qui se déploie, par exemple : aide-moi à vérifier la météo de demain à Pékin.

Son flux de travail central est une boucle classiquePerception-Réflexion-Action, comme le montre la figure ci-dessous :


Cas de test simple

agent-demo/
  agent.py        # 主实现(下面给出)
  tools.py        # 工具实现(可单独文件)
  memory.py       # 简单记忆实现(可单独文件)
  README.md

Exemple

"""
agent.py - Prototype minimal d'Agent IA (peut être exécuté directement)
Explication :
- La partie LLM est simulée par un "répondeur basé sur des règles" très simple ; lors d'une connexion réelle à un LLM, remplacez LLMInterface.generate(...)
- Composants : abstraction LLM, cerveau (analyse/décision), planificateur, registre d'outils, mémoire, exécuteur
"""


from typing import Any, Dict, List, Callable
import time

# -----------------------------
# Mémoire (très légère)
# -----------------------------
class Memory:
    def __init__(self):
        self.short = {}   # Contexte de conversation actuel
        self.long = {}    # Préférences/contacts à long terme, etc.

    def get_short(self, k, default=None):
        return self.short.get(k, default)

    def set_short(self, k, v):
        self.short[k] = v

    def get_long(self, k, default=None):
        return self.long.get(k, default)

    def set_long(self, k, v):
        self.long[k] = v

# -----------------------------
# Abstraction LLM (point de remplacement)
# -----------------------------
class LLMInterface:
    def generate(self, prompt: str) -> str:
        """
Ici, nous fournissons un répondeur simulé très simple basé sur des règles.
En utilisation réelle : remplacez par du code d'appel à OpenAI/à un autre modèle, et renvoyez le texte du modèle.
        """

        # Exemple d'analyse minimal : identifier si nous devons déterminer "pluie"
        if "s'il pleut" in prompt or "pluie" in prompt:
            return "Veuillez d'abord interroger la météo ; s'il va pleuvoir, générez un rappel et envoyez-le au contact cible."
        if "Générer un rappel" in prompt:
            return "Veuillez rappeler à Xiao Wang : il pleuvra à Pékin demain, veuillez apporter un parapluie."
        return "Je comprends."

# -----------------------------
# Enregistrement des outils et outils simulés
# -----------------------------
class ToolRegistry:
    def __init__(self):
        self.tools: Dict[str, Callable[..., Any]] = {}

    def register(self, name: str, fn: Callable[..., Any]):
        self.tools[name] = fn

    def call(self, name: str, *args, **kwargs):
        if name not in self.tools:
            raise ValueError(f"Outil non enregistré : {name}")
        return self.tools[name](*args, **kwargs)

# Outil simulé : requête météo (dans des situations réelles, une API météo serait appelée)
def mock_weather_api(city: str, date: str) -> Dict[str, Any]:
    # Règle simple : si city contient "Beijing" et date contient "tomorrow", renvoyer un exemple de pluie
    if "Beijing" in city and "tomorrow" in date:
        return {"city": city, "date": date, "cond": "rain", "precip_mm": 5}
    return {"city": city, "date": date, "cond": "sunny", "precip_mm": 0}

# Outil simulé : envoyer un message (dans des situations réelles, SMS/e-mail/WeCom, etc. seraient appelés)
def mock_send_message(contact: str, message: str) -> bool:
    print(f"[Envoyer un message] à={contact} message={message}")
    return True

# Outil simulé : recherche simple (illustrative)
def mock_search(query: str) -> str:
    return f"Résultat de recherche simulé : résumé d'informations sur `{query}`."

# -----------------------------
# Planificateur / Exécuteur
# -----------------------------
class SimplePlanner:
    def plan(self, goal: str) -> List[Dict[str, Any]]:
        """
Décomposer l'objectif en une liste d'étapes (une implémentation très simplifiée)
Chaque étape contient : action (nom d'outil ou action interne), params
        """

        steps = []
        # Exemple : si le prompt contient "weather", générer deux étapes : interroger la météo, décider s'il faut envoyer un rappel
        if "weather" in goal or "rain" in goal:
            steps.append({"action": "query_weather", "params": {"city": "Beijing", "date": "tomorrow"}})
            steps.append({"action": "decide_and_notify", "params": {"contact_name": "Xiao Wang"}})
        else:
            steps.append({"action": "search", "params": {"query": goal}})
        return steps

class Executor:
    def __init__(self, tools: ToolRegistry, memory: Memory, llm: LLMInterface):
        self.tools = tools
        self.memory = memory
        self.llm = llm

    def run_step(self, step: Dict[str, Any]):
        action = step["action"]
        params = step.get("params", {})
        if action == "query_weather":
            res = self.tools.call("weather", params["city"], params["date"])
            self.memory.set_short("last_weather", res)
            return res
        if action == "decide_and_notify":
            weather = self.memory.get_short("last_weather", {})
            # Décision par règle simple
            if weather.get("cond") == "rain":
                # Laisser le LLM générer le texte du rappel (exemple)
                prompt = f"D'après les informations météo : {weather}, générez un rappel pour {params['contact_name']}."
                reminder = self.llm.generate(prompt)
                # Obtenir les informations de contact depuis la mémoire à long terme
                contact = self.memory.get_long(params["contact_name"]) ou "13800000000"
                ok = self.tools.call("send_message", contact, reminder)
                return {"notified": ok, "message": reminder}
            else:
                return {"notified": False, "reason": "temps ensoleillé"}
        if action == "search":
            return self.tools.call("search", params["query"])
        raise ValueError(f"Action inconnue : {action}")

# -----------------------------
# Cœur de l'agent
# -----------------------------
class SimpleAgent:
    def __init__(self):
        self.memory = Memory()
        self.tools = ToolRegistry()
        self.llm = LLMInterface()
        self.planner = SimplePlanner()
        self.executor = Executor(self.tools, self.memory, self.llm)
        # Enregistrer les outils par défaut
        self.tools.register("weather", mock_weather_api)
        self.tools.register("send_message", mock_send_message)
        self.tools.register("search", mock_search)
        # Supposons que les informations de contact de Xiao Wang soient stockées dans la mémoire à long terme
        self.memory.set_long("Xiao Wang", "13911112222")

    def handle(self, user_prompt: str):
        # 1) Analyse du cerveau (abstraite avec LLM)
        intent = self.llm.generate(user_prompt)
        # 2) Planification
        steps = self.planner.plan(user_prompt)
        # 3) Exécution étape par étape
        results = []
        for step in steps:
            r = self.executor.run_step(step)
            results.append({"step": step, "result": r})
        # 4) Fusion des sorties
        return {"intent": intent, "steps": results}

# -----------------------------
# Exemple d'exécution
# -----------------------------
if __name__ == "__main__":
    agent = SimpleAgent()
    task = Vérifie la météo de demain à Pékin ; s'il pleut, écris-moi un rappel et envoie-le à Xiao Wang.
    out = agent.handle(task)
    import json
    print(json.dumps(out, ensure_ascii=False, indent=2))

Description:

  1. Abstraction du LLM:LLMInterface.generate()C'est un point remplaçable. Remplacez simplement ceci par du code qui se connecte à OpenAI, Claude ou à un LLM local.
  2. PlanificateurResponsable de décomposer des objectifs en langage naturel en étapes ordonnées. Pour les débutants, vous pouvez utiliser des règles ou des gabarits ; pour un usage avancé, vous pouvez demander à un LLM de produire des étapes et de les analyser pour les transformer en actions.
  3. Couche des outilsChaque outil est une fonction indépendante, uniformément enregistrée auprès deToolRegistryDans de vrais projets, il peut s'agir de requêtes HTTP, d'appels SDK, de lectures/écritures de base de données, etc.
  4. Mémoire: Distinguer court terme/long terme. Le court terme est utilisé pour les résultats intermédiaires de la tâche en cours, le long terme est utilisé pour les contacts, les préférences, etc.
  5. ExécuteurAssocier les étapes aux appels d'outils et gérer les valeurs de retour, les échecs et la logique de nouvelle tentative.

Construisez votre premier agent IA : Assistant de planification de tâches

Nous allons construire unassistant de planification de tâchesSon objectif est : à partir d'une tâche complexe donnée par l'utilisateur (par exemple, je veux voyager), la décomposer automatiquement en une série d'étapes spécifiques ordonnées et exécutables.

La structure du répertoire est la suivante :

Étape 1 : Construire le cerveau intelligent

Le cerveau de l'Agent a besoin de capacités de raisonnement. Nous utiliserons le modèle GPT d'OpenAI (via des appels API) comme cerveau de notre Agent.

Vous devez préparer une clé API OpenAI. Vous pouvez également utiliser la clé API de DeepSeek ; elle est compatible.

Les exemples de test de ce chapitre utilisent la clé API de DeepSeek. Nous pouvons d'abord aller surhttps://platform.deepseek.com/api_keyspour faire une demande.

Vous pouvez également utiliser directement les forfaits Coding Plan de Bailian et Ark :https://www.example.com/claude-code/coding-plan.html。

Tout d'abord, installez les bibliothèques nécessaires :

pip3 install openai

Vous pouvez utiliser le code suivant pour tester s'il s'exécute correctement :

Exemple

import os
from openai import OpenAI


DEEPSEEK_API_KEY = "sk-xxxxxxx"  # Définissez ici la clé que vous avez demandée
DEEPSEEK_API_URL = "https://api.deepseek.com/v1"

client = OpenAI(
    api_key = DEEPSEEK_API_KEY,
    base_url = DEEPSEEK_API_URL)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable"},
        {"role": "user", "content": "Bonjour"},
    ],
    stream=False
)

print(response.choices[0].message.content)

Si l'installation et la configuration réussissent, la sortie ressemblera à ce qui suit :

Hello! How can I assist you today?

Ensuite, créons le module de cerveau le plus simple :

code du fichier brain.py

# brain.py
from openai import OpenAI
import os


DEEPSEEK_API_KEY = "sk-xxxxxxx"  # Définissez ici la clé que vous avez demandée
DEEPSEEK_API_URL = "https://api.deepseek.com/v1"

client = OpenAI(
    api_key = DEEPSEEK_API_KEY,
    base_url = DEEPSEEK_API_URL)

class AgentBrain:
    Cerveau de l'agent, responsable de la réflexion et de la prise de décision
   
    def __init__(self, model="deepseek-v4-flash"):
        self.model = model
   
    def think(self, prompt):
        Fonction de réflexion centrale : reçoit un prompt et renvoie le résultat de réflexion du modèle
        try:
            # Appel de l'API Chat Completions à l'aide du client (syntaxe de la version v1.x)
            response = client.chat.completions.create(
                model=self.model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0.5,  # Contrôler la créativité, plus la valeur est faible, plus le résultat est ciblé
                max_tokens=500    # Contrôler la longueur de la réponse
            )
            # Extraire le contenu textuel renvoyé par le modèle (changement du chemin d'attribut dans la version v1.x)
            reasoning = response.choices[0].message.content
            return reasoning.strip()
        except Exception as e:
            return f"Erreur du processus de réflexion : {e}"

# Test rapide pour voir si le cerveau fonctionne
if __name__ == "__main__":
    brain = AgentBrain()
    test_prompt = "Bonjour, veuillez vous présenter brièvement."
    print("Question de test :", test_prompt)
    print("Réponse du cerveau :", brain.think(test_prompt))

En exécutant le code ci-dessus, la sortie est à peu près la suivante :

测试提问: 你好,请简单介绍一下你自己。
大脑回复: 你好!我是DeepSeek,由深度求索公司创造的AI助手,很高兴认识你!😊

让我简单介绍一下自己:

**我的特点:**
**完全免费**:目前没有任何收费计划,你可以放心使用
**知识丰富**:知识截止到2024年7月,涵盖各个领域
**对话能力强**:支持128K上下文,可以进行长篇深入对话

Explication du code:

  1. Nous avons créé uneAgentBrainclasse pour encapsuler l'interaction avec le LLM.
  2. thinkLa méthode est le cœur, elle reçoit une chaîneprompt(prompt) et l'envoie à l'API GPT.
  3. temperatureLe paramètre est très important : le définir à 0.5 permet à l'Agent de trouver un équilibre entre créativité et stabilité, adapté aux tâches de planification.
  4. Enfin, il renvoie le texte généré par le modèle, qui est le résultat de la réflexion de l'Agent.

Étape 2 : Définir les mains et les pieds : outils et actions

L'Agent a besoin d'une capacité d'exécution. Nous définissons quelques outils simples (fonctions) pour lui afin qu'il puisse agir.

Code du fichier tools.py

# tools.py
import datetime

class AgentTools:
    """Une collection d'outils que l'Agent peut utiliser"""
   
    @staticmethod
    def search_web(query):
        """Outil de recherche web simulé (simulé ici)"""
        mock_results = {
            "Recommandation de destination de voyage": "Paris, Tokyo, Maldives, Lijiang, Yunnan...",
            "Météo à Pékin": "Ensoleillé demain, température 15-25°C, légère brise.",
            "Tutoriel Python": "Recommander des sites web comme Rookie Tutorial."
        }
        for key, value in mock_results.items():
            if key in query:
                return f"[Recherche Web] Résultats pour '{query}' : {value}"
        return f"[Recherche Web] Aucune information claire trouvée pour '{query}'."
   
    @staticmethod
    def make_schedule(steps):
        """Outil de planification d'horaires"""
        schedule = "Planification générée :"\n"
        for i, step in enumerate(steps, 1):
            schedule += f"{i}. {step}"\n"
        return schedule
   
    @staticmethod
    def get_current_time():
        """Outil pour obtenir l'heure actuelle"""
        now = datetime.datetime.now()
        return f"[Heure système] Il est actuellement : {now.strftime('%Y-%m-%d %H:%M:%S')}"
   
    @staticmethod
    def calculate(expression):
        """Outil de calculatrice simple (version sécurisée, correction des problèmes de compatibilité)"""
        try:
            # 1. Filtrer strictement les caractères illégaux (autoriser uniquement les chiffres, les opérateurs de base, les parenthèses, les espaces)
            allowed_chars = set("0123456789+-*/(). ")
            if not all(c in allowed_chars for c in expression):
                return "[Calculatrice] L'expression contient des caractères illégaux, refus de calculer."
           
            # 2. Simplifier la validation de sécurité : supprimer la logique ast.walk sujette aux erreurs, utiliser plutôt une vérification syntaxique de base
            # Remplacer d'abord les espaces pour éviter les expressions vides
            clean_expr = expression.strip().replace(" ", "")
            if not clean_expr:
                return "[Calculatrice] L'expression ne peut pas être vide."
           
            # 3. Exécuter le calcul en toute sécurité (restreindre les fonctions intégrées, ne conserver que les opérations de base)
            # Définir un environnement global sécurisé personnalisé, n'autoriser que les opérations mathématiques de base
            safe_globals = {
                '__builtins__': {},
                'pow': pow,
                'abs': abs
            }
            # Utiliser eval tout en restreignant strictement l'environnement, et avec les caractères illégaux filtrés, ce qui réduit grandement le risque
            result = eval(clean_expr, safe_globals)
            return f"[Calculatrice] {expression} = {result}"
       
        except ZeroDivisionError:
            return "[Calculatrice] Erreur : le diviseur ne peut pas être zéro."
        except SyntaxError:
            return "[Calculatrice] Erreur de syntaxe de l'expression (par ex., parenthèses non appariées, erreurs d'opérateur)."
        except Exception as e:
            return f"[Calculatrice] Erreur de calcul : {str(e)}"

# Outil de test
if __name__ == "__main__":
    print(AgentTools.search_web("Météo à Pékin"))
    print(AgentTools.get_current_time())
    print(AgentTools.calculate("3 + 5 * 2"))       # Calcul normal
    print(AgentTools.calculate("10 / 0"))          # Erreur de division par zéro
    print(AgentTools.calculate("__import__('os').system('ls')"))  # Filtrage des caractères illégaux

Analyse de code:

  1. Chaque@staticmethoddéfinit un outil que l’Agent peut appeler.
  2. search_webActuellement simulé ; dans des scénarios réels, une véritable API de recherche doit être intégrée.
  3. make_scheduleUtilisé pour formater une liste de tâches en un plan.
  4. Remarque importante sur la sécurité:calculateDans l’outil,eval()la fonction est extrêmement dangereuse dans des produits réels et doit être remplacée par une approche plus sûre (telle queast.literal_eval) pour la remplacer ou la supprimer complètement. Ceci sert uniquement à démontrer comment l’Agent appelle des fonctions.

Étape 3 : Assembler l’Agent : implémenter la boucle principale

Maintenant, nous allons assembler le cerveau et les outils ensemble et implémenter la boucle de décision principale. Nous allons concevoir une règle simple : laisser le cerveau décider quel outil utiliser en fonction de la tâche.

Exemple

# agent.py
from brain import AgentBrain
from tools import AgentTools

class SimpleAgent:
    """Un agent IA simple de planification de tâches"""
   
    def __init__(self):
        self.brain = AgentBrain()
        # La classe d'outils statique n'a pas besoin d'être instanciée
        self.tools = AgentTools
        # Définir la liste des outils que l'Agent connaît et leurs descriptions, utilisées pour solliciter le cerveau
        self.tool_descriptions = """
Vous pouvez utiliser les outils suivants :
1. Outil de recherche : Utilisez-le lorsque vous devez obtenir les informations les plus récentes et inconnues, par exemple 'search Beijing weather'.
2. Outil de planification : Utilisez-le lorsque vous devez organiser plusieurs étapes en un plan, par exemple 'make plan [step1, step2]'.
3. Outil de temps : Utilisez-le lorsque vous devez connaître l'heure actuelle, la commande est 'get time'.
4. Outil de calcul : Utilisez-le lorsque vous devez effectuer des calculs mathématiques, par ex. 'calculez 3+5*2'.
        """

   
    def run(self, user_task):
        """Exécute la boucle principale de l'Agent"""
        print(f"🎯 Tâche utilisateur : {user_task}")
        print("=" * 40)
       
        # Étape 1 : Perception et réflexion préliminaire
        initial_prompt = f"""
Votre rôle est celui d'un assistant de planification de tâches.
        {self.tool_descriptions}
       
La tâche de l'utilisateur est : {user_task}
       
Veuillez répondre strictement dans le format fixe suivant, n'ajoutez aucun contenu supplémentaire :
Réflexion : [analysez brièvement ce que la tâche requiert]
Outil : [sélectionnez le nom de l'outil à utiliser ; si aucun ne convient, écrivez 'None']
Instruction : [le contenu spécifique de l'instruction envoyé à l'outil]
        """

       
        initial_response = self.brain.think(initial_prompt)
        print(🧠 Résultat initial de la réflexion :)
        print(initial_response)
        print("-" * 20)
       
        # Étape 2 : Analyser le résultat de la réflexion, extraire les outils et les instructions (optimisation de la robustesse)
        lines = [line.strip() for line in initial_response.split('\n') if line.strip()]
        tool_to_use = None
        tool_instruction = ""
       
        for line in lines:
            if line.startswith(Thinking:):
                continue  # Ignorer la ligne de réflexion
            elif line.startswith(Tool:):
                tool_to_use = line.replace(Tool:, "").strip()
            elif line.startswith(Instruction:):
                tool_instruction = line.replace(Instruction:, "").strip()
       
        # Étape 3 : Exécuter l'action
        result = self._use_tool(tool_to_use, tool_instruction)
        print(🛠️ Résultat de l'exécution :)
        print(result)
        print("=" * 40)
       
        # Étape 4 : Intégrer les résultats et fournir un retour à l'utilisateur
        final_prompt = f"""
Tâche originale de l'utilisateur : {user_task}
Vous avez déjà réfléchi et utilisé des outils.
Processus de réflexion : {initial_response}
Résultat de l'exécution de l'outil : {result}
       
Maintenant, veuillez générer une réponse finale complète à l'utilisateur, en fournissant directement une réponse ou un plan utile, dans un langage naturel et convivial.
        """

       
        final_response = self.brain.think(final_prompt)
        print(💡 Réponse finale à l'utilisateur :)
        print(final_response)
       
        return final_response
   
    def _use_tool(self, tool_name, instruction):
        """Appeler la fonction d'outil spécifique en fonction du nom de l'outil"""
        # Correspondance unifiée des noms d'outils (insensible à la casse / tolérante aux espaces supplémentaires)
        tool_name = tool_name.strip()
       
        if tool_name == Search tool:
            return self.tools.search_web(instruction)
        elif tool_name == Planning tool:
            # Compatible avec les virgules et parenthèses chinoises/anglaises, gérer les instructions vides
            if not instruction:
                return [Planning tool] Aucune étape de planification fournie, impossible de générer le planning.
            # Supprimer les crochets et séparer les étapes (compatible avec les crochets []/()/{})
            clean_instr = instruction.strip('[](){}').strip()
            # Prend également en charge la séparation par virgules chinoises et anglaises
            steps = [s.strip() for s in clean_instr.replace(',', ',').split(',') if s.strip()]
            return self.tools.make_schedule(steps)
        elif tool_name == Time tool:
            return self.tools.get_current_time()
        elif tool_name == Calculation tool:
            return self.tools.calculate(instruction)
        elif tool_name == None:
            return [Système] Pas besoin d'utiliser des outils, il suffit de répondre directement à l'utilisateur.
        else:
            return f[Système] Outil inconnu : {tool_name}, impossible d'exécuter.

# Exécuter notre agent !
if __name__ == "__main__":
    print(🤖 Démarrage de SimpleAgent...)
    my_agent = SimpleAgent()
   
    # Tester plusieurs tâches différentes
    test_tasks = [
        Je veux voyager, aidez-moi à planifier ce que je dois préparer,
        Quelle heure est-il maintenant ?,
        Calculez 15 au carré plus un tiers de 20,
    ]
   
    for task in test_tasks:
        my_agent.run(task)
        print("\n" + "#" * 50 + "\n")

Exécutez le code, produisez une sortie semblable à ce qui suit :

启动 SimpleAgent...
用户任务: 我想去旅行,帮我规划一下需要准备什么
========================================
初始思考结果:
思考:用户需要规划旅行前的准备工作。这是一个通用任务,不需要最新信息或计算,但需要将多个准备步骤整理成一个清晰的计划。

工具:计划工具

指令:制定计划 [1. 确定目的地和旅行时间,2. 预订交通票(机票/火车票)和住宿,3. 准备旅行证件(身份证、护照、签证等),4. 安排行程和景点门票,5. 打包行李(衣物、洗漱用品、药品、充电器等),6. 安排家中事务(宠物、植物、邮件等),7. 兑换货币或准备支付方式,8. 购买旅行保险]
--------------------
执行结果:
...

Flux d'analyse et d'exécution du code:

  1. Initialisation: L'agent a créé son propre cerveau (AgentBrain) et la boîte à outils (AgentTools)。
  2. Recevoir une tâche:runLa méthode démarre, reçoituser_task(par exemple, "Je veux voyager").
  3. Phase de réflexion: Combinez les descriptions de la tâche et de l'outil eninitial_prompt, envoyez au cerveau. Le texte renvoyé par le cerveau contient l'« outil » qu'il a sélectionné et les « instructions » données à l'outil.
  4. Phase d'action:_use_toolLa fonction appelle la fonction d'outil correspondante en fonction du choix du cerveau et renvoie le résultat.
  5. Retour d'information et résumé: Envoyez à nouveau la tâche d'origine, le processus de réflexion et les résultats des actions au cerveau, afin qu'il génère une réponse finale conviviale.

Exécutez ce programme et vous verrez comment l'Agent analyse les tâches étape par étape, sélectionne les outils, exécute et fournit des réponses.


Exercice pratique : Améliorez votre Agent

Vous avez déjà un Agent IA fonctionnel ! Mais ce n'est qu'un point de départ. Essayez de réaliser les exercices suivants pour le rendre plus puissant :

  1. Exercice 1 : Ajouter une fonction de mémoire

    • Objectif: Permettre à l'Agent de mémoriser l'historique de conversation.
    • Indice: Dans laSimpleAgentclasse, ajoutez unself.conversation_history = []liste. Chaque fois que vous appelezbrain.think, non seulement envoyez le prompt actuel, mais envoyez également l'historique de conversation précédent comme contexte. Après l'exécution, ajoutez le nouveau tour de conversation (entrée utilisateur, réflexion de l'IA, résultats d'outils) à la liste d'historique.
  2. Exercice 2 : Implémenter la sélection automatique d'outils

    • Objectif: Faire en sorte que la réponse du cerveau soit au format JSON standard pour faciliter l'analyse automatique par le programme, plutôt que de dépendre de l'extraction de texte.
    • Indice: Modifiez le prompt pour exiger que le cerveau renvoie une{"thought": "…", "tool": "…", "instruction": "…"}chaîne JSON. Ensuite, dans le code, utilisezjson.loads()pour analyser, ce qui améliore la stabilité et la précision.
  3. Exercice 3 : Ajouter un nouvel outil

    • Objectif: Permettre à l'Agent de gérer les tâches à faire.
    • Indice: Dans laAgentToolsclasse, ajouteztodo_list = []et deux nouvelles méthodes :add_todo(item)etshow_todos(). Dans la description de l'outil, informez le cerveau de ce nouvel outil, et mettez à jour le_use_toolméthode pour l'appeler.

Résumé et perspectives

Félicitations ! Vous avez construit avec succès un agent IA à cyclepercevoir-réfléchir-agirde base. Passons en revue les points clés :

  • Concepts clés: Agent IA = Cerveau (LLM) + Perception + Action + Objectif.
  • Clé de l'implémentation:
    1. Cerveau: Appeler le LLM (comme GPT) via l'API pour le raisonnement.
    2. Outils: Encapsuler des capacités spécifiques dans des fonctions que l'Agent peut appeler.
    3. Boucle: Utiliser une logique de code pour relier la réflexion, la prise de décision et l'exécution.

Ce n'est que la pointe de l'iceberg dans le monde des agents IA. Des frameworks de niveau industriel tels queLangChain、AutoGenoffrent une intégration d'outils plus puissante, une gestion de la mémoire, une collaboration multi-agents et d'autres fonctionnalités. Pour aller plus loin, il est recommandé de :

Autres extensions