Technical Practice of Integrating Financial Market Data via MCP Protocol

Here's the thing. I spend quite a bit of time monitoring the markets, but as you know, staring at stock tickers is exhausting—after a while your eyes just glaze over. I started thinking, could I get AI to help with this? I'm not asking it to trade for me, just that when I ask "how's Apple doing today?" it doesn't make up some stock price to fool me, but actually looks up the real market data.

Initially, my idea was simple: write a Python script myself, call a free market data API, format the data into a prompt and feed it to GPT. I spent half a day banging away on it, got it working, but every time I switched models, I had to readapt the function calling format. Plus, this kind of "glue code" got messier the more I wrote, and eventually I didn't even want to maintain it. Later, a friend who does quantitative trading told me: "Try MCP. iTick has something ready to go—works out of the box. Don't reinvent the wheel."

I'd only heard of MCP (Model Context Protocol) before—knew it was Anthropic's protocol for letting large models call external tools—but never actually tried it. So I decided to spend a weekend seriously going through the process and documenting it as a reference for others with similar needs.

One: The Core Problem I Faced

To put it simply, what I wanted was really straightforward: let the large model "see" real market data. Not manually copy-pasting data to it, not writing a bunch of glue code, but talking to it naturally—asking "how much is Tesla now?" or "show me the Bollinger Bands for the last 20 days on the daily chart"—and having it fetch the data, calculate indicators, and tell me the results in plain language.

This breaks down into two steps: first, the model understands my intent; second, it can access the data. The first step modern large models can do. The second requires external tools. MCP solves exactly that—it abstracts "data fetching" into standardized tools that the model can call directly through the MCP channel.

What iTick does is wrap their market data and technical indicators into an MCP service that runs locally. No need to expose ports, no need to worry about data formats.

Two: Getting Started—It's Not That Mysterious

Let me describe my environment: an M1 MacBook, Node.js 18 already installed, Python 3.11. Nothing special. iTick's MCP server is an npm package—just one command to start it.

Configuration file

I created itick-mcp.json like this:

{
  "apiKey": "put-your-key-here",
  "defaultMarket": "US"
}

I just put this in my project root. Nothing fancy.

Starting the service

In the terminal:

npx @itick/mcp-server --config itick-mcp.json

After hitting enter, no UI appears—just a startup success log, then it quietly waits. To be honest, I was a bit nervous the first time I saw this, thought it might be stuck. Later I realized it uses stdio communication—it's just waiting for a client to connect.

Three: Testing With a Python Client

I didn't want to connect to Claude right away—worried I'd misconfigured something and get a bunch of red errors. So I first wrote a minimal Python script to see if I could actually get the data back.

Install the MCP Python SDK:

pip install mcp

Then write test.py:

import asyncio
from mcp import Client
from mcp.client.stdio import stdio_client

async def main():
    # Connect to the MCP service we just started
    async with stdio_client(
        "npx", ["-y", "@itick/mcp-server", "--config", "itick-mcp.json"]
    ) as (read, write):
        async with Client(read, write) as client:
            await client.initialize()

            # See what tools are available
            tools = await client.list_tools()
            print("Available tools:", [t.name for t in tools])

            # Get Apple's real-time quote
            quote = await client.call_tool("get_realtime_quote", {"symbol": "AAPL"})
            print("=== AAPL Real-time Quote ===")
            print(quote.content[0].text)

            # Get technical indicators: MA20 and Bollinger Bands
            tech = await client.call_tool("get_technical_indicator", {
                "symbol": "AAPL",
                "interval": "1d",
                "period": 20,
                "indicators": ["MA", "BOLL"]
            })
            print("=== Technical Indicators (MA20 and Bollinger Bands) ===")
            print(tech.content[0].text)

asyncio.run(main())

Running it, the output looks something like:

