Comment fonctionnent les agents IA

Avant d'approfondir les agents IA, répondons d'abord à une question fondamentale :Puisque nous avons déjà des LLM, pourquoi avons-nous encore besoin d'agents ?

Imaginez que vous avez un ami très cultivé — il a lu un nombre immense de livres et peut répondre à presque toutes les questions, mais depuis 2024, il n'a plus accès à de nouvelles informations, n'a pas de téléphone, ne peut pas se connecter à Internet, ne peut pas vous commander un plat à emporter, et ne peut pas consulter la météo d'aujourd'hui. C'est à cela que ressemble un grand modèle de langage (LLM) — riche en connaissances, maisles connaissances sont limitées aux données d'entraînement, et il ne peut pas obtenir de façon proactive des informations en temps réel ni effectuer des actions concrètes.

etAgent IAC'est comme doter cet ami de : un téléphone qui peut accéder à Internet, une calculatrice, un calendrier... afin qu'il puisse non seulement penser, mais aussivéritablement accomplir des choses. En combinant les LLM avec des outils et de la mémoire, l'Agent IA surmonte cette limite, atteignantl'unité de la pensée et de l'action。

Les trois composants essentiels d'un agent IA

Un agent IA typique possède trois éléments clés qui travaillent ensemble. Continuons avec l'analogie ci-dessus pour comprendre :

1. Le cerveau — Grand modèle de langage (LLM)

  • Rôle: le centre de décision et le moteur de raisonnement de l'Agent.
  • Fonction: comprend l'entrée de l'utilisateurl'objectifetle contexte, analyse la situation actuelle, puis décide quoi faire ensuite — répondre directement ou appeler un outil ? Il est responsable de la planification et de la décomposition de tâches complexes.
  • Analogie: tout comme le PDG d'une entrepriseou le commandant, responsable de la réflexion stratégique, de la planification des tâches et de l'émission d'ordres. Il sait quoi faire, mais a besoin d'outils pour le faire réellement.

2. Outils - Actions exécutables

  • Rôle: les mains et les pieds de l'Agent, une extension de ses capacités.
  • Fonction: fonctions concrètes ou API permettant à l'Agent d'interagir avec le monde extérieur. Par exemple :search_web(recherche web),execute_python_code(exécuter du code),read_file(lire des fichiers),send_email(envoyer des e-mails), etc.
  • Analogie: comme sur le bureau d'un employédivers logiciels et appareils de bureau, tels que Excel, navigateurs, téléphones et imprimantes. Le PDG (cerveau) donne des ordres, et les employés (outils) les exécutent.
  • Point clé: Sans outils, le LLM ne peut que parler ; avec des outils, l'Agent peut réellement agir.

