Blog

Trading Agents in einen echten Trading API Workflow umwandeln

Ashley Innocent

Ashley Innocent

26 March 2026

Trading Agents in einen echten Trading API Workflow umwandeln

Apidog für Unternehmen

On-Premises-Bereitstellung

SSO & RBAC

SOC 2 konform

Apidog Enterprise entdecken

TL;DR / Kurzantwort

Der schnellste praktische Weg, TradingAgents zu nutzen, ist, es als Python-Paket auszuführen, es in einem kleinen FastAPI-Dienst zu verpacken und diesen Dienst dann in Apidog zu testen. Das ermöglicht einen wiederholbaren Workflow zum Auslösen von Analysen, Abfragen von Ergebnissen, Dokumentieren des Anfragevertrags und Teilen der Einrichtung mit Ihrem Team.

Einführung

TradingAgents ist von außen leicht zu bewundern. Das GitHub-Repository zeigt einen Multi-Agenten-Handelsworkflow, eine ausgefeilte CLI, Unterstützung für mehrere Modell-Provider und ein Forschungspapier, das das Framework-Design erklärt. Der schwierigere Teil beginnt, wenn man versucht, es in einem echten Engineering-Workflow zu nutzen.

Die meisten Teams möchten kein Repository, das nur ein Entwickler lokal ausführen kann. Sie wünschen sich eine wiederholbare Methode, um Analysen auszulösen, einen Ticker und ein Datum zu übergeben, eine Job-ID zurückzugeben, das Ergebnis später zu überprüfen und diesen Workflow an Frontend-, QA- oder Plattform-Teammitglieder weiterzugeben, ohne jede Frage in eine Python-Debugging-Sitzung zu verwandeln. Und da jedes Handelsforschungssystem letztendlich zur Information über Echtgeldentscheidungen verwendet wird, ist es noch wichtiger, TradingAgents in eine kontrollierte, dokumentierte API zu verpacken, anstatt es als einmaliges Skript auf dem Laptop eines Einzelnen zu belassen.

💡
Apidog passt natürlich in diesen Workflow. Sie können das OpenAPI-Schema aus FastAPI importieren, Umgebungen für lokale und Remote-Bereitstellungen speichern, Variablen aus Antworten extrahieren, Polling-Anfragen zu einem Szenario verketten und Dokumente für den Rest Ihres Teams veröffentlichen. Laden Sie Apidog kostenlos herunter, um mitzumachen.
Schaltfläche

Was TradingAgents ist und was nicht

Bevor Sie mit dem Codieren beginnen, ist es hilfreich, das Tool genau zu definieren.

null

TradingAgents ist ein Open-Source-Multi-Agenten-Handelsframework. Das Repository beschreibt eine Reihe spezialisierter Rollen, die die Struktur einer Handelsfirma widerspiegeln:

null

Das Repository gibt außerdem an, dass das Framework mit LangGraph erstellt wurde und mehrere Modell-Provider unterstützt, darunter OpenAI, Google, Anthropic, xAI, OpenRouter und Ollama. In der öffentlichen Standardkonfiguration verwendet das Projekt derzeit Werte wie:

Das ist wichtig, denn es sagt Ihnen, womit Sie es wirklich zu tun haben: einem konfigurierbaren Python-Framework, nicht einer direkt nutzbaren SaaS-API.

Das Repository achtet auch auf den Geltungsbereich. TradingAgents wird als Forschungs-Framework präsentiert, nicht als Finanzberatung. Wenn Sie es intern verwenden oder Software darum herum entwickeln, halten Sie diese Einordnung in Ihren Dokumenten und in der Benutzererfahrung sichtbar.

Schritt 1: TradingAgents installieren

Beginnen Sie mit der Einrichtung aus dem Repository selbst:

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

Wenn Sie auch den API-Wrapper aus diesem Tutorial erstellen möchten, fügen Sie FastAPI und Uvicorn hinzu:

pip install fastapi uvicorn

Das TradingAgents-Repository enthält auch eine .env.example mit Provider-Variablen wie:

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=

Abhängig von Ihren Modell- und Datenentscheidungen benötigen Sie möglicherweise auch andere Anbieterzugangsdaten, wie die von Alpha Vantage.

Zwei praktische Regeln sind hier wichtig:

  1. Bewahren Sie Anmeldeinformationen in Umgebungsvariablen oder einem Secrets Manager auf.
  2. Geben Sie später keine Anbietergeheimnisse über Ihren öffentlichen API-Anfragekörper weiter.

