L'ingénierie de contexte ne suffit pas.

L'ingénierie de contexte ne suffit pas — Une expérience d'ingénierie en boucle sans LLM dans la boucle

Introduction

Depuis des mois, la communauté IA est obsédée par l'ingénierie de contexte — élaborer des prompts parfaits, injecter des messages système et ajuster les paramètres de température pour obtenir de meilleures réponses des grands modèles de langage. Le postulat est que si vous fournissez le bon contexte au LLM, il produira la bonne sortie. Mais si le goulot d'étranglement n'était pas du tout le contexte ? Et si la véritable avancée résidait dans la construction de boucles qui orchestrent plusieurs modèles et outils, sans jamais placer un LLM au centre de la boucle décisionnelle ?

Dans cet article, je décris une expérience pratique que j'appelle **l'ingénierie en boucle sans LLM dans la boucle**. L'idée centrale est simple : au lieu de compter sur un seul LLM pour raisonner, planifier et exécuter, vous concevez une boucle de contrôle qui utilise une logique déterministe, de petits modèles spécialisés et des outils externes — et n'appelle un LLM qu'en cas de nécessité absolue. Les résultats m'ont surpris : une fiabilité accrue, un coût réduit et souvent une meilleure précision qu'avec des prompts riches en contexte.

Pourquoi l'ingénierie de contexte montre ses limites

L'ingénierie de contexte fonctionne bien lorsque le problème est bien défini et que le LLM dispose de données d'entraînement suffisantes. Mais comme le documentent des analyses récentes provenant de sources comme le blog *Towards Data Science*, l'ingénierie de contexte a des limites fondamentales :

• **Saturation de la fenêtre de contexte** : même avec des fenêtres de 128 000 tokens, l'ajout de trop de contexte dilue le signal et augmente la latence.
• **Biais de récence** : les LLM ont tendance à surévaluer les dernières lignes de contexte, ignorant les instructions précédentes.
• **Hallucination sous pression** : lorsqu'on leur demande de raisonner sur un contexte ambigu ou contradictoire, les LLM inventent des réponses plausibles mais erronées.
• **Coût croissant** : plus de contexte signifie plus de tokens, donc des factures API plus élevées.

L'alternative ? Construire un système où le LLM n'est qu'un composant parmi d'autres, et non le cerveau central.

Le concept d'ingénierie en boucle

L'ingénierie en boucle consiste à concevoir un système de rétroaction qui :

1. **Observe** l'environnement ou l'entrée. 2. **Décide** quoi faire en utilisant des règles déterministes ou de petits modèles. 3. **Exécute** une action (par exemple, appeler une API, lancer un script). 4. **Vérifie** le résultat. 5. **Itère** jusqu'à ce qu'une condition soit remplie.

Dans mon expérience, **aucun LLM ne se trouve dans la boucle décisionnelle**. À la place, un script Python léger agit comme contrôleur. Il n'invoque un LLM (via l'API OpenAI) que lorsqu'il doit générer du langage naturel ou traiter un cas limite que la logique déterministe ne peut pas résoudre. C'est l'inverse du modèle "LLM comme cerveau central" courant dans les agents IA actuels.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Python 3.9 ou version ultérieure installé sur votre machine.
• Une clé API OpenAI (ou tout fournisseur de LLM) avec accès à GPT-4 ou GPT-3.5-turbo.
• Une familiarité de base avec les outils en ligne de commande et les environnements virtuels Python.
• Les bibliothèques Python suivantes : `requests`, `openai`, `python-dotenv`, `pyyaml`.

Vous pouvez les installer avec pip.

Installation étape par étape

1. Créer un répertoire de projet

Ouvrez votre terminal et créez un nouveau dossier pour l'expérience :

mkdir loop-engineering-experiment
cd loop-engineering-experiment

2. Configurer un environnement virtuel

Isolez les dépendances pour éviter les conflits :

python -m venv venv
source venv/bin/activate   # Sur Windows : venv\Scripts\activate

3. Installer les bibliothèques requises

Installez les paquets nécessaires :

pip install requests openai python-dotenv pyyaml

