Construire des Agents IA Gratuitement : Outils et Modèles Open Source

Vous pouvez construire un système multi-agents fonctionnel sur votre laptop en utilisant uniquement des outils gratuits et des modèles open source. Pas de carte bancaire, pas de limites de débit d’API, pas de dépendance fournisseur. Le compromis ? Une inférence plus lente et légèrement moins de capacité. Mais pour apprendre, expérimenter et l’automatisation à petite échelle, c’est plus que suffisant.

À la fin de ce guide, vous aurez un agent de recherche local fonctionnant sur votre propre matériel — cherchant sur le web, lisant des fichiers et synthétisant des informations — entièrement gratuitement.

Le Cas pour le Développement d’Agents Open Source

Réalité des Coûts

La tarification de l’API Claude est raisonnable pour les charges de travail en production, mais l’apprentissage et l’expérimentation s’accumulent rapidement. L’inférence locale élimine cette préoccupation entièrement — des itérations infinies à coût marginal zéro.

Confidentialité et Contrôle des Données

Certaines charges de travail ne peuvent pas aller vers des APIs cloud. Les données patients, le code propriétaire, la logique métier sensible — tout cela bénéficie de rester sur votre machine.

Le Bilan de Réalité

Les modèles open source à 7–13B paramètres sont nettement en retard sur les modèles frontier en raisonnement complexe et génération de code. Pour la production où la précision compte, les APIs commerciales restent le meilleur choix. Pour l’apprentissage et le prototypage, les modèles locaux sont excellents.

Sélectionner votre LLM Open Source

Les Familles de LLM

• Llama (Meta) : La famille la plus largement supportée. Llama 3 est particulièrement capable.
• Mistral : Excellent ratio qualité/paramètre. Mistral-7B dépasse sa taille.
• Phi (Microsoft) : Petits modèles extrêmement efficaces. Phi-3 Mini fonctionne sans GPU.
• Qwen (Alibaba) : Bonnes performances multilingues.

Taille du Modèle et Exigences Matérielles

Quantification : Pourquoi ça Compte

La quantification compresse les poids du modèle pour utiliser moins de mémoire. Un modèle 7B en précision complète nécessite ~28Go de RAM. Le même modèle en quantification 4-bit nécessite ~4Go, avec seulement une légère perte de qualité.

Points de départ selon le matériel :

• Laptop (8–16Go RAM) : Phi-3 Mini ou Mistral-7B en 4-bit
• PC fixe avec GPU milieu de gamme : Mistral-7B ou Llama-3-8B avec accélération GPU
• PC fixe avec GPU haut de gamme : Mixtral-8x7B ou Llama-3-70B en 4-bit

Configuration de l’Inférence Locale

Ollama : Le Point d’Entrée le Plus Simple

# Installer sur macOS
brew install ollama

# Installer sur Linux
curl -fsSL https://ollama.com/install.sh | sh

# Télécharger Mistral-7B
ollama pull mistral

# Option plus légère pour matériel lent
ollama pull phi3

# Démarrer le serveur d'inférence
ollama serve

Vérifier que ça fonctionne :

curl http://localhost:11434/api/generate -d '{
  "model": "mistral",
  "prompt": "Qu'\''est-ce qu'\''un agent IA en une phrase ?",
  "stream": false
}'

LM Studio : Alternative en Interface Graphique

LM Studio est une application de bureau qui fournit une interface graphique pour télécharger et exécuter des modèles. Expose une API compatible OpenAI.

Frameworks d’Agents Open Source

Commencez avec AutoGen ou LangChain. AutoGen est plus rapide à prototyper ; LangChain vous donne plus de contrôle sur la boucle d’agent.

Construire votre Premier Agent : Assistant de Recherche Local

Configuration de l’Environnement

python3 -m venv agent-env
source agent-env/bin/activate
pip install langchain langchain-ollama langchain-community duckduckgo-search

L’Agent Complet

#!/usr/bin/env python3
"""
Agent de Recherche Local avec Ollama + LangChain
Prérequis :
  - ollama serve (en cours d'exécution en arrière-plan)
  - ollama pull mistral
  - pip install langchain langchain-ollama langchain-community duckduckgo-search
"""

import json
from langchain_core.tools import tool
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama
from langchain.agents import AgentExecutor, create_react_agent
from duckduckgo_search import DDGS


@tool
def search_web(query: str) -> str:
    """Recherche des informations sur le web avec DuckDuckGo."""
    try:
        with DDGS() as ddgs:
            results = list(ddgs.text(query, max_results=5))
        if not results:
            return "Aucun résultat trouvé."
        return json.dumps([
            {"title": r["title"], "snippet": r["body"], "url": r["href"]}
            for r in results
        ], indent=2)
    except Exception as e:
        return f"Recherche échouée : {e}"


@tool
def read_file(filepath: str) -> str:
    """Lit un fichier local et retourne son contenu."""
    try:
        with open(filepath, "r") as f:
            return f.read()
    except FileNotFoundError:
        return f"Fichier introuvable : {filepath}"


