Construire un système multi-agents avec Novita et CrewAI

Alors que l’industrie de l’IA commençait à reconnaître les capacités de raisonnement des grands modèles de langage (LLM), nous avons décidé de les rendre plus agentiques en leur permettant d’effectuer des actions plus complexes. Ces catégories de grands modèles de langage sont devenues connues sous le nom d’agents.

Les systèmes à agent unique sont donc nés. Mais il est rapidement devenu évident que confier plusieurs actions à un seul agent n’était pas la manière la plus intelligente de construire des systèmes agentiques. Une meilleure approche consistait à utiliser plusieurs agents, chacun ayant sa propre tâche à accomplir, travaillant ensemble pour atteindre un objectif défini par l’utilisateur.

Cependant, un autre problème est apparu. La gestion de plusieurs agents n’est pas aussi simple que celle d’un seul. Pour résoudre ce problème, plusieurs frameworks de systèmes multi-agents ont été introduits, et l’un des plus prometteurs est CrewAI.

CrewAI aide les développeurs à construire des systèmes multi-agents. Avec CrewAI, vous pouvez gérer vos agents, leurs tâches et leur flux de travail. Dans cet article, nous utiliserons CrewAI ainsi que la pléthore de LLM disponibles sur Novita pour construire des systèmes multi-agents pratiques et intelligents.

Qu’est-ce qu’un système multi-agents et pourquoi en avons-nous besoin ?

Depuis l’introduction des grands modèles de langage (LLM), plusieurs approches ont été explorées pour les rendre plus autonomes. L’une des plus populaires était le motif ReAct introduit dans l’article Synergizing Reasoning and Acting in Language Models. Des frameworks comme LangChain ont rapidement implémenté ReAct pour doter les LLM de capacités agentiques.

Des outils comme AutoGPT sont allés encore plus loin en construisant des agents IA plus robustes capables d’effectuer presque toutes les tâches souhaitées par l’utilisateur avec une simple invite textuelle. Bien que ces systèmes à agent unique aient montré de grandes promesses, ils présentaient des limites. Un agent unique s’appuie généralement sur un seul LLM pour gérer toutes les tâches, ce qui entraîne quelques inconvénients critiques :

• Contexte limité : Un agent unique doit gérer toutes les tâches à l’aide d’une seule fenêtre de contexte. Au fur et à mesure que le flux de travail progresse, l’agent finit par manquer d’espace de contexte.
• Complexité accrue : Au fur et à mesure que davantage de tâches sont confiées à un seul agent, le raisonnement devient plus difficile à gérer, rendant l’agent plus sujet aux hallucinations ou aux pannes.
• Point de défaillance unique : Avec un seul agent responsable de tout, il n’y a pas de solution de secours. S’il ne peut pas gérer une tâche, le système échoue complètement.
• Manque de parallélisation : Les tâches sont traitées les unes après les autres. Il n’y a pas de support intégré pour que les agents travaillent en parallèle pour accélérer les choses.

Les systèmes multi-agents ont été introduits pour répondre à ces défis. Au lieu de s’appuyer sur un seul agent pour gérer plusieurs tâches, un système multi-agents répartit les responsabilités entre plusieurs agents travaillant en collaboration. Cela permet d’éviter des problèmes comme le dépassement de la longueur du contexte, puisque chaque agent n’a qu’à gérer sa propre partie du flux de travail, et la charge globale de contexte est réduite.

Les configurations multi-agents vous permettent également d’utiliser différents modèles à des fins différentes : certains peuvent être affinés pour des tâches spécifiques, d’autres peuvent être livrés avec des invites prédéfinies, certains peuvent être équipés d’outils spécialisés et d’autres peuvent être optimisés pour le raisonnement. Cette diversité améliore non seulement les performances, mais permet également la parallélisation, rendant les systèmes multi-agents plus rapides et plus efficaces que leurs homologues à agent unique.

Pour construire un système multi-agents, vous avez besoin de deux composants principaux : un fournisseur de modèles qui fournit les LLM, et un framework multi-agents pour gérer l’ensemble du flux de travail agentique. Dans cet article, nous utiliserons Novita comme fournisseur de modèles et CrewAI comme framework de choix.