Diese Trennung wird Ihre Apidog-Umgebungen sauberer und Ihr Sicherheitsmodell wesentlich sicherer machen.

Schritt 2: TradingAgents zuerst in Python ausführen

Bevor Sie einen API-Wrapper erstellen, beweisen Sie, dass das Kern-Framework in Ihrer Umgebung läuft.

Die README zeigt ein minimales Python-Nutzungsmuster:

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)

Dies ist der richtige erste Prüfpunkt, da er die einzige Frage beantwortet, die frühzeitig wichtig ist: Können Ihr Computer, Ihre Modelleinrichtung und Ihre Abhängigkeiten tatsächlich einen TradingAgents-Lauf ausführen?

Wenn das funktioniert, können Sie mit der kontrollierten Konfiguration fortfahren. Das Repository zeigt auch, dass Sie die Standardkonfiguration überschreiben können:

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)

Dieses zweite Beispiel ist wichtiger, als es scheint. Es sagt Ihnen, welche Parameter es wert sind, später in einer API offengelegt zu werden:

Wenn Sie diese lokale Python-Phase überspringen und direkt zu HTTP wechseln, erschweren Sie das Debugging unnötig.

Schritt 3: Entscheiden Sie, wie Sie TradingAgents nutzen möchten

An diesem Punkt haben Sie drei gängige Möglichkeiten, das Framework zu nutzen.

Option 1: Nur CLI

Das Repository enthält eine interaktive CLI, in der Sie Ticker, Datum, Anbieter und Forschungstiefe auswählen können. Dies ist eine gute Möglichkeit, das Projekt schnell zu erkunden.

Verwenden Sie dies, wenn:

Halten Sie hier nicht an, wenn Ihr nächster Schritt ein Frontend, ein Admin-Tool, ein Shared Service oder ein QA-Workflow ist.

Option 2: Nur Python

Das direkte Aufrufen von TradingAgentsGraph aus Python ist besser als die CLI, wenn Sie eine benutzerdefinierte Orchestrierung oder lokale Skripte benötigen.

Verwenden Sie dies, wenn:

Dies reicht immer noch nicht aus, wenn mehrere Teams den Workflow nutzen müssen.

Option 3: API-Wrapper plus Apidog

Dies ist die nützlichste Team-Einrichtung. Sie behalten TradingAgents als Ausführungs-Engine, stellen es über einen kleinen FastAPI-Dienst bereit und verwenden Apidog, um den Vertrag zu testen und zu dokumentieren.

Verwenden Sie dies, wenn:

Für die meisten Teams ist dies der Punkt, an dem "wie man TradingAgents verwendet" zu einer echten Implementierungsantwort wird, anstatt nur einer lokalen Demo.

Schritt 4: TradingAgents in einem FastAPI-Dienst verpacken

Das sauberste Muster für einen ersten Wrapper ist eine jobbasierte API.

Warum jobbasiert? Weil eine Multi-Agenten-Analyse lange genug dauern kann, dass es für Clients umständlich ist, eine Anfrage offen zu halten. Ein besseres Muster ist:

POST /analyses -> returns analysis_id
GET /analyses/{id} -> returns queued, running, completed, or failed

Diese Struktur ist einfacher für Browser, einfacher für die QA und einfacher in Apidog zu dokumentieren.

Den API-Vertrag erstellen

Ein minimaler Vertrag sieht wie folgt aus:

EndpunktZweck
GET /healthgrundlegende Zustandsprüfung
POST /analyseseinen TradingAgents-Lauf auslösen
GET /analyses/{analysis_id}Jobstatus und Endergebnis abrufen

Den Wrapper erstellen

Hier ist ein kompaktes FastAPI-Beispiel:

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

Den Dienst starten:

uvicorn app:app --reload

Sobald der Server läuft, stellt FastAPI Folgendes bereit:

Diese zweite URL ist besonders nützlich, da Apidog sie direkt importieren kann.

Schritt 5: TradingAgents über die API nutzen

Jetzt sind Sie bereit, TradingAgents auf eine Weise zu nutzen, die stabil und wiederholbar ist.

Eine Analyse auslösen

Senden Sie eine POST /analyses Anfrage mit einem Body wie diesem:

{
 "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
}