@tool
def calculate(expression: str) -> str:
    """Évalue une expression arithmétique simple en toute sécurité."""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"Erreur de calcul : {e}"


llm = ChatOllama(
    model="mistral",
    base_url="http://localhost:11434",
    temperature=0.3,
)

prompt = ChatPromptTemplate.from_messages([
    ("system", """Vous êtes un assistant de recherche. Répondez aux questions en utilisant vos outils.

Outils disponibles : {tool_names}
Descriptions des outils : {tools}

Suivez ce format exactement :
Thought: Que dois-je trouver ?
Action: nom_outil
Action Input: l'entrée pour l'outil
Observation: résultat de l'outil
... (répétez si nécessaire)
Thought: J'ai maintenant suffisamment d'informations.
Final Answer: votre réponse complète"""),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

tools = [search_web, read_file, calculate]
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=8,
    handle_parsing_errors=True,
)

if __name__ == "__main__":
    result = agent_executor.invoke({
        "input": "Quels sont les trois LLM open source les plus populaires en ce moment ? Donnez les noms et une caractéristique clé pour chacun."
    })
    print(f"\nRÉPONSE FINALE :\n{result['output']}")

L’Exécuter

# Terminal 1 : Démarrer Ollama
ollama serve

# Terminal 2 : Lancer l'agent
python research_agent.py

Débogage des Problèmes Courants

• “Modèle introuvable” — Exécutez ollama pull mistral d’abord.
• Erreurs de parsing — Les modèles locaux sont moins fiables avec les formats stricts. Utilisez handle_parsing_errors=True.
• Inférence très lente — Passez à phi3 dans ChatOllama.
• Plus de mémoire — Fermez les autres applications ou utilisez phi3.

Élargir les Capacités : Outils Sans APIs

Accès à la Base de Données Locale

import sqlite3

@tool
def query_database(sql: str) -> str:
    """Exécute une requête SQL en lecture seule sur la base de données locale."""
    try:
        conn = sqlite3.connect("data.db")
        cursor = conn.cursor()
        cursor.execute(sql)
        rows = cursor.fetchall()
        columns = [desc[0] for desc in cursor.description]
        conn.close()
        return json.dumps([dict(zip(columns, row)) for row in rows], indent=2)
    except Exception as e:
        return f"Erreur base de données : {e}"

Recherche de Documents Locale avec Embeddings

pip install sentence-transformers chromadb

from sentence_transformers import SentenceTransformer
import chromadb

model = SentenceTransformer("all-MiniLM-L6-v2")
client = chromadb.Client()
collection = client.create_collection("docs")

@tool
def search_docs(query: str) -> str:
    """Recherche des documents locaux par similarité sémantique."""
    results = collection.query(
        query_embeddings=[model.encode(query).tolist()],
        n_results=3
    )
    return json.dumps(results["documents"][0], indent=2)

Contraintes du Monde Réel et Solutions

Latence

Attendez 2–30 secondes par étape d’inférence. Stratégies :

• Concevez des agents avec moins d’étapes
• Regroupez les appels d’outils quand c’est possible

Lacunes de Précision

Stratégies de mitigation qui fonctionnent réellement :

• Prompts plus courts et explicites — Spécifiez exactement le format attendu
• Décomposez les tâches complexes en étapes
• Validez les sorties des outils avant de les renvoyer à l’agent
• Température de 0.1–0.3 pour l’utilisation des outils

Déploiement : Du Laptop au Toujours Actif

Docker

FROM python:3.12-slim
RUN pip install langchain langchain-ollama langchain-community duckduckgo-search
COPY research_agent.py .
ENV OLLAMA_HOST=host.docker.internal:11434
CMD ["python3", "research_agent.py"]

Service Systemd (Linux)

sudo systemctl enable ollama
sudo systemctl start ollama

Aller Plus Loin : Systèmes Multi-Agents à la Maison

def run_pipeline(question: str) -> str:
    research_result = researcher.invoke({"input": question})
    final_output = writer.invoke({
        "input": f"Sur la base de cette recherche, écrivez un résumé clair :\n{research_result['output']}"
    })
    return final_output["output"]

Utilisez SQLite pour l’état partagé quand les agents doivent communiquer entre les exécutions.

Le développement d’agents open source est pratique aujourd’hui. Le chemin est : Ollama pour l’inférence, LangChain ou AutoGen pour la boucle d’agent, DuckDuckGo pour la recherche, et le système de fichiers de votre machine pour tout le reste.

Commencez simple — l’agent de recherche ci-dessus. Faites-le fonctionner. Puis ajoutez un deuxième outil. Puis un deuxième agent.

Articles Connexes

• Introduction au Développement Agentique
• Patterns d’Utilisation des Outils : Interfaces Agent-Outil Fiables
• Patterns Multi-Agents : Orchestrateurs, Workers et Pipelines
• Construire Son Premier Serveur MCP