CrewAI

Ce guide vous montre comment utiliser Weave pour surveiller et tracer des applications multi-agents CrewAI, y compris les Crews et les Flows. CrewAI est un framework Python destiné à créer des agents d’IA autonomes. Il est indépendant de LangChain et des autres frameworks d’agents, et prend en charge deux abstractions : les Crews de haut niveau et les Flows de bas niveau. Les applications CrewAI se composent souvent de plusieurs agents qui collaborent entre eux, ce qui rend essentiel de comprendre comment ils coopèrent et communiquent. Weave capture automatiquement les traces de vos applications CrewAI afin que vous puissiez surveiller et analyser les performances et les interactions de vos agents. Les sections suivantes expliquent le traçage d’un Crew, le suivi de l’utilisation des outils, le traçage d’un Flow et l’encapsulation d’une fonction de garde-fou en tant qu’op Weave.

Premiers pas avec Crew

Pour exécuter cet exemple, installez CrewAI et Weave. Pour plus d’informations sur l’installation de CrewAI, voir le guide d’installation de CrewAI.

pip install crewai weave

L’exemple suivant crée un Crew CrewAI et suit l’exécution à l’aide de Weave. Pour activer le traçage, appelez weave.init() au début de votre script. L’argument de weave.init() est le nom du projet dans lequel Weave journalise les traces.

import weave
from crewai import Agent, Task, Crew, LLM, Process

# Initialiser Weave avec le nom de votre projet
weave.init(project_name="crewai_demo")

# Créer un LLM avec une température de 0 pour garantir des sorties déterministes
llm = LLM(model="gpt-4o-mini", temperature=0)

# Créer des agents
researcher = Agent(
    role='Research Analyst',
    goal='Find and analyze the best investment opportunities',
    backstory='Expert in financial analysis and market research',
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

writer = Agent(
    role='Report Writer',
    goal='Write clear and concise investment reports',
    backstory='Experienced in creating detailed financial reports',
    llm=llm,
    verbose=True,
    allow_delegation=False,
)

# Créer des tâches
research_task = Task(
    description='Deep research on the {topic}',
    expected_output='Comprehensive market data including key players, market size, and growth trends.',
    agent=researcher
)

writing_task = Task(
    description='Write a detailed report based on the research',
    expected_output='The report should be easy to read and understand. Use bullet points where applicable.',
    agent=writer
)

# Créer un crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    verbose=True,
    process=Process.sequential,
)

# Exécuter le crew
result = crew.kickoff(inputs={"topic": "AI in material science"})
print(result)

Weave suit et consigne tous les appels effectués via la bibliothèque CrewAI, y compris les interactions entre agents, les exécutions de tâches et les appels LLM. Vous pouvez consulter les traces dans l’interface web de Weave.

CrewAI fournit plusieurs méthodes pour mieux contrôler le processus de kickoff : kickoff(), kickoff_for_each(), kickoff_async() et kickoff_for_each_async(). L’intégration prend en charge la journalisation des traces pour toutes ces méthodes.

Suivi des outils

Les outils CrewAI offrent aux agents des capacités telles que la recherche sur le Web, l’analyse de données, la collaboration et la délégation de tâches entre collègues. L’intégration en assure également le traçage. L’exemple suivant améliore la qualité du rapport généré à partir de l’exemple précédent en donnant à l’agent accès à un outil capable d’effectuer des recherches sur Internet et de renvoyer les résultats les plus pertinents. Commencez par installer la dépendance supplémentaire :

pip install 'crewai[tools]'

Cet exemple utilise SerperDevTool pour permettre à l’agent ‘Research Analyst’ d’effectuer des recherches d’informations pertinentes sur Internet. Pour plus d’informations sur cet outil et sur les exigences de l’API, voir la documentation de SerperDevTool.

# .... existing imports ....
from crewai_tools import SerperDevTool

# Nous fournissons l'outil à l'agent.
researcher = Agent(
    role='Research Analyst',
    goal='Find and analyze the best investment opportunities',
    backstory='Expert in financial analysis and market research',
    llm=llm,
    verbose=True,
    allow_delegation=False,
    tools=[SerperDevTool()],
)

# .... existing code ....

Exécuter ce Crew avec un agent ayant accès à Internet produit un résultat plus pertinent. Weave trace automatiquement l’utilisation des outils, comme illustré dans l’image suivante.

L’intégration applique automatiquement un patch à tous les outils disponibles dans le dépôt crewAI-tools.

Premiers pas avec Flow

L’exemple suivant définit un Flow CrewAI et le trace avec Weave. Comme pour les Crews, appelez weave.init() avant de définir le Flow afin que Weave capture automatiquement le point d’entrée Flow.kickoff, ainsi que les décorateurs @start, @listen, @router, @or_ et @and_.

import weave
# Initialiser Weave avec le nom de votre projet
weave.init("crewai_demo")

from crewai.flow.flow import Flow, listen, router, start
from litellm import completion


