DEV Community

Cover image for Trading Agents in einen echten Trading API Workflow umwandeln
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Trading Agents in einen echten Trading API Workflow umwandeln

TL;DR / Kurzantwort

Der schnellste Weg, TradingAgents praktisch einzusetzen, ist, es als Python-Paket auszuführen, in einen schlanken FastAPI-Service zu verpacken und diesen Dienst anschließend in Apidog zu testen. So schaffen Sie einen wiederholbaren Workflow für Analysen, geben Ticker und Datum an, erhalten eine Job-ID, können das Ergebnis abfragen, den Anfragevertrag dokumentieren und die Einrichtung einfach im Team teilen.

Teste Apidog noch heute

Einführung

TradingAgents ist von außen beeindruckend: Das GitHub-Repository zeigt einen Multi-Agenten-Handelsworkflow, eine durchdachte CLI, Unterstützung für verschiedene Modell-Provider und ein Forschungspaper zum Framework-Design. Die eigentliche Herausforderung beginnt, wenn man TradingAgents in einen echten Engineering-Workflow integrieren will.

Die meisten Teams brauchen mehr als ein lokal laufendes Skript. Sie suchen einen wiederholbaren Weg, Analysen anzustoßen, Ticker/Datum zu übergeben, Jobs zu verfolgen und das Setup Frontend-, QA- oder Plattform-Kollegen zu übergeben – ohne dass jede Frage in einer Python-Debugging-Session endet. Gerade bei Handelsforschung mit Relevanz für Echtgeldentscheidungen ist es entscheidend, TradingAgents in eine dokumentierte API zu verpacken, statt es als einmaliges Skript zu nutzen.

💡 Apidog passt optimal in diesen Ablauf. Importieren Sie das OpenAPI-Schema direkt aus FastAPI, speichern Sie Umgebungen für verschiedene Deployments, extrahieren Sie Variablen aus Antworten, verketten Sie Polling-Requests zu Szenarien und veröffentlichen Sie Dokumente für Ihr Team. Laden Sie Apidog kostenlos herunter, um direkt zu starten.

Was TradingAgents ist und was nicht

Vor dem Start: Definieren Sie das Tool eindeutig.

null

TradingAgents ist ein Open-Source-Multi-Agenten-Handelsframework, das verschiedene spezialisierte Rollen abbildet – Analysten, Forscher, Händler-Agent, Risikomanagement, Portfoliomanager.

null

Das Framework basiert auf LangGraph und unterstützt mehrere Modell-Provider wie OpenAI, Google, Anthropic, xAI, OpenRouter, Ollama. Typische Standardeinstellungen sind:

  • llm_provider = "openai"
  • deep_think_llm = "gpt-5.2"
  • quick_think_llm = "gpt-5-mini"
  • backend_url = "https://api.openai.com/v1"
  • max_debate_rounds = 1

Sie arbeiten also mit einem konfigurierbaren Python-Framework – keiner fertigen SaaS-API.

Wichtig: TradingAgents ist ein Forschungs-Framework, keine Finanzberatung. Halten Sie diese Trennung auch in Ihrer API und Dokumentation klar sichtbar.

Schritt 1: TradingAgents installieren

Installieren Sie das Framework direkt aus dem Repository:

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents
conda create -n tradingagents python=3.13
conda activate tradingagents
pip install .
Enter fullscreen mode Exit fullscreen mode

Für den API-Wrapper zusätzlich:

pip install fastapi uvicorn
Enter fullscreen mode Exit fullscreen mode

Nutzen Sie die .env.example aus dem Repo und setzen Sie Modellprovider-Keys:

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=
Enter fullscreen mode Exit fullscreen mode

Praktische Regeln:

  1. Provider-Keys immer in Umgebungsvariablen oder einem Secrets Manager speichern.
  2. Geben Sie keine Secrets im API-Request-Body weiter.

So bleiben Apidog-Umgebungen und Ihr Sicherheitsmodell sauber und sicher.

Schritt 2: TradingAgents lokal in Python testen

Vor dem API-Wrapper: Testen Sie, ob TradingAgents in Ihrer Umgebung läuft.

Minimalbeispiel (README):

from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

ta = TradingAgentsGraph(debug=True, config=DEFAULT_CONFIG.copy())
_, decision = ta.propagate("NVDA", "2026-01-15")
print(decision)
Enter fullscreen mode Exit fullscreen mode

Läuft das Beispiel, können Sie mit individueller Konfiguration weitermachen:

from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

config = DEFAULT_CONFIG.copy()
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-5.2"
config["quick_think_llm"] = "gpt-5-mini"
config["max_debate_rounds"] = 2

