Notes pratiques : Créer un agent financier IA avec le serveur MCP d’EODHD

Ce guide reconstitue le parcours allant des matières premières à un système fonctionnel pour : créer un agent financier basé sur l’IA avec le serveur MCP d’EODHD. L’accent est mis sur des étapes opérationnelles, des vérifications explicites, ainsi que du code que vous pouvez intégrer directement dans un dépôt sans devoir deviner son intention. Pour une vue d’ensemble, définissez les entrées, le responsable de chaque étape et les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès, et refusez toute complétion partielle silencieuse.

L’approche traditionnelle basée sur l’API de données financières échoue rapidement

Lorsque vous travaillez sur le livre « The Traditional Financial Data API Approach Breaks Down Fast », notez d’abord les exigences du contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque l’environnement passe de la version démo à des environnements partagés. Conservez enregistré le nom de l’outil, son hash d’arguments, la latence et le résultat de chaque appel. Sans ces traces, le débogage de boucles d’agent peut prendre des heures.

Le véritable problème, c’est le contexte, pas les données

Lorsque vous travaillez sur « The Real Problem Is Context, Not Data », notez d’abord les exigences : entrées requises, signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Enregistrez le nom de l’outil, le hash des arguments, la latence et le résultat de chaque appel. Sans ces traces, le débogage des boucles d’agent prend des heures inutilement.

Ce qu’un serveur MCP apporte aux API de données financières

Lorsque vous travaillez sur le document « What an MCP Server Changes for Financial Data APIs », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications de code ultérieures. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées plus tard. Enregistrez le nom de l’outil, le hash des arguments, la latence et le résultat de chaque appel. Sans cette trace, le débogage des boucles d’agent prend des heures. Lorsque vous travaillez sur le document « What an MCP Server Changes for Financial Data APIs », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications de code ultérieures. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez les terminations partielles silencieuses.

Création de l’agent financier IA avec le serveur MCP d’EODHD

La création de l’agent financier IA à l’aide du serveur MCP d’EODHD fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés. Exposez des outils dotés de schémas restreints et de labels explicites indiquant les effets secondaires. Les hôtes doivent savoir quels appels modifient l’état avant d’approuver automatiquement.

Mise en place

La configuration fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Exposez des outils dotés de schémas restreints et de labels explicites indiquant leurs effets secondaires. Les hôtes doivent savoir quels appels modifient l’état du système avant de les valider automatiquement.

pip install anthropic

Connexion de l’agent au serveur MCP d’EODHD en Python

Le lien de l’agent au serveur MCP d’EODHD en Python fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Fixez l’interpréteur ainsi que le fichier de verrouillage des dépendances avant d’expliquer la boucle. Les différences entre l’ordinateur portable et l’environnement CI sont la cause la plus fréquente de dysfonctionnements silencieux dans les démos API. Le lien de l’agent au serveur MCP d’EODHD en Python fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des critères de succès et refusez toute complétion partielle silencieuse.

import anthropic

client = anthropic.Anthropic(api_key="YOUR_ANTHROPIC_API_KEY")EODHD_API_KEY = "YOUR_EODHD_API_TOKEN"response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1500,
    messages=[
        {
            "role": "user",
            "content": (
                "Give me a quick pre-earnings health check on AAPL: "
                "key fundamentals, the next earnings date, and how the "
                "stock has moved over the last month."
            )
        }
    ],
    mcp_servers=[
        {
            "type": "url",
            "url": f"https://mcp.eodhd.com/v1/mcp?apikey={EODHD_API_KEY}",
            "name": "eodhd-mcp"
        }
    ]
)for block in response.content:
    if block.type == "text":
        print(block.text)

Que se passe-t-il réellement ici

Pour savoir ce qui se passe réellement ici, il faut définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrer les temps d’exécution ainsi que le coût des jetons ou des requêtes à côté des résultats fonctionnels permet de détecter tôt les problèmes, évitant ainsi des factures inattendues lorsque le processus passe d’un environnement de démonstration à un environnement partagé. Authentifier au niveau du gateway et ré-autoriser au niveau du plan de données : un simple jeton porteur ne constitue pas une frontière entre les tenants.

Lire la réponse

Pour lire la réponse, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Authentifiez-vous au niveau du gateway et réautorisez-vous au niveau du plan de données. Un token porteur seul ne constitue pas une frontière entre les tenants.

