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.

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. Téléchargez Apidog gratuitement pour suivre.

bouton

Ce que TradingAgents est et n'est pas

Avant de commencer à coder, il est utile de définir l'outil avec précision.

TradingAgents est un framework de trading multi-agents open-source. Le dépôt décrit un ensemble de rôles spécialisés qui reflètent la structure d'une société de trading :

des analystes pour les fondamentaux, le sentiment, les actualités et les signaux techniques
des chercheurs haussiers et baissiers pour le débat
un agent trader
des rôles de gestion des risques
un gestionnaire de portefeuille pour la décision finale

Le dépôt indique également que le framework est construit avec LangGraph et prend en charge plusieurs fournisseurs de modèles, notamment OpenAI, Google, Anthropic, xAI, OpenRouter et Ollama. Dans la configuration publique par défaut, le projet utilise actuellement des valeurs telles que :

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 important car cela vous dit avec quoi vous travaillez réellement : un framework Python configurable, et non une API SaaS prête à l'emploi.

Le dépôt est également prudent quant à la portée. TradingAgents est présenté comme un cadre de recherche, et non comme un conseil financier. Si vous l'utilisez en interne ou développez des logiciels autour de lui, gardez ce cadrage visible dans vos documents et l'expérience utilisateur.

Étape 1 : Installer TradingAgents

Commencez par la configuration du dépôt lui-même :

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

Si vous souhaitez également construire le wrapper API de ce tutoriel, ajoutez FastAPI et Uvicorn :

pip install fastapi uvicorn

Le dépôt TradingAgents comprend également un fichier .env.example avec des variables de fournisseur telles que :

OPENAI_API_KEY=
GOOGLE_API_KEY=
ANTHROPIC_API_KEY=
XAI_API_KEY=
OPENROUTER_API_KEY=

Selon vos choix de modèles et de données, vous pourriez également avoir besoin d'autres identifiants de fournisseurs, tels qu'Alpha Vantage.

Deux règles pratiques sont importantes ici :

Gardez les identifiants dans les variables d'environnement ou un gestionnaire de secrets.
Ne transmettez pas les secrets du fournisseur via le corps de votre requête API publique plus tard.

Cette séparation rendra vos environnements Apidog plus propres et votre modèle de sécurité beaucoup plus sûr.

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

Avant de construire n'importe quel wrapper API, prouvez que le framework principal fonctionne dans votre environnement.

Le README montre un modèle d'utilisation Python minimal :

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)

C'est le premier point de contrôle idéal car il répond à la seule question qui compte au début : votre machine, la configuration de votre modèle et vos dépendances peuvent-elles réellement exécuter un cycle TradingAgents ?

Si cela fonctionne, vous pouvez passer à la configuration contrôlée. Le dépôt montre également que vous pouvez remplacer la configuration par défaut :

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)

Ce deuxième exemple est plus important qu'il n'y paraît. Il vous indique quels paramètres méritent d'être exposés dans une API ultérieurement :

ticker
analysis_date
llm_provider
deep_think_llm
quick_think_llm
profondeur de recherche ou nombre de tours de débat

Si vous sautez cette phase Python locale et passez directement à HTTP, vous rendez le débogage plus difficile qu'il ne devrait l'être.

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

À ce stade, vous avez trois façons courantes d'utiliser le framework.

Option 1 : CLI uniquement

Le dépôt comprend une CLI interactive où vous pouvez choisir le ticker, la date, le fournisseur et la profondeur de recherche. C'est un bon moyen d'explorer rapidement le projet.

Utilisez ceci lorsque :

vous apprenez l'outil
vous réalisez des expériences en solo
vous n'avez pas besoin d'un contrat stable pour une autre application

N'arrêtez pas ici si votre prochaine étape est une interface utilisateur, un outil d'administration, un service partagé ou un workflow QA.

Option 2 : Python uniquement

Appeler TradingAgentsGraph directement depuis Python est préférable à la CLI lorsque vous avez besoin d'une orchestration personnalisée ou de scripts locaux.

Utilisez ceci lorsque :

vous voulez des notebooks ou une automatisation locale
vous avez besoin d'un contrôle programmatique
un seul développeur gère le flux de travail de bout en bout

Ceci est toujours insuffisant lorsque plusieurs équipes doivent consommer le flux de travail.

Option 3 : Wrapper API plus Apidog

C'est la configuration d'équipe la plus utile. Vous gardez TradingAgents comme moteur d'exécution, l'exposez via un petit service FastAPI, et utilisez Apidog pour tester et documenter le contrat.

Utilisez ceci lorsque :

une interface utilisateur doit déclencher une analyse
la QA a besoin d'un flux de requêtes reproductible
vous voulez des environnements, des assertions et de la documentation au même endroit
le flux de travail peut durer assez longtemps pour que l'interrogation ait plus de sens qu'une seule requête synchrone

