Du LLM local à l'agent utilisant des outils

Du LLM local à l'agent utilisant des outils

Le passage d'un grand modèle de langage (LLM) exécuté sur votre propre matériel à la création d'un agent utilisant des outils est l'un des changements les plus transformateurs de l'IA appliquée aujourd'hui. Alors que les LLM locaux offrent confidentialité, contrôle et capacités hors ligne, ils ne peuvent pas interagir avec des systèmes externes—bases de données, API, systèmes de fichiers ou services web. En ajoutant des capacités d'utilisation d'outils, vous transformez un modèle statique en un agent autonome capable de récupérer des informations, d'effectuer des calculs et d'exécuter des actions. Cet article fournit un guide pratique, étape par étape, pour combler cet écart.

Pourquoi passer d'un LLM local à un agent ?

Les LLM locaux, comme ceux propulsés par Llama, Mistral ou Phi, sont excellents pour la génération de texte, le résumé et la réponse aux questions. Cependant, ils sont limités par la date de coupure de leurs données d'entraînement et leur incapacité à accéder à des informations en temps réel ou à des outils externes. Un agent utilisant des outils étend le LLM avec un ensemble de fonctions qu'il peut appeler—comme un moteur de recherche, une calculatrice ou un outil de requête de base de données—et décide quand les utiliser en fonction de la demande de l'utilisateur.

Cette approche est centrale dans le développement moderne de l'IA. Comme le soulignent les mises à jour de l'industrie d'OpenAI et Microsoft, la tendance est aux modèles capables de planifier et d'exécuter des tâches en plusieurs étapes en utilisant des ressources externes. Pour les déploiements locaux, cela signifie que vous pouvez construire un agent qui fonctionne entièrement sur votre machine, respecte la confidentialité de vos données et effectue néanmoins des tâches complexes et basées sur les données.

Prérequis

Avant de commencer, assurez-vous que votre système répond à ces exigences :

• **Matériel** : Un ordinateur avec au moins 8 Go de RAM (16 Go recommandé). Un GPU avec 6 Go+ de VRAM (par exemple, NVIDIA RTX 3060 ou supérieur) accélère considérablement l'inférence locale du LLM.
• **Système d'exploitation** : Linux (Ubuntu 22.04+), macOS (Ventura+) ou Windows (avec WSL2 pour une meilleure compatibilité).
• **Logiciel** :
• Python 3.10 ou ultérieur
• pip (gestionnaire de paquets Python)
• Git
• Un environnement d'exécution LLM local (par exemple, Ollama, llama.cpp ou LM Studio)
• Une familiarité de base avec la ligne de commande

Installation étape par étape

Nous utiliserons **Ollama** pour le LLM local et un framework Python appelé **LangChain** pour construire l'agent. LangChain fournit une interface simple pour définir des outils et les connecter au LLM.

1. Installer Ollama et télécharger un LLM local

Ollama est un outil convivial pour exécuter des LLM locaux. Commencez par l'installer :

# Sur Linux ou macOS (en utilisant le script officiel)
curl -fsSL https://ollama.com/install.sh | sh

# Sur Windows, téléchargez l'installateur depuis ollama.com et exécutez-le

Après l'installation, démarrez le service Ollama :

ollama serve

Téléchargez maintenant un modèle performant. Pour l'utilisation d'outils, nous recommandons **Mistral 7B** ou **Llama 3.1 8B** :

# Télécharger Mistral 7B (environ 4 Go)
ollama pull mistral

# Alternativement, télécharger Llama 3.1 8B
ollama pull llama3.1

Vérifiez que le modèle fonctionne :

ollama run mistral "Bonjour, quel est ton nom ?"

Vous devriez voir une réponse du modèle.

2. Configurer l'environnement Python

Créez un nouveau répertoire pour votre projet d'agent et configurez un environnement virtuel :