ta = TradingAgentsGraph(debug=True, config=config)
_, decision = ta.propagate("NVDA", "2026-01-15")
print(decision)
Enter fullscreen mode Exit fullscreen mode

Diese Parameter sollten später in Ihrer API steuerbar sein:

  • ticker
  • analysis_date
  • llm_provider
  • deep_think_llm
  • quick_think_llm
  • Forschungstiefe/Debattenrunden

Überspringen Sie diesen lokalen Test nicht – so vermeiden Sie unnötiges Debugging beim HTTP-Wrapper.

Schritt 3: Nutzungsmodell wählen

Option 1: Nur CLI

Ideal zum Erkunden, Solo-Tests oder Lernen. Nicht geeignet für Team-Workflows, Frontends oder QA.

Option 2: Nur Python

Direkter Aufruf von TradingAgentsGraph aus Python für Notebooks oder lokale Automatisierung.

Nicht ausreichend für geteilte Workflows.

Option 3: API-Wrapper + Apidog

TradingAgents als Engine, Zugriff via FastAPI-API, Testing/Dokumentation via Apidog.

Empfohlen, wenn:

  • Frontend Analysen auslöst
  • QA wiederholbare Anfragen benötigt
  • Sie Szenarien, Umgebungen und Dokumentation zentral verwalten wollen
  • Polling sinnvoller ist als lange Synchro-Anfragen

Ab hier wird TradingAgents teamtauglich und produktionsreif.

Schritt 4: TradingAgents in einen FastAPI-Service verpacken

Ein jobbasierter API-Ansatz ist praxistauglich, weil Analysen dauern können.

Typisches Pattern:

POST /analyses    -> analysis_id zurück
GET /analyses/{id} -> Status/Ergebnis abfragen
Enter fullscreen mode Exit fullscreen mode

Minimaler API-Vertrag

Endpunkt Zweck
GET /health Service-Check
POST /analyses TradingAgents-Analyse starten
GET /analyses/{analysis_id} Status/Ergebnis des Jobs abfragen

Beispiel-Wrapper in FastAPI 

from concurrent.futures import ThreadPoolExecutor
from datetime import date, datetime
from uuid import uuid4

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field

from tradingagents.default_config import DEFAULT_CONFIG
from tradingagents.graph.trading_graph import TradingAgentsGraph

app = FastAPI(title="TradingAgents API", version="0.1.0")
executor = ThreadPoolExecutor(max_workers=2)
jobs: dict[str, dict] = {}

class AnalysisRequest(BaseModel):
    ticker: str = Field(..., min_length=1, examples=["NVDA"])
    analysis_date: date
    llm_provider: str = Field(default="openai")
    deep_think_llm: str = Field(default="gpt-5.2")
    quick_think_llm: str = Field(default="gpt-5-mini")
    research_depth: int = Field(default=1, ge=1, le=5)

def run_analysis(job_id: str, payload: AnalysisRequest) -> None:
    jobs[job_id]["status"] = "running"
    jobs[job_id]["started_at"] = datetime.utcnow().isoformat()

    config = DEFAULT_CONFIG.copy()
    config["llm_provider"] = payload.llm_provider
    config["deep_think_llm"] = payload.deep_think_llm
    config["quick_think_llm"] = payload.quick_think_llm
    config["max_debate_rounds"] = payload.research_depth
    config["max_risk_discuss_rounds"] = payload.research_depth

    try:
        graph = TradingAgentsGraph(debug=False, config=config)
        _, decision = graph.propagate(
            payload.ticker,
            payload.analysis_date.isoformat(),
        )
        jobs[job_id].update(
            {
                "status": "completed",
                "finished_at": datetime.utcnow().isoformat(),
                "result": decision,
            }
        )
    except Exception as exc:
        jobs[job_id].update(
            {
                "status": "failed",
                "finished_at": datetime.utcnow().isoformat(),
                "error": str(exc),
            }
        )

@app.get("/health")
def health() -> dict:
    return {"status": "ok"}

@app.post("/analyses", status_code=202)
def create_analysis(payload: AnalysisRequest) -> dict:
    analysis_id = str(uuid4())
    jobs[analysis_id] = {
        "status": "queued",
        "ticker": payload.ticker,
        "analysis_date": payload.analysis_date.isoformat(),
        "created_at": datetime.utcnow().isoformat(),
    }
    executor.submit(run_analysis, analysis_id, payload)
    return {"analysis_id": analysis_id, "status": "queued"}

@app.get("/analyses/{analysis_id}")
def get_analysis(analysis_id: str) -> dict:
    job = jobs.get(analysis_id)
    if not job:
        raise HTTPException(status_code=404, detail="Analysis not found")
    return job