Pourquoi avez-vous besoin d’un framework comme CrewAI ?

La construction d’un système multi-agents est bien plus complexe que celle d’un système à agent unique. Par exemple, vous pouvez facilement transformer n’importe quel modèle sur Novita en agent en lui fournissant des outils grâce à l’utilisation du function calling. Mais une fois que vous commencez à connecter plusieurs agents, la complexité augmente considérablement. Vous devez maintenant gérer plusieurs éléments mobiles, notamment :

• Communication et délégation de tâches : Vous devez coordonner la façon dont les agents communiquent entre eux et dont les tâches sont transmises entre eux.
• Gestion des outils : Sans framework, vous êtes responsable de la gestion manuelle des définitions d’outils et des schémas JSON, ce qui peut rapidement devenir désordonné.
• Architectures et motifs agentiques : Les frameworks multi-agents sont souvent livrés avec un support intégré pour des motifs agentiques bien établis. Si vous construisez à partir de zéro, vous devrez rester à jour sur ces motifs en évolution et les implémenter vous-même.
• Observabilité : Sans framework, vous êtes également responsable de la mise en place de vos propres outils pour surveiller, déboguer et visualiser la façon dont vos agents interagissent et performent.

Un framework multi-agents peut aider à gérer toutes ces complexités. Dans cet article, nous utiliserons CrewAI comme framework de choix. CrewAI offre plusieurs avantages par rapport aux autres frameworks : il se distingue par sa simplicité, utilisant des concepts intuitifs pour modéliser des systèmes multi-agents ; il est mature et bien établi ; et il offre une excellente expérience développeur.

Comprendre les concepts clés de CrewAI

Pour construire des systèmes multi-agents avec CrewAI, vous devez être familiarisé avec quelques concepts clés introduits par le framework. Voici un bref aperçu des principaux que nous utiliserons dans cet article :

• Agents
• Tasks
• Crews
• Processes
• Flows

Agents

Les agents sont le cœur de CrewAI. Ils représentent les véritables travailleurs IA alimentés par un LLM. Chaque agent dans CrewAI est défini par un rôle, un objectif qui guide sa prise de décision et une histoire de fond qui façonne sa personnalité. Tous ces éléments sont représentés sous forme d’invites textuelles envoyées au LLM. Les agents peuvent également être équipés d’outils, parmi lesquels ils peuvent choisir pour effectuer des actions spécifiques. L’objectif principal d’un agent dans CrewAI est d’accomplir la ou les tâches qui lui sont assignées.

Tasks

Les tâches définissent le travail qui doit être accompli. Dans CrewAI, vous pouvez créer des tâches et soit les assigner directement à des agents spécifiques, soit laisser les agents les récupérer s’ils correspondent aux exigences de la tâche. Chaque tâche comprend généralement une description claire, un résultat attendu et d’autres paramètres pertinents tels qu’un agent facultatif pouvant gérer la tâche.

Crew

Il s’agit du concept central de CrewAI. Dans CrewAI, un groupe d’agents travaillant ensemble pour accomplir des tâches est appelé un crew. Un crew définit également le flux de travail des agents qui le composent.

Processes

Un processus est un flux de travail prédéfini qui indique à un crew comment exécuter ses tâches. CrewAI prend en charge deux types principaux de processus :

• Séquentiel : Les tâches sont traitées une par une par les agents du crew.
• Hiérarchique : Dans ce processus, un agent fait office de manager, coordonnant les autres agents et déléguant des tâches si nécessaire.

Flows

Alors que les processus sont des flux de travail prédéfinis, les flows CrewAI offrent aux développeurs la flexibilité de concevoir des flux de travail d’agents personnalisés. Un flow peut inclure des agents, des tâches et même des crews entiers, permettant des interactions plus complexes.

Construire des Crews avec Novita

Maintenant que nous avons couvert les concepts clés de CrewAI, passons à la construction d’un Crew. Dans cet exemple, nous allons créer un Crew conçu pour aider les utilisateurs à construire rapidement un produit minimum viable (MVP). Ce Crew est composé de trois agents spécialisés :

