Un agent de trading LangChain soutenu par des données de marché EODHD en temps réel, étape par étape

De nombreux agents de trading prétendument basés sur l’IA montrés dans les vidéos ne sont en réalité pas des agents. Il s’agit de modèles de langage équipés de prompts bien formulés et de chiffres inventés. Un véritable agent a besoin de trois éléments : la capacité de raisonnement, des outils pour agir, et des données en temps réel afin d’éviter les hallucinations. Sans ces derniers, les deux premiers ont peu d’importance. Cet article s’adresse à toute personne qui crée des agents pour l’analyse financière, qui souhaite relier LangChain à des données de marché réelles, ou qui a essayé un « bot de trading » basé sur un LLM et a constaté que, sans données fiables, il ne s’agit que de pure illusion.

En bref, un agent est un LLM à qui l’on fournit des outils (fonctions) ainsi que la liberté de décider quand et comment les utiliser, au lieu de répondre en s’appuyant uniquement sur ses connaissances issues de son entraînement. LangChain est un framework Python qui relie le modèle, les outils, la mémoire et le cycle de décision en une seule unité exécutable. EODHD fournit ce que aucun modèle n’a par défaut : des prix en temps réel, des données fondamentales, des indicateurs techniques et des actualités financières récentes, via une API REST. Ensemble, cela permet d’obtenir un agent capable de répondre à la question « Ce titre devrait-il figurer dans mon suivi en ce moment ? » en s’appuyant sur des données actuelles et non sur une mémoire obsolète.

Le modèle n’est pas le point faible

Si vous demandez à n’importe quel LLM le prix actuel d’une action, il fournira un chiffre. Ce chiffre peut être obsolète depuis des mois ou simplement inventé. Les modèles n’ont pas accès au marché en temps réel, ignorent ce qui s’est passé hier et n’ont pas consulté le dernier rapport de résultats, pourtant de nombreux projets les utilisent comme s’ils en disposaient. Les conséquences sont prévisibles : des recommandations basées sur des données anciennes, des fondamentaux fabriqués présentés avec une grande assurance, et une analyse technique effectuée sur des prix qui n’ont jamais existé.

Rien de tout cela ne montre que le modèle est mauvais en finance. Le problème, c’est que personne ne lui fournit les bonnes données d’entrée. Un modèle sans outils, c’est comme une bibliothèque sans fenêtres : beaucoup de connaissances, mais aucune vue sur le présent. Un modèle plus grand ne résout pas ce problème. Ce qui compte, c’est l’accès à des données externes vérifiables, ainsi que la possibilité de laisser le modèle décider quand chercher ces informations. C’est à cela que sert un agent.

L’ensemble des composants

LangChain gère la logique de l’agent. Il prend la question de l’utilisateur, choisit un outil, exécute la requête, interprète le résultat et rédige une réponse. Il n’y a rien de magique là-dedans, juste un cycle de raisonnement basé sur des règles.

EODHD comble les lacunes de données. Grâce à son API, l’agent peut obtenir des prix OHLCV en temps réel et historiques, des données fondamentales de l’entreprise telles que les ratios, le bilan et les revenus, des indicateurs techniques comme le RSI, les moyennes mobiles et le MACD, ainsi que des nouvelles reflétant l’opinion du marché. Les raisons de choisir cette solution pour ce type d’automatisation sont pratiques : sa couverture inclut des bourses du monde entier, pas seulement la NYSE et le NASDAQ. Les données fondamentales, les indicateurs techniques et les nouvelles sont accessibles via des endpoints distincts, ce qui permet à chacun d’eux de fonctionner en tant qu’outil indépendant. De plus, son plan gratuit est suffisamment généreux pour permettre de créer des prototypes avant d’élargir l’échelle.

Évaluer EODHD en tant que couche de données

