So stellen Sie den MultiAgent-Workflow mit CrewAI auf TrueFoundry bereit

In diesem Handbuch zeigen wir Ihnen, wie Sie eine bereitstellen Crew A Agent auf TrueFoundry, einer Plattform, die entwickelt wurde, um die KI-Bereitstellung mit minimalem DevOps- oder MLOps-Fachwissen zu vereinfachen. TrueFoundry automatisiert Infrastrukturmanagement, Skalierung und Überwachung, sodass Sie sich darauf konzentrieren können, Erkenntnisse zu gewinnen, anstatt sich um die Komplexität der Bereitstellung zu kümmern. Mit nur wenigen Klicks können Sie Anfragen in natürlicher Sprache in SQL-Abfragen und dynamische Diagramme umwandeln und so die Datenexploration nahtlos und intelligent gestalten. Keine manuelle Abfrage erforderlich!

Wenn Sie dies direkt ausprobieren möchten, besuchen Sie bitte die TrueFoundry-Plattform und navigieren Sie zu Live-Demos und CrewAI-StreamLit: Live-Demo unseres Agenten-Workflows

Überblick über die Architektur

Dieses Projekt besteht aus mehreren Schlüsselkomponenten, die zusammenarbeiten:

Abfrage-Agent

• Verwendet GPT-4o für das Verständnis natürlicher Sprache
• Generiert entsprechende SQL-Abfragen für ClickHouse
• Führt die SQL-Abfrage für eine vorkonfigurierte Datenbank aus
• Gibt die Daten im tabellarischen Format als Eingabe für den Visualisierungsagenten zurück

Visualisierungsagent: Ein zweiter KI-Agent, der

• Ermittelt den für die Daten am besten geeigneten Visualisierungstyp
• Generiert Plots mit matplotlib/seaborn
• Behandelt das Formatieren und Stylen von Visualisierungen

FastAPI-Backend: RESTful-API, die

• Koordinaten zwischen Agenten, die CrewAI verwenden
• Verwaltet die asynchrone Auftragsverarbeitung
• Serviert Plotbilder und Ergebnisse

Streamlit-Frontend: Benutzeroberfläche, die

• Bietet eine intuitive Abfrageschnittstelle
• Zeigt den Verarbeitungsstatus in Echtzeit an
• Zeigt interaktive Visualisierungen

Datenfluss

Der Benutzer sendet eine Anfrage in natürlicher Sprache über Streamlit.

• Query Agent verwendet CrewAI mit GPT-4o, um SQL-Abfragen für ClickHouse zu generieren
• Führt die SQL-Abfrage für die ClickHouse-Datenbank aus
• Ergebnisse werden in tabellarischer Form als Eingabe für den Visualization Agent zurückgegeben
• Visualization Agent generiert Visualisierungen und gibt Bilder zur Anzeige zurück

Erste Schritte

Klonen Sie das Repository

Navigieren Sie zunächst zum Beispiele für die ersten Schritte mit TrueFoundry Repository und klone es:

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

Navigieren Sie zum CrewAI Plot Agent-Verzeichnis:

cd getting-started-examples/plot_agent/crewai_plot_agent

Einrichtung der Umgebung

Erstellen und aktivieren Sie eine virtuelle Umgebung:

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

Abhängigkeiten installieren:

pip install uv
uv pip install -r requirements.txt

Umgebungsvariablen konfigurieren

Erstellen Sie eine .env datei:

# 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

Hinweis: Bei Verwendung des TrueFoundry LLM Gateways sollte das Modell-ID-Format wie folgt lauten Anbietername/Modellname (z. B. openai-main/gpt-4o). Stellen Sie sicher, dass Ihre .env Die Datei enthält die richtigen LLM-Gateway-Anmeldeinformationen, wie im Abschnitt Umgebungskonfiguration gezeigt.

Um Clickhouse-Zugangsdaten zu erhalten, erstellen Sie ein Konto unter Clickhouse, melden Sie sich an und erstellen Sie einen Dienst. Nachdem Sie auf den Dienst geklickt haben, wird in der Mitte der linken Seitenleiste eine Verbindungsschaltfläche angezeigt, auf die Sie klicken können, um die unten gezeigten Anmeldeinformationen anzuzeigen. Sie können entweder eine Datenbank erstellen, indem Sie Ihre Dateien hochladen, oder eine vordefinierte verwenden.