• Architecte : Définit la structure du logiciel et décrit le périmètre du MVP. Cet agent est alimenté par le modèle moonshotai/kimi-k2-instruct, hébergé sur Novita.
• Développeur : Met en œuvre le plan de l’Architecte et écrit le code réel. Il utilise un outil FileWriter pour créer tous les fichiers du projet et fonctionne sur le modèle qwen/qwen3-coder-480b-a35b-instruct de Novita.
• Réviseur : Analyse le code généré par le Développeur et suggère des améliorations sous forme de feedback de type diff. Tout comme l’Architecte, il utilise également le modèle moonshotai/kimi-k2-instruct.

Notre Crew suivra un processus séquentiel.

Installation et configuration

Maintenant que nous avons un plan en place, commençons par configurer notre environnement. Nous allons d’abord installer CrewAI ainsi que son support d’outils intégré :

pip install 'crewai[tools]'

Ensuite, vous aurez besoin de votre clé API Novita. Une fois que vous l’avez, ajoutez-la à vos variables d’environnement sous le nom NOVITA_API_KEY :

export NOVITA_API_KEY=your_api_key_here

Une fois cela fait, nous sommes prêts à commencer à construire le Crew.

Création des LLM

Commençons par importer les dépendances nécessaires :

import os
from crewai import Agent, Task, Crew, Process, LLM
from crewai_tools import FileWriterTool

Ensuite, nous allons créer une instance de FileWriterTool, qui sera utilisée par l’agent Développeur pour écrire des fichiers sur le disque :

file_writer_tool = FileWriterTool()

Avec les outils en place, nous pouvons maintenant initialiser les LLM pour chacun de nos agents :

architect_llm = LLM(
   model="novita/moonshotai/kimi-k2-instruct",
   temperature=0.5,
   api_base="https://api.novita.ai/v3/openai",
   api_key=os.environ['NOVITA_API_KEY']
)

coder_llm = LLM(
   model="novita/qwen/qwen3-coder-480b-a35b-instruct",
   temperature=0.4,
   api_base="https://api.novita.ai/v3/openai",
   api_key=os.environ['NOVITA_API_KEY']
)

reviewer_llm = LLM(
   model="novita/moonshotai/kimi-k2-instruct",
   temperature=0.5,
   api_base="https://api.novita.ai/v3/openai",
   api_key=os.environ['NOVITA_API_KEY']
)

Ces trois instances de LLM correspondent aux modèles décrits dans notre plan. Ils sont hébergés sur Novita et accessibles via CrewAI. En coulisses, CrewAI utilise LiteLLM pour se connecter à ces modèles et les gérer.

Définition des Agents

Maintenant, créons les trois agents :

architect = Agent(
   role="Software Architect for MVP Projects",
   goal="Define a basic system structure and simple feature set to guide MVP development",
   backstory="""You specialize in quickly outlining software architectures and project scopes for
minimum viable products. Your plans help guide coders with enough structure to get started while staying lean.""",
   llm=architect_llm,
   verbose=True
)

coder = Agent(
   role="Developer for MVP Projects",
   goal="Implement the MVP using simple, clear code, and write all necessary code files using the FileWriter tool",
   backstory="""You're a practical developer focused on speed. You prioritize working code over polish.
Simulate any runtime behavior if needed, and make sure to keep code clear and modular.""",
   llm=coder_llm,
   verbose=True,
   tools=[file_writer_tool]
)

reviewer = Agent(
   role="Code Reviewer for MVP Projects",
   goal="Read the code files, provide helpful feedback, and write improvements as diffs into a markdown file",
   backstory="""You're a fast but thoughtful reviewer. You check code for clarity, obvious bugs, and
provide improvements as diffs. Instead of modifying code directly, you 
save your suggestions in a markdown file
for easy inspection.""",
   llm=reviewer_llm,
   verbose=True,
   tools=[file_writer_tool]
)

Chaque agent se voit attribuer un rôle, un objectif et une histoire de fond spécifiques.

Définition des Tâches

Créons les tâches des agents :

architect_task = Task(
   description="""
Create a basic plan for building a simple MVP version of a {project}.
Focus on the core features, basic file structure, and tech stack.
Make the structure minimal but enough to get a working demo.
""",
   expected_output="""
A simple architectural overview with:
- Project goals
- Key components or files
- Basic data flow or structure
""",
   agent=architect,
   output_file="architecture.md"
)

