Cara Membangun MCP Client untuk FXMacroData

oleh Tim FXMacroData
Dipublikasikan pada tanggal 10 Juni 2026

Tutorial ini mengikuti bentuk resmi Membuat klien MCP Pada akhirnya Anda akan memiliki klien Python yang terhubung ke output FXMacroData MCP endpoint, daftar alat dan panggilan data makro langsung dari Inflasi USD, yang Kalender rilis, dan alur kerja FX lainnya.

Persyaratan

• Python 3.11 atau lebih baru.
• UV atau pip untuk manajemen ketergantungan.
• Kunci API FXMacroData jika Anda ingin data non-USD, COT, atau komoditas.
• Pengertian dasar dari Python async.

Jika Anda hanya ingin membuktikan koneksi terlebih dahulu, Anda dapat menggunakan URL MCP publik tanpa kredensial. Itu cukup untuk kueri indikator USD terbaru, nilai tukar mata uang asing, pencarian katalog, dan status sesi. suku bunga kebijakan Perbandingan antar mata uang atau COT posisi, menambahkan kunci API Anda sebagai parameter kueri atau menggunakan OAuth.

Langkah 1. Buat proyek dan instal MCP SDK

Tutorial resmi dimulai dengan proyek klien lokal.

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

Jika kau lebih suka. pip, ini setara:

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

Perubahan utama dari demo resmi adalah transportasi. tutorial pada modelcontextprotocol.io menunjukkan klien yang meluncurkan server lokal lebih stdio. FXMacroData di-host dari jarak jauh, jadi klien Anda akan menggunakan Python SDK Streamable HTTP Transport sebagai gantinya.

Langkah 2. Simpan URL server dan kunci API opsional

Buatlah .env file di root proyek:

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

Pergilah. FXMD_API_KEY kosong jika Anda hanya ingin akses publik USD. Ketika Anda siap untuk alat yang dilindungi, atur dan klien akan terhubung dengan:

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

Ini adalah jalur tercepat untuk klien kustom. Untuk aplikasi produksi yang menghadap pengguna, OAuth biasanya lebih baik karena menghindari pengiriman kunci API bersama di dalam aplikasi Anda.

Langkah 3. Tulis minimal remote MCP client

Ciptakan client.py dan tambahkan kode berikut:

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://fxmacrodata.com/mcp")
    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())

Ini melakukan empat hal penting:

1. Memasukkan URL MCP FXMacroData dari lingkungan.
2. - Tambahkan ?api_key=... hanya jika kau benar-benar memilikinya.
3. Menggunakan streamable_http_client() bukannya lokal stdio_client() Transportasi dari tutorial dasar.
4. Mencetak baik JSON terstruktur dan output alat teks polos, yang membuat debugging jauh lebih mudah.

Langkah 4. Memverifikasi koneksi dan memeriksa alat yang tersedia

Mulailah dengan daftar alat:

uv run python client.py tools

Anda harus melihat alat seperti:

• data_catalogue
• indicator_query
• release_calendar
• forex
• market_sessions

Jika Anda mengikuti tutorial MCP resmi dengan cermat, ini adalah setara jarak jauh dari titik pemeriksaan "pastikan klien dapat menemukan alat".

Sekarang hubungi katalog untuk cakupan publik USD:

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

Lalu tarik baru-baru ini inflasi data:

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

Dan akhirnya memeriksa acara USD berikutnya di Kalender rilis:

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

Pada titik ini Anda memiliki klien MCP yang nyata, bukan hanya entri file konfigurasi di dalam editor. yang penting jika Anda ingin menyematkan alur kerja ke dalam backend Anda sendiri, asisten notebook, atau UI penelitian.

Langkah 5. Tambahkan alur kerja penelitian sederhana

Setelah alat penemuan bekerja, langkah berguna berikutnya adalah menyusun beberapa panggilan. Federal Reserve konteks terhadap EUR/USD dengan menanyakan suku bunga kebijakan dan spot secara berurutan.

Tambahkan pembantu ini di dalam. client.py Jika Anda ingin pola beton:

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

Ini juga merupakan titik di mana otentikasi penting. Server publik cukup untuk penemuan USD saja dan data publik jangka pendek. Perbandingan multi-mata uang seperti EUR versus USD biasanya membutuhkan kunci API berbayar atau token OAuth.

Langkah 6. Mengubah klien MCP yang sama ke dalam lapisan alat LLM

Panduan pembangun klien resmi biasanya berakhir dengan loop chatbot. ide yang sama bekerja di sini: terhubung ke FXMacroData pertama, kemudian menyerahkan skema alat yang ditemukan ke model Anda sehingga dapat memutuskan kapan memanggilnya.

Penyedia LLM yang tepat terserah Anda.

1. Buka sesi MCP.
2. Hubungi. list_tools()Aku tidak tahu.
3. Mengubah alat-alat ke dalam skema alat penyedia model Anda.
4. Ketika model meminta panggilan alat, mengeksekusi melalui session.call_tool()Aku tidak tahu.
5. Umpan hasil alat kembali ke model dan melanjutkan loop.

Sebuah sketsa kompak terlihat seperti ini:

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

Nama model di sini hanya contoh. takeaway yang sebenarnya adalah arsitektur: FXMacroData tetap sumber alat, sementara model yang Anda pilih menangani penalaran dan generasi bahasa.

Langkah 7. Tahu kapan REST langsung masih pilihan yang lebih baik

MCP sangat ideal ketika Anda ingin penemuan, skema alat, dan loop agen. Direct REST masih lebih baik untuk skrip deterministik, pekerjaan cron, dan pipa data.

Misalnya, jika Anda sudah tahu Anda hanya membutuhkan satu titik akhir, permintaan HTTP biasa lebih sederhana:

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

Dalam prakteknya, pembagian yang baik adalah:

• REST untuk produksi stabil dan pekerjaan terjadwal.
• MCP untuk penelitian eksploratif, antarmuka obrolan, dan alur kerja yang didorong agen.

Jika Anda membangun asisten penelitian AI, Anda akan sering menggunakan keduanya: MCP untuk lapisan alat percakapan, REST untuk laporan yang dapat direproduksi dan lapisan penyimpanan di bawahnya.

Penghapusan masalah

• Anda dapat daftar alat tapi panggilan dilindungi gagal. Koneksi server Anda berhasil; kunci API atau token OAuth Anda tidak memiliki akses ke dataset itu.
• Klien gagal sebelumnya. initialize()Aku tidak tahu. Periksa lagi apa yang kau tunjukkan. https://fxmacrodata.com/mcp dan bukan halaman website.
• Kau hanya perlu tes asap cepat. Mulailah dengan data_catalogue Untuk usd, maka cobalah market_sessionsAku tidak tahu.
• Kau ingin pengguna-per-pengguna keaslian. Ganti pintasan kunci API query-param dengan OAuth dan simpan token per sesi pengguna.

Mengakhiri

Anda sekarang memiliki bentuk inti yang sama dengan tutorial klien MCP resmi, tetapi menunjuk ke server jarak jauh hidup yang berguna untuk kerja makro dan FX. stdio Transport untuk HTTP Streamable remote, kemudian memperlakukan FXMacroData sebagai sumber alat untuk klien Anda.

Dari sini, langkah selanjutnya yang masuk akal adalah menambahkan OAuth, persisten keadaan percakapan, dan membangun satu alur kerja konkret di sekitar kasus penggunaan nilai tertinggi Anda, apakah itu briefing pra-pasar, pemantauan peristiwa makro, atau penelitian tingkat pasangan di sekitar rilis dan reaksi spot.