Un agente financiero con IA usando el MCP de EODHD

Construye un agente financiero con IA que combina fundamentales, precios, y sentimiento de noticias de EODHD para puntuar oportunidades reales de inversión, con código Python incluido.

La mayoría de la gente que construye agentes financieros con IA conecta cuatro o cinco APIs a mano.

Una para precios. Una para fundamentales. Una para noticias. Una para fechas de resultados.

El problema no es la falta de datos. Es la fragmentación.

Si estás:

construyendo un copiloto de investigación para acciones,
automatizando el cribado pre-resultados,
o diseñando un agente que razona sobre precio, fundamentales, y sentimiento,

esto te importa.

Así se construye un agente financiero con IA que junta las cuatro cosas, usando la API de datos financieros de EODHD como columna vertebral.

El enfoque tradicional de API de datos financieros se rompe rápido

Así es como suele verse construir un agente financiero con una REST API normal.

Escribes una función para traer precios. Otra para fundamentales. Otra para noticias. Luego escribes lógica de orquestación para que tu agente sepa qué endpoint llamar, en qué orden, y cómo fusionar las respuestas en algo sobre lo que el modelo pueda razonar.

Cada tipo de dato nuevo significa una función wrapper nueva.

Cada función wrapper es un nuevo punto de fallo.

Y cada vez que el agente necesita responder una pregunta que cruza dos tipos de datos, como "¿son los fundamentales de esta empresa lo bastante sólidos como para justificar mantenerla durante los resultados?", eres tú quien cose el contexto, no el modelo.

Los desarrolladores suelen descubrir esto por las malas. El agente funciona bien en una demo con una sola fuente de datos. Luego llega una pregunta real que necesita precios, fundamentales, y noticias a la vez, y toda la capa de orquestación hay que reconstruirla.

El problema real es el contexto, no los datos

Los agentes financieros no necesitan más APIs.

Necesitan una forma de llegar a cada tipo de dato a través de una interfaz consistente, para que el modelo pueda decidir qué llamar y combinarlo, en lugar de que tú codifiques esa lógica de antemano.

Para eso está construido MCP (Model Context Protocol).

Qué cambia un servidor MCP para las APIs de datos financieros

MCP (Model Context Protocol) estandariza cómo un modelo de IA descubre y llama a herramientas externas. En lugar de que tú escribas un wrapper personalizado para cada endpoint, el modelo ve una lista de herramientas disponibles con sus esquemas, y decide cuáles llamar según la pregunta que está respondiendo. Es la misma idea subyacente que el function calling de Claude, solo que extendida a todo un catálogo de herramientas en lugar de una función a la vez.

Para datos financieros, esto importa porque una sola pregunta rara vez mapea a un solo endpoint.

EODHD ofrece un servidor MCP oficial con más de 70 herramientas que cubren fundamentales, precios históricos y en tiempo real, calendarios de resultados, noticias, y sentimiento. Apuntas tu agente al servidor, y consigue acceso a todo eso sin que escribas un solo wrapper de API.

Sáltate las funciones wrapper
El servidor MCP de EODHD expone más de 70 herramientas de datos financieros de fábrica, listas para Claude y otros agentes de IA.
→ Consigue tu API key de EODHD

Construyendo el agente financiero con IA usando el servidor MCP de EODHD

Vamos a construir un agente que pueda responder a una pregunta que cruza varios tipos de datos en una sola llamada: fundamentales, próximos resultados, y el movimiento de precio reciente de un ticker dado.

Configuración

pip install anthropic

Necesitarás un token de API de EODHD y una API key de Anthropic. El servidor MCP de EODHD está disponible como endpoint alojado, así que no hay ningún servidor que tengas que correr tú mismo.

Conectando el agente al servidor MCP de EODHD en Python

El servidor MCP de EODHD tiene dos versiones: v1 recibe tu API key directamente en la URL, v2 usa OAuth 2.1 para clientes que lo soportan (como Claude Desktop). Para un script de servidor como este, v1 es más simple.

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)

Qué está pasando realmente aquí

El parámetro mcp_servers es todo el truco. No estás llamando a tres endpoints y fusionando los resultados tú mismo. Le estás dando al modelo una conexión al catálogo de herramientas de EODHD y dejando que decida qué necesita.

