Bereitstellung Ihres ersten Langgraph-Agenten auf TrueFoundry

In diesem Handbuch zeigen wir Ihnen, wie Sie eine bereitstellen Langgraph Agent auf Wahre Gießerei, eine Plattform zur Vereinfachung der KI-Bereitstellung mit minimalem DevOps- oder MLOps-Fachwissen. TrueFoundry automatisiert das Infrastrukturmanagement, die Skalierung und die Ü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 das direkt ausprobieren möchten, besuchen Sie bitte die TrueFoundry-Plattform und navigieren Sie zu Live-Demos und Langgraph-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 Langgraph 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

1. Der Benutzer sendet eine Anfrage in natürlicher Sprache über die Streamlit-Benutzeroberfläche
2. Die Abfrage wird vom SQL-Agenten verarbeitet, um SQL zu generieren
3. SQL wird gegen die ClickHouse-Datenbank ausgeführt
4. Die Ergebnisse werden an Plot Agent weitergegeben
5. Plot Agent erstellt entsprechende Plots
6. Die Ergebnisse werden in der Streamlit-Benutzeroberfläche angezeigt

‍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 Plot Agent-Verzeichnis

Wechseln Sie in das plot_agent-Verzeichnis:

cd getting-started-examples/plot_agent/langgraph_plot_agent

Einrichtung der Umgebung

Um eine virtuelle Umgebung zu erstellen und zu aktivieren:

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

Abhängigkeiten installieren

pip install -r requirements.txt

Konfiguration der Umgebung

Kopieren Sie die Beispiel-Umgebungsdatei:

```bash
cp .env.example .env
```

Erstellen Sie eine .env Datei mit Ihren Zugangsdaten

# 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 Database Configuration
CLICKHOUSE_HOST=your_clickhouse_host_here
CLICKHOUSE_PORT=443
CLICKHOUSE_USER=your_clickhouse_user_here
CLICKHOUSE_PASSWORD=your_clickhouse_password_here
CLICKHOUSE_DATABASE=default

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 Langgraph Agent

Das Projekt verwendet zwei LangGraph-Agenten, was es auch zu einer nützlichen praktischen Referenz bei der Bewertung macht AutoGen gegen LangGraph für das Workflow-Design mit mehreren Agenten. Wenn Sie lieber nur Openai verwenden möchten, ersetzen Sie:

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

Mit:

model=OpenAIChat(
        id="gpt-4o",  # Specify model here
        api_key=os.getenv("OPENAI_API_KEY")
      ),

So werden sie in einem Setup konfiguriert, in dem Langflow gegen LangGraph kommt oft auf Orchestrierungsentscheidungen an.

