Cómo implementar el flujo de trabajo de MultiAgent con CrewAI en TrueFoundry

En esta guía, le mostraremos cómo implementar un Tripulación AI agente en TrueFoundry, una plataforma diseñada para simplificar la implementación de la IA con una experiencia mínima en DevOps o MLOps. TrueFoundry automatiza la administración, el escalado y la supervisión de la infraestructura, lo que le permite centrarse en obtener información en lugar de gestionar las complejidades de la implementación. Con solo unos pocos clics, puede transformar las solicitudes en lenguaje natural en consultas SQL y gráficos dinámicos, lo que hace que la exploración de datos sea fluida e inteligente. ¡No es necesario realizar consultas manuales!

Si quieres probarlo directamente, visita la plataforma TrueFoundry y navega hasta Live Demos y Crewai-Streamlit: demostración en vivo del flujo de trabajo de nuestros agentes

Descripción general de la arquitectura

Este proyecto consta de varios componentes clave que trabajan en conjunto:

Agente de consultas

• Utiliza GPT-4o para la comprensión del lenguaje natural
• Genera las consultas SQL adecuadas para ClickHouse
• Ejecuta la consulta SQL en una base de datos preconfigurada
• Devuelve los datos en formato tabular como entrada para el agente de visualización

Agente de visualización: Un segundo agente de IA que

• Determina el tipo de visualización más apropiado teniendo en cuenta los datos
• Genera gráficos usando matplotlib/seaborn
• Maneja el formato y el estilo de las visualizaciones

Backend de FastAPI: API RESTful que

• Coordina entre los agentes que utilizan CrewAI
• Gestiona el procesamiento asincrónico de trabajos
• Sirve imágenes y resultados de la trama

Interfaz optimizada: Interfaz de usuario que

• Proporciona una interfaz de consulta intuitiva
• Muestra el estado del procesamiento en tiempo real
• Muestra visualizaciones interactivas

Flujo de datos

El usuario envía una consulta en lenguaje natural a través de Streamlit.

• Query Agent usa CrewAI con GPT-4o para generar consultas SQL para ClickHouse
• Ejecuta la consulta SQL en la base de datos de ClickHouse
• Los resultados se devuelven en formato tabular como entrada para el agente de visualización
• El agente de visualización genera visualizaciones y devuelve imágenes para su visualización

Cómo empezar

Clonar el repositorio

En primer lugar, navegue hasta el Ejemplos de introducción a TrueFoundry reposicionarlo y clonarlo:

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

Navegue al directorio de agentes gráficos de CrewAI:

cd getting-started-examples/plot_agent/crewai_plot_agent

Configuración del entorno

Cree y active un entorno virtual:

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

Instale las dependencias:

pip install uv
uv pip install -r requirements.txt

Configurar variables de entorno

Crea un .env archivo:

# 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

Nota: Al utilizar TrueFoundry LLM Gateway, el formato de ID del modelo debe ser nombre-proveedor/nombre-modelo (p. ej., openai-main/gpt-4o). Asegúrese de que su .env El archivo contiene las credenciales correctas de LLM Gateway, tal como se muestra en la sección Configuración del entorno.

Para obtener las credenciales de Clickhouse, cree una cuenta en Clickhouse, inicia sesión y crea un servicio. Tras hacer clic en el servicio, verás un botón de conexión en el centro de la barra lateral izquierda, en el que podrás hacer clic para ver las credenciales, tal y como se muestra a continuación. Puedes crear una base de datos cargando tus archivos o usar una base de datos predefinida.

Implementación 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/
		)
	

Los decoradores @Crewbase, @agent, @task, etc. son para habilitar el rastreo en truefoundry, que se menciona en detalle más adelante.

Ejecución de los servicios

Inicie CrewAI Workflow

crewai run

Inicie el backend de FastAPI:

python api.py

Inicie Streamlit UI (nueva terminal):

streamlit run app.py

Despliegue en TrueFoundry

Prerrequisitos

Instale la CLI de TrueFoundry:

pip install -U "truefoundry"

Inicie sesión en TrueFoundry:

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

Pasos de implementación

1. Navegue hasta la sección de despliegues en TrueFoundry.

2. Haz clic en Servicio en la parte inferior.
3. Selecciona el espacio de trabajo de tu clúster.
4. Puedes realizar la implementación desde tu portátil, GitHub o Docker. Si realizas la implementación desde tu portátil, asegúrate de haber completado los requisitos previos anteriores.
5. La plataforma TrueFoundry generará un archivo deploy.py y lo añadirá a su proyecto. Tendrás que editar este archivo para añadir tus variables de entorno. Busca la sección env en el archivo generado y agrega tus credenciales:
6. Usa el generado deploy.py y edite el env sección:

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

Sustituya los marcadores de posición por sus credenciales y configuraciones de entorno.

Probar el despliegue

Enviar una consulta de prueba:

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>

Ejemplo de respuesta exitosa:

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

Puntos finales de API

• Enviar una consulta:

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

• Verificar el estado de la consulta:

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

• Recuperar imagen de la trama:

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

Frontend y CORS

Configure CORS en FastAPI:

from fastapi.middleware.cors import CORSMiddleware

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

Defina la variable de entorno en Streamlit:

import os

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

Notas posteriores a la implementación

• Pruebe la conectividad de la API de Streamlit a FastAPI.
• Actualiza Streamlit's .env archivo con el punto final de FastAPI.
• Confirme que la configuración de CORS permita las solicitudes Streamlit.

Supervise y administre su implementación a través de TrueFoundry de la siguiente manera:

• Visualización de registros
• Supervisión del uso de los recursos
• Configuración de reglas de escalado automático
• Comprobar el estado del backend (/salud), documentación de la API (/documentos) y métricas en /métricas

Añade trazas a tu agente

El rastreo te ayuda a entender lo que ocurre de manera clandestina cuando se llama a un agente. Cuando ejecutas tu agente con la función de rastreo de Truefoundry, solo tienes que añadir muy pocas líneas de código para entender la ruta, las herramientas, las llamadas realizadas, el contexto utilizado y la latencia que se sigue.

Debe instalar lo siguiente

 pip install traceloop-sdk

Y, a continuación, añada las variables de entorno necesarias para habilitar el rastreo

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

En su base de código donde define su agente, solo necesita estas líneas para habilitar el rastreo

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

A continuación, añada un decorador al agente y a los flujos de trabajo como los siguientes:

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

Con estos pasos, ¡el flujo de trabajo de su agente de CrewAI ahora se ha implementado correctamente en TrueFoundry!

‍