Bereitstellung Ihres Agno-Agenten auf TrueFoundry

In diesem Handbuch zeigen wir Ihnen, wie Sie ein Agno 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 AGNO-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 Agno 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 agno 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 Agno Plot Agent-Verzeichnis:

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

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
agno_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.

Agno Agent-Implementierung

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,
                          )

Ausführen der Dienste

Starten Sie agno Workflow

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

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

• Überprüfen Sie den Abfragestatus:

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

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 wird Ihr Agno-Agent-Workflow jetzt erfolgreich auf TrueFoundry bereitgestellt!