IA Multi-Agents : Réduire les Coûts des Tokens Efficacement

La problématique de la consommation de tokens dans les systèmes IA multi-agents

Dans le domaine de l'intelligence artificielle, l'utilisation de plusieurs agents pour collaborer sur des tâches complexes est devenue courante. Cependant, cette approche peut rapidement entraîner une augmentation significative du nombre de tokens utilisés. Les tokens, qui sont des unités de texte ou d'information, s'accumulent à travers divers éléments tels que les journaux de mémoire, les spécifications d'outils, et les instructions système. Cette accumulation peut non seulement ralentir les processus mais aussi épuiser les budgets de calcul alloués.

Pour les développeurs et les praticiens de l'IA, gérer efficacement l'utilisation des tokens est devenu crucial. Heureusement, il existe des solutions pour optimiser les architectures multi-agents sans nécessairement augmenter les coûts. Cet article explore quatre stratégies qui permettent de réduire l'utilisation des tokens tout en maintenant l'efficacité des systèmes.

Stratégies pour optimiser l'utilisation des tokens

Voici quatre approches couramment adoptées pour améliorer l'efficacité des solutions d'IA multi-agents en matière de gestion des tokens.

1. Mise en cache des instructions statiques

La première stratégie repose sur la mise en cache des instructions statiques, également connue sous le nom de Prefix-Match Caching. Les grands modèles de langage (LLMs), qui constituent le cœur des agents IA modernes, passent souvent beaucoup de temps à relire les mêmes instructions lors de chaque interaction. En stockant ces instructions sous forme de paires clé-valeur, la mise en cache des préfixes permet de conserver des directives longues et statiques comme référence. Ainsi, au lieu de relire intégralement le manuel d'instructions à chaque requête, le modèle peut simplement accéder à un état résumé et se concentrer sur la nouvelle tâche. Cette méthode réduit considérablement la latence de préparation et diminue les coûts en tokens.

2. Mise en cache sémantique : rappel basé sur l'intention

La mise en cache sémantique est une autre stratégie efficace. Elle repose sur l'idée que si un agent IA a déjà résolu un problème similaire, il n'est pas nécessaire de générer une nouvelle réponse à partir de zéro. Cette approche utilise des embeddings, qui sont des représentations numériques du texte, pour identifier rapidement des intentions similaires dans le passé. Par exemple, des requêtes telles que "Comment réinitialiser mon routeur ?" et "Quelles étapes pour redémarrer ma box wifi ?" peuvent être reconnues comme ayant la même intention grâce à la mise en cache sémantique. Cela permet parfois d'éviter complètement le recours aux LLMs tout en fournissant une réponse appropriée.

3. Utilisation d'outils à la demande

La troisième stratégie, connue sous le nom de lazy loading, vise à éviter le préchargement de vastes manuels de référence pour chaque API et outil disponible. Plutôt que de surcharger les agents avec des informations inutiles, il est plus efficace de fournir un annuaire concis de leurs capacités. L'agent ne récupère les instructions détaillées et les paramètres nécessaires que lorsqu'une tâche spécifique le requiert. Cette approche réduit la consommation de tokens en ne chargeant que les informations nécessaires au moment opportun.

4. Escalade des tâches : routage de modèle rentable

Enfin, l'escalade des tâches est une méthode qui consiste à analyser chaque requête utilisateur pour déterminer le modèle le plus approprié à utiliser. Toutes les tâches ne nécessitent pas l'intervention de modèles massifs et coûteux. Les architectures d'IA multi-agents efficaces fonctionnent comme des centres de triage, dirigeant les tâches simples vers des modèles légers et gratuits, capables de les traiter localement. Les modèles plus puissants sont réservés aux tâches complexes nécessitant un raisonnement approfondi ou une orchestration sur plusieurs étapes.

Exemple d'implémentation pratique

