Guide

CAMEL : des agents qui dialoguent selon des rôles

CAMEL est une bibliothèque multi-agents née de la recherche : jeu de rôles, workforce, génération de données synthétiques et simulations. Quand l'utiliser.

L'équipe CodeWorlds13 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article10

CAMEL est né d'une question de recherche plutôt que d'un besoin de production, et sa construction le montre. La thèse d'origine était la suivante : deux modèles de langage, l'un jouant le demandeur et l'autre l'exécutant, résoudront une tâche mieux qu'un seul modèle à qui l'on donne directement l'instruction.

Cela ressemble à un tour de passe-passe et s'est avéré être la direction qu'a prise tout le domaine. Répartir les rôles entre celui qui formule les étapes suivantes et celui qui les exécute réduit la tendance du modèle à sauter des étapes et produit une trace du raisonnement que tu peux lire.

Aujourd'hui, le projet est plus que ce seul concept. C'est une bibliothèque pour construire des systèmes multi-agents, un outillage pour générer des données d'entraînement et une base pour exécuter des simulations. Cette étendue est sa force et aussi la raison pour laquelle on le juge mal.

Trois usages pour lesquels il convient

Les séparer dès le départ est rentable, car la documentation sur le projet les mélange généralement, et la décision de l'utiliser dépend de celui que tu as en tête.

Le premier est de construire des agents qui exécutent des tâches, c'est-à-dire ce que font les autres bibliothèques de cette catégorie. Ici le projet est un choix parmi d'autres, sans avantage particulier.

Le deuxième est de générer des données synthétiques. Deux agents qui conversent selon des rôles produisent une trace utilisable comme matériel d'entraînement ou de test. C'est l'usage où le projet devance réellement la concurrence, car il a été construit exactement pour cela.

Le troisième est la simulation. Des dizaines d'agents avec des rôles, des objectifs et la capacité de communiquer permettent d'étudier ce qui se passe au sein d'un groupe. C'est un usage de recherche, qui atteint rarement un produit, tout en restant intéressant pour modéliser des comportements.

Si tu cherches une bibliothèque pour construire un agent qui traite des tickets clients, le deuxième et le troisième ne te concernent pas, et pour le premier il vaut la peine de comparer avec des outils directement orientés production.

Un seul agent

Bash
pip install "camel-ai[all]"
Python
from camel.agents import ChatAgent
from camel.messages import BaseMessage

agent = ChatAgent(
    system_message=BaseMessage.make_assistant_message(
        role_name="Analyst",
        content="You analyse sales data. You answer with numbers and conclusions.",
    ),
)

response = agent.step("Which quarter had the highest margin and why?")
print(response.msg.content)

La notion de rôle est présente dès la première ligne, et c'est ce qui distingue la bibliothèque. Un agent n'est pas simplement un modèle avec des instructions mais un personnage avec une fonction nommée, ce qui compte dès que tu places plusieurs de ces personnages ensemble.

Les modèles de différents fournisseurs et ceux exécutés en local sont pris en charge, de même que les outils attachés via un protocole largement adopté, donc l'intégration avec des systèmes existants ne demande pas de connecteurs sur mesure.

Conversation selon des rôles

C'est le mécanisme d'où tout est parti.

Python
from camel.societies import RolePlaying

session = RolePlaying(
    assistant_role_name="Python developer",
    user_role_name="Data analyst",
    task_prompt="Build a sales report broken down by region.",
)

message = session.init_chat()
for _ in range(15):
    assistant_reply, user_reply = session.step(message)
    if assistant_reply.terminated or user_reply.terminated:
        break
    message = assistant_reply.msg

L'agent dans le rôle du demandeur formule des instructions successives, l'agent dans le rôle de l'exécutant les réalise, et la conversation se poursuit jusqu'à ce que la tâche soit résolue ou que la limite de tours soit atteinte. Personne ne planifie cela à l'avance : le découpage de la tâche en étapes émerge au fil de l'eau.

L'avantage est réel sur les tâches ouvertes où tu ne sais pas d'avance combien d'étapes elles demandent. L'inconvénient aussi : sur une tâche à l'ordre connu, ce mécanisme ajoute de l'incertitude et du coût sans rien rapporter.

La limite de tours est ici une protection plutôt qu'une formalité. Deux agents peuvent tomber dans un échange de politesses ou tourner en boucle sur une clarification, et chaque tour représente deux appels de modèle, donc la facture grandit à un rythme invisible tant qu'on ne compte pas.

Il vaut aussi la peine de savoir d'où vient le vrai coût d'une telle conversation. Chaque tour transporte tout l'historique jusque-là, donc la quinzième réplique coûte bien plus que la première alors qu'elle a l'air identique. Sur vingt tours, le coût d'une seule tâche peut dépasser le point où toute l'idée n'a plus de sens économique, et c'est exactement le moment de vérifier si la tâche a vraiment besoin d'une conversation.

