Déploiement de votre agent Agno sur TrueFoundry

Dans ce guide, nous allons vous montrer comment déployer un Agno 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 AGNO-streamlit : 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 opérations entre les agents à l'aide d'agno
• 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 agno 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 Magno Plot :

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

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
agno_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 d'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,
                          )

Exécution des services

Démarrer un nouveau flux de travail

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

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://agno-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érifiez l'état de la requête :

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

• Récupérez 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="agno")

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'agno agent est désormais déployé avec succès sur TrueFoundry !