Cómo crear un cliente MCP para FXMacroData

Por el equipo de FXMacroData
Publicado el 10 de junio de 2026

Este tutorial sigue la forma del oficial Construir un cliente MCP El programa de programación de Python es un programa de software que se utiliza para la creación de un programa, pero lo adapta para un servidor remoto real en lugar de un proceso de demostración local. Inflación en dólares, el calendario de liberación, y otros flujos de trabajo de FX.

Los requisitos previos

• Python 3.11 o más nuevo.
• el ¿ Qué ? pip para la gestión de la dependencia.
• Una clave de la API de FXMacroData si desea datos no en USD, COT o materias primas.
• Una comprensión básica de Python asíncrono.

Si sólo desea probar la conexión primero, puede utilizar la URL pública de MCP sin credenciales. Eso es suficiente para consultas recientes de indicadores de USD, tasas de cambio, búsquedas de catálogo y estado de sesión. Cuando desea datos más amplios como tipo de interés las comparaciones entre monedas o El COT posicionamiento, añadir su clave API como un parámetro de consulta o utilizar OAuth.

Paso 1. Crear el proyecto e instalar el MCP SDK

El tutorial oficial comienza con un proyecto de cliente local.

mkdir fxmd-mcp-client
cd fxmd-mcp-client
uv init
uv add mcp python-dotenv

Si lo prefiere . pip, esto es equivalente:

python -m venv .venv
source .venv/bin/activate
pip install mcp python-dotenv

El cambio clave desde la demostración oficial es el transporte. El tutorial en modelcontextprotocol.io muestra un cliente que inicia un servidor local sobre stdio. FXMacroData se aloja de forma remota, por lo que su cliente utilizará el transporte HTTP Streamable del SDK de Python en su lugar.

Paso 2. Almacenar la URL del servidor y la clave de API opcional

Crear un .env archivo en la raíz del proyecto:

FXMD_MCP_URL=https://mcp.fxmacrodata.com
FXMD_API_KEY=

- ¿ Qué pasa ? FXMD_API_KEY Cuando esté listo para herramientas protegidas, configúrelo y el cliente se conectará con:

https://mcp.fxmacrodata.com?api_key=YOUR_API_KEY

Este es el camino más rápido para un cliente personalizado. Para aplicaciones de producción orientadas al usuario, OAuth suele ser mejor porque evita enviar una clave de API compartida dentro de su aplicación.

Paso 3. Escribir un cliente MCP remoto mínimo

Crear . client.py y añadir el siguiente código:

import argparse
import asyncio
import json
import os
from urllib.parse import urlencode

from dotenv import load_dotenv
from mcp import ClientSession, types
from mcp.client.streamable_http import streamable_http_client


load_dotenv()


def build_server_url() -> str:
    base_url = os.getenv("FXMD_MCP_URL", "https://mcp.fxmacrodata.com")
    api_key = os.getenv("FXMD_API_KEY", "").strip()

    if not api_key or "api_key=" in base_url:
        return base_url

    separator = "&" if "?" in base_url else "?"
    return f"{base_url}{separator}{urlencode({'api_key': api_key})}"


def extract_content(result: types.CallToolResult) -> str:
    parts = []

    if result.structuredContent:
        parts.append(json.dumps(result.structuredContent, indent=2))

    for item in result.content:
        if isinstance(item, types.TextContent):
            parts.append(item.text)

    return "\n".join(parts).strip()


async def run() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("command", choices=["tools", "call"])
    parser.add_argument("--tool", help="Tool name to call")
    parser.add_argument(
        "--args",
        default="{}",
        help='JSON object of tool arguments, for example: {"currency":"usd"}',
    )
    cli_args = parser.parse_args()

    server_url = build_server_url()

    async with streamable_http_client(server_url) as (
        read_stream,
        write_stream,
        _,
    ):
        async with ClientSession(read_stream, write_stream) as session:
            await session.initialize()

            if cli_args.command == "tools":
                tools = await session.list_tools()
                print(json.dumps([tool.model_dump() for tool in tools.tools], indent=2))
                return

            if not cli_args.tool:
                raise SystemExit("--tool is required when command=call")

            arguments = json.loads(cli_args.args)
            result = await session.call_tool(cli_args.tool, arguments)
            print(extract_content(result))


if __name__ == "__main__":
    asyncio.run(run())

Esto hace cuatro cosas importantes:

1. Carga la dirección de la producción FXMacroData MCP desde el entorno.
2. - ¿ Qué ? ?api_key=... sólo cuando realmente tienes uno.
3. ¿ Cómo se usa ? streamable_http_client() En vez de la local. stdio_client() transporte desde el tutorial básico.
4. Imprime tanto la salida de JSON estructurada como la de la herramienta de texto plano, lo que facilita mucho la depuración.

Paso 4. Verifique la conexión e inspeccione las herramientas disponibles

Comience por hacer una lista de herramientas:

uv run python client.py tools

Deberías ver herramientas como:

• data_catalogue
• indicator_query
• release_calendar
• forex
• market_sessions

Si usted está siguiendo el tutorial oficial de MCP de cerca, este es el equivalente remoto del "asegúrese de que el cliente puede descubrir herramientas" punto de control.

Ahora llama al catálogo para la cobertura pública de USD:

uv run python client.py call --tool data_catalogue --args "{\"currency\":\"usd\"}"

Entonces saca reciente . la inflación datos:

uv run python client.py call --tool indicator_query --args "{\"currency\":\"usd\",\"indicator\":\"inflation\",\"start_date\":\"2025-01-01\",\"end_date\":\"2026-01-01\"}"

Y finalmente inspeccionar los próximos eventos de USD en el calendario de liberaciónSe trata de:

uv run python client.py call --tool release_calendar --args "{\"currency\":\"usd\"}"

En este punto tienes un cliente MCP real, no sólo una entrada de archivo de configuración dentro de un editor.

Paso 5. Añadir un flujo de trabajo de investigación simple

Una vez que la herramienta de descubrimiento funciona, el siguiente paso útil es componer algunas llamadas. Reserva Federal contexto contra El valor de la moneda de referencia En el caso de las empresas de seguros, el tipo de interés de las políticas de seguros es el tipo del interés de los seguros de seguros.

Añade este ayudante dentro . client.py Si quieres un patrón concreto:

async def quick_macro_snapshot(session: ClientSession) -> None:
    usd_rates = await session.call_tool(
        "indicator_query",
        {
            "currency": "usd",
            "indicator": "policy_rate",
            "start_date": "2024-01-01",
            "end_date": "2026-12-31",
        },
    )
    eur_rates = await session.call_tool(
        "indicator_query",
        {
            "currency": "eur",
            "indicator": "policy_rate",
            "start_date": "2024-01-01",
            "end_date": "2026-12-31",
        },
    )
    spot = await session.call_tool(
        "forex",
        {"base": "eur", "quote": "usd"},
    )

    print("USD policy rate:")
    print(extract_content(usd_rates))
    print("\nEUR policy rate:")
    print(extract_content(eur_rates))
    print("\nEUR/USD spot:")
    print(extract_content(spot))

Este es también el punto en el que la autenticación es importante. El servidor público es suficiente para el descubrimiento de solo USD y datos públicos de corto alcance. Las comparaciones de monedas múltiples como EUR versus USD generalmente requieren una clave API pagada o un token OAuth.

Paso 6. Convierta el mismo cliente MCP en una capa de herramientas LLM

La guía oficial de compilación del cliente generalmente termina con un bucle de chatbot. La misma idea funciona aquí: conecta con FXMacroData primero, luego entrega los esquemas de herramientas descubiertos a tu modelo para que pueda decidir cuándo llamarlos.

El proveedor exacto de LLM depende de usted.

1. Abre la sesión del MCP.
2. Llama . list_tools()- ¿ Qué ?
3. Convierta esas herramientas en el esquema de herramienta de su proveedor de modelos.
4. Cuando el modelo solicita una llamada de herramienta, ejecutarlo a través de session.call_tool()- ¿ Qué ?
5. Alimentación del resultado de la herramienta de nuevo al modelo y continuar el bucle.

Un boceto compacto se ve así:

async def chat_loop(session: ClientSession, llm_client, user_prompt: str) -> str:
    tools = await session.list_tools()

    tool_specs = [
        {
            "type": "function",
            "name": tool.name,
            "description": tool.description or "",
            "parameters": tool.inputSchema,
        }
        for tool in tools.tools
    ]

    messages = [{"role": "user", "content": user_prompt}]

    while True:
        response = llm_client.responses.create(
            model="gpt-4.1",
            input=messages,
            tools=tool_specs,
        )

        output = response.output[0]
        if output.type == "message":
            return output.content[0].text

        if output.type == "function_call":
            result = await session.call_tool(
                output.name,
                json.loads(output.arguments),
            )
            messages.append(output.model_dump())
            messages.append(
                {
                    "type": "function_call_output",
                    "call_id": output.call_id,
                    "output": extract_content(result),
                }
            )

El nombre del modelo aquí es sólo un ejemplo. La verdadera lección es arquitectónica: FXMacroData sigue siendo la fuente de herramientas, mientras que el modelo elegido maneja el razonamiento y la generación de lenguaje.

Paso 7. Conocer cuándo el REST directo sigue siendo la mejor opción

MCP es ideal cuando se desea el descubrimiento, esquemas de herramientas y un bucle de agente.

Por ejemplo, si ya sabe que sólo necesita un punto final, una simple solicitud HTTP es más simple:

curl "https://api.fxmacrodata.com/v1/announcements/usd/inflation?api_key=YOUR_API_KEY"

En la práctica, una buena división es:

• El resto para la producción estable y los puestos de trabajo programados.
• El MCP para investigación exploratoria, interfaces de chat y flujos de trabajo impulsados por agentes.

Si está construyendo un asistente de investigación de IA, a menudo usará ambos: MCP para la capa de herramientas de conversación, REST para la reportaje reproducible y la capa del almacenamiento debajo.

Solución de problemas

• Puedes enumerar herramientas pero las llamadas protegidas fallan. Su conexión al servidor funciona; su clave API o token OAuth no tiene acceso a ese conjunto de datos.
• El cliente falla antes . initialize()- ¿ Qué ? Revisa lo que estás apuntando . https://mcp.fxmacrodata.com y no una página web.
• Sólo necesitas una prueba rápida de humo. Empieza con data_catalogue ¿ Por qué ? usdEntonces , prueba . market_sessions- ¿ Qué ?
• Quieres autenticación de usuario por usuario. Reemplazar el acceso directo de la clave de API de parámetro de consulta con OAuth y almacenar tokens por sesión de usuario.

En el final

Ahora tiene la misma forma del núcleo que el tutorial oficial del cliente MCP, pero apuntado a un servidor remoto en vivo que es útil para el trabajo macro y FX. stdio transporte para HTTP Streamable remoto, luego tratar FXMacroData como el origen de la herramienta para su cliente.

A partir de aquí, los siguientes pasos sensatos son agregar OAuth, persistir en el estado de la conversación y construir un flujo de trabajo concreto en torno a su caso de uso de mayor valor, ya sea información previa al mercado, monitoreo de eventos macro o investigación a nivel de par alrededor de versiones y reacciones puntuales.