Le conseil pratique en découle directement. Avant de lancer le jeu de rôles sur mille cas, lance-le sur dix et additionne les tokens consommés. Ce seul chiffre multiplié par l'échelle prévue en dit plus que n'importe quelle estimation faite à l'avance.

Une équipe d'agents

Un module plus récent te permet d'assembler une équipe où une tâche est divisée et répartie entre des exécutants de spécialités différentes.

Python
from camel.societies.workforce import Workforce

workforce = Workforce("Analytics team")
workforce.add_single_agent_worker("Data analyst", worker=analyst)
workforce.add_single_agent_worker("Report editor", worker=editor)

result = workforce.process_task(task)

Un coordinateur découpe la tâche en parties, les attribue et assemble les résultats, en revenant au découpage en cas d'échec. C'est plus proche de ce qu'on attend d'une bibliothèque de production qu'une conversation libre entre deux agents.

Juge-la avec prudence, cependant. Un arrangement avec coordinateur coûte cher, car la planification et l'assemblage des résultats sont des appels de modèle en plus du travail lui-même. Sur une tâche qui se décrit en trois étapes séquentielles, un flux plus simple fait mieux sur tous les plans.

Le gain n'apparaît que lorsque des parties de la tâche sont indépendantes les unes des autres et peuvent s'exécuter en parallèle. Le temps de réponse tombe alors à celui de la partie la plus lente au lieu de croître jusqu'à la somme de toutes, et le coût de planification se répartit sur quelque chose qui a vraiment été rentable. Avec des parties interdépendantes, le coordinateur devient un goulot d'étranglement et ajoute de la latence sans rien rapporter.

Les données synthétiques, le véritable avantage

Ici le projet fait quelque chose que la concurrence ignore ou ne fait qu'accessoirement.

Une conversation entre deux agents selon des rôles est une trace de dialogue prête à l'emploi, découpée en messages, étapes et résultat. Exécutée sur mille variantes de tâche, elle donne un jeu utilisable comme matériel de fine-tuning pour un modèle plus petit ou comme jeu de cas de test.

L'usage qui marche le mieux ressemble à ceci. Tu as un modèle coûteux qui traite une tâche et tu veux un modèle moins cher, d'efficacité comparable sur ce seul travail. Tu génères quelques milliers de conversations, tu les filtres pour la justesse et tu affines un modèle plus petit avec elles.

Trois réserves méritent d'être énoncées honnêtement. Première : les données générées par un modèle portent ses erreurs et ses biais, donc le filtrage et la vérification de la justesse font partie du processus plutôt que d'être un extra. Deuxième : les conditions d'utilisation des modèles restreignent parfois l'entraînement de modèles concurrents sur leurs sorties, donc lis-les avant de commencer. Troisième : un jeu généré à partir d'un seul modèle de tâche manque de variété, et la variété détermine la qualité du fine-tuning plus que le nombre d'exemples.

Comment construire un bon jeu de données

Puisque c'est l'avantage principal du projet, il vaut la peine de décrire tout le processus, car générer les conversations en est la partie la plus facile.

Commence par définir ce que le modèle cible doit faire. Pas « traiter les tickets » mais précisément : affecter un ticket à l'une de huit catégories, extraire le numéro de commande et proposer une réponse parmi trois variantes. Plus la tâche est étroite, mieux le fine-tuning d'un modèle plus petit fonctionne.

Occupe-toi ensuite de la variété des entrées, car c'est elle qui décide de la qualité. Mille conversations générées à partir d'un seul modèle de tâche valent moins que deux cents conversations issues de deux cents vrais cas différents. La meilleure source de variété est ton propre historique de données, utilisé comme point de départ des conversations.

La troisième étape est le filtrage, et une bonne part du jeu tombe généralement ici. Des contrôles automatisés repèrent les réponses au mauvais format, incomplètes ou contredisant l'entrée. Une revue manuelle sur une centaine d'exemples révèle des erreurs qu'aucune règle n'attrape et vaut l'heure qu'elle prend.

La quatrième est la séparation entre un jeu d'entraînement et un jeu d'évaluation, ce dernier étant construit à partir de vrais cas plutôt que de cas générés. Juger un modèle sur des données issues du même processus que celui qui l'a formé produit un chiffre gonflé et inutile.

La cinquième est la comparaison. Un modèle affiné gagne quand, à efficacité comparable, il coûte nettement moins cher ou répond nettement plus vite. Si l'écart de coût est d'une dizaine de pour cent, tout l'effort ne se rentabilise généralement pas et il est plus sage de rester sur un modèle plus grand avec un meilleur prompt.

Cette dernière voie mérite d'être envisagée plus tôt, car un meilleur prompt peut lui aussi être trouvé mécaniquement. DSPy optimise l'instruction et le choix des exemples placés dans la requête, guidé par une mesure de qualité que tu définis toi-même. Le jeu rassemblé pour le fine-tuning lui sert tel quel, et le résultat arrive en heures plutôt qu'en jours, donc l'ordre sensé est d'abord l'optimisation du prompt et le fine-tuning seulement si elle ne suffit pas.

Simulations multi-agents