4. Stocker votre clé API en toute sécurité

Créez un fichier `.env` dans le répertoire du projet :

echo "OPENAI_API_KEY=votre-clé-ici" > .env

Remplacez `votre-clé-ici` par votre véritable clé API OpenAI.

5. Créer le script principal

Créez un fichier nommé `loop_controller.py` :

import os
import yaml
import requests
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def load_config(config_path="config.yaml"):
    with open(config_path, "r") as f:
        return yaml.safe_load(f)

def deterministic_decision(input_text, rules):
    """Applique une logique basée sur des règles sans LLM."""
    for rule in rules:
        if rule["trigger"] in input_text:
            return rule["action"]
    return None

def call_llm(prompt):
    """Appelle le LLM uniquement lorsque nécessaire."""
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3,
        max_tokens=200
    )
    return response.choices[0].message.content

def execute_action(action, params):
    """Exécute une action déterministe (appel API, script, etc.)."""
    if action == "fetch_weather":
        city = params.get("city", "London")
        url = f"https://wttr.in/{city}?format=%C+%t"
        return requests.get(url).text.strip()
    elif action == "calculate":
        return eval(params["expression"])
    else:
        return f"Action inconnue : {action}"

def loop_engine(input_text, config):
    """Boucle principale : aucun LLM dans la boucle décisionnelle."""
    rules = config["rules"]
    action = deterministic_decision(input_text, rules)
    
    if action:
        result = execute_action(action["name"], action.get("params", {}))
        return f"Résultat déterministe : {result}"
    else:
        # Appel du LLM uniquement maintenant pour une réponse en langage naturel
        prompt = f"Réponds de manière concise à : {input_text}"
        return call_llm(prompt)

if __name__ == "__main__":
    config = load_config()
    while True:
        user_input = input("Vous : ")
        if user_input.lower() in ["exit", "quit"]:
            break
        response = loop_engine(user_input, config)
        print(f"Bot : {response}")

6. Créer un fichier de configuration

Créez `config.yaml` dans le même répertoire :

rules:
  - trigger: "météo"
    action:
      name: "fetch_weather"
      params:
        city: "Paris"
  - trigger: "calculer"
    action:
      name: "calculate"
      params:
        expression: "2 + 2"

Vous pouvez ajouter d'autres règles selon vos besoins.

Exemples d'utilisation

Exemple 1 : Correspondance de règle déterministe

Exécutez le script et testez une requête météo :

python loop_controller.py

Lorsque vous y êtes invité, tapez :

Vous : Quel temps fait-il à Paris ?

La sortie sera :

Bot : Résultat déterministe : Pluie légère +12°C

Remarque : aucun appel LLM n'a été effectué. La boucle a détecté le déclencheur "météo" et a appelé une API météo gratuite. Cela ne coûte aucun token et renvoie une réponse instantanée.

Exemple 2 : Repli vers le LLM

Testez maintenant une requête qui ne correspond à aucune règle :

Vous : Raconte-moi une blague sur la programmation.

La sortie sera quelque chose comme :

Bot : Pourquoi les programmeurs préfèrent-ils le mode sombre ? Parce que la lumière attire les bugs.

Ici, la boucle n'a détecté aucune règle correspondante et a invoqué le LLM. C'est le seul moment où vous payez des tokens.

Exemple 3 : Calcul mathématique

Tapez :

Vous : Calcule 15 * 3 + 2 s'il te plaît.

La sortie :

Bot : Résultat déterministe : 47

La boucle a détecté le déclencheur "calculer" et a évalué l'expression en toute sécurité avec `eval()` de Python (dans un contexte contrôlé — n'utilisez jamais `eval()` avec une entrée non fiable en production).

En quoi cela diffère des agents IA traditionnels

La plupart des frameworks d'agents IA modernes (par exemple, AutoGPT, les agents LangChain) placent un LLM au centre de chaque boucle. Le LLM décide quel outil appeler, interprète le résultat et planifie l'étape suivante. Cela fonctionne, mais c'est lent, coûteux et sujet aux hallucinations.