coder_task = Task(
   description="""
Based on the architect's plan, implement the core parts of the {project} MVP.
Keep it lean and functional. Use the FileWriter tool to save all your code files.
If you need to simulate behavior (e.g. without a real interpreter), do so with clear comments or mocked logic.
""",
   expected_output="""
Working code files saved using the FileWriter tool that implement the key features defined in the plan.
Code should be readable and logically structured.
""",
   agent=coder,
   context=[architect_task]
)

review_task = Task(
   description="""
Review the code files created for the {project} MVP. Read each file using the FileRead tool.
Suggest improvements using diffs. Do not modify the original code files directly.
Instead, save all your suggested diffs into a markdown file using the FileWriter tool.
""",
   expected_output="""
A markdown file containing diff-style suggestions for each file reviewed.
""",
   agent=reviewer,
   context=[coder_task],
   output_file="code_review_diffs.md"
)

Création du Crew

Maintenant que nous avons défini nos agents, leurs LLM respectifs et leurs tâches, rassemblons tout en constituant le crew :

code_crew = Crew(
   agents=[architect, coder, reviewer],
   tasks=[architect_task, coder_task, review_task],
   process=Process.sequential,
   verbose=True
)

Une fois tout configuré, nous pouvons maintenant exécuter le crew :

if __name__ == "__main__":
   code_crew.kickoff(inputs={"project": "Todo App"})

Nous avons maintenant un crew entièrement fonctionnel capable de générer un projet MVP basé sur une spécification définie par l’utilisateur. Dans l’exemple ci-dessus, nous avons demandé au crew de construire une simple application de to-do.

Voici comment cela fonctionne :

1. L’agent Architecte lance les opérations en concevant l’architecture logicielle et en enregistrant le plan dans un fichier appelé architecture.md.
2. L’agent Développeur récupère ensuite la sortie de l’architecte et crée les répertoires et fichiers de code nécessaires pour implémenter l’application de to-do.
3. Enfin, l’agent Réviseur examine le code généré et fournit des suggestions sous forme de diffs, enregistrant ses retours dans un fichier appelé code_review_diffs.md.

Ce flux de travail de développement basé sur un crew est puissant et modulaire, mais il n’est pas sans quelques limites :

• Invites codées en dur : En intégrant des invites directement dans le code, il devient plus difficile de les maintenir ou de les améliorer au fil du temps.
• Structure dispersée : Les agents et les tâches sont définis en ligne, ce qui peut conduire à un script désordonné et plus difficile à naviguer au fur et à mesure que le projet grandit.

Dans la section suivante, nous verrons comment nettoyer cela en externalisant les définitions d’agents et les invites de tâches dans des fichiers YAML.

Construction de Crews basés sur des classes

CrewAI nous permet de créer des crews basés sur des classes. Mettons à jour notre code précédent pour suivre cette structure. Tout d’abord, créez un dossier appelé config. Ce dossier contiendra des fichiers YAML qui définissent la configuration des agents et des tâches.

Créons un fichier nommé agents.yaml, qui servira de fichier de configuration des agents :

architect:
 role: >
   Software Architect for MVP Projects
 goal: >
   Define a basic system structure and simple feature set to guide MVP development
 backstory: >
   You specialize in quickly outlining software architectures and project scopes for minimum viable products.
  Your plans help guide coders with enough structure to get started while staying lean.

coder:
 role: >
   Developer for MVP Projects
 goal: >
   Implement the MVP using simple, clear code, and write all necessary code files using the FileWriter tool
 backstory: >
   You're a practical developer focused on speed. You prioritize working code over polish.
  Simulate any runtime behavior if needed, and make sure to keep code clear and modular.

reviewer:
 role: >
   Code Reviewer for MVP Projects
 goal: >
   Read the code files, provide helpful feedback, and write improvements as diffs into a markdown file
 backstory: >
   You're a fast but thoughtful reviewer. You check code for clarity, obvious bugs, and provide improvements
  as diffs. Instead of modifying code directly, you save your suggestions in a markdown file for easy inspection.

Ce fichier définit les rôles, les objectifs et les histoires de fond de chaque agent.