Implementierung von 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/
		)
	

Die Dekorateure @Crewbase, @agent, @task usw. dienen dazu, das Tracing in Truefoundry zu ermöglichen, das später ausführlich erwähnt wird.

Ausführen der Dienste

CrewAI Workflow starten

crewai run

Starten Sie das FastAPI-Backend:

python api.py

Starten Sie Streamlit UI (neues Terminal):

streamlit run app.py

Bereitstellung auf TrueFoundry

Voraussetzungen

Installieren Sie TrueFoundry CLI:

pip install -U "truefoundry"

Loggen Sie sich bei TrueFoundry ein:

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

Schritte zur Bereitstellung

1. Navigieren Sie in TrueFoundry zum Abschnitt Deployments.

2. Klicken Sie unten auf Service.
3. Wählen Sie Ihren Cluster-Workspace aus.
4. Sie können die Bereitstellung von Ihrem Laptop, GitHub oder Docker aus durchführen. Wenn Sie die Bereitstellung von Ihrem Laptop aus vornehmen, stellen Sie sicher, dass Sie die oben genannten Voraussetzungen erfüllt haben.
5. Die TrueFoundry-Plattform generiert eine Datei deploy.py und fügt sie Ihrem Projekt hinzu. Sie müssen diese Datei bearbeiten, um Ihre Umgebungsvariablen hinzuzufügen. Suchen Sie den Abschnitt env in der generierten Datei und fügen Sie Ihre Anmeldeinformationen hinzu:
6. Benutze das generierte deploy.py und bearbeite die env Abschnitt:

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"
},

Ersetzen Sie Platzhalter durch Ihre Anmeldeinformationen und Umgebungskonfigurationen.

Bereitstellung testen

Senden Sie eine Testanfrage:

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>

Beispiel für eine erfolgreiche Antwort:

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

API-Endpunkte

• Senden Sie eine Anfrage:

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

• Abfragestatus überprüfen:

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

• Plotbild abrufen:

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

Frontend und CORS

CORS in FastAPI konfigurieren:

from fastapi.middleware.cors import CORSMiddleware

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

Definieren Sie die Umgebungsvariable in Streamlit:

import os

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

Hinweise nach der Bereitstellung

• Testen Sie die API-Konnektivität von Streamlit zu FastAPI.
• Streamlit's aktualisieren .env Datei mit dem FastAPI-Endpunkt.
• Bestätigen Sie, dass die CORS-Einstellungen Streamlit-Anfragen zulassen.

Überwachen und verwalten Sie Ihre Bereitstellung über TrueFoundry, indem Sie:

• Protokolle anzeigen
• Überwachung der Ressourcennutzung
• Regeln für die automatische Skalierung festlegen
• Überprüfung des Backend-Zustands (/gesundheit), API-Dokumentation (/dokumente) und Metriken unter /metriken

Fügen Sie Ihrem Agenten Spuren hinzu

Tracing hilft Ihnen zu verstehen, was unter der Haube passiert, wenn ein Agent Run aufgerufen wird. Sie erhalten einen Überblick über den Pfad, die getätigten Tools-Aufrufe, den verwendeten Kontext und die Latenz, die entsteht, wenn Sie Ihren Agenten mithilfe der Tracing-Funktion von Truefoundry ausführen, indem Sie nur sehr wenige Codezeilen hinzufügen.

Sie müssen Folgendes installieren

 pip install traceloop-sdk

Fügen Sie dann die erforderlichen Umgebungsvariablen hinzu, um die Ablaufverfolgung zu aktivieren

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

In Ihrer Codebasis, in der Sie Ihren Agenten definieren, benötigen Sie nur diese Zeilen, um das Tracing zu aktivieren

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

Fügen Sie dann Decorator zum Agenten und den Workflows wie folgt hinzu

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

Mit diesen Schritten ist Ihr CrewAI-Agent-Workflow jetzt erfolgreich auf TrueFoundry bereitgestellt!

‍