Comment déployer un flux de travail multi-agents à l'aide de CrewAI sur TrueFoundry

Dans ce guide, nous allons vous montrer comment déployer un IA de l'équipage agent sur TrueFoundry, une plateforme conçue pour simplifier le déploiement de l'IA avec un minimum d'expertise DevOps ou MLOps. TrueFoundry automatise la gestion, la mise à l'échelle et la surveillance de l'infrastructure, ce qui vous permet de vous concentrer sur l'obtention d'informations plutôt que sur la gestion des complexités de déploiement. En quelques clics, vous pouvez transformer les requêtes en langage naturel en requêtes SQL et en graphiques dynamiques, rendant ainsi l'exploration des données fluide et intelligente. Aucune requête manuelle n'est requise !

Si vous souhaitez l'essayer directement, rendez-vous sur la plateforme TrueFoundry et accédez à Live Demos et CrewAI-Samlit : démonstration en direct de notre flux de travail pour les agents

Présentation de l'architecture

Ce projet comprend plusieurs éléments clés qui travaillent ensemble :

Agent de requête

• Utilise GPT-4o pour la compréhension du langage naturel
• Génère des requêtes SQL appropriées pour ClickHouse
• Exécute la requête SQL sur une base de données préconfigurée
• Renvoie les données sous forme de tableau en tant qu'entrée pour l'agent de visualisation

Agent de visualisation: Un deuxième agent d'IA qui

• Détermine le type de visualisation le plus approprié en fonction des données
• Génère des tracés à l'aide de matplotlib/seaborn
• Gère le formatage et le style des visualisations

Backend FastAPI: API RESTful qui

• Coordonne les activités entre les agents à l'aide de CrewAI
• Gère le traitement asynchrone des tâches
• Propose des images et des résultats de l'intrigue

Frontend rationalisé: interface utilisateur qui

• Fournit une interface de requête intuitive
• Affiche l'état du traitement en temps réel
• Affiche des visualisations interactives

Flux de données

L'utilisateur soumet une requête en langage naturel via Streamlit.

• Query Agent utilise CrewAI avec GPT-4o pour générer des requêtes SQL pour ClickHouse
• Exécute la requête SQL sur la base de données ClickHouse
• Les résultats sont renvoyés sous forme de tableau en tant qu'entrée pour l'agent de visualisation.
• L'agent de visualisation génère des visualisations et renvoie des images à afficher

Pour commencer

Cloner le référentiel

Tout d'abord, accédez au Exemples de démarrage avec TrueFoundry référentiel et clonez-le :

git clone <https://github.com/truefoundry/getting-started-examples.git>

Accédez au répertoire des agents de CrewAI Plot :

cd getting-started-examples/plot_agent/crewai_plot_agent

Configuration de l'environnement

Créez et activez un environnement virtuel :

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

Installez les dépendances :

pip install uv
uv pip install -r requirements.txt

Configuration des variables d'environnement

Créez un .env fichier :

# Truefoundry LLMGateway Configuration if using Truefoundry LLM Gateway for calling models
LLM_GATEWAY_BASE_URL=your_llm_gateway_base_url_here
LLM_GATEWAY_API_KEY=your_llm_gateway_api_key_here

# OPENAI API Configuration if not using Truefoundry LLM Gateway
OPENAI_API_KEY=<your_openai_api_key_here>
CLICKHOUSE_HOST=your_clickhouse_host
CLICKHOUSE_PORT=443
CLICKHOUSE_USER=your_user
CLICKHOUSE_PASSWORD=your_password
CLICKHOUSE_DATABASE=default
CREWAI_VERBOSE=true

Remarque : Lorsque vous utilisez la passerelle TrueFoundry LLM Gateway, le format de l'ID du modèle doit être nom du fournisseur/nom du modèle (par exemple, openai-main/gpt-4o). Assurez-vous que votre .env Le fichier contient les informations d'identification LLM Gateway correctes, comme indiqué dans la section Configuration de l'environnement.

Pour obtenir les informations d'identification Clickhouse, créez un compte sur clickhouse, connectez-vous et créez un service. Après avoir cliqué sur le service, vous verrez un bouton de connexion au milieu de la barre latérale gauche, sur lequel vous pouvez cliquer pour voir les informations d'identification, comme indiqué ci-dessous. Vous pouvez créer une base de données en téléchargeant vos fichiers ou en utiliser une prédéfinie.

Implémentation de CrewAI Agent

@CrewBase
class CrewaiPlotAgent():
	"""CrewaiPlotAgent crew"""

	# Learn more about YAML configuration files here:
	# Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
	# Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
	agents_config = 'config/agents.yaml'
	tasks_config = 'config/tasks.yaml'

	# def process_output(self, output):
	# 	# Modify output after the crew finishes
	# 	output.raw += "\nProcessed after kickoff."
	# 	print("Output", output ,"sdfsdfsdfsd")
	# 	return output

	# If you would like to add tools to your agents, you can learn more about it here:
	# https://docs.crewai.com/concepts/agents#agent-tools
	@agent
	def sql_writer(self) -> Agent:
		return Agent(
			config=self.agents_config['sql_writer'],
			verbose=True,
			tools=[ClickHouseTool()]
		)

	@agent
	def plot_writer(self) -> Agent:
		return Agent(
			config=self.agents_config['plot_writer'],
			verbose=True,
			tools=[PlotTools()],
			pydantic_output=PlotResult,
		)

	# To learn more about structured task outputs, 
	# task dependencies, and task callbacks, check out the documentation:
	# https://docs.crewai.com/concepts/tasks#overview-of-a-task
	@task
	def sql_task(self) -> Task:
		return Task(
			config=self.tasks_config['sql_task'],
		)

	@task
	def plot_task(self) -> Task:
		return Task(
			config=self.tasks_config['plot_task'],
			# callback=self.process_output,
			allow_code_execution=True,
			output_pydantic=PlotResult,
			# output_file='plot.png'
		)

	@crew
	def crew(self) -> Crew:
		"""Creates the CrewaiPlotAgent crew"""
		# To learn how to add knowledge sources to your crew, check out the documentation:
		# https://docs.crewai.com/concepts/knowledge#what-is-knowledge

		return Crew(
			agents=self.agents, # Automatically created by the @agent decorator
			tasks=self.tasks, # Automatically created by the @task decorator
			process=Process.sequential,
			verbose=True,
			# output_pydantic=True,
			# process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
		)
	