Ensuite, nous allons créer un fichier tasks.yaml pour contenir les configurations des tâches :

À la place, enregistrez toutes vos diffs suggérées dans un fichier markdown en utilisant l’outil FileWriter.

architect_task:
 description: >
   Create a basic plan for building a simple MVP version of a {project}.
  Focus on the core features, basic file structure, and tech stack.
  Make the structure minimal but enough to get a working demo.
 expected_output: >
   A simple architectural overview with:
  - Project goals
  - Key components or files
  - Basic data flow or structure
 agent: architect
 output_file: architecture.md

coder_task:
 description: >
   Based on the architect's plan, implement the core parts of the {project} MVP.
  Keep it lean and functional. Use the FileWriter tool to save all your code files.
  If you need to simulate behavior (e.g. without a real interpreter), do so with clear comments or mocked logic.
 expected_output: >
   Working code files saved using the FileWriter tool that implement the key features defined in the plan.
  Code should be readable and logically structured.
 agent: coder
 context:
   - architect_task

review_task:
 description: >
   Review the code files created for the {project} MVP. Read each file using the FileRead tool.
  Suggest improvements using diffs. Do not modify the original code files directly.
  Instead, save all your suggested diffs into a markdown file using the FileWriter tool.
 expected_output: >
   A markdown file containing diff-style suggestions for each file reviewed.
 agent: reviewer
 context:
   - coder_task
 output_file: code_review_diffs.md

Ensuite, créons notre Crew basé sur des classes. Pour cela, nous définissons une classe et la décorons avec le décorateur @CrewBase fourni par CrewAI.

@CrewBase
class CodeCrew():
   """Three-agent code crew: architect, coder, reviewer"""

   @agent
   def architect(self) -> Agent:
       pass

   @agent
   def coder(self) -> Agent:
       pass

   @agent
   def reviewer(self) -> Agent:
       pass

   @task
   def architect_task(self) -> Task:
       pass

   @task
   def code_task(self) -> Task:
       pass

   @task
   def review_task(self) -> Task:
       pass

   @crew
   def crew(self) -> Crew:
       pass

Dans cette structure :

• Le décorateur @agent est utilisé pour définir les méthodes produisant des agents.
• Le décorateur @task marque les méthodes produisant des tâches.
• Le décorateur @crew spécifie la méthode qui assemble l’ensemble du crew.

Maintenant, examinons l’implémentation complète :

import os
from crewai import Agent, Crew, Process, Task, LLM
from crewai.project import CrewBase, agent, crew, task
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

from crewai_tools import FileWriterTool

# Instantiate tool
file_writer_tool = FileWriterTool()

@CrewBase
class CodeCrew():

   agents: List[BaseAgent]
   tasks: List[Task]

   agents_config = 'config/agents.yaml'
   tasks_config = 'config/tasks.yaml'
  
   @agent
   def architect(self) -> Agent:
       llm = LLM(
           model="novita/moonshotai/kimi-k2-instruct",
           temperature=0.5,
           api_base="https://api.novita.ai/v3/openai",
           api_key=os.environ['NOVITA_API_KEY']
       )
       return Agent(
           config=self.agents_config['architect'],
           llm=llm,
           verbose=True
       )

   @agent
   def coder(self) -> Agent:
       llm = LLM(
           model="novita/qwen/qwen3-coder-480b-a35b-instruct",
           temperature=0.4,
           api_base="https://api.novita.ai/v3/openai",
           api_key=os.environ['NOVITA_API_KEY']
       )
       return Agent(
           config=self.agents_config['coder'],
           llm=llm,
           verbose=True,
           tools=[file_writer_tool]
       )

   @agent
   def reviewer(self) -> Agent:
       llm = LLM(
           model="novita/moonshotai/kimi-k2-instruct",
           temperature=0.5,
           api_base="https://api.novita.ai/v3/openai",
           api_key=os.environ['NOVITA_API_KEY']
       )
       return Agent(
           config=self.agents_config['reviewer'],
           llm=llm,
           verbose=True,
       )

   @task
   def architect_task(self) -> Task:
       return Task(config=self.tasks_config['architect_task'])

   @task
   def coder_task(self) -> Task:
       return Task(config=self.tasks_config['coder_task'])

   @task
   def review_task(self) -> Task:
       return Task(config=self.tasks_config['review_task'])

   @crew
   def crew(self) -> Crew:
       return Crew(
           agents=self.agents,
           tasks=self.tasks,
           process=Process.sequential,
           verbose=True
       )