Pour la plupart des équipes, c'est à ce stade que "comment utiliser TradingAgents" devient une véritable réponse d'implémentation au lieu d'une simple démonstration locale.

Étape 4 : Encapsuler TradingAgents dans un service FastAPI

Le modèle le plus propre pour un premier wrapper est une API basée sur les tâches.

Pourquoi basé sur les tâches ? Parce qu'une analyse multi-agents peut prendre suffisamment de temps pour qu'il soit difficile pour les clients de maintenir une requête ouverte. Un meilleur modèle est :

POST /analyses -> renvoie analysis_id
GET /analyses/{id} -> renvoie en file d'attente, en cours, terminé ou échoué

Cette structure est plus facile pour les navigateurs, plus facile pour le QA, et plus facile à documenter dans Apidog.

Créer le contrat API

Un contrat minimal ressemble à ceci :

Point d'accès (Endpoint)	Objectif
`GET /health`	vérification de santé basique
`POST /analyses`	déclencher une exécution de TradingAgents
`GET /analyses/{analysis_id}`	récupérer le statut de la tâche et le résultat final

Construire le wrapper

Voici un exemple compact de 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

Démarrez le service :

uvicorn app:app --reload

Une fois le serveur démarré, FastAPI exposera :

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

Cette deuxième URL est particulièrement utile car Apidog peut l'importer directement.

Étape 5 : Utiliser TradingAgents via l'API

Vous êtes maintenant prêt à utiliser TradingAgents de manière stable et reproductible.

Déclencher une analyse

Envoyez une requête POST /analyses avec un corps comme celui-ci :

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

La réponse devrait être rapide et courte :

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

C'est exactement ce que vous voulez. Votre client n'a pas besoin du rapport final immédiatement. Il a besoin d'un identifiant stable pour l'exécution.

Interroger le résultat

Utilisez GET /analyses/{analysis_id} pour vérifier la progression :

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

Lorsque le workflow est terminé, la réponse peut inclure la décision finale :

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

Si quelque chose ne va pas, renvoyez un état failed clair et un message d'erreur au lieu de laisser les clients deviner.

Étape 6 : Importer l'API dans Apidog

C'est là que le flux de travail devient beaucoup plus facile à maintenir.

Dans Apidog, importez le schéma OpenAPI depuis :

http://localhost:8000/openapi.json

Après l'importation, vous devriez voir vos points d'accès avec leur structure de requête et de réponse déjà en place.

Cela vous donne quelques avantages immédiats :

la documentation correspond à l'implémentation
les paramètres de chemin sont générés correctement
les corps de requête restent alignés avec votre code
les coéquipiers n'ont pas besoin de reconstruire la collection manuellement

Si vous passez d'un test cURL ad hoc, il s'agit d'une amélioration significative. Si vous passez d'un outil de requête uniquement, c'est là qu'Apidog commence à prendre plus d'importance, car vous pouvez conserver la conception, les tests, les environnements et la documentation au même endroit.

Étape 7 : Créer un environnement Apidog

Une fois l'API importée, créez un environnement pour votre service local.

Exemple de variables :

base_url = http://localhost:8000
analysis_id =

Si votre API utilise l'authentification, incluez-la également :

internal_api_key = your-local-dev-key

Cette étape semble mineure, mais elle prévient de nombreuses frictions :

vous pouvez basculer plus rapidement entre le local, la pré-production et la production
vos requêtes restent réutilisables
vos coéquipiers n'ont pas à réécrire les URL et les en-têtes à chaque fois

C'est l'une des raisons les plus simples pour lesquelles Apidog est un compagnon solide pour TradingAgents. Le framework lui-même gère la logique d'analyse. Apidog gère le flux de travail partagé qui l'entoure.

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

Vous pouvez maintenant utiliser Apidog pour tester TradingAgents de la même manière qu'un vrai client.

Requête 1 : Créer l'analyse

Configurer :

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
}

Ajoutez un script de test qui valide le statut et stocke l'ID :

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

Requête 2 : Interroger l'analyse

Configurer :

méthode : GET
URL : {{base_url}}/analyses/{{analysis_id}}

Ensuite, ajoutez une assertion comme :

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

Si vous souhaitez également une vérification du chemin de succès :

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

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

C'est là qu'Apidog devient plus qu'un simple client API. Construisez un scénario qui :

envoie POST /analyses
stocke l'analysis_id
attend quelques secondes
exécute GET /analyses/{{analysis_id}}

Cela donne à vos équipes QA et d'ingénierie un moyen reproductible de valider le cycle de vie au lieu de simplement vérifier si un point d'accès renvoie un 200.

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

