Petits modèles IA : révolution dans la création d'agents

Les petits modèles IA locaux révolutionnent la création d'agents intelligents

Introduction

Autrefois, la création d'agents d'intelligence artificielle (IA) était un domaine réservé aux géants de la technologie, nécessitant des infrastructures coûteuses et complexes. Les développeurs devaient s'appuyer sur des API cloud onéreuses et des serveurs puissants pour concevoir ces agents. Cependant, cette image a radicalement changé avec l'avènement des petits modèles linguistiques (SLMs), qui permettent désormais à quiconque, même aux novices, de construire des agents IA fonctionnels directement sur un ordinateur personnel.

Ces SLMs sont suffisamment légers pour fonctionner sans connexion Internet après une configuration initiale, éliminant ainsi les coûts récurrents liés aux API. Ils offrent des capacités de raisonnement, de planification et de réponse, tout en étant assez compacts pour tourner sur des machines standards. Cet article vous guidera dans la création d'un agent IA local en utilisant des outils comme Ollama et LangChain/LangGraph, que vous soyez un débutant en Python ou un développeur intermédiaire explorant l'IA.

Qu'est-ce qu'un agent IA ?

Un agent IA est un programme sophistiqué qui utilise un modèle linguistique pour réfléchir, prendre des décisions et agir dans le but d'atteindre un objectif spécifique. Contrairement aux chatbots traditionnels, qui se contentent de répondre à des messages, un agent IA est capable de :

• Décomposer une tâche complexe en étapes plus simples.
• Choisir l'outil ou l'action approprié pour chaque étape.
• Utiliser les résultats obtenus pour informer les étapes suivantes.
• Poursuivre le processus jusqu'à l'accomplissement de la tâche.

Imaginez la différence entre une simple calculatrice, qui attend vos instructions, et un assistant personnel, qui anticipe vos besoins, détermine les étapes nécessaires et les exécute de manière autonome.

Un agent IA de base se compose de trois éléments principaux :

| Partie | Fonction | |--------|----------| | Cerveau (LLM/SLM) | Comprend l'entrée et décide des actions à entreprendre | | Mémoire | Conserve le contexte des interactions précédentes | | Outils | Fonctions externes que l'agent peut utiliser, comme la recherche ou le calcul |

Qu'est-ce que les petits modèles linguistiques ?

Les petits modèles linguistiques (SLMs) sont des modèles d'IA entraînés sur de vastes ensembles de données textuelles, similaires aux grands modèles comme GPT-4, mais conçus pour être beaucoup plus compacts. Alors que GPT-4 peut contenir des centaines de milliards de paramètres, les SLMs tels que Phi-3, Mistral 7B ou Llama 3.2 (3B) varient entre 1 milliard et 13 milliards de paramètres. Cette réduction de taille les rend adaptés à une exécution sur des ordinateurs personnels dotés de CPU modernes ou de GPU grand public.

Voici quelques exemples de SLMs populaires :

| Modèle | Développeur | Taille | Usage recommandé | |--------|-------------|--------|------------------| | Phi-3 Mini | Microsoft | 3.8B | Raisonnement rapide, faible consommation de mémoire | | Mistral 7B | Mistral AI | 7B | Tâches générales, suivi d'instructions | | Llama 3.2 (3B) | Meta | 3B | Performance équilibrée |

Pour ceux qui hésitent sur le choix du modèle, Phi-3 Mini et Llama 3.2 (3B) sont des options bien documentées et accessibles, parfaites pour débuter sur des machines locales.

Pourquoi exécuter des agents IA localement ?

Vous pourriez vous demander pourquoi ne pas simplement utiliser des services cloud comme l'API d'OpenAI ou Google Gemini. Voici quelques raisons pour lesquelles les SLMs locaux sont une alternative intéressante :

• Économie sur les coûts d'API. Les services cloud facturent souvent par token ou par requête, ce qui peut rapidement devenir coûteux si votre agent effectue de nombreuses requêtes. En revanche, une fois configurés, les modèles locaux fonctionnent sans frais supplémentaires.

• Confidentialité renforcée. L'utilisation d'une API cloud implique que vos données quittent votre appareil, ce qui peut poser des problèmes de confidentialité, notamment pour des informations sensibles comme des dossiers médicaux ou des données commerciales. Les modèles locaux conservent toutes les données sur votre appareil.

• Fonctionnement hors ligne. Même sans connexion Internet, votre agent IA continue de fonctionner, offrant une flexibilité accrue.

• Contrôle total. Vous avez la liberté de choisir le modèle, de définir les paramètres et de personnaliser le comportement de votre agent sans être limité par des politiques d'utilisation ou des restrictions de taux.

• Apprentissage approfondi. Configurer et exécuter des modèles localement vous oblige à comprendre leur fonctionnement interne, ce qui enrichit vos compétences en développement.

Outils que vous utiliserez

Pour construire votre agent IA local, vous utiliserez les outils suivants :

• Ollama : Cet outil open source vous permet de télécharger et d'exécuter des modèles linguistiques sur votre machine locale avec une seule commande, simplifiant ainsi la configuration.