tool_calls = [
    {"name": b.name, "input": b.input}
    for b in response.content
    if b.type == "mcp_tool_use"
]

for call in tool_calls:
    print(call["name"], call["input"])

Évaluer les opportunités boursières à l’aide de l’API de données financières d’EODHD

Pour évaluer les opportunités boursières à l’aide de l’API de données financières d’EODHD, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Authentifiez-vous au niveau du gateway et réautorisez-vous au niveau du plan de données. Un token porteur seul ne constitue pas une frontière entre les tenants. Pour évaluer les opportunités boursières à l’aide de l’API de données financières d’EODHD, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les résultats partiels silencieux.

Fin de la traduction.

Étape 1 : Sélectionner les candidats avec l’API Screener

Lors de l’exécution de l’Étape 1 : Sélectionner les candidats avec l’API Screener, notez d’abord le contrat : entrées requises, signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet des modifications de code plus fiables par la suite. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Enregistrez le nom outil, l’hash des arguments, la latence et le résultat de chaque appel. Sans ce suivi, le débogage des boucles d’agent prend des heures.

import requests
API_TOKEN = "YOUR_EODHD_API_TOKEN"
def get_candidates():
    url = "https://eodhd.com/api/screener"
    params = {
        "api_token": API_TOKEN,
        "sort": "market_capitalization.desc",
        "filters": '[["market_capitalization",">",1000000000],'
                   '["exchange","=","us"],'
                   '["sector","=","Technology"]]',
        "limit": 20,
        "fmt": "json",
    }
    response = requests.get(url, params=params)
    return response.json()["data"]
candidates = get_candidates()
tickers = [c["code"] for c in candidates]
print(tickers)

Étape 2 : Récupérer les informations de base pour chaque candidat

Lors de l’exécution de l’Étape 2 : Rassembler les informations de base pour chaque candidat, notez d’abord le contrat : les données requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Enregistrez le nom outil, le hash des arguments, la latence et le résultat de chaque appel. Sans cette trace, le débogage des boucles d’agent prend des heures inutilement.

def get_fundamentals(symbol):
    url = f"https://eodhd.com/api/fundamentals/{symbol}.US"
    params = {"api_token": API_TOKEN, "fmt": "json"}
    data = requests.get(url, params=params).json()
highlights = data.get("Highlights", {})
    return {
        "pe_ratio": highlights.get("PERatio"),
        "peg_ratio": highlights.get("PEGRatio"),
        "profit_margin": highlights.get("ProfitMargin"),
        "eps_growth": highlights.get("EPSEstimateNextYear"),
    }

Étape 3 : Vérifier l’évolution récente des prix

Lors de l’exécution de l’Étape 3 : Vérifier l’évolution récente des prix, notez d’abord les éléments du contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Documentez à la fois le parcours normal et celui de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Enregistrez le nom de l’outil, le hash des arguments, la latence et le résultat de chaque appel. Sans ce suivi, le débogage des boucles d’agent prend des heures. Lors de l’exécution de l’Étape 3 : Vérifier l’évolution récente des prix, notez d’abord les éléments du contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des critères de succès et refusez les terminations partielles silencieuses.

import pandas as pd
from datetime import date, timedelta
def get_price_trend(symbol):
    url = f"https://eodhd.com/api/eod/{symbol}.US"
    params = {
        "api_token": API_TOKEN,
        "period": "d",
        "order": "d",
        "from": (date.today() - timedelta(days=90)).isoformat(),
        "fmt": "json",
    }
    prices = requests.get(url, params=params).json()
    df = pd.DataFrame(prices)
    last_close = df.iloc[0]["close"]
    month_ago_close = df.iloc[21]["close"] if len(df) > 21 else df.iloc[-1]["close"]
    change_pct = ((last_close - month_ago_close) / month_ago_close) * 100
    return {"last_close": last_close, "change_30d_pct": round(change_pct, 2)}

Étape 4 : Lire l’opinion des médias

Étape 4 : L’analyse de l’opinion dans les nouvelles fonctionne le mieux lorsqu’elle est traitée comme une donnée mesurable. Recueillez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le champ d’application. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts permet d’éviter des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Mettez à disposition des outils dotés de schémas restreints et de labels explicites indiquant les effets secondaires. Les administrateurs doivent savoir quels appels modifient l’état du système avant d’approuver automatiquement ces opérations.