Die Antwort sollte schnell und klein sein:

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

Das ist genau das, was Sie wollen. Ihr Client benötigt den Abschlussbericht nicht sofort. Er benötigt einen stabilen Handle für den Lauf.

Das Ergebnis abfragen

Verwenden Sie GET /analyses/{analysis_id}, um den Fortschritt zu überprüfen:

{
 "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"
}

Wenn der Workflow abgeschlossen ist, kann die Antwort die endgültige Entscheidung enthalten:

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

Wenn etwas schiefgeht, geben Sie einen eindeutigen failed Status und eine Fehlermeldung zurück, anstatt Clients im Ungewissen zu lassen.

Schritt 6: Die API in Apidog importieren

Hier wird der Workflow wesentlich einfacher zu pflegen.

Importieren Sie in Apidog das OpenAPI-Schema von:

http://localhost:8000/openapi.json

Nach dem Import sollten Sie Ihre Endpunkte mit ihrer Anfrage- und Antwortstruktur bereits vorhanden sehen.

Das bringt Ihnen einige sofortige Vorteile:

Wenn Sie von Ad-hoc-cURL-Tests umsteigen, ist dies ein sinnvolles Upgrade. Wenn Sie von einem reinen Anfragetool umsteigen, wird Apidog hier wichtiger, da Sie Design, Tests, Umgebungen und Dokumentation an einem Ort aufbewahren können.

Schritt 7: Eine Apidog-Umgebung erstellen

Sobald die API importiert ist, erstellen Sie eine Umgebung für Ihren lokalen Dienst.

Beispielvariablen:

base_url = http://localhost:8000
analysis_id =

Wenn Ihre API Authentifizierung verwendet, fügen Sie diese ebenfalls hinzu:

internal_api_key = your-local-dev-key

Dieser Schritt wirkt klein, verhindert aber viel Reibung:

Dies ist einer der einfachsten Gründe, warum Apidog ein starker Begleiter für TradingAgents ist. Das Framework selbst kümmert sich um die Analyselogik. Apidog kümmert sich um den gemeinsamen Workflow darum herum.

Schritt 8: Den vollständigen Workflow in Apidog testen

Jetzt können Sie Apidog verwenden, um TradingAgents so zu testen, wie es ein echter Client tun würde.

Anfrage 1: Die Analyse erstellen

Konfigurieren Sie:

{
 "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
}

Fügen Sie ein Testskript hinzu, das den Status validiert und die ID speichert:

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

Anfrage 2: Die Analyse abfragen

Konfigurieren Sie:

Fügen Sie dann eine Zusicherung wie diese hinzu:

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

Wenn Sie auch eine Erfolgs-Pfad-Prüfung wünschen:

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

Beide Anfragen zu einem Szenario verketten

Hier wird Apidog mehr als nur ein API-Client. Erstellen Sie ein Szenario, das:

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

Das gibt Ihren QA- und Entwicklungsteams eine reproduzierbare Möglichkeit, den Lebenszyklus zu validieren, anstatt nur zu überprüfen, ob ein Endpunkt zufällig einen 200-Statuscode zurückgibt.

Schritt 9: Interne Dokumentation für Ihr Team veröffentlichen

Sobald die Anfragen funktionieren, hören Sie nicht beim Testen auf.

Verwenden Sie Apidog, um interne Dokumentation zu veröffentlichen, die erklärt:

Dies ist einer der wichtigsten Aspekte, um TradingAgents gut zu nutzen. Das Kern-Framework ist clever, aber clevere Frameworks werden zu Team-Engpässen, wenn der Vertrag nur im Kopf eines Entwicklers existiert.

Laden Sie Apidog kostenlos herunter, um TradingAgents in einen dokumentierten API-Workflow mit Umgebungen, Zusicherungen und wiederverwendbaren, teamtauglichen Szenarien zu verwandeln.

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

Das Framework wie eine gehostete API behandeln

TradingAgents ist kein vorgefertigter öffentlicher Dienst. Es ist ein Python-Framework. Erstellen Sie den Vertrag, den Ihr Team verwenden soll, anstatt zu erwarten, dass das Repository ihn für Sie bereitstellt.

Geheimnisse über Anfragekörper weitergeben

Bewahren Sie Anbieterschlüssel im Umgebungsmanagement auf. Geben Sie sie nicht in Beispielen, Frontend-Aufrufen oder geteilten Screenshots preis.