class CustomerFeedbackFlow(Flow):
    model = "gpt-4o-mini"

    @start()
    def fetch_feedback(self):
        print("Fetching customer feedback")
        # Dans un scénario réel, ceci pourrait être remplacé par un appel API.
        # Pour cet exemple, nous simulons le feedback client.
        feedback = (
            "I had a terrible experience with the product. "
            "It broke after one use and customer service was unhelpful."
        )
        self.state["feedback"] = feedback
        return feedback

    @router(fetch_feedback)
    def analyze_feedback(self, feedback):
        # Utiliser le modèle de langage pour analyser le sentiment
        prompt = (
            f"Analyze the sentiment of this customer feedback and "
            "return only 'positive' or 'negative':\n\n"
            f"Feedback: {feedback}"
        )
        response = completion(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
        )
        sentiment = response["choices"][0]["message"]["content"].strip().lower()
        # Si la réponse est ambiguë, utiliser « negative » par défaut
        if sentiment not in ["positive", "negative"]:
            sentiment = "negative"
        return sentiment

    @listen("positive")
    def handle_positive_feedback(self):
        # Générer un message de remerciement pour un feedback positif
        prompt = "Generate a thank you message for a customer who provided positive feedback."
        response = completion(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
        )
        thank_you_message = response["choices"][0]["message"]["content"].strip()
        self.state["response"] = thank_you_message
        return thank_you_message

    @listen("negative")
    def handle_negative_feedback(self):
        # Générer un message d'excuse avec une promesse d'amélioration du service pour un feedback négatif
        prompt = (
            "Generate an apology message to a customer who provided negative feedback and offer assistance or a solution."
        )
        response = completion(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
        )
        apology_message = response["choices"][0]["message"]["content"].strip()
        self.state["response"] = apology_message
        return apology_message

# Instancier et démarrer le flow
flow = CustomerFeedbackFlow()
result = flow.kickoff()
print(result)

L’intégration applique automatiquement un patch au point d’entrée Flow.kickoff, ainsi que tous les décorateurs disponibles (@start, @listen, @router, @or_ et @and_).

Garde-fou Crew : suivez vos propres ops

Les garde-fous de tâche vous permettent de valider et de transformer les résultats d’une tâche avant que CrewAI ne les transmette à la suivante. Vous pouvez utiliser une fonction Python pour valider l’exécution de l’agent à la volée. En décorant la fonction de garde-fou avec @weave.op, vous capturez ses entrées, ses sorties et la logique de l’application afin de pouvoir déboguer la manière dont les données sont validées par vos agents. Cela gère également automatiquement le versionnement du code pendant que vous expérimentez, en capturant des détails ad hoc qui n’ont pas encore été validés dans Git. L’exemple suivant étend le Crew d’analyste de recherche et de rédacteur en ajoutant un garde-fou qui valide la longueur du rapport généré.

# .... importations existantes et initialisation de weave ....

# Décorez votre fonction de garde-fou avec `@weave.op()`
@weave.op(name="guardrail-validate_blog_content")
def validate_blog_content(result: TaskOutput) -> Tuple[bool, Any]:
    # Obtenir le résultat brut sous forme de chaîne
    result = result.raw

    """Validate blog content meets requirements."""
    try:
        # Vérifier le nombre de mots
        word_count = len(result.split())

        if word_count > 200:
            return (False, {
                "error": "Blog content exceeds 200 words",
                "code": "WORD_COUNT_ERROR",
                "context": {"word_count": word_count}
            })

        # Logique de validation supplémentaire ici
        return (True, result.strip())
    except Exception as e:
        return (False, {
            "error": "Unexpected error during validation",
            "code": "SYSTEM_ERROR"
        })


# .... agents existants et tâche de l'analyste de recherche ....

writing_task = Task(
    description='Write a detailed report based on the research under 200 words',
    expected_output='The report should be easy to read and understand. Use bullet points where applicable.',
    agent=writer,
    guardrail=validate_blog_content,
)

# .... code existant pour exécuter le crew ....

En décorant la fonction de garde-fou avec @weave.op, vous pouvez suivre les entrées et les sorties de cette fonction, ainsi que le temps d’exécution, les informations sur les tokens si la fonction utilise un LLM, la version du code, et bien plus encore.

Conclusion

Vous disposez maintenant d’une application CrewAI tracée avec Weave qui capture les interactions des agents, l’utilisation des outils, l’exécution des Flow et les validations des garde-fous. Pour suggérer des améliorations ou signaler des problèmes avec cette intégration, ouvrez une issue sur GitHub. Pour en savoir plus sur la création de systèmes multi-agents avec CrewAI, consultez les exemples et la documentation de CrewAI.

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

Premiers pas avec Crew

Suivi des outils

Premiers pas avec Flow

Garde-fou Crew : suivez vos propres ops

Conclusion

​Premiers pas avec Crew

​Suivi des outils

​Premiers pas avec Flow

​Garde-fou Crew : suivez vos propres ops

​Conclusion

Premiers pas avec Crew

Suivi des outils

Premiers pas avec Flow

Garde-fou Crew : suivez vos propres ops

Conclusion