Cómo implementar su Agno Agent en TrueFoundry

En esta guía, le mostraremos cómo implementar un Agno 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 Agno-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 agentes usando agno
• 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 agno 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 de Agno Plot:

cd getting-started-examples/plot_agent/agno_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 install

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
agno_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 Agno Agent

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from plot_tools import PlotTools
from query_tools import QueryTools
import os
# Query Agent for SQL generation - Using TrueFoundry LLM Gateway
sql_agent: Agent = Agent(
                        model=OpenAIChat(
                            id="openai-main/gpt-4o",  # Format: provider-name/model-name
                            api_key=os.getenv("LLM_GATEWAY_API_KEY"),
                            base_url=os.getenv("LLM_GATEWAY_BASE_URL")
                        ),
                        description="",
                        instructions=[],
                        tools=[ClickHouseTools()],
                        show_tool_calls=True,
                        markdown=True,
                        response_model=SQLQueryResult,
                        structured_outputs=True,
                        )
# Visualization Agent - Using TrueFoundry LLM Gateway
plot_agent: Agent = Agent(
                          model=OpenAIChat(
                              id="openai-main/gpt-4o",
                              api_key=os.getenv("LLM_GATEWAY_API_KEY"),
                              base_url=os.getenv("LLM_GATEWAY_BASE_URL")
                          ),
                          description="",
                          instructions=[],
                          tools=[PlotTools()],
                          markdown=True,
                          response_model=VisualizationRequest,
                          structured_outputs=True,
                          )

Ejecución de los servicios

Iniciar Gano Workflow

agno 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",
    "AGNO_VERBOSE": "true"
},

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://agno-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."}'

• Compruebe 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="agno")

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 agno agente ahora se ha implementado correctamente en TrueFoundry!