• LangChain / LangGraph : LangChain est un cadre populaire pour créer des applications basées sur des modèles linguistiques. LangGraph, une extension de LangChain, facilite la création de flux de travail d'agents, en définissant comment votre agent pense et agit étape par étape à l'aide d'une structure basée sur des graphes.

Configuration de votre environnement

Avant de commencer à coder votre agent, vous devez configurer votre environnement de travail.

Étape 1 : Installer Ollama

Rendez-vous sur ollama.com pour télécharger l'installateur correspondant à votre système d'exploitation (Windows, Mac ou Linux). Une fois installé, ouvrez votre terminal et téléchargez un modèle avec la commande suivante :

ollama pull phi3

Cela téléchargera le modèle Phi-3 Mini sur votre machine. Pour vérifier son bon fonctionnement, exécutez :

ollama run phi3

Vous devriez voir une invite vous permettant d'interagir directement avec le modèle. Tapez /bye pour quitter.

Étape 2 : Installer les bibliothèques Python

Créez un environnement virtuel et installez les packages nécessaires :

python -m venv agent-env

Pour Linux/Mac :

source agent-env/bin/activate

Sur Windows :

agent-env\Scripts\activate

Installez ensuite les bibliothèques requises :

pip install langchain langchain-ollama langgraph

Assurez-vous d'utiliser Python 3.9 ou une version plus récente. Vérifiez votre version avec :

python --version

Construire votre premier agent IA local

Passons à la création d'un agent simple capable de répondre à des questions et d'utiliser un outil de base, tel qu'une calculatrice.

Dans votre fichier agent.py, insérez le code suivant :

from langchain_ollama import OllamaLLM
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import tool
from langchain import hub

# Étape 1 : Charger le modèle local via Ollama
llm = OllamaLLM(model="phi3")

# Étape 2 : Définir un outil simple -- une calculatrice
@tool
def calculator(expression: str) -> str:
    """Évalue une expression mathématique de base. L'entrée doit être une expression mathématique valide en Python."""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Erreur : {str(e)}"

# Étape 3 : Regrouper les outils
tools = [calculator]

# Étape 4 : Charger un modèle de prompt ReAct (Raison + Agir)
prompt = hub.pull("hwchase17/react")

# Étape 5 : Créer l'agent
agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)

# Étape 6 : Envelopper dans un exécuteur pour gérer la boucle de l'agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Étape 7 : Exécuter l'agent
response = agent_executor.invoke({
    "input": "Quelle est la multiplication de 245 par 18, puis divisée par 5 ?"
})

print("\n--- Réponse de l'agent ---")
print(response["output"])

Voici ce qui se passe dans ce script :

• La classe OllamaLLM se connecte au modèle Phi-3 en cours d'exécution localement.
• Le décorateur @tool transforme une fonction Python classique en un outil que l'agent peut appeler.
• La fonction create_react_agent utilise le modèle ReAct, une méthode où l'agent raisonne sur le problème puis agit en utilisant un outil, de manière répétée, jusqu'à obtenir une réponse.
• AgentExecutor gère la boucle de raisonnement, d'action et d'observation des résultats.

Pour exécuter le script, utilisez la commande suivante :

python agent.py

Vous verrez le processus de réflexion de l'agent s'afficher dans le terminal avant qu'il ne produise la réponse finale.

Ajouter de la mémoire et des outils à votre agent

Pour qu'un agent soit véritablement utile, il doit se souvenir des conversations passées. Voici comment ajouter une mémoire de conversation et un second outil, comme une recherche dans une base de connaissances.

Dans votre fichier agent_with_memory.py :

from langchain_ollama import OllamaLLM
from langchain.agents import AgentExecutor, create_react_agent
from langchain.tools import tool
from langchain.memory import ConversationBufferMemory
from langchain import hub

llm = OllamaLLM(model="phi3")

# Outil 1 : Calculatrice
@tool
def calculator(expression: str) -> str:
    """Évalue une expression mathématique de base."""
    try:
        return str(eval(expression))
    except Exception as e:
        return f"Erreur : {str(e)}"

# Outil 2 : Recherche simulée dans une base de connaissances
@tool
def knowledge_base(query: str) -> str:
    """Recherche des informations dans une base de connaissances locale."""
    kb = {
        "python": "Python est un langage de programmation convivial pour les débutants, largement utilisé en IA et en science des données.",
        "agent IA": "Un agent IA est un programme qui utilise un modèle linguistique pour raisonner et prendre des actions.",
        "ollama": "Ollama est un outil pour exécuter des modèles linguistiques localement sur votre ordinateur.",
    }
    for key in kb:
        if key in query.lower():

Conclusion

En suivant ces étapes, vous pouvez créer un agent IA local qui non seulement répond à des questions, mais se souvient également des conversations passées et utilise des outils pour enrichir ses réponses. Cela ouvre la voie à des applications plus complexes et personnalisées, tout en garantissant la confidentialité et le contrôle sur vos données.