def get_sentiment(symbol):
    url = "https://eodhd.com/api/sentiments"
    params = {
        "s": f"{symbol}.US",
        "api_token": API_TOKEN,
        "from": (date.today() - timedelta(days=14)).isoformat(),
        "fmt": "json",
    }
    data = requests.get(url, params=params).json()
    entries = data.get(f"{symbol}.US", [])
    if not entries:
        return {"avg_sentiment": None}
avg = sum(e["normalized"] for e in entries) / len(entries)
    return {"avg_sentiment": round(avg, 3)}

Étape 5 : Combiner tout cela en un seul score

Étape 5 : Combiner tout cela en un seul score fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Exposez des outils dotés de schémas restreints et de labels explicites indiquant les effets secondaires. Les hôtes doivent savoir quels appels modifient l’état avant de valider automatiquement.

def score_opportunity(symbol):
    fundamentals = get_fundamentals(symbol)
    price = get_price_trend(symbol)
    sentiment = get_sentiment(symbol)
score = 0
    if fundamentals["pe_ratio"] and fundamentals["pe_ratio"] < 25:
        score += 1
    if fundamentals["profit_margin"] and fundamentals["profit_margin"] > 0.10:
        score += 1
    if price["change_30d_pct"] < -5:
        score += 1
    if sentiment["avg_sentiment"] and sentiment["avg_sentiment"] > 0.15:
        score += 1
    return {
        "symbol": symbol,
        "score": score,
        **fundamentals,
        **price,
        **sentiment,
    }
results = [score_opportunity(t) for t in tickers]
ranked = sorted(results, key=lambda r: r["score"], reverse=True)
for r in ranked[:5]:
    print(r["symbol"], "score:", r["score"], "| P/E:", r["pe_ratio"],
          "| 30d change:", r["change_30d_pct"], "%",
          "| sentiment:", r["avg_sentiment"])

Réintégration dans l’agent

Intégrer cela au agent fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et celui de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Exposez des outils dotés de schémas restreints et de labels explicites indiquant les effets secondaires. Les hôtes doivent savoir quels appels modifient l’état avant d’approuver automatiquement. Intégrer cela au agent fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les terminations partielles silencieuses.

À partir d’ici, vous pouvez construire

Dans « From Here You Can Build », il convient de définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des jetons ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts permet d’éviter des factures inattendues lorsque le parcours passe de l’environnement de démonstration à des environnements partagés. Authentifiez-vous au niveau du gateway et réautorisez-vous au niveau du plan de données. Un simple jeton porteur ne constitue pas une frontière entre les tenants.

Points clés

Pour les points clés, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Authentifiez-vous au niveau du gateway et réautorisez-vous au niveau du plan de données. Un token porteur seul ne constitue pas une frontière entre les tenants.

FAQ

Pour les FAQ, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure. Authentifiez au niveau du gateway et réautorisez au niveau du plan de données. Un token porteur seul ne constitue pas une frontière entre les tenants. Pour les FAQ, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définissez des vérifications de succès et refusez les terminations partielles silencieuses.

Liste de contrôle opérationnelle

La liste de contrôle opérationnelle est la plus efficace lorsqu’elle est considérée comme un cadre mesurable. Recueillez une transcription exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre.

Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’erreur doit pointer vers une seule responsabilité et non vers un processus embrouillé.

Faites en sorte que les outils disposent de schémas restreints et d’étiquettes explicites indiquant les effets secondaires. Les administrateurs doivent savoir quels appels modifient l’état avant d’approuver automatiquement.

Mettez en place une approbation humaine pour les opérations qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas une couverture complète des besoins métier.

Rédigez un guide de fonctionnement succinct : comment rotationner les clés, comment vider la file d’attente, comment réversionner la dernière ingestion.

Gardez les configurations en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système.

Au préalable de promouvoir le stack, figez les versions, conservez une transcription d’ référence pour le chemin critique, et confirmez les étapes de rollback. Les environnements partagés nécessitent des limites de débit, des vérifications de location, ainsi qu’un responsable clair pour la rotation des secrets. Préférez une fiabilité solide à des démonstrations brillantes mais ponctuelles.

Note de batch pour 5a103d42eb4a : gardez les clés du fournisseur hors du repo, fixez un plafond pour les tokens par session, et stockez les transcriptions à côté des fichiers de configuration d’évaluation afin que les remplacements ultérieurs de modèles restent comparables.