Available tools: ['get_realtime_quote', 'get_historical_bars', 'get_technical_indicator', 'search_instrument', 'get_financials']
=== AAPL Real-time Quote ===
{
  "symbol": "AAPL",
  "price": 198.75,
  "change": 2.34,
  "changePercent": 1.19,
  "timestamp": "2026-06-23T14:30:00Z"
}
=== Technical Indicators (MA20 and Bollinger Bands) ===
{
  "ma20": 195.40,
  "boll_upper": 200.15,
  "boll_mid": 195.40,
  "boll_lower": 190.65,
  "current_price": 198.75,
  "position": "Price is in the upper half of Bollinger Bands, close to upper band"
}

I was genuinely excited at that moment. I hadn't looked up any API docs—basically guessed the parameter names (symbol, interval, indicators—pretty standard stuff)—and it worked first try! The Bollinger Bands upper/mid/lower values came back with a position description, saved me calculating it with pandas myself.

Four: The Real Fun—Connecting to Claude Desktop

Getting it working on the command line was just the warm-up. The real place to use MCP is having the large model call these tools itself. I use Claude Desktop regularly and it natively supports MCP.

Configuration is straightforward. Find Claude Desktop's config file (on Mac: ~/Library/Application Support/Claude/claude_desktop_config.json) and add:

{
  "mcpServers": {
    "itick": {
      "command": "npx",
      "args": ["-y", "@itick/mcp-server", "--config", "/your-path/itick-mcp.json"]
    }
  }
}

Save, restart Claude Desktop, then I tried asking in the chat:

What's Tesla's stock price right now? And where are we at with the Bollinger Bands on the daily chart?

Claude went silent for a couple seconds (I'm guessing it called get_realtime_quote and get_technical_indicator), then came back with: the current price, the upper/mid/lower Bollinger Band values, and told me the price is in the upper half of the bands, close to resistance. Then I asked:

What about NVIDIA? Same indicators, let's compare.

It fetched the data separately for both and gave me a comparison table of prices and Bollinger Band positions. I never left the chat box, never copied any market numbers.

Honestly, this experience is very close to my ideal of "an AI assistant that actually gets things done." It didn't make up a stock price—it didn't have the chance to—because every data point came fresh from iTick's API in real time.

Five: A Pitfall I Hit (Fair Warning)

One evening I tried writing a multi-turn conversation test script, wanting to ask about several stocks in one conversation. The second time I called a tool, I got a "session expired" error. After debugging for ages, I realized it was my own logic problem: I'd made the async with scope too narrow, so the connection closed after the first call.

The fix was simple: put all tool calls in the same async with block to keep the connection alive. iTick's docs mention this, but I hadn't read carefully enough and wasted half an hour. If you're building a continuous interaction app, remember to manage the client lifecycle properly.

Six: Who Is This Really For?

After a week of using it, here's my take: iTick's MCP isn't selling a black box—it's offering a really clean "standard data integration module." The pros:

• Deployment cost is minimal. One command and it runs. No separate service needed.
• Returns clean structured JSON. Easy to process further or store in a database.
• Built-in technical indicators work out of the box. No need to write calculation logic yourself (especially for Bollinger Bands—I used to always mess up edge cases when calculating it manually).
• Security is handled well. API key lives in the config file, never appears in client code.

But there are limitations I should be honest about:

• If you need ultra-low latency for high-frequency trading, this won't work. It uses local stdio communication—fundamentally not designed for that.
• If you want some very obscure indicators, they might not be built in. You'd have to calculate them yourself.
• The server updates fairly frequently. I had a version bump this week, but it didn't break the old interface.

So who's it best for? Let me think:

1. Individual investors or trading enthusiasts who want to quickly check charts and do technical analysis using natural language.
2. Developers writing quantitative scripts who want to outsource the data integration work and focus on strategy logic.
3. People like me who like to "arm" their AI assistants and turn them from chat toys into actual tools.

Final Thoughts

After going through this whole setup, my biggest takeaway is: we've always complained that large models "don't understand finance," but really it's not that they're not smart—it's that they can't see real market data. MCP opens that window. And iTick happens to be the one that opened the window smoothly—I don't have to worry about how to mount the frame, just walk up and push it open.

If you've been tortured by "glue code" like me, or want your AI assistant to actually be useful, spend ten minutes trying this. That feeling of asking one question and getting a result—it's genuinely addictive.

github
docs