mkdir local-agent
cd local-agent
python3 -m venv venv
source venv/bin/activate   # Sur Windows : venv\Scripts\activate

Installez les paquets Python requis :

pip install langchain langchain-community langchain-ollama requests

• `langchain` — le framework central pour construire des agents
• `langchain-community` — intégrations maintenues par la communauté
• `langchain-ollama` — intégration directe avec Ollama
• `requests` — pour effectuer des appels HTTP (utilisé par certains outils)

3. Définir les outils

Les outils sont des fonctions que l'agent peut appeler. Nous allons créer trois outils simples : une calculatrice, un simulateur de recherche web (utilisant un jeu de données statique) et un lecteur de fichiers.

Créez un fichier appelé `tools.py` :

# tools.py
import requests
import json

def calculator(expression: str) -> str:
    """
    Évalue une expression mathématique.
    Exemple d'entrée : "2 + 3 * 4"
    """
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Erreur : {e}"

def search_web(query: str) -> str:
    """
    Simule une recherche web. En réalité, vous utiliseriez une API de recherche.
    Ici, nous renvoyons un résultat statique pour la démonstration.
    """
    # Remplacez ceci par un véritable appel API (par exemple, DuckDuckGo, SerpAPI)
    fake_results = {
        "population de tokyo": "Tokyo a une population d'environ 14 millions d'habitants (estimation 2024).",
        "météo à londres": "Météo actuelle à Londres : 15°C, partiellement nuageux.",
        "version python": "Python 3.12 est la dernière version stable en date de 2025."
    }
    return fake_results.get(query.lower(), f"Aucun résultat trouvé pour '{query}'.")

def read_file(file_path: str) -> str:
    """
    Lit le contenu d'un fichier texte.
    """
    try:
        with open(file_path, 'r') as f:
            return f.read()
    except Exception as e:
        return f"Erreur lors de la lecture du fichier : {e}"

4. Construire l'agent

Créez maintenant le script principal de l'agent `agent.py` :

# agent.py
from langchain_ollama import ChatOllama
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from tools import calculator, search_web, read_file

# Initialiser le LLM local
llm = ChatOllama(
    model="mistral",          # ou "llama3.1"
    temperature=0.7,
    num_predict=2048
)

# Définir la liste des outils
tools = [
    Tool(
        name="Calculatrice",
        func=calculator,
        description="Utile pour effectuer des calculs mathématiques. L'entrée doit être une expression mathématique."
    ),
    Tool(
        name="RechercheWeb",
        func=search_web,
        description="Recherche sur le web des informations actuelles. L'entrée doit être une chaîne de requête de recherche."
    ),
    Tool(
        name="LecteurFichier",
        func=read_file,
        description="Lit le contenu d'un fichier. L'entrée doit être un chemin de fichier valide."
    )
]

# Initialiser l'agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    handle_parsing_errors=True
)

# Exécuter une requête simple
if __name__ == "__main__":
    query = "Quelle est la population de Tokyo ? Calcule aussi 15 * 23."
    response = agent.run(query)
    print(response)

5. Exécuter l'agent

Exécutez l'agent :

python agent.py

Vous devriez voir le processus de raisonnement de l'agent (en mode verbeux) et une réponse finale combinant le résultat de la recherche web et le calcul.

Exemples d'utilisation

Exemple 1 : Requête multi-outils

Exécutez l'agent avec une requête nécessitant à la fois un calcul et une lecture de fichier :

# Dans agent.py, modifiez la requête
query = "Lis le fichier 'notes.txt' puis calcule combien de caractères il contient."
response = agent.run(query)

Cela amènera l'agent à appeler d'abord `LecteurFichier`, puis `Calculatrice` sur la longueur du texte retourné.

Exemple 2 : Outil personnalisé — Obtenir l'heure actuelle

Ajoutez un nouvel outil à `tools.py` :

import datetime