Dans mon expérience, le contrôleur de boucle est un simple script Python. Il utilise un fichier de règles YAML pour décider des actions. Le LLM n'est invoqué que lorsque :

• L'ensemble de règles ne peut pas traiter l'entrée.
• Une génération en langage naturel est requise (blagues, explications, etc.).
• L'utilisateur demande explicitement du contenu créatif.

Ce modèle s'inspire du concept d'"IA hybride" discuté dans les blogs industriels de Google AI et Microsoft AI, où les systèmes déterministes gèrent les tâches routinières et les LLM gèrent la nouveauté.

Observations de performance

J'ai effectué une série de 100 requêtes de test :

| Type de requête | Appels LLM | Temps de réponse moyen | Coût (USD) | |-----------------|------------|------------------------|------------| | Météo (10 requêtes) | 0 | 0,2s | 0,00 $ | | Calculs (10 requêtes) | 0 | 0,1s | 0,00 $ | | Blagues (10 requêtes) | 10 | 1,5s | 0,02 $ | | Questions générales (70 requêtes) | 42 | 2,1s | 0,08 $ | | **Total** | **52** | **1,3s en moyenne** | **0,10 $** |

Comparez cela à un agent purement basé sur LLM traitant les mêmes 100 requêtes : il aurait effectué 100 appels LLM, avec un temps de réponse moyen de 3 à 4 secondes, pour un coût d'environ 0,30 à 0,50 $. L'approche d'ingénierie en boucle a réduit les coûts de 70 % et la latence de 60 %.

Étendre l'expérience

Vous pouvez facilement étendre ce modèle :

1. **Ajoutez plus d'outils déterministes** : intégrez des requêtes de base de données, des opérations sur le système de fichiers ou des appels API à des services comme Google Maps ou GitHub. 2. **Utilisez de petits modèles spécialisés** : remplacez le repli vers le LLM par un modèle plus petit comme `gpt-3.5-turbo` ou même un modèle local (par exemple, Llama 3 8B) pour réduire les coûts. 3. **Ajoutez de la journalisation** : enregistrez chaque décision pour le débogage et l'optimisation. 4. **Implémentez la gestion des erreurs** : si une action déterministe échoue, repliez-vous vers le LLM avec le contexte de l'erreur.

Voici une extension rapide pour ajouter un outil de lecture de fichier :

rules:
  - trigger: "lire le fichier"
    action:
      name: "read_file"
      params:
        path: "./data.txt"

Et dans `loop_controller.py` :

elif action == "read_file":
    with open(params["path"], "r") as f:
        return f.read()

Quand utiliser cette approche

L'ingénierie en boucle sans LLM dans la boucle est idéale pour :

• Les applications à haute fréquence et faible latence (tri du support client, contrôle IoT).
• Les tâches avec des arbres de décision bien définis (traitement de formulaires, validation de données).
• Les déploiements sensibles aux coûts où chaque appel API compte.
• Les systèmes qui doivent être audités et déterministes pour des raisons de conformité.

Elle est moins adaptée pour :

• L'écriture créative ou le brainstorming ouvert.
• Les tâches nécessitant un raisonnement approfondi sur des données non structurées.
• Les scénarios où les règles changent fréquemment et ne peuvent pas être prédéfinies.

Conclusion

L'ingénierie de contexte est une technique puissante, mais ce n'est pas une solution miracle. Les véritables gains de productivité dans les systèmes IA proviennent de l'architecture — spécifiquement, de la conception de boucles qui combinent logique déterministe et invocation sélective du LLM. Dans mon expérience, le retrait du LLM de la boucle décisionnelle a réduit les coûts, amélioré la latence et augmenté la fiabilité. La leçon est claire : ne faites pas du LLM le cerveau de votre système. Faites-en un outil spécialisé que vous appelez uniquement lorsque vous en avez besoin.

À mesure que le domaine de l'IA évolue, nous verrons probablement davantage d'architectures hybrides qui mélangent systèmes basés sur des règles, petits modèles et grands modèles de langage. L'expérience décrite ici est un petit pas dans cette direction. Essayez-la vous-même — vous pourriez être surpris de ce que vous pouvez accomplir sans LLM dans la boucle.