DEV Community

Cover image for Comment Transformer TradingAgents en un Véritable Workflow API de Trading
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Comment Transformer TradingAgents en un Véritable Workflow API de Trading

TL;DR / Réponse Rapide

Le moyen le plus rapide et pratique d'utiliser TradingAgents est de l'exécuter comme un package Python, de l'encapsuler dans un petit service FastAPI, puis de tester ce service dans Apidog. Cela vous donne un flux de travail reproductible pour déclencher l'analyse, interroger les résultats, documenter le contrat de requête et partager la configuration avec votre équipe.

Essayez Apidog dès aujourd'hui

Introduction

TradingAgents est facile à admirer de l'extérieur. Le dépôt GitHub présente un workflow de trading multi-agents, une interface en ligne de commande (CLI) soignée, un support pour plusieurs fournisseurs de modèles et un document de recherche qui explique la conception du framework. La partie la plus difficile commence lorsque vous essayez de l'utiliser dans un flux de travail d'ingénierie réel.

La plupart des équipes ne veulent pas d'un dépôt que seul un développeur peut exécuter localement. Elles veulent un moyen reproductible de déclencher une analyse, de passer un ticker et une date, de renvoyer un ID de tâche, d'inspecter le résultat plus tard, et de transmettre ce flux de travail aux coéquipiers du frontend, de l'assurance qualité (QA) ou de la plateforme sans transformer chaque question en une session de débogage Python. Et parce que tout système de recherche en trading sera finalement utilisé pour éclairer des décisions financières réelles, il est encore plus important d'encapsuler TradingAgents dans une API contrôlée et documentée au lieu de le laisser comme un script unique sur l'ordinateur de quelqu'un.

💡 Apidog s'intègre naturellement dans ce flux de travail. Vous pouvez importer le schéma OpenAPI de FastAPI, enregistrer des environnements pour les déploiements locaux et distants, extraire des variables des réponses, chaîner les requêtes d'interrogation dans un scénario, et publier des documents pour le reste de votre équipe. Essayez Apidog gratuitement pour suivre.

Ce que TradingAgents est et n'est pas

Avant de commencer à coder, définissez précisément l'outil.

Diagramme TradingAgents

TradingAgents est un framework de trading multi-agents open-source. Il structure un ensemble de rôles spécialisés (analystes fondamentaux, sentiment, actualités, signaux techniques ; chercheurs haussiers/baissiers ; agent trader ; gestion des risques ; gestionnaire de portefeuille).

Architecture TradingAgents

Le framework s'appuie sur LangGraph et supporte plusieurs fournisseurs de modèles : OpenAI, Google, Anthropic, xAI, OpenRouter, Ollama. Par défaut :

  • 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

C'est un framework Python configurable, pas une API SaaS prête à l'emploi. Le dépôt insiste aussi sur la portée : c'est un cadre de recherche, pas un conseil financier. Gardez cette posture dans vos docs et votre UX.

Étape 1 : Installer TradingAgents

Clonez le dépôt et installez les dépendances :

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

Pour le wrapper API de ce tutoriel, ajoutez FastAPI et Uvicorn :

pip install fastapi uvicorn
Enter fullscreen mode Exit fullscreen mode

Configurez vos clés dans .env :

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

Bonnes pratiques :

  1. Mettez vos identifiants dans des variables d'environnement ou un gestionnaire de secrets.
  2. Ne passez jamais de secrets fournisseur dans le corps d'une requête API publique.

Cela sécurise vos environnements et simplifie leur gestion dans Apidog.

Étape 2 : Exécuter TradingAgents en Python d'abord

Avant l'API, validez le workflow Python localement :

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

Testez aussi la surcharge de configuration :

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

C'est ici que vous identifiez quels paramètres exposer plus tard via l'API : ticker, analysis_date, llm_provider, deep_think_llm, quick_think_llm, profondeur de recherche.

Étape 3 : Décidez comment vous voulez utiliser TradingAgents

Trois usages courants :

Option 1 : CLI uniquement

La CLI intégrée permet d'explorer rapidement le projet.

À privilégier pour :

  • découverte et expérimentation solo
  • pas de besoin d'intégration ou de contrat stable

Option 2 : Python uniquement

Utilisez TradingAgentsGraph en script ou notebook pour de l'automatisation locale ou de l'orchestration personnalisée.

Utile si :

  • un seul dev pilote le workflow de bout en bout
  • notebooks ou scripts locaux suffisent

Option 3 : Wrapper API + Apidog

Exposez TradingAgents via une API FastAPI, testez et documentez avec Apidog.

À privilégier pour :

  • intégration UI/frontend
  • QA automatisé
  • partage d'environnements, assertions et documentation
  • workflows longs nécessitant du polling asynchrone

C'est la voie la plus robuste pour les équipes.

Étape 4 : Encapsuler TradingAgents dans un service FastAPI

Adoptez une API basée sur les tâches :

POST /analyses -> renvoie analysis_id
GET /analyses/{id} -> statut (queued/running/completed/failed) et résultat
Enter fullscreen mode Exit fullscreen mode

Créer le contrat API

Endpoint Objectif
GET /health vérification de santé
POST /analyses déclencher une exécution TradingAgents
GET /analyses/{analysis_id} récupérer le statut et le résultat final

Exemple de wrapper 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

Démarrez le service :

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