def current_time(format_string: str = "%Y-%m-%d %H:%M:%S") -> str:
    """Retourne la date et l'heure actuelles. Permet de spécifier un format optionnellement."""
    return datetime.datetime.now().strftime(format_string)

Enregistrez-le ensuite dans `agent.py` :

from tools import current_time

tools.append(
    Tool(
        name="HeureActuelle",
        func=current_time,
        description="Retourne la date et l'heure actuelles. Le format d'entrée est optionnel."
    )
)

Vous pouvez maintenant demander : "Quelle heure est-il actuellement ?" et l'agent appellera l'outil.

Exemple 3 : Utilisation avec un autre LLM local

Pour passer à Llama 3.1, changez simplement le nom du modèle dans `agent.py` :

llm = ChatOllama(
    model="llama3.1",
    temperature=0.7
)

N'oubliez pas de télécharger d'abord le modèle avec `ollama pull llama3.1`.

Comment l'agent fonctionne en coulisses

L'agent utilise le modèle **ReAct** (Raisonnement + Action). Lorsque vous envoyez une requête, le LLM :

1. **Réfléchit** à l'outil à utiliser et pourquoi. 2. **Agit** en appelant l'outil avec l'entrée appropriée. 3. **Observe** la sortie de l'outil. 4. **Répète** jusqu'à ce qu'il ait suffisamment d'informations pour répondre.

Cela est visible dans la sortie verbeuse. Par exemple, vous pourriez voir :

> Entrée dans le nouvel AgentExecutor chain...
Pensée : J'ai besoin de trouver la population de Tokyo et de calculer 15*23. Je peux utiliser RechercheWeb pour le premier et Calculatrice pour le second.
Action : RechercheWeb
Action Input : population de Tokyo
Observation : Tokyo a une population d'environ 14 millions d'habitants (estimation 2024).
Pensée : Maintenant, je dois calculer 15*23.
Action : Calculatrice
Action Input : 15*23
Observation : 345
Pensée : J'ai les deux informations.
Réponse finale : La population de Tokyo est d'environ 14 millions d'habitants, et 15 * 23 égale 345.

Passage à l'échelle : Du local à la production

Bien que cet exemple utilise un LLM local et des outils simples, le même modèle s'adapte aux environnements de production. Des entreprises comme Microsoft et Anthropic ont démontré des agents qui s'intègrent avec des bases de données, des API cloud et des systèmes d'entreprise. Les principales différences sont :

• **Taille du modèle** : Les modèles plus grands (70B+ paramètres) performent souvent mieux dans la sélection d'outils.
• **Complexité des outils** : Les outils du monde réel peuvent nécessiter une authentification, une limitation de débit et une gestion des erreurs.
• **Mémoire** : Les agents de production utilisent des bases de données vectorielles pour stocker l'historique des conversations et le contexte récupéré.

Pour les déploiements locaux, vous pouvez étendre cette configuration avec des outils pour :

• Requêtes de base de données SQL
• Appels API vers des services comme la météo ou les cours de la bourse
• Génération d'images en utilisant des modèles locaux (par exemple, Stable Diffusion)
• Gestion de fichiers (créer, modifier, supprimer)

Conclusion

Transformer un LLM local en un agent utilisant des outils débloque un nouveau niveau de capacité. Avec seulement quelques lignes de Python et un modèle local, vous pouvez construire un assistant qui non seulement génère du texte mais aussi calcule, recherche et interagit avec vos fichiers. Cette approche respecte votre vie privée, fonctionne hors ligne et vous donne un contrôle total sur les outils que votre agent peut utiliser.

L'exemple fourni ici est un point de départ. À mesure que vous ajoutez plus d'outils et affinez les invites de l'agent, vous le verrez s'attaquer à des tâches de plus en plus complexes. L'avenir de l'IA locale ne consiste pas seulement à exécuter des modèles—il s'agit de construire des agents qui agissent en votre nom, de manière sécurisée et autonome.