Para este único prompt, el modelo típicamente:

Llama a una herramienta de fundamentales para traer márgenes, crecimiento de ingresos, y ratios de valoración
Llama a una herramienta de calendario de resultados para encontrar la próxima fecha de publicación
Llama a una herramienta de precios históricos para calcular el movimiento reciente del precio

Tres llamadas a herramientas, una conversación, cero código de orquestación escrito por ti.

Leyendo la respuesta

La API devuelve una mezcla de bloques de contenido: text para la respuesta del modelo, mcp_tool_use para cada herramienta que llamó, y mcp_tool_result para los datos en crudo. Si quieres inspeccionar qué trajo realmente el agente (útil para depurar o registrar), filtra por tipo de bloque en lugar de asumir un orden fijo:

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"])

Vale la pena hacer esto pronto. Te muestra exactamente a qué herramientas recurrió el modelo, lo que te ayuda a detectar cuándo está llamando a algo innecesario o le falta un tipo de dato que tu prompt implicaba.

Puntuando oportunidades de acciones con la API de datos financieros de EODHD

El agente MCP de arriba decide por su cuenta qué herramientas de EODHD llamar. Eso es cómodo, pero también esconde lo que está pasando. Si quieres entender de verdad (y personalizar) la lógica detrás de "qué acciones parecen buenas oportunidades", ayuda llamar directamente a los mismos endpoints de EODHD y construir tú mismo la puntuación.

Esto también es útil si quieres un script programado que escanee el mercado cada mañana en lugar de esperar a que le preguntes a un agente de chat.

Vamos a construirlo: un pipeline corto que trae candidatos de la Screener API, trae fundamentales y movimiento de precio reciente para cada uno, comprueba el sentimiento de noticias, y combina todo en una sola puntuación de oportunidad.

Paso 1: preseleccionar candidatos con la Screener API

En lugar de traer fundamentales para miles de tickers, empieza estrecho. La Screener API filtra todo el mercado a una shortlist en una sola petición.

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)

Esto trae acciones tecnológicas de EE. UU. por encima de 1.000 M$ de capitalización, ordenadas por tamaño. Cambia los filtros por el criterio que para ti defina un "buen precio": PER bajo, alta rentabilidad por dividendo, crecimiento positivo del BPA, o una señal de mínimo de 52 semanas.

Paso 2: traer fundamentales de cada candidato

Una vez tienes una shortlist, trae los fundamentales de cada ticker. Aquí es donde compruebas si el precio está realmente respaldado por finanzas sólidas, y no solo es barato por alguna razón.

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"),
    }

Paso 3: comprobar el movimiento de precio reciente

Los fundamentales te dicen si una empresa está sana. El histórico de precio te dice si el mercado ya lo ha puesto en precio, o si hay un hueco al que merece la pena prestar atención.

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

Una acción con fundamentales sólidos que acaba de caer un 15% en un mes es una oportunidad muy distinta a una que ya subió un 40%.

Paso 4: leer el sentimiento de las noticias

El precio y los fundamentales no te dicen por qué se movió una acción. El sentimiento llena ese hueco, y a menudo es lo que separa una oportunidad real de una trampa de valor.

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

Paso 5: combinar todo en una sola puntuación

Esta es la parte que una API en crudo no puede hacer por ti. Cada endpoint te da una dimensión. Decidir qué significa una "buena oportunidad" es un juicio, y pertenece a tu código, no enterrado en la puntuación de caja negra de otra persona.

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"])

Cuatro puntos de datos, un bucle, una lista puntuada. Una valoración razonable, márgenes sanos, una caída reciente, y un sentimiento que mejora, juntos, son una señal mucho más fuerte que cualquiera de ellos por separado.

Esta lógica de puntuación es deliberadamente simple. Vas a querer ponderarla de forma distinta según tu estrategia: a un inversor de valor le importan más el PER y los márgenes, a un swing trader le importan más la caída de precio y el cambio de sentimiento. La idea es que los cuatro endpoints de EODHD te dan la materia prima, y la lógica de decisión es tuya para ajustar.

Nada de esto es asesoramiento financiero. Es un marco para convertir datos dispersos en una shortlist que merece más investigación, no una señal para comprar.

Conectando esto de vuelta al agente