Ce code définit toutes les méthodes nécessaires et inclut des attributs pour les agents et les tâches. Il spécifie également les chemins vers les fichiers de configuration, qui sont utilisés dans les méthodes d’agent et de tâche pour charger leurs paramètres respectifs.

Vous pouvez maintenant exécuter le crew en ajoutant le code suivant au script :

def main():
   code_crew = CodeCrew()
   code_crew.crew().kickoff(inputs={"project": "Todo App"})
if __name__ == '__main__':
   main()

Construire des Flows avec Novita

Nous avons précédemment construit un crew qui suivait un processus séquentiel. Maintenant, explorons comment construire un flow qui suit un flux de travail conçu sur mesure.

Notre flux de travail

Nous voulons concevoir un système multi-agents de support client qui dispose d’un agent principal responsable de la classification des problèmes des clients. Sur la base de cette classification, le système déterminera quel agent spécialisé est le plus à même de traiter le problème. La configuration est composée de quatre agents :

• Agent client : Il s’agit de l’agent principal. Il reçoit le problème du client et le classe dans l’une des catégories suivantes : Facturation, Technique ou Général.
• Agent de facturation : Traite tous les problèmes liés à la facturation.
• Agent technique : Traite les problèmes techniques.
• Agent général : Traite tous les problèmes qui ne rentrent pas dans les catégories ci-dessus.

Définition de l’état du Flow

Les flows dans CrewAI disposent d’un état partagé. L’état est accessible à tous les agents et crews du flow. Pour notre flux de support client, l’état contient le libellé du problème et la requête de l’utilisateur.

Importons les modules nécessaires et définissons notre état :

import json
import os
from typing import Literal, Dict, Any
from pydantic import BaseModel, ValidationError
from crewai import Agent, LLM
from crewai.flow.flow import Flow, start, router, listen

# Define the flow state
class SupportState(BaseModel):
   issue: Literal["billing", "technical", "general"] = "general"
   message: str = ""

Création du Flow

Les flows dans CrewAI sont basés sur des graphes et utilisent un système événementiel pour gérer les transitions entre les nœuds. Pour créer notre flow, nous allons commencer par un nœud qui classe le problème, suivi d’un nœud routeur qui détermine vers quel nœud de traitement acheminer la demande en fonction de la classification.

class CustomerSupportFlow(Flow[SupportState]):

   @start()
   def classify_issue(self):
       pass

   @router(classify_issue)
   def route_based_on_issue(self) -> str:
       print(f"📨 Routing to agent for issue type: {self.state.issue}")
       if self.state.issue == "billing":
           return "billing"
       if self.state.issue == "technical":
           return "technical"
       else:
           return "general"       

   @listen("billing")
   def handle_billing(self):
       pass

   @listen("technical")
   def handle_technical(self):
       pass

   @listen("general")
   def handle_general(self):
       pass

La méthode décorée avec @start() est le point d’entrée du flow. Dans ce cas, elle gère la classification des problèmes. La méthode décorée avec @router() est exécutée après classify_issue et détermine vers quel agent acheminer la demande. Les autres méthodes utilisent le système événementiel pour répondre lorsqu’elles sont acheminées.

Implémentation des méthodes du Flow

Implémentons maintenant chaque méthode et assignons l’agent approprié à chacune :