Une fois que les requêtes fonctionnent, ne vous arrêtez pas aux tests.

Utilisez Apidog pour publier une documentation interne qui explique :

quels fournisseurs sont autorisés
ce que signifie research_depth dans votre déploiement
quelles valeurs de statut les clients doivent attendre
combien de temps les exécutions prennent généralement
quelles erreurs sont re-tentables
où la clause de non-responsabilité de recherche s'applique

C'est l'une des parties les plus importantes pour bien utiliser TradingAgents. Le framework principal est intelligent, mais les frameworks intelligents deviennent des goulots d'étranglement pour l'équipe lorsque le contrat ne vit que dans la tête d'un seul développeur.

Téléchargez Apidog gratuitement pour transformer TradingAgents en un workflow API documenté avec des environnements, des assertions et des scénarios réutilisables prêts pour l'équipe.

Erreurs courantes lors de l'utilisation de TradingAgents de cette manière

Traiter le framework comme une API hébergée

TradingAgents n'est pas un service public prêt à l'emploi. C'est un framework Python. Construisez le contrat que votre équipe doit utiliser au lieu d'attendre que le dépôt vous le fournisse.

Passer des secrets via les corps de requête

Gardez les clés des fournisseurs dans la gestion de l'environnement. Ne les laissez pas apparaître dans les exemples, les appels frontend ou les captures d'écran partagées.

Renvoyer une longue réponse synchrone unique

Pour un workflow d'agents en plusieurs étapes, une API basée sur les tâches est généralement plus facile à gérer qu'une longue requête bloquante.

Exposer trop d'options de configuration

Le dépôt offre des options de configuration utiles, mais votre API n'a pas besoin d'exposer tous les paramètres internes dès le premier jour. Commencez par un contrat petit et stable.

Conserver les résultats uniquement en mémoire

Le code du tutoriel utilise un dictionnaire en mémoire car il est facile à comprendre. En production, stockez l'état des tâches dans Redis, Postgres ou un autre backend durable.

Masquer la clause de non-responsabilité de recherche

Si votre service encapsule TradingAgents, conservez le même avertissement utilisé par le projet. Le framework est destiné à la recherche et à l'expérimentation, et non à des conseils financiers.

Conclusion

La meilleure façon d'utiliser TradingAgents dépend de ce que vous essayez de faire. Si vous explorez le framework seul, la CLI et le package Python sont suffisants. Si vous voulez un flux de travail d'équipe stable et reproductible, encapsulez TradingAgents dans une petite API et utilisez Apidog pour la tester et la documenter.

Si vous voulez passer rapidement d'un dépôt GitHub à un flux de travail d'équipe utilisable, installez TradingAgents, confirmez que TradingAgentsGraph fonctionne localement, ajoutez POST /analyses et GET /analyses/{id}, puis importez le schéma dans Apidog et construisez un scénario de bout en bout. Ce chemin est beaucoup plus facile à maintenir qu'une collection de commandes de terminal et de connaissances tacites.

bouton

FAQ

Comment utiliser TradingAgents pour la première fois ?

Commencez par installer le dépôt, définir les variables d'environnement du fournisseur de modèle et exécuter l'exemple Python avec TradingAgentsGraph. Une fois que cela fonctionne, décidez si vous avez seulement besoin de la CLI ou si vous devez l'encapsuler dans une API.

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

Non, d'après les documents du dépôt public examinés le 26 mars 2026. Le projet est présenté comme une CLI et un package Python, c'est pourquoi de nombreuses équipes voudront ajouter 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. Exposez-le via une API backend qui renvoie un analysis_id, puis laissez le frontend interroger les résultats.

Pourquoi utiliser Apidog avec TradingAgents ?

Apidog vous offre un endroit propre pour importer le schéma OpenAPI, enregistrer les valeurs d'environnement, stocker des exemples de requêtes, ajouter des assertions et partager le flux de travail avec des coéquipiers qui ne devraient pas avoir à faire de la rétro-ingénierie du code Python.

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

L'ensemble de départ le plus sûr comprend le ticker, la date d'analyse, le fournisseur, les choix de modèles et la profondeur de recherche. Vous pouvez toujours l'étendre plus tard si le cas d'utilisation est réel.

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

Uniquement pour l'apprentissage ou le prototypage. En production, stockez l'état de la tâche et les résultats dans un backend durable afin qu'un redémarrage du service n'efface pas les analyses actives.

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

Les documents du projet public le décrivent comme un cadre de recherche et précisent explicitement qu'il ne s'agit pas de conseils financiers ou d'investissement. Traitez-le comme un système de recherche et d'expérimentation à moins d'ajouter vos propres contrôles, validations et gouvernance.