Una vez este pipeline de puntuación funciona como script independiente, puedes exponerlo a tu agente MCP como una herramienta personalizada junto a las que ya trae EODHD. Entonces un prompt como "encuéntrame acciones tecnológicas que hayan caído recientemente pero sigan pareciendo sólidas en fundamentales" ejecuta tu lógica de puntuación exacta en lugar de que el modelo adivine los criterios por su cuenta.

Esa es la verdadera ventaja de combinar llamadas directas a la API con MCP: obtienes control total sobre la lógica de decisión, y el modelo sigue gestionando la capa de lenguaje natural encima.

Esto es, en la práctica, lo que significa construir un agente financiero con IA: no un solo prompt ingenioso, sino una capa de datos en la que confías más un modelo que sabe cuándo recurrir a ella.

A partir de aquí puedes construir

Una vez el agente puede combinar fundamentales, precios, resultados, y noticias por su cuenta, los casos de uso dejan de ser demos de una sola pregunta.

screeners pre-resultados que señalan fundamentales débiles antes de una fecha de publicación
alertas sensibles al sentimiento que combinan el tono de las noticias con movimientos de precio
copilotos de investigación que responden preguntas de varias partes sin un guion rígido

Nada de esto requiere código wrapper nuevo. Requiere mejores prompts y, de vez en cuando, un system prompt más estrecho que le diga al agente qué herramientas priorizar.

Ideas clave

Las integraciones REST tradicionales te obligan a escribir y mantener lógica de orquestación para cada combinación de tipos de datos
MCP traslada esa orquestación al propio modelo, así que una sola conversación puede abarcar fundamentales, precios, resultados, y noticias
Combinar directamente los endpoints de Screener, fundamentales, precio, y sentimiento te da control total sobre qué cuenta como "buena oportunidad", en lugar de depender de una sola métrica
El servidor MCP de EODHD te da más de 70 herramientas financieras sin escribir un solo wrapper, y puedes añadir tu propia lógica de puntuación como una herramienta personalizada encima

Preguntas frecuentes

❓ ¿Necesito correr mi propio servidor MCP para usar las herramientas de EODHD?
✅ No. EODHD aloja el servidor MCP, así que te conectas con una URL y tu token de API, de la misma forma que llamarías a un endpoint REST.

❓ ¿MCP sustituye a la REST API de EODHD?
✅ No, se apoya encima de ella. La REST API sigue impulsando cada llamada a herramienta, MCP simplemente le da al modelo de IA una forma estructurada de descubrir y usar esos endpoints sin código wrapper personalizado.

❓ ¿Puedo limitar a qué herramientas tiene acceso el agente?
✅ Sí. Puedes acotar el system prompt o restringir la conversación a categorías de herramientas específicas si no quieres que el agente recurra a endpoints fuera de un caso de uso dado, como limitarlo solo a fundamentales y resultados.

❓ ¿Este enfoque solo es útil con Claude?
✅ No. MCP es un protocolo abierto, así que el servidor de EODHD funciona con cualquier cliente compatible con MCP, incluyendo ChatGPT, Cursor, y Windsurf, no solo Claude.

❓ ¿Cuántas llamadas a la API usa un escaneo como este?
✅ Depende del tamaño de tu shortlist. Cada petición al screener cuenta como 5 llamadas, y cada llamada de fundamentales, precio, o sentimiento para un ticker cuenta como 1. Escanear 20 candidatos sale a aproximadamente 65 llamadas, bien dentro del plan gratuito de EODHD para ejecuciones ocasionales.

❓ ¿Puedo usar este script de puntuación para automatizar operaciones reales?
✅ El script solo ordena e imprime candidatos. Conectarlo a la API de ejecución de un bróker es un paso aparte, y vale la pena añadir revisión manual antes de cualquier decisión con dinero real, sin importar cómo se generó la shortlist.

Si eres una empresa de software o de APIs y buscas explicar tu producto con contenido educativo de calidad (no marketing genérico), no dudes en escribirme por LinkedIn.

¿Quieres más contenido como este?
Tutoriales de Python, APIs, fintech, y agentes de IA para desarrolladores.
→ Visita kevinmeneses.com

¿Buscas contenido técnico para tu empresa? Puedo ayudarte — LinkedIn · kevinmenesesgonzalez@gmail.com