class CustomerSupportFlow(Flow[SupportState]):

   @start()
   def classify_issue(self) -> Dict[str, Any]:
       intake_agent = Agent(
           role="User Intake Agent",
           goal="Classify user support issue and summarize the message",
           backstory="You classify the user query into billing, technical, or general categories.",
           llm=LLM(
               model="novita/qwen/qwen2.5-vl-72b-instruct",
               temperature=0.3,
               api_base="https://api.novita.ai/v3/openai",
               api_key=os.environ["NOVITA_API_KEY"]
           ),
           verbose=True
       )
      
       prompt = f"""
           A user submitted this message: "{self.state.message}"

           Your task:
           1. Identify whether the issue is "billing", "technical", or "general".
           2. Rephrase or extract the message clearly.

           Respond in valid JSON format like the example below:

           {{
               "issue": "billing",
               "message": "The user has been charged twice for their subscription and is requesting a refund."
           }}
       """

       output = intake_agent.kickoff(prompt, response_format=SupportState)
      
       try:
           # Parse the JSON string
           print(output.raw)
           parsed_json = json.loads(output.raw)

           # Validate with Pydantic
           validated = SupportState(**parsed_json)

           # Save to state
           self.state.issue = validated.issue
           self.state.message = validated.message

       except (json.JSONDecodeError, ValidationError) as e:
           print("❌ Failed to parse or validate response:", e)
           self.state.issue = "general"

   @router(classify_issue)
   def route_based_on_issue(self) -> str:
       print(f"📨 Routing to agent for issue type: {self.state.issue}")
       if self.state.issue == "billing":
           return "billing"
       if self.state.issue == "technical":
           return "technical"
       else:
           return "general"       

   @listen("billing")
   def handle_billing(self):
       agent = Agent(
           role="Billing Agent",
           goal="Handle billing questions, refunds, and invoice issues",
           backstory="You resolve billing-related queries effectively.",
           llm=LLM(
               model="novita/meta-llama/llama-3.3-70b-instruct",
               temperature=0.5,
               api_base="https://api.novita.ai/v3/openai",
               api_key=os.environ["NOVITA_API_KEY"]
           ),
           verbose=True
       )
       result = agent.kickoff(self.state.message)
       print("💰 Billing Agent Response:", result)

   @listen("technical")
   def handle_technical(self):
       agent = Agent(
           role="Technical Support Agent",
           goal="Help users resolve technical issues",
           backstory="You're a technical expert providing troubleshooting support.",
           llm=LLM(
               model="novita/meta-llama/llama-3.1-8b-instruct",
               temperature=0.5,
               api_base="https://api.novita.ai/v3/openai",
               api_key=os.environ["NOVITA_API_KEY"]
           ),
           verbose=True
       )
       result = agent.kickoff(self.state.message)
       print("🛠 Technical Agent Response:", result)

   @listen("general")
   def handle_general(self):
       agent = Agent(
           role="General Support Agent",
           goal="Provide helpful answers to non-technical and non-billing questions",
           backstory="You're friendly and well-informed about our services.",
           llm=LLM(
               model="novita/minimaxai/minimax-m1-80k",
               temperature=0.5,
               api_base="https://api.novita.ai/v3/openai",
               api_key=os.environ["NOVITA_API_KEY"]
           ),
           verbose=True
       )
       result = agent.kickoff(self.state.message)
       print("📋 General Agent Response:", result)

La méthode classify_issue utilise Pydantic pour s’assurer que le modèle renvoie une réponse valide. Une fois cette configuration terminée, nous pouvons maintenant exécuter le flow en utilisant le code suivant :

def run():
   flow = CustomerSupportFlow()
   flow.plot("CustomerSupportFlowPlot")

   # Example input message
   example_input = {
       "message": "Hello, I was charged twice for my subscription and need a refund."
   }

   flow.kickoff(inputs=example_input)

if __name__ == "__main__":
   run()

Conclusion

Pour construire un système multi-agents, vous avez besoin de deux composants clés : un fournisseur de modèles qui offre une grande variété de modèles, et un framework multi-agents pour orchestrer leurs interactions. Dans cet article, nous avons montré comment Novita et CrewAI peuvent remplir ces rôles efficacement. Pour en savoir plus sur CrewAI, n’hésitez pas à explorer leur documentation. Et si vous cherchez à expérimenter avec plus de modèles pour vos crews, consultez le terrain de jeu LLM Novita.

Dépôt avec les fichiers - https://github.com/novitalabs/Novita-CollabHub/tree/main/examples/novita-crewai

À propos de Novita AI

NovitaAIest une plateforme cloud IA qui offre aux développeurs un moyen simple de déployer des modèles IA grâce à notre API simple, tout en fournissant un cloud GPU abordable et fiable pour la construction et la mise à l’échelle.