class State(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

tools_list = [execute_clickhouse_query, create_plot]

def tools_condition_modified(state):
    ans = tools_condition(state)
    human_messages_id = [m.id for m in state["messages"] if m.type == "human"]
    if ans == "tools":
        return "tools"
    else:
        return "__end__"

def create_agent():
    builder = StateGraph(State)

    llm = ChatOpenAI(
        model=os.getenv("MODEL_ID"), 
        api_key=os.getenv("LLM_GATEWAY_API_KEY"), 
        base_url=os.getenv("LLM_GATEWAY_BASE_URL"),
        streaming=True  # Enable streaming for the LLM
    )

    llm.bind_tools(tools_list)

    # Define nodes: these do the work
    builder.add_node("assistant", llm)
    builder.add_node("tools", ToolNode(tools_list))

    # Define edges: these determine how the control flow moves
    builder.add_edge(START, "assistant")
    builder.add_edge("tools", "assistant")
    builder.add_conditional_edges(
        "assistant",
        tools_condition_modified,
    )
    builder.add_edge("assistant", "__end__")

    agent = builder.compile()
    return agent

agent = create_agent()

Ausführen der Dienste

Starten Sie den FastAPI-Server:

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:

# In the generated deploy.py file, locate the env section and add your variables:  
  env={
      # If using OPENAI  
      "OPENAI_API_KEY": "your_openai_api_key",  
      # If using LLM_GATEWAY
      "LLM_GATEWAY_API_KEY": "your_llm_gateway_api_key",
      "LLM_GATEWAY_BASE_URL": "your_llm_gateway_base_url",
      "CLICKHOUSE_HOST": "your_clickhouse_host",  
      "CLICKHOUSE_PORT": "443",  
      "CLICKHOUSE_USER": "your_user",  
      "CLICKHOUSE_PASSWORD": "your_password",  
      "CLICKHOUSE_DATABASE": "default",  
      "MODEL_ID": "gpt-4o"  
  },  

Stellen Sie sicher, dass Sie die Platzhalterwerte durch Ihre tatsächlichen Anmeldeinformationen ersetzen. Ohne diese Umgebungsvariablen funktioniert Ihre Anwendung nicht richtig.

6. Führen Sie den Bereitstellungsbefehl aus:

python deploy.py

Ihre SQL- und Plot-Workflow-API ist jetzt auf TrueFoundry bereitgestellt und läuft!

7. Um zu bestätigen, dass alles funktioniert, können Sie eine Testabfrage mit curl senden:

curl -X POST -H "Content-Type: application/json" \  
  -d '{"query": "Show me the cost trends by model over the last week"}' \  
  https://Langgraph-plot-agent-demo-8000.aws.demo.truefoundry.cloud/query  

Wenn alles richtig eingerichtet ist, sollten Sie eine Antwort erhalten wie:

{  
  "job_id": "123e4567-e89b-12d3-a456-426614174000",  
  "status": "processing",  
  "message": "Query is being processed. Check status with /status/{job_id}"  
}  

Überwachung und Verwaltung

Greifen Sie auf das TrueFoundry-Dashboard zu, um:

• Überwachen Sie die Ressourcennutzung
• Anwendungsprotokolle anzeigen
• Ressourcen nach Bedarf skalieren
• Regeln für die automatische Skalierung konfigurieren

Überprüfen Sie den Zustand der Anwendung:

• Gesundheit im Backend: /health
• API-Dokumentation: /docs
• Metriken: /Metriken

Beispiel für die Verwendung:

1. Senden Sie eine Anfrage über die API:

curl -X POST "https://plot-agent-8000.your-workspace.truefoundry.cloud/query" \  
     -H "Content-Type: application/json" \  
     -d '{"query": "Show me the cost trends by model over the last week"}'  

2. Über die Streamlit-Benutzeroberfläche:

• Navigiere zur UI-URL
• Geben Sie Ihre Anfrage in die Texteingabe ein
• Abfrageverarbeitung und Ergebnisse in Echtzeit anzeigen

API-Endpunkte

Senden Sie eine Anfrage

curl -X POST http://localhost:8000/query \  
  -H "Content-Type: application/json" \  
  -d '{"query": "Show me the cost trends by model over the last week. Filter models that show a 0 cost."}'  

‍

Antwort

{  
  "job_id": "123e4567-e89b-12d3-a456-426614174000",  
  "status": "processing",  
  "message": "Query is being processed. Check status with /status/{job_id}"  
}  

‍

Jobstatus überprüfen

curl -X GET http://localhost:8000/status/123e4567-e89b-12d3-a456-426614174000  

‍

Plotbild abrufen

curl -X GET http://localhost:8000/plot/123e4567-e89b-12d3-a456-426614174000 --output plot.png  

Streamlit separat bereitstellen

Um eine ordnungsgemäße Kommunikation zwischen FastAPI und Streamlit sicherzustellen, müssen Sie Streamlit als separaten Dienst auf der TrueFoundry-Plattform bereitstellen.

1. Stellen Sie das Streamlit-Frontend getrennt von FastAPI auf TrueFoundry bereit.
2. CORS in FastAPI konfigurieren:

from fastapi.middleware.cors import CORSMiddleware  

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

3. Definieren Sie eine Umgebungsvariable in Streamlit

Ihre Streamlit-Anwendung sollte eine Umgebungsvariable verwenden, um auf das FastAPI-Backend zu verweisen: In Ihrem Optimierte Umgebung Konfiguration:

FASTAPI_ENDPOINT="https://langgraph-plot-agent-demo-8000.aws.demo.truefoundry.cloud"

Ändern Sie dann Ihre Streamlit-App um diese Umgebungsvariable zu lesen:

import os

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

Dadurch wird sichergestellt, dass Streamlit dynamisch auf die richtige FastAPI-Instanz verweist.

4. Verwenden Sie separate Anschlüsse

Stellen Sie sicher, dass bei der lokalen Bereitstellung oder wenn TrueFoundry Portkonflikte nicht automatisch behandelt FastAPI und Streamlit laufen auf separaten Ports.

Beispiel:

Schnelle API: https://langgraph-plot-agent-demo-8000.aws.demo.truefoundry.cloud

Streamlit: https://langgraph-streamlit-demo-8501.aws.demo.truefoundry.cloud

Um Streamlit lokal auf einem anderen Port auszuführen:

streamlit run app.py --server.port 8501

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
Traceloop.init(app_name="langraph")

Letzte Anmerkungen

Stellen Sie nach der Bereitstellung beider Dienste Folgendes sicher:

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

Dadurch wird sichergestellt, dass Ihre SQL- und Plot-Workflow-API in beiden Diensten ordnungsgemäß funktioniert.

‍

‍