Enter fullscreen mode Exit fullscreen mode

Service starten:

uvicorn app:app --reload
Enter fullscreen mode Exit fullscreen mode

FastAPI stellt bereit:

  • http://localhost:8000/docs
  • http://localhost:8000/openapi.json

Die OpenAPI-JSON ist für Apidog der direkte Einstieg.

Schritt 5: TradingAgents über die API nutzen

Analyse starten

POST /analyses mit folgendem Body:

{
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "llm_provider": "openai",
  "deep_think_llm": "gpt-5.2",
  "quick_think_llm": "gpt-5-mini",
  "research_depth": 2
}
Enter fullscreen mode Exit fullscreen mode

Antwort:

{
  "analysis_id": "88f9f0f5-7315-4c73-8ed5-d0a71f613d31",
  "status": "queued"
}
Enter fullscreen mode Exit fullscreen mode

Ihr Client braucht kein Sofortergebnis, sondern einen Handle für den Analyselauf.

Ergebnis abfragen

GET /analyses/{analysis_id}

Im Verlauf:

{
  "status": "running",
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "created_at": "2026-03-26T06:00:00.000000",
  "started_at": "2026-03-26T06:00:01.000000"
}
Enter fullscreen mode Exit fullscreen mode

Nach Abschluss:

{
  "status": "completed",
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "result": {
    "decision": "hold"
  }
}
Enter fullscreen mode Exit fullscreen mode

Bei Fehlern:

{
  "status": "failed",
  "error": "..."
}
Enter fullscreen mode Exit fullscreen mode

Schritt 6: API in Apidog importieren

Öffnen Sie Apidog und importieren Sie das OpenAPI-Schema:

http://localhost:8000/openapi.json
Enter fullscreen mode Exit fullscreen mode

Apidog erkennt alle Endpunkte und Strukturen – keine manuelle Nachpflege.

Vorteile:

  • Dokumentation entspricht der tatsächlichen Implementierung
  • Pfadparameter und Request-Bodys sind synchron mit Ihrem Code
  • Teammitglieder müssen keine Sammlungen nachbauen

Mit Apidog verwalten Sie Design, Tests, Umgebungen und Dokumentation zentral.

Schritt 7: Apidog-Umgebung einrichten

Nach dem Import: Legen Sie eine Umgebung für Ihre lokale API an.

Beispielvariablen:

base_url = http://localhost:8000
analysis_id =
Enter fullscreen mode Exit fullscreen mode

Falls Authentifizierung nötig ist:

internal_api_key = your-local-dev-key
Enter fullscreen mode Exit fullscreen mode

Vorteile:

  • Einfacher Wechsel zwischen lokalen, Staging- und Produktionsumgebungen
  • Reproduzierbare Requests
  • Teammitglieder müssen keine Header oder URLs kopieren

So wird Apidog zum perfekten Begleiter für TradingAgents – das Framework liefert die Logik, Apidog den geteilten Workflow.

Schritt 8: End-to-End-Workflow in Apidog testen

Nutzen Sie Apidog, um den kompletten Analyseflow wie ein echter Client zu testen.

Anfrage 1: Analyse starten

  • Methode: POST
  • URL: {{base_url}}/analyses
  • Body: 
{
  "ticker": "NVDA",
  "analysis_date": "2026-03-26",
  "llm_provider": "openai",
  "deep_think_llm": "gpt-5.2",
  "quick_think_llm": "gpt-5-mini",
  "research_depth": 2
}
Enter fullscreen mode Exit fullscreen mode

Testskript:

pm.test("Status is 202", function () {
  pm.response.to.have.status(202);
});

const data = pm.response.json();
pm.expect(data.analysis_id).to.exist;
pm.environment.set("analysis_id", data.analysis_id);
Enter fullscreen mode Exit fullscreen mode

Anfrage 2: Analyse abfragen

  • Methode: GET
  • URL: {{base_url}}/analyses/{{analysis_id}}

Testskript:

pm.test("Analysis has a valid status", function () {
  const data = pm.response.json();
  pm.expect(["queued", "running", "completed", "failed"]).to.include(data.status);
});
Enter fullscreen mode Exit fullscreen mode

Optional für Erfolgsprüfung:

pm.test("Completed jobs include a result", function () {
  const data = pm.response.json();
  if (data.status === "completed") {
    pm.expect(data.result).to.exist;
  }
});
Enter fullscreen mode Exit fullscreen mode

Beide Anfragen in einem Szenario verketten