Tout fournisseur de données mérite d’être examiné avec attention avant d’être intégré dans un agent. Sur le plan positif, les prix, les données fondamentales, les indicateurs techniques et les actualités sont regroupés sous une seule clé et un seul plan de facturation, ce qui évite de devoir combiner trois fournisseurs différents. De nombreuses alternatives gratuites, telles que des outils de scraping basés sur Yahoo et des plans limités d’Alpha Vantage, ne couvrent que les actions américaines, tandis qu’EODHD atteint des dizaines de bourses, ce qui est important pour les actions hors États-Unis. Les réponses sont fournies sous forme de JSON structuré avec des champs prévisibles (close, change_p, PERatio et ainsi de suite), ce qui rend les enveloppes logicielles simples et évite toute dépendance à une analyse HTML fragile. Vous pouvez créer et tester l’ensemble de l’agent, y compris les données de prix, les informations fondamentales et le RSI, avant de payer. Les limites de fréquence d’appel sont documentées et prévisibles, ce qui est crucial lorsque l’agent doit appeler un outil plusieurs fois pour une même question.

Il y a des inconvénients. Le plan gratuit impose des limites quotidiennes sur le nombre de requêtes, ce qui convient pour une liste de suivi personnelle mais est insuffisant pour un service professionnel utilisé par plusieurs utilisateurs. Les mises à jour des données de base se font selon le calendrier du fournisseur, et non dès la publication des résultats financiers, une contrainte commune à toutes les API de ce type mais importante si votre agent a besoin d’analyses en temps réel. De plus, c’est à vous de rédiger les descriptions des outils : un outil LangChain mal écrit sera toujours appelé au mauvais moment ou mal interprété par le modèle, quel que soit la qualité de l’API. Pour un agent capable de raisonnement qui a besoin de données financières structurées sans pipeline de scraping, les compromis favorisent l’utilisation d’une API hébergée plutôt que d’une couche de données personnalisée.

Fonctionnement du cycle de raisonnement

La plupart des tutoriels omettent d’expliquer en détail ce qu’est mécaniquement un « agent ». Un agent LangChain utilisant le modèle ReAct (Raisonnement + Action) exécute un cycle composé de quatre étapes.

1. Le LLM, qui lit la question et les descriptions des outils puis choisit la prochaine action à entreprendre.
2. Les outils, des fonctions appelables chacune possédant un nom, une description ainsi que des entrées et sorties attendues, tels que get_live_price, get_fundamentals et get_rsi.
3. L’exécuteur, qui exécute réellement l’outil demandé, renvoie la sortie au modèle afin qu’il puisse décider de la suite des opérations.
4. Le carnet de travail, un enregistrement continu des étapes de réflexion, d’action et d’observation au cours d’une même requête, permettant ainsi au modèle de se souvenir de ce qu’il a déjà vérifié.

Une question comme « Devrions-nous examiner AAPL.US en ce moment ? » génère une chaîne de ce type. D’abord, le modèle souhaite obtenir le prix :

Thought: I need the current price first.
Action: get_live_price("AAPL.US")
Observation: AAPL.US: current price 227.50, change +0.8%

Puis il conclut que le prix seul ne dit pas grand-chose et passe à la dynamique du marché et à l’évaluation :

Thought: Price alone isn't enough — check momentum.
Action: get_rsi("AAPL.US")
Observation: AAPL.US — RSI(14): 58.3Thought: Not overbought. Check if valuation is reasonable.
Action: get_fundamentals("AAPL.US")
Observation: AAPL.US — PE: 31.2, Market Cap: 3.4T, Dividend Yield: 0.4%Thought: I now have enough data to answer.
Final Answer: [synthesized response]

C’est là la différence architecturale entre un agent et un chatbot doté d’un système de prompts. Le modèle choisit, en temps réel, l’ordre des appels aux outils en fonction de ce que révèlent chaque observation, sans recourir à un script fixe. C’est également pour cette raison que la qualité et la structure de la source de données sont si importantes. Si get_fundamentals renvoie des données erronées ou obsolètes, chaque réflexion basée sur celles-ci hérite de l’erreur sans aucun avertissement visible. Chaque étape de raisonnement dépend de la fiabilité de celle qui la précède, ce qui explique pourquoi les agents financiers ont besoin d’une API réelle et structurée plutôt que de données extraites ou mémorisées.

Le développement

L’agent dispose de trois outils liés à EODHD : les prix en temps réel, les données fondamentales et les indicateurs techniques. Commencez par installer les paquets nécessaires :

pip install langchain langchain-openai requests

Les outils eux-mêmes ne sont que des fonctions simples. Chacun appelle une seule interface EODHD et renvoie un résultat structuré et propre que le modèle peut lire :