Eine lange synchrone Antwort zurückgeben

Für einen mehrstufigen Agenten-Workflow ist eine jobbasierte API in der Regel einfacher zu verwalten als eine lange blockierende Anfrage.

Zu viele Konfigurationsoptionen offenlegen

Das Repository verfügt über nützliche Konfigurationsoptionen, aber Ihre API muss nicht am ersten Tag jede interne Einstellung offenlegen. Beginnen Sie mit einem kleinen, stabilen Vertrag.

Ergebnisse nur im Speicher halten

Der Tutorial-Code verwendet ein In-Memory-Wörterbuch, weil es leicht verständlich ist. In der Produktion speichern Sie den Job-Status in Redis, Postgres oder einem anderen dauerhaften Backend.

Den Forschungs-Haftungsausschluss verstecken

Wenn Ihr Dienst TradingAgents umschließt, behalten Sie die gleiche Warnung bei, die das Projekt verwendet. Das Framework dient der Forschung und dem Experimentieren, nicht der Finanzberatung.

Fazit

Die beste Art, TradingAgents zu nutzen, hängt davon ab, was Sie erreichen möchten. Wenn Sie das Framework alleine erkunden, genügen die CLI und das Python-Paket. Wenn Sie einen stabilen, wiederholbaren Team-Workflow wünschen, verpacken Sie TradingAgents in einer kleinen API und nutzen Sie Apidog zum Testen und Dokumentieren.

Wenn Sie schnell von einem GitHub-Repository zu einem nutzbaren Team-Workflow gelangen möchten, installieren Sie TradingAgents, bestätigen Sie, dass TradingAgentsGraph lokal funktioniert, fügen Sie POST /analyses und GET /analyses/{id} hinzu, importieren Sie dann das Schema in Apidog und erstellen Sie ein End-to-End-Szenario. Dieser Weg ist wesentlich einfacher zu pflegen als eine Sammlung von Terminalbefehlen und Stammeswissen.

Schaltfläche

FAQ

Wie nutzen Sie TradingAgents zum ersten Mal?

Beginnen Sie mit der Installation des Repositories, dem Festlegen der Umgebungsvariablen des Modellanbieters und dem Ausführen des Python-Beispiels mit TradingAgentsGraph. Sobald dies funktioniert, entscheiden Sie, ob Sie nur die CLI benötigen oder ob Sie es in eine API verpacken sollten.

Kommt TradingAgents mit einer offiziellen REST-API?

Nicht gemäß den am 26. März 2026 überprüften öffentlichen Repository-Materialien. Das Projekt wird als CLI- und Python-Paket präsentiert, weshalb viele Teams eine dünne FastAPI-Schicht hinzufügen möchten.

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

Rufen Sie das Python-Framework nicht direkt vom Frontend auf. Stellen Sie es über eine Backend-API bereit, die eine analysis_id zurückgibt, und lassen Sie das Frontend dann die Ergebnisse abfragen.

Warum Apidog mit TradingAgents verwenden?

Apidog bietet Ihnen eine saubere Oberfläche, um das OpenAPI-Schema zu importieren, Umgebungswerte zu speichern, Beispielanfragen abzulegen, Zusicherungen hinzuzufügen und den Workflow mit Teamkollegen zu teilen, die den Python-Code nicht reverse-engineeren müssen.

Welche TradingAgents-Einstellungen sollten in einer API offengelegt werden?

Die sicherste Startkonfiguration umfasst Ticker, Analysedatum, Anbieter, Modellauswahl und Forschungstiefe. Sie können diese später jederzeit erweitern, wenn der Anwendungsfall dies erfordert.

Kann ich den Beispiel-Jobstatus im Speicher halten?

Nur zum Lernen oder Prototyping. In der Produktion speichern Sie den Jobstatus und die Ergebnisse in einem dauerhaften Backend, damit ein Dienstneustart aktive Analysen nicht löscht.

Ist TradingAgents für Live-Finanzentscheidungen geeignet?

Die öffentlichen Projektmaterialien beschreiben es als Forschungsframework und weisen ausdrücklich darauf hin, dass es keine Finanz- oder Anlageberatung ist. Behandeln Sie es als Forschungs- und Experimentiersystem, es sei denn, Sie fügen Ihre eigenen Kontrollen, Validierungen und Governance hinzu.

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload