Votre premier agent IA utilisant des outils avec LangChain

Un petit exercice en Python + LangChain permet de créer un agent de type calculatrice qui peut invoquer des fonctions d’addition, de soustraction, de multiplication, de division ou de calcul de racine carrée selon les besoins.

L’arithmétique n’est qu’un élément secondaire. La leçon importante réside dans l’observation d’un LLM qui reçoit des fonctions appelables et choisit quelle fonction invoquer à quel moment.

Exemples de questions que l’agent finalisé peut résoudre :

Multipliez 25 par 4. Calculez la racine carrée de 144, puis multipliez ce résultat par 5.

Au lieu de programmer séquentiellement les calculs, plusieurs fonctions sont enregistrées. Le modèle choisit parmi elles en fonction des instructions fournies par l’utilisateur.

1. Initialiser le modèle

Commencez par construire le modèle de conversation :

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-4o-mini")

Rien d’approchant un agent n’existe pour l’instant — seulement un modèle de texte capable de lire et d’écrire.

2. Enregistrer les fonctions appelables

Les agents deviennent utiles lorsqu’ils vont au-delà de la simple génération de texte et peuvent appeler des fonctions d’application.

Définissez cinq assistants minimaux :

from langchain.tools import tool
import math

@tool
def add(a: float, b: float) -> float:
    """Add two numbers."""
    return a + b

@tool
def subtract(a: float, b: float) -> float:
    """Subtract two numbers."""
    return a - b


@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers."""
    return a * b


@tool
def divide(a: float, b: float) -> float:
    """Divide two numbers."""
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b


@tool
def square_root(a: float) -> float:
    """Calculate the square root of a number."""
    if a < 0:
        raise ValueError("Cannot calculate square root of a negative number.")
    return math.sqrt(a)

L’ajout du tag @tool permet de présenter chaque fonction sous une forme compréhensible par le moteur d’exécution de l’agent.

Deux éléments guident le modèle :

1. Les paramètres annotés indiquent les types d’arguments attendus.

a: float
b: float

1. Les documents de description fournissent des explications en langage courant que le modèle lit pour déterminer la pertinence.

Dans le cadre des outils d’agent, la description narrative d’une fonction fait partie de l’interface de contrôle, et non d’une simple décoration.

"""Multiply two numbers."""

3. Connecter l’agent

Attachez les assistants au modèle :

from langchain.agents import create_agent

agent = create_agent(
    model=model,
    tools=[
        add,
        subtract,
        multiply,
        divide,
        square_root
    ],
)

Désormais, le modèle de chat peut fonctionner en tant qu’agent plutôt que simplement comme un répondant ponctuel.

Les étapes typiques incluent :

1. Analyser l’intention de l’utilisateur

Décider s’un assistant est nécessaire

Sélectionner un assistant

Fournir des arguments

Utiliser la valeur de retour de l’assistant

Décider s’une autre étape est requise

Émettre la réponse finale

En termes généraux :

User
 ↓
Agent
 ↓
Should I use a tool?
 ↓
Choose tool
 ↓
Execute tool
 ↓
Get result
 ↓
Final response

Les questions à plusieurs étapes peuvent répéter ce cycle.

4. Exécuter une exécution

Un simple enveloppe suffit pour la faire fonctionner :

def run_agent(question: str):
    """Run the agent and print the execution trace."""

    print(f"User: {question}")

    result = agent.invoke({
        "message": [("user", question)],
    })

    print("Agent:", result)

Appeler avec une question simple :

run_agent("What is 25 multiplied by 4?")

On remarque qu’il n’y a aucune instruction indiquant « appeler multiply ».

Seul le catalogue des assistants a été fourni.

Compte tenu de la formulation et de la description de chaque assistant, le modèle en déduit que la multiplication est appropriée.

5. Chaîner plus d’un assistant

Essayer une demande composée :

run_agent(
    "Calculate the square root of 144 and multiply the result by 5."
)

Deux opérations sont nécessaires.

Le suivi conceptuel ressemble à ceci :

User:

Calculate √144 × 5
        ↓
Agent chooses square_root
        ↓
square_root(144)
        ↓
12
        ↓
Agent chooses multiply
        ↓
multiply(12, 5)
        ↓
60
        ↓
Final answer

Cette boucle — choisir, appeler, observer, choisir à nouveau — constitue l’essence des agents utilisant des outils.

Le code d’application n’a pas besoin d’enregistrer à l’avance l’ordre complet des opérations.

Le modèle peut déduire l’étape suivante à partir des outils restants et de l’état de la conversation.

6. Contraste avec un simple LLM

Sans outils, un modèle pourrait inventer « La réponse est 60 » sous forme de texte.

Avec des outils enregistrés, il peut confier les tâches numériques à de vraies fonctions.

Le transfert du contrôle

Parcours uniquement textuel : Utilisateur → modèle → chaîne de réponse

contre :

Tool-using agent

User
  ↓
LLM
  ↓
Choose tool
  ↓
Execute code
  ↓
Observe result
  ↓
LLM
  ↓
Answer

Le modèle n’a plus besoin d’effectuer lui-même chaque calcul.

Il propose quelle action doit être exécutée en premier ; l’application décide quelles actions existent et comment elles s’exécutent.

7. La frontière à protéger

La calculatrice est un jouet pédagogique.

L’idée fondamentale réside dans la séparation entre le jugement du modèle et l’autorité d’application.

La compréhension du langage naturel et le choix des actions conviennent bien aux LLM.

L’exécution de ces actions doit se faire en Python, sous votre contrôle.

Le modèle peut conclure qu’une telle séparation est nécessaire.

Votre processus gère l’implémentation de cette séparation ainsi que ses effets secondaires.

Remplacez les outils mathématiques simplifiés par des opérations propres au domaine, telles que :

get_customer()
search_transactions()
create_report()
send_email()
query_database()
get_weather()
create_ticket()

et le même schéma d’orchestration commence alors à ressembler aux conceptions d’agents en environnement de production.

Résumé de l’exercice

Quelques modules ont permis de créer un agent capable de :

• Interpréter des questions libres
• Sélectionner parmi plusieurs outils disponibles
• Lier correctement les arguments
• Combiner ces outils au cours d’une même session
• Reprendre les résultats des outils dans le raisonnement ultérieur

Répondez à l’utilisateur une fois la chaîne terminée

En bref : un LLM qui sélectionne et exécute des actions, et non un modèle qui ne produit que du texte.