Les décorateurs @Crewbase, @agent, @task, etc. sont destinés à permettre le traçage dans Truefoundry, mentionné en détail plus loin.

Exécution des services

Démarrez CrewAI Workflow

crewai run

Démarrez FastAPI Backend :

python api.py

Démarrez Streamlit UI (nouveau terminal) :

streamlit run app.py

Déploiement sur TrueFoundry

Prérequis

Installez la CLI TrueFoundry :

pip install -U "truefoundry"

Connectez-vous à TrueFoundry :

tfy login --host "<https://app.truefoundry.com>"

Étapes de déploiement

1. Accédez à la section Déploiements dans TrueFoundry.

2. Cliquez sur Service en bas de la page.
3. Sélectionnez l'espace de travail de votre cluster.
4. Vous pouvez effectuer le déploiement depuis votre ordinateur portable, GitHub ou Docker. Si vous effectuez un déploiement à partir de votre ordinateur portable, assurez-vous de remplir les conditions préalables ci-dessus.
5. La plateforme TrueFoundry générera un fichier deploy.py et l'ajoutera à votre projet. Vous devez modifier ce fichier pour ajouter vos variables d'environnement. Recherchez la section env dans le fichier généré et ajoutez vos informations d'identification :
6. Utilisez le généré deploy.py et modifiez le env rubrique :

env={
    "OPENAI_API_KEY": "your_openai_api_key",
    "CLICKHOUSE_HOST": "your_clickhouse_host",
    "CLICKHOUSE_PORT": "443",
    "CLICKHOUSE_USER": "your_user",
    "CLICKHOUSE_PASSWORD": "your_password",
    "CLICKHOUSE_DATABASE": "default",
    "CREWAI_VERBOSE": "true"
},

Remplacez les espaces réservés par vos informations d'identification et vos configurations d'environnement.

Déploiement des tests

Envoyez une requête de test :

curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"query": "Show me the cost trends by model over the last week"}' \
  <https://crewai-plot-agent-demo-8000.aws.demo.truefoundry.cloud/query>

Exemple de réponse réussie :

{
  "job_id": "1234-abcd-5678-efgh"
}

Points de terminaison de l'API

• Soumettre une requête:

curl -X POST <http://localhost:8000/query> -H "Content-Type: application/json" -d '{"query": "Your query here."}'

• Vérifier l'état de la requête:

curl -X GET <http://localhost:8000/status/{job_id}>

• Récupérer l'image du tracé:

curl -X GET <http://localhost:8000/plot/{job_id}> > plot.png

Frontend et CORS

Configurez CORS dans FastAPI :

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

Définissez la variable d'environnement dans Streamlit :

import os

FASTAPI_ENDPOINT = os.getenv("FASTAPI_ENDPOINT", "<http://localhost:8000>")

Notes après le déploiement

• Testez la connectivité de l'API de Streamlit à FastAPI.
• Mettre à jour Streamlit .env fichier avec le point de terminaison FastAPI.
• Vérifiez que les paramètres CORS autorisent les requêtes Streamlit.

Surveillez et gérez votre déploiement via TrueFoundry en :

• Affichage des journaux
• Surveillance de l'utilisation des ressources
• Définition de règles de dimensionnement automatique
• Vérification de l'état du backend (/santé), la documentation de l'API (/documents), et des indicateurs sur /métriques

Ajoutez des traces à votre agent

Le traçage vous permet de comprendre ce qui se passe sous le capot lorsqu'un agent est appelé. Vous apprenez à comprendre le chemin, les appels d'outils effectués, le contexte utilisé, la latence prise lorsque vous exécutez votre agent à l'aide de la fonctionnalité de traçage de Truefoundry en ajoutant très peu de lignes de code.

Vous devez installer les éléments suivants

 pip install traceloop-sdk

Ajoutez ensuite les variables d'environnement nécessaires pour activer le traçage

"TRACELOOP_BASE_URL": "<your_host_name>/api/otel" # "https://internal.devtest.truefoundry.tech/api/otel"
"TRACELOOP_HEADERS"="Authorization=Bearer%20<your_tfy_api_key>"

Dans votre base de code où vous définissez votre agent, vous avez juste besoin de ces lignes pour activer le traçage

from traceloop.sdk import Traceloop
from traceloop.sdk.decorators import workflow, agent, task
Traceloop.init(app_name="crew-ai")

Ajoutez ensuite un décorateur à l'agent et aux flux de travail comme suit

@agent(name="sql_and_plot_workflow")
@workflow(name="plotting workflow")
@task(name="execute sql query")

Grâce à ces étapes, votre flux de travail d'agent CrewAI est désormais déployé avec succès sur TrueFoundry !

‍