Pour illustrer l'application de ces stratégies, examinons un exemple d'implémentation combinant la mise en cache sémantique et le routage de modèle. Le code suivant utilise un modèle de transformation de phrases pour convertir le texte en embeddings nécessaires à la mise en cache sémantique. Les appels aux LLMs sont simulés, mais peuvent être remplacés par des modèles réels et gratuits disponibles sur des plateformes comme Groq.

import numpy as np
from sentence_transformers import SentenceTransformer

# Chargement d'un modèle local gratuit pour convertir le texte en embeddings
embedder = SentenceTransformer('all-MiniLM-L6-v2')

# Cache sémantique en mémoire et seuil de similarité (0.90 = 90% similaire)
semantic_cache = {}
SIMILARITY_THRESHOLD = 0.90

def cosine_similarity(vec1, vec2):
    """Calcule à quel point deux requêtes sont étroitement liées."""
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

def route_and_respond(user_query):
    # 1. Conversion de la requête actuelle en un vecteur d'embedding
    query_vector = embedder.encode(user_query)

    # 2. Mise en cache sémantique : Vérifiez si un problème similaire a été résolu récemment
    for cached_vector, past_response in semantic_cache.values():
        if cosine_similarity(query_vector, cached_vector) >= SIMILARITY_THRESHOLD:
            return f"[Servi depuis le cache] {past_response}"

    # 3. Routage de modèle : Triage de la tâche en fonction de sa complexité
    # Les tâches simples sont routées vers un modèle gratuit, hébergé localement (par exemple, Llama 3 via Ollama)
    # Cette logique de routage est illustrative uniquement ; ne pas utiliser en production
    if "résumer" in user_query.lower() or len(user_query) < 100:
        response = call_free_local_agent(user_query)
    else:
        # Le raisonnement complexe à plusieurs étapes est escaladé vers un agent d'orchestration plus grand
        response = call_heavy_reasoning_agent(user_query)

    # 4. Enregistrer le nouveau vecteur et la réponse dans notre cache pour les futurs utilisateurs
    semantic_cache[user_query] = (query_vector, response)

# --- Simulation des fonctions d'agent pour illustration : aucun LLM réel invoqué ici ---
def call_free_local_agent([prompt](/glossaire/prompt)):
    return "Action complétée par un modèle local, sans coût."

def call_heavy_reasoning_agent(prompt):
    return "Action complétée par un agent d'orchestration complexe."

# Exemple d'utilisation : simulation de l'utilisation alternative de différents agents/modèles
# Commenter/décommenter pour essayer les deux exemples et essayer le vôtre
print(route_and_respond("Résumer les journaux du serveur d'aujourd'hui"))
# print(route_and_respond("Rédiger un itinéraire optimal d'un mois pour mon prochain voyage au Japon. Prendre en compte l'ensemble des documents, les horaires des transports en commun et d'autres documents fournis, ainsi que les informations API en temps réel"))

La complexité de la tâche demandée dans l'invite passée à `route_and_respond()` déterminera quel type de modèle est utilisé.

La sortie de l'exécution de ce code sera l'un des deux messages de retour dans ces fonctions :

```python
def call_free_local_agent(prompt):
    return "Action complétée par un modèle local, sans coût."

def call_heavy_reasoning_agent(prompt):
    return "Action complétée par un agent d'orchestration complexe."

Cet article a décrit quatre stratégies clés à prendre en compte lors de la mise en œuvre d'applications et d'architectures d'IA multi-agents, en mettant l'accent sur l'optimisation de l'utilisation des tokens et la réduction des coûts et de la latence. À travers un exemple pratique basé sur des simulations, nous avons renforcé notre compréhension de l'application de deux d'entre elles en combinaison : la mise en cache sémantique et le routage de modèle.

Iván Palomares Carrascosa est un leader, écrivain, conférencier et conseiller en IA, apprentissage automatique, apprentissage profond et LLMs. Il forme et guide les autres dans l'exploitation de l'IA dans le monde réel.