Les endpoints OpenAPI sont alors disponibles à :

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

Importez ce dernier dans Apidog pour générer la documentation et les requêtes.

Étape 5 : Utiliser TradingAgents via l'API

Déclencher une analyse

Envoyez :

POST /analyses
{
  "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

Réponse attendue :

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

Interroger le résultat 

GET /analyses/{analysis_id}
{
  "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

Lorsque terminé :

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

En cas d'erreur, retournez "status": "failed" et un message d'erreur explicite.

Étape 6 : Importer l'API dans Apidog

Dans Apidog, importez :

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

Vous obtenez immédiatement :

  • documentation synchronisée avec le code
  • paramètres de chemin générés
  • corps de requête alignés
  • partage facilité avec les coéquipiers

Le workflow passe d'un test cURL manuel à une gestion structurée du contrat API.

Étape 7 : Créer un environnement Apidog

Définissez un environnement pour votre service local :

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

Ajoutez des variables d'auth si besoin :

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

Avantages :

  • changement rapide entre local, pré-prod, prod
  • requêtes réutilisables
  • configuration partagée pour l'équipe

Étape 8 : Tester le flux de travail complet dans Apidog

Requête 1 : Créer l'analyse

  • Méthode : POST
  • URL : {{base_url}}/analyses
  • Corps : 
{
  "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

Script de test :

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

Requête 2 : Interroger l'analyse

  • Méthode : GET
  • URL : {{base_url}}/analyses/{{analysis_id}}

Assertion :

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

Vérification si terminé :

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

Chaîner les deux requêtes dans un scénario

Construisez un scénario qui :

  1. POST /analyses
  2. stocke l'analysis_id
  3. attend quelques secondes
  4. GET /analyses/{{analysis_id}}

Vos équipes QA et dev peuvent ainsi valider le cycle de vie complet.

Étape 9 : Publier une documentation interne pour votre équipe

Publiez dans Apidog :

  • fournisseurs autorisés
  • signification de research_depth
  • statuts attendus
  • durée moyenne d'exécution
  • erreurs re-tentables
  • clause de non-responsabilité de recherche

Cela évite que le contrat ne vive que dans la tête d'un seul développeur.

Erreurs courantes lors de l'utilisation de TradingAgents

Traiter le framework comme une API hébergée

TradingAgents n'est pas un service public prêt à l'emploi. C'est à vous de construire le contrat adapté à votre équipe.

Passer des secrets via les corps de requête

Gardez les clés dans l'environnement, jamais dans les payloads ou le frontend.

Renvoyer une longue réponse synchrone unique

Privilégiez une API basée sur les tâches plutôt qu'une requête bloquante.

Exposer trop d'options de configuration

Commencez avec un contrat simple et stable. N'exposez pas tous les paramètres internes dès le début.

Conserver les résultats uniquement en mémoire

Le tuto utilise un dict en mémoire (simplicité). En production, stockez les tâches dans Redis, Postgres ou autre backend persistant.

Masquer la clause de non-responsabilité de recherche

Communiquez clairement : TradingAgents est destiné à la recherche et à l'expérimentation, pas aux conseils financiers.

Conclusion

Utilisez TradingAgents selon vos besoins : CLI et package Python pour l'exploration individuelle ; encapsulez dans une API testée/documentée avec Apidog pour un flux de travail d'équipe robuste.

Pour passer rapidement d'un dépôt GitHub à un workflow d'équipe :

  1. Installez TradingAgents
  2. Testez TradingAgentsGraph localement
  3. Ajoutez POST /analyses et GET /analyses/{id}
  4. Importez le schéma dans Apidog
  5. Construisez un scénario de bout en bout

C'est bien plus maintenable qu'une suite de commandes shell ou des connaissances orales.

FAQ

Comment utiliser TradingAgents pour la première fois ?

Installez le dépôt, configurez les variables d'environnement du fournisseur de modèle, puis exécutez l'exemple Python avec TradingAgentsGraph. Ensuite, choisissez entre la CLI ou l'API selon vos besoins.

TradingAgents est-il livré avec une API REST officielle ?

Non, selon la doc publique (26 mars 2026), il s'agit d'une CLI et d'un package Python. Beaucoup d'équipes ajoutent donc une fine couche FastAPI.

Quelle est la manière la plus simple d'utiliser TradingAgents dans une application frontend ?

N'appelez pas le framework Python directement depuis le frontend. Passez par une API backend qui renvoie un analysis_id à interroger.

Pourquoi utiliser Apidog avec TradingAgents ?

Apidog permet d'importer le schéma OpenAPI, de gérer les environnements, stocker des exemples de requêtes, ajouter des assertions et partager le workflow avec des coéquipiers non Python.

Quels paramètres de TradingAgents méritent d'être exposés dans une API ?

Commencez par le ticker, la date d'analyse, le fournisseur, les modèles et la profondeur de recherche. Étendez au besoin.

Puis-je conserver l'état de la tâche exemple en mémoire ?

Uniquement pour l'apprentissage ou le prototypage. En production, utilisez un backend persistant pour ne pas perdre l'état au redémarrage.

TradingAgents est-il adapté aux décisions financières en temps réel ?

Non. Le projet se décrit comme un cadre de recherche, pas un outil de décision financière. Ajoutez vos propres contrôles et gouvernance si besoin professionnel.

Essayez Apidog dès aujourd'hui

Top comments (0)