import requests
from langchain.tools import tool
EODHD_API_KEY = "YOUR_API_KEY"
BASE_URL = "https://eodhd.com/api"
@tool
def get_live_price(ticker: str) -> str:
    """Returns the current price of a stock. Example ticker: AAPL.US"""
    url = f"{BASE_URL}/real-time/{ticker}"
    params = {"api_token": EODHD_API_KEY, "fmt": "json"}
    r = requests.get(url, params=params).json()
    return f"{ticker}: current price {r['close']}, change {r['change_p']}%"
@tool
def get_fundamentals(ticker: str) -> str:
    """Returns key fundamental metrics: PE ratio, market cap, dividend yield."""
    url = f"{BASE_URL}/fundamentals/{ticker}"
    params = {"api_token": EODHD_API_KEY}
    r = requests.get(url, params=params).json()
    highlights = r.get("Highlights", {})
    return (
        f"{ticker} - PE: {highlights.get('PERatio')}, "
        f"Market Cap: {highlights.get('MarketCapitalization')}, "
        f"Dividend Yield: {highlights.get('DividendYield')}"
    )
@tool
def get_rsi(ticker: str) -> str:
    """Returns the 14-day RSI to assess overbought or oversold conditions."""
    url = f"{BASE_URL}/technical/{ticker}"
    params = {"api_token": EODHD_API_KEY, "function": "rsi", "period": 14, "fmt": "json"}
    r = requests.get(url, params=params).json()
    latest = r[-1]
    return f"{ticker} - RSI(14): {latest['rsi']} as of {latest['date']}"

Ensuite, assemblez l’agent à partir d’un modèle de chat, des outils et d’une instruction ReAct :

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [get_live_price, get_fundamentals, get_rsi]

prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Ce sont donc trois outils, un LLM et une boucle qui choisit parmi eux en fonction de la question. Son appel s’effectue comme ceci :

response = executor.invoke({
    "input": "Should we be looking at AAPL.US right now?"
})
print(response["output"])

L’agent ne répond pas en se basant sur sa mémoire. Il appelle d’abord get_live_price, puis get_rsi, et get_fundamentals lorsque l’évaluation est importante, avant de fusionner les résultats des trois fonctions pour fournir une réponse fondée sur des données réelles et non sur une hallucination soigneusement formatée. Parmi les extensions possibles, on trouve un agent capable de gérer plusieurs actions en une seule requête, un système qui intègre des nouvelles via l’interface de sentiment, ainsi qu’un service d’alertes horaires qui surveille une liste de suivi.

Points clés à retenir

Un agent sans données réelles n’est qu’un générateur de texte persuasif, et non un outil d’analyse. LangChain s’occupe de l’orchestration, tandis qu’une API de données fiable traite le problème fondamental, à savoir des informations financières actuelles et fiables. Dans un agent ReAct, chaque étape hérite de la fiabilité des données de l’étape précédente ; par conséquent, la couche de données est tout aussi importante que le prompt. De plus, des outils simples ayant chacun une seule responsabilité se développent mieux que si toute la logique était regroupée dans un seul prompt volumineux.

Voici quelques questions fréquentes. Qu’est-ce qu’un agent dans un contexte de trading ? C’est un système où le LLM choisit les outils à utiliser, allant des prix aux données fondamentales en passant par les actualités, afin d’accomplir une tâche à l’aide de données réelles et non seulement de connaissances apprises. Pourquoi LangChain plutôt que d’appeler directement l’API ? Il gère le cycle de décision, c’est-à-dire quel outil utiliser, quand et comment combiner plusieurs résultats, ce que l’on devrait normalement coder manuellement pour chaque cas. Est-il nécessaire d’avoir un compte payant EODHD pour essayer cela ? Non, le plan gratuit suffit pour créer un prototype. Quel est l’équilibre principal par rapport à la création de son propre pipeline ? On renonce au contrôle total sur les sources en échange de vitesse et de fiabilité, avec une API structurée qui remplace les outils de collecte de données ou plusieurs intégrations avec des fournisseurs ; la limite à prendre en compte est alors le plafond quotidien du plan gratuit une fois que l’on cesse de travailler sur des prototypes.