Le troisième usage mérite quelques phrases, car on le confond avec la construction de systèmes de production, et c'est un travail entièrement différent.

Une simulation consiste à exécuter de nombreux agents avec des rôles, des objectifs et la capacité d'échanger des messages, puis à observer ce qui émerge. Il n'y a ici aucune bonne réponse et aucune métrique de succès au sens ordinaire, puisque le comportement du groupe est lui-même l'objet d'étude.

Les usages sont surtout de la recherche : vérifier comment une répartition des rôles affecte la qualité des solutions, comment l'information se propage dans un groupe, quand des boucles apparaissent et ce qui se passe quand un agent reçoit des instructions contradictoires. C'est précieux quand tu conçois ton propre système multi-agents, car cela révèle des limites que tu rencontreras de toute façon plus tard.

Garde toutefois deux choses en tête. La première est le coût : une simulation de vingt agents sur cent tours, c'est deux mille appels de modèle, donc un plafond de dépenses fixé à l'avance est obligatoire ici. La seconde est de tirer des conclusions avec prudence. Le comportement d'un modèle de langage dans une simulation en dit long sur les modèles et pas forcément sur les humains, et confondre les deux est l'erreur d'interprétation la plus courante dans ce domaine.

CAMEL face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
CAMELRôles, génération de données, simulationsRacines dans la recherche, moins d'outils de productionDonnées synthétiques et recherche sur les agents
CrewAIRôles avec des tâches clairement attribuées, simplicitéMoins flexible sur les tâches ouvertesUn processus aux étapes connues
LangGraphGraphe explicite, contrôle de l'état, diagnosticPlus de concepts et de codeUne production qui exige de la répétabilité
Microsoft Agent FrameworkSupport à long terme, une variante .NETAttirance vers AzureUne entreprise sur les technologies Microsoft

La décision est ici plus simple que d'habitude, car les projets visent des choses différentes. Pour un système qui sert de vrais utilisateurs, prends l'une des entrées orientées production, car elles offrent une meilleure observabilité, des points de reprise et du support.

Pour produire des données d'entraînement, étudier le comportement de groupe entre agents ou expérimenter avec des répartitions de rôles, cette bibliothèque fournit des outils que les autres n'ont tout simplement pas.

Erreurs courantes

La première est d'utiliser le jeu de rôles pour une tâche à l'ordre d'étapes connu. Le mécanisme ajoute alors du coût et de l'incertitude sans rien rapporter.

La deuxième est de ne mettre ni limite de tours ni plafond de coût. Chaque tour est deux appels de modèle, donc une conversation qui boucle fait monter la facture plus vite que l'intuition ne le suggère.

La troisième est de traiter des données générées par un modèle comme finies. Le filtrage et la vérification de la justesse font partie du processus, car un modèle reproduit ses propres erreurs.

La quatrième est de générer un jeu à partir d'un seul modèle de tâche. La variété détermine la qualité du fine-tuning plus que le nombre d'exemples.

La cinquième est de sauter les conditions d'utilisation du modèle avant de générer des données d'entraînement. Certains fournisseurs restreignent l'entraînement de modèles concurrents sur leurs sorties.

La sixième est de choisir cette bibliothèque pour un système de production uniquement parce qu'elle se lisait bien. La production valorise les points de reprise, l'observabilité et la prévisibilité, et l'accent est ici mis ailleurs.

FAQ

En quoi CAMEL diffère-t-il de CrewAI ?

Par son but. CrewAI vise des processus avec des rôles et des tâches clairement attribués, construit avec la production en tête. CAMEL est né de la recherche sur la façon dont les agents conversent et penche davantage vers la génération de données et la simulation. Pour l'automatisation typique, le premier est plus simple ; pour la recherche, le second apporte davantage.

Pour quoi convient-il vraiment ?

Trois choses : produire des données synthétiques à partir de conversations entre agents, étudier le comportement de groupe entre agents et construire des agents qui exécutent des tâches. Il est en tête sur les deux premières et il est un choix parmi d'autres sur la troisième.

Les données générées par des agents sont-elles utilisables pour l'entraînement ?

Après filtrage et vérification de la justesse, oui, et c'est une voie éprouvée vers un modèle moins cher d'efficacité comparable sur un seul travail. Sans cette étape, le jeu reproduit les erreurs du modèle qui l'a produit.

Fonctionne-t-il avec des modèles de plusieurs fournisseurs ?

Oui, différents fournisseurs sont pris en charge ainsi que des modèles exécutés en local, par exemple via Ollama. Les outils s'attachent aussi via un protocole largement adopté, donc l'intégration avec des systèmes existants ne demande pas de connecteurs sur mesure.

Convient-il à la production ?

Pour des usages simples, oui, tandis que les bibliothèques conçues directement pour la production offrent une meilleure observabilité, des points de reprise et une meilleure prévisibilité des exécutions. Si la répétabilité et le diagnostic facile comptent pour toi, commence par celles-là.

La documentation se trouve sur le site du projet, et le code dans le dépôt GitHub.

À lire aussi