3. Mémoire - Stockage des conversations et des expériences

  • Rôle: Enregistre le processus de travail, assurant la continuité des tâches.
  • Fonction：
    • Mémoire à court terme: Préserve l'historique de la conversation en cours, permettant à l'Agent de se souvenir de ce qui a été dit et fait. Tout comme lorsqu'on discute avec un ami, vous n'avez pas besoin de vous présenter à nouveau à chaque phrase.
    • Mémoire à long terme: Peut stocker des informations plus persistantes (par exemple, les préférences de l'utilisateur, les résultats historiques des tâches) pour référence dans de futures tâches. Comme avoir un profil utilisateur qui vous est dédié.
  • Analogie: comme lesnotes de travail et fichiers de projetd'un employé, évitant le travail répétitif et permettant à chaque tâche de se poursuivre à partir de l'expérience précédente.

💡 Résumé en une phrase: Le cerveau pense, les outils agissent, et la mémoire assure la continuité ; les trois sont indispensables.

Types d'agents IA

Selon différents objectifs de conception et niveaux de complexité, les agents IA peuvent être divisés en plusieurs types :

Type d'agent Caractéristiques Applications typiques
Agent réactif Réagit immédiatement en fonction de sa perception actuelle, sans maintenir d'état interne. Comme un agent du service client qui ne voit que le présent et ne se souvient pas du passé. Questions-réponses simples, IA de jeu
Agent basé sur des objectifs Planifie des actions autour d'objectifs spécifiques et évalue si les objectifs sont atteints. Comme un employé avec des KPI, qui sait ce qu'il fait et vers quel objectif il travaille. Assistants de tâches, flux de travail automatisés
Agent basé sur l'utilité Utilise une « fonction d'utilité » pour évaluer différentes actions possibles et choisir le plan optimal. Comme un décideur qui pèse le pour et le contre et poursuit la solution optimale. Optimisation des ressources, planification de trajectoire
Agent apprenant Peut apprendre de l'expérience et optimiser continuellement les stratégies de prise de décision. Plus il est utilisé, plus il devient intelligent, comme un employé qui examine diligemment son travail. Systèmes de recommandation, assistants personnalisés
Système multi-agents Plusieurs agents collaborent et se répartissent le travail, chacun jouant son propre rôle. Comme une équipe bien répartie où chaque personne s'occupe d'une partie. Décomposition de tâches complexes, collaboration d'équipe

Les débutants n'ont besoin de maîtriser d'abord que les deux premiers types ; ce sont les formes de base les plus courantes.

Flux de travail : la boucle ReAct

Après avoir compris la composition d'un Agent, la question suivante est : comment celafonctionne-t-il ??

Les Agents IA suivent généralement un paradigme appeléReAct = Reasoning + Acting, un paradigme de pensée classique. Comme son nom l'indique, il consiste àpenser d'abord, puis agir, puis penser, puis agir... Cette boucle se répète continuellement jusqu'à ce que la tâche soit terminée.

Vous pouvez le voir comme la façon dont travaille un nouvel employé consciencieux et responsable à qui l'on confie une tâche :"D'abord, je réfléchis à la façon de procéder → je vais chercher des informations → je regarde ce que j'ai trouvé → je réfléchis à l'étape suivante → je continue d'agir...", plutôt que d'agir imprudemment sur un coup de tête.

Visualisation SVG : organigramme de la boucle ReAct Outer loop Center: User User User Node 1: Think Think Reason LLM reasoning Node 2: Act Act Action Call tools Node 3: Observe Observe Observe Get result Node 4: Memory Memory Memory Store context Arrow Label 1. Generate plan 2. Execute action 3. Receive feedback 4. Update memory, continue reasoning

Utiliser un exemple complet pour parcourir cette boucle

L'utilisateur donne une commande à l'Agent :"Aide-moi à trouver un restaurant italien à Pékin avec une note supérieure à 4.5, et indique-moi son adresse et son plat signature."

Suivons maintenant pas à pas la "réflexion" de l'Agent :

Étape 1 : Réfléchir/Raisonner

  • Le cerveau analyse l'objectif: Le cerveau de l'Agent (LLM) reçoit cette tâche et organise d'abord dans son esprit :"Il s'agit d'une tâche de recherche d'informations qui nécessite deux types d'informations : ① trouver un restaurant qui correspond aux critères ; ② obtenir l'adresse et le plat signature. Je ne sais rien pour l'instant, je devrais donc d'abord chercher."
  • Générer une instruction d'action: Le cerveau décide :"Appelersearch_webl'outil, avec le mot-clé défini sur 'Restaurants italiens à Pékin avec une note supérieure à 4.5'."

💡 Remarque: À cette étape, l'Agent n'a encore "rien fait" ; il est simplement en train de "réfléchir". La valeur du LLM est démontrée ici — être capable de comprendre l'intention, de décomposer les tâches et d'établir des plans.

Étape 2 : Agir

  • Appeler l'outil: D'après la décision de l'étape précédente, l'Agent appelle réellementsearch_webl'outil, et transmet le mot-clé.
  • Exécution de l'outil: L'outil de recherche effectue une recherche sur Internet et renvoie un lot de résultats de recherche bruts (titres de pages web, extraits, liens, etc.).

💡 Remarque: L'outil lui-même ne « pense » pas ; il exécute simplement fidèlement. Penser est le travail du cerveau, exécuter est le travail de l'outil — une répartition claire des tâches.

Étape 3 : Observer

  • Recevoir le retour: L'Agent reçoit les résultats de recherche renvoyés par l'outil et les stocke dansla mémoirepour les utiliser lors du prochain cycle de raisonnement.
  • Supposons que les résultats incluent plusieurs restaurants : Bottega Yiku (note 4.7), Da Vittorio, Le Marche, etc.

Étape 4 : Réfléchir à nouveau

  • Le cerveau réanalyse: Après avoir vu les résultats de recherche, le cerveau poursuit son raisonnement :« OK, j'ai trouvé plusieurs restaurants candidats. Mais ce que l'utilisateur veut, c'est l'adresse et le plat signature, qui ne figurent pas dans les extraits de recherche. Je dois interroger plus en détail les informations de Bottega Yiku. »
  • Générer une nouvelle instruction：« Appelerget_restaurant_detailsl'outil pour interroger les informations détaillées de 'Bottega Yiku'.

Étape 5 : Agir à nouveau → Observer à nouveau (la boucle continue)

  • CetteRéfléchir → Agir → Observerboucle se répète sans cesse, et chaque tour rapproche l'Agent un peu plus de l'objectif, jusqu'à ce que le cerveau détermine que « j'ai déjà assez d'informations pour répondre à l'utilisateur ».

Étape 6 : Produire la réponse finale (Final Answer)

  • Lorsque le cerveau confirme que la tâche est terminée, il consolide toutes les informations collectées (stockées en mémoire) et génère une réponse structurée et conviviale :
  • « J'ai trouvé un restaurant qui répond aux exigences :Bottega Yiku(Note 4.7). Adresse : No. XX, Sanlitun Road, Chaoyang District, Beijing. Plats signature : pizza à la truffe noire, tiramisu fait main. »

CeRéfléchir → Agir → Observer → Réfléchir à nouveau...cycle est le mécanisme moteur central qui permet à un Agent IA d'accomplir de manière autonome des tâches complexes. Il ne donne pas une réponse d'un seul coup, mais, comme un humain,avance pas à pas, en réfléchissant tout en agissant.。

Implémenter un Agent IA en Python

La théorie est terminée ; passons maintenant au code. Un système d'Agent IA se compose généralement de plusieurs modules centraux qui travaillent ensemble. Comprendre cette architecture nous aide à comprendre comment il pense et agit.

Décomposons chaque module et utilisons un peu de code Python simple pour démontrer ses responsabilités. Les débutants n'ont pas besoin de se plonger dans chaque ligne de code ; l'essentiel est de comprendrece que fait chaque module。

1. Module de perception — Les « yeux et oreilles » de l'Agent

Le module de perception est chargé d'obtenir de l'environnementles informations, c'est-à-dire « quelle entrée a été reçue ». L'environnement peut être :

  • Monde numérique: un texte, une page web, des enregistrements de base de données, des données renvoyées par une API.
  • Monde physique(via le matériel) : images de caméra, audio de microphone, données de capteurs.

Pour l'Agent basé sur le texte le plus courant, la perception consiste à « recevoir une phrase de saisie utilisateur ».

Exemple

# Module de perception : responsable de la « réception » des informations externes
def perceive_from_environment():
    """
Percevoir les informations de l'environnement.
Dans cet exemple, l'environnement est le texte saisi par l'utilisateur dans la ligne de commande.
    """
    user_input = input("Veuillez saisir votre instruction ou votre question :")
    print(f"[Module de perception] Informations reçues : '{user_input}'")
    return user_input  # Transmettre le contenu perçu au module suivant (module de décision)

# Obtenir les informations perçues
current_observation = perceive_from_environment()

2. Module de décision (Cerveau) — Le "Commandant" de l'Agent

C'est le cœur de l'Agent, généralementun modèle d'IA (comme un grand modèle de langage, LLM)le pilote. Il reçoit les informations du module de perception et est responsable de trois choses :

  • Comprendre: Que signifie cette information ? Que veut l'utilisateur ?
  • Raisonner: Que dois-je faire dans les circonstances actuelles ?
  • Planifier: Quel outil faut-il appeler ensuite (ou dans les prochaines étapes), et quelle opération faut-il effectuer ?

Le code suivant utilise la plus simple des "correspondances de mots-clés" pour simuler le processus de décision. Dans un véritable Agent, cette étape est réalisée par un LLM, qui peut gérer une compréhension sémantique bien plus complexe.

Exemple

# Module de décision : responsable de la "réflexion" et de la "planification"
def make_decision(observation):
    """
Prendre des décisions simples en fonction des informations perçues.
Ici, la correspondance de mots-clés est utilisée pour simuler ; en pratique, le LLM effectue un raisonnement plus complexe.
    """
    print(f"[Module de décision] Analyse des informations : '{observation}'")
   
    # En fonction des mots-clés dans l'entrée utilisateur, déterminer quel outil appeler
    if "Météo" in observation:
        decision = "Invoquer l'outil de requête météo"
    elif "Calculer" in observation:
        decision = "Appeler l'outil de calcul"
    elif "Fin" in observation:
        decision = "Exécuter l'action de terminaison"
    else:
        decision = "Donner une réponse conversationnelle générique"  # Si aucun outil ne correspond, répondre directement dans la conversation
   
    print(f[Module de décision] Résultat de la décision : {decision})
    return decision  # Transmettre le résultat de la décision au module d'action

# Prendre des décisions en fonction de la perception
current_decision = make_decision(current_observation)

3. Module d'action — L'"Exécuteur" de l'agent

Le module de décision produit des "pensées" (ce qu'il faut faire), tandis que le module d'action est chargé de transformer les pensées en "réalité" (en les exécutant réellement). Il exécute des opérations spécifiques pour affecter l'environnement externe. Les actions courantes comprennent :

  • Actions numériques: Afficher des réponses à l'écran, appeler une fonction, effectuer une requête API, écrire dans un fichier.
  • Actions physiques(En contrôlant le matériel) : Contrôler le mouvement d'un bras robotisé, faire émettre un son à un haut-parleur.

Exemple

# Module d'action : responsable de l'"exécution" des instructions données par le module de décision
def execute_action(decision):
    """
Exécute les instructions données par le module de décision et renvoie le résultat de l'exécution.
Le résultat de l'exécution sera stocké en mémoire pour être utilisé lors du prochain cycle de raisonnement.
    """
    print(f[Module d'action] Exécution : {decision})
   
    if decision == "Invoquer l'outil de requête météo":
        # Ceci peut être remplacé par un véritable appel à l'API météo
        result = "Pékin : Ensoleillé, 25°C."
    elif decision == "Appeler l'outil de calcul":
        result = "1+1=2"
    elif decision == "Exécuter l'action de terminaison":
        result = “Tâche terminée.”
        print(result)
        exit()  # Terminer tout le programme
    else:
        result = fJ'ai compris votre intention : '{decision}'
   
    print(f[Module d'action] Résultat de l'action : {result})
    return result  # Retourner le résultat et entrer dans la phase "observation"

# Exécuter la décision et obtenir le résultat
action_result = execute_action(current_decision)

4. Module de mémoire — Les "notes de travail" de l'Agent

Sans mémoire, l'Agent serait dans un état "amnésique" à chaque réponse — oubliant ce que vous avez dit avant, et oubliant ce qu'il a lui-même fait. Le module de mémoire résout ce problème, et il se divise en deux types :

  • Mémoire à court terme / Historique de conversation: Enregistre ce qui a été dit dans la conversation en cours, ce qui permet à l'Agent de rester cohérent sur plusieurs tours. Tout comme lorsque vous discutez avec un ami, vous n'avez pas besoin de réexpliquer le contexte à chaque phrase.
  • Mémoire à long terme / Base de connaissances: Connaissances propriétaires stockées via des technologies telles que les bases de données vectorielles (par ex., documents internes de l'entreprise, préférences utilisateur), utilisées pour améliorer les capacités du modèle. Les débutants peuvent temporairement ignorer cette partie et se concentrer d'abord sur la maîtrise de la mémoire à court terme.

Dans l'exemple complet ci-dessous, nous utilisons une liste Python pour simuler la mémoire à court terme.

5. Module d'outil — Le « couteau suisse » de l'Agent

Les capacités propres du modèle sont limitées (par exemple, il ne connaît pas la météo en temps réel, ne peut pas effectuer de calculs complexes, ne peut pas manipuler de fichiers). Le module d'outils fournit à l'Agent un ensemble de « compétences externes », élargissant considérablement les limites de ses capacités. Un outil peut être une fonction Python, une API tierce ou un logiciel externe complet.

Voici l'exemple d'outil le plus simple :

Exemple

# Exemple de module d'outil : un outil de calculatrice simple
def calculator_tool(expression):
    """
Reçoit une chaîne d'expression mathématique et renvoie le résultat du calcul.
Ceci est un « outil » — attendant d'être appelé à la demande par le cerveau de l'Agent.
    """
    try:
        # Remarque : eval() présente des risques de sécurité dans les environnements de production ; il n'est utilisé ici que pour la démonstration.
        result = eval(expression)
        return f"Résultat du calcul : {expression} = {result}"
    except Exception as e:
        return f"Erreur de calcul : {e}"

# Simulation : après que le cerveau a pris une décision, appeler cet outil
tool_result = calculator_tool("3 + 5 * 2")
print(tool_result)  # Sortie : Résultat du calcul : 3 + 5 * 2 = 13
# Remarque : Python calcule la multiplication et la division avant l'addition et la soustraction, donc c'est 3 + 10 = 13, et non 8 * 2 = 16

Travaux pratiques : construire un agent IA simple en ligne de commande

Ci-dessus, nous avons présenté chaque module séparément. Maintenant, mettons-lesensemblepour créer un mini Agent complet capable de conversation continue et d'appel d'outils.

Avant de l'exécuter, veuillez parcourir cette structure dans votre esprit :

  • Entrée utilisateur →Perception → Décision(correspondance de mots-clés) →Action(appel d'un outil ou conversation) → résultat de sortie →Mémoire(stockée dans l'historique) → attendre le prochain tour de saisie

Exemple

# Exemple complet de mini-agent IA
import random

# ==================== Définitions des outils ====================
def get_weather(city):
    Outil 1 : Requête météo simulée (peut être remplacée par une véritable API météo en pratique)
    weather_options = [Dégagé, Nuageux, Pluie légère, Vent fort]
    temperature = random.randint(15, 35)
    return fLa météo à {city} est {random.choice(weather_options)}, avec une température de {temperature}°C.

def simple_calculator(a, b, operator):
    Outil 2 : Calculatrice simple
    if operator == '+':
        return f"{a} + {b} = {a + b}"
    elif operator == '-':
        return f"{a} - {b} = {a - b}"
    else:
        return Cette opération n'est pas encore prise en charge.

Mémoire (à court terme)
Utilisez une liste pour simuler l'historique de conversation, où chaque entrée est une chaîne de caractères.
conversation_history = []

# ==================== Boucle principale de l'agent ====================
def run_simple_agent():
    print("[Démarrage de l'agent IA simple] Tapez 'exit' pour terminer la conversation.")
    print(Astuce : vous pouvez demander la météo (par ex., « météo à Beijing aujourd'hui ») ou faire des calculs (par ex., « calculer 1+1 »).\n")
   
    while True:
        # ---- Étape de perception : obtenir l'entrée utilisateur ----
        user_input = input(Vous :)
        conversation_history.append(fUtilisateur : {user_input})
       
        # Instruction spéciale : exit
        if user_input.lower() in [Exit, "exit", "quit"]:
            print(Agent : Au revoir !)
            break
       
        # ---- Phase de décision + action : sélectionner un outil ou un dialogue en fonction de l'entrée ----
        response = ""

        if weather in user_input:
            # Essayer d'identifier le nom de la ville à partir de l'entrée, par défaut Beijing.
            city = Beijing
            for c in [Beijing, Shanghai, Guangzhou, Shenzhen]:
                if c in user_input:
                    city = c
                    break
            Appeler l'outil météo
            response = get_weather(city)

        elif Calculate in user_input or "+" in user_input or "-" in user_input:
            # Correspondance de motifs simple, reconnaissant quelques expressions de calcul fixes.
            if "1+1" in user_input:
                response = simple_calculator(1, 1, '+')
            elif "10-5" in user_input:
                response = simple_calculator(10, 5, '-')
            else:
                response = Veuillez essayer de saisir "calculate 1+1" ou "calculate 10-5".

        else:
            # Aucun outil correspondant trouvé, retour à la conversation normale.
            default_responses = [
                Je comprends ce que vous voulez dire.,
                C'est un sujet intéressant !,
                Mes compétences actuelles sont limitées, mais vous pouvez essayer de me poser des questions sur la météo ou d'effectuer des calculs simples.,
                "D'accord, veuillez continuer."
            ]
            response = random.choice(default_responses)
       
        # ---- Étape de sortie + mémoire : afficher la réponse et stocker dans l'historique ----
        print(f"Agent：{response}")
        conversation_history.append(f"Agent：{response}")
   
    Une fois la conversation terminée, affichez l'historique complet de la conversation (simulant le contenu de la mémoire à court terme).
    print("\n=== Historique de cette conversation (contenu de la mémoire à court terme) ===)
    for line in conversation_history:
        print(line)

Démarrer l'agent
if __name__ == "__main__":
    run_simple_agent()

Exécutez ce programme et vous découvrirez :

  • Celui qui peutmaintenir un dialogue multi-touren boucle (module de perception fonctionnant en continu).
  • En fonction de vos mots-clés d'entrée (tels que "weather", "calculation")déclencher automatiquement différents outils(module d'action).
  • Après la fin du dialogue, vous pouvez voir l'historique completde la conversation(module de mémoire).

💡 Réfléchissez-y: Si vous voulez rendre cet Agent plus puissant, vous pouvez essayer : ① Ajouter davantage d’outils (comme la vérification des taux de change, la traduction) ; ② Remplacer la correspondance par mots-clés dans le module de décision par de véritables appels à l’API LLM, et l’Agent pourra comprendre le langage naturel !

Résumé et perspectives

Grâce à cet article, vous devriez avoir maîtrisé les concepts de base de l’Agent IA :

  • Il est composé deperception, décision (cerveau), action, mémoire, outilsUn programme intelligent constitué de modules tels que ceux-ci ;
  • Il utilisela boucle ReAct(penser → agir → observer → repenser) pour poursuivre des objectifs de manière autonome ;
  • Le LLM est son cerveau, les outils sont ses mains et ses pieds, et la mémoire assure sa cohérence.

Retenez l’essentiel en une phrase :Le LLM peut seulement « parler », l’Agent peut « faire ».

Étapes suivantes suggérées pour l’apprentissage

  • Approfondir les API des grands modèles de langage (LLM): Apprenez à appeler les API de modèles tels qu’OpenAI GPT, DeepSeek et Tongyi Qianwen, en les utilisant comme véritable cerveau de votre Agent, et en remplaçant la grossière correspondance par mots-clés de nos exemples.
  • Apprendre les frameworks de développement d’Agent: ExplorezLangChain、LlamaIndexouAutoGenet d’autres frameworks matures. Ils encapsulent des modules tels que la mémoire, les chaînes d’outils et l’orchestration des tâches. Les utiliser permet d’obtenir deux fois plus de résultats avec la moitié de l’effort et d’éviter de réinventer la roue.
  • Connectez-vous à de vrais outils: Essayez de connecter votre Agent à de véritables API, telles que des bases de données, des systèmes de messagerie ou des services météo, afin de résoudre des problèmes pratiques. Cette étape vous donnera une toute nouvelle appréciation du concept d’« outils ».
  • Apprendre l’ingénierie des prompts: La façon d’écrire des « instructions » de haute qualité pour le LLM détermine directement le niveau de performance du cerveau de l’Agent. C’est une compétence clé à ne pas négliger lors du développement d’Agents efficaces.

Le monde des Agents IA est vaste et plein de possibilités, des assistants personnels automatisés aux solutions intelligentes d’entreprise, il devient un nouveau paradigme pour l’interaction homme-machine. Nous espérons que vous utiliserez cet article comme point de départ pour commencer à construire votre propre agent intelligent.

Autres extensions