Erstellen Sie ein Szenario, das:

  1. POST /analyses sendet
  2. Die analysis_id speichert
  3. Einige Sekunden wartet
  4. GET /analyses/{{analysis_id}} ausführt

So können QA- und Entwicklungsteams den kompletten Lebenszyklus automatisiert prüfen.

Schritt 9: Interne Dokumentation im Team bereitstellen

Sobald die API-Tests laufen, erstellen Sie mit Apidog interne Dokumentation, die erklärt:

  • Welche Provider unterstützt werden
  • Bedeutung von research_depth
  • Erwartbare Statuswerte
  • Typische Laufzeiten
  • Wiederholbare Fehlerquellen
  • Wo der Forschungs-Haftungsausschluss gilt

TradingAgents entfaltet erst im Team mit klarem API-Vertrag und Dokumentation seine volle Stärke.

Nutzen Sie Apidog kostenlos, um TradingAgents in einen dokumentierten API-Workflow mit Umgebungen, Tests und teamfähigen Szenarien zu integrieren.

Häufige Fehler bei der Nutzung von TradingAgents auf diese Weise

Das Framework wie eine gehostete API behandeln

TradingAgents ist kein fertiger öffentlicher Dienst, sondern ein Python-Framework. Definieren Sie selbst den API-Vertrag für Ihr Team.

Provider-Secrets über Request-Bodys weitergeben

Provider-Keys gehören ins Umgebungsmanagement – nie in Requests, Beispiele oder Screenshots.

Lange synchrone Antworten zurückgeben

Jobbasierte APIs sind für mehrstufige Analysen besser wartbar als blockierende Requests.

Zu viele Konfigurationsoptionen offenlegen

Starten Sie mit einem kleinen, stabilen API-Vertrag. Nicht jede interne Option muss von Tag 1 exposed werden.

Ergebnisse nur im RAM halten

Der Beispielcode speichert Jobs im Speicher. In Produktion: Persistenz z.B. via Redis oder Postgres.

Forschungs-Haftungsausschluss verschweigen

Übernehmen Sie die Warnung aus dem Projekt – TradingAgents dient Forschung und Experimenten, nicht der Anlageberatung.

Fazit

Wie Sie TradingAgents nutzen, hängt vom Ziel ab: Zum Erkunden reicht die CLI oder das Python-Paket. Für einen stabilen, teamfähigen Workflow verpacken Sie TradingAgents in eine API und nutzen Apidog für Tests und Dokumentation.

Für einen schnellen Übergang vom Repository zum Team-Workflow: TradingAgents installieren, TradingAgentsGraph lokal testen, API-Endpunkte POST /analyses und GET /analyses/{id} bauen, das Schema in Apidog importieren und ein End-to-End-Szenario anlegen. So haben Sie einen wartbaren, dokumentierten Workflow statt losem Stammeswissen.

FAQ

Wie nutzen Sie TradingAgents zum ersten Mal?

Installieren Sie das Repository, setzen Sie die Modellprovider-Umgebungsvariablen und testen Sie das Python-Beispiel mit TradingAgentsGraph. Entscheiden Sie dann, ob Sie es in eine API packen wollen.

Kommt TradingAgents mit einer offiziellen REST-API?

Nein. Das Projekt wird (Stand 26. März 2026) als CLI- und Python-Paket geliefert. Für API-Nutzung empfiehlt sich eine eigene (z.B. FastAPI-)Schicht.

Was ist der einfachste Weg, TradingAgents in einer Frontend-App zu verwenden?

Nicht direkt aus dem Frontend aufrufen! Bauen Sie eine Backend-API, die eine analysis_id zurückgibt, und lassen Sie das Frontend das Ergebnis abfragen.

Warum Apidog mit TradingAgents verwenden?

Apidog bietet eine zentrale Oberfläche für OpenAPI-Import, Umgebungsmanagement, Beispielanfragen, Zusicherungen und geteilte Workflows – ohne Reverse-Engineering von Python-Code.

Welche TradingAgents-Einstellungen sollten in einer API offengelegt werden?

Ticker, Analysedatum, Provider, Modellauswahl, Forschungstiefe. Weitere Optionen später nach Bedarf.

Kann ich den Beispiel-Jobstatus im Speicher halten?

Nur für Prototyping. In der Produktion persistieren Sie Status und Ergebnisse dauerhaft (z.B. Redis, Postgres).

Ist TradingAgents für Live-Finanzentscheidungen geeignet?

Das Framework ist als Forschungssystem konzipiert und keine Finanz- oder Anlageberatung. Nutzen Sie es für Forschung und Experimente, es sei denn, Sie ergänzen eigene Governance und Validierung.

Top comments (0)