DEV Community: laguia

I Built 2 Production MCP Servers — Here's What I Learned

laguia — Mon, 09 Mar 2026 05:22:52 +0000

I Built 2 Production MCP Servers — Here's What I Learned

Most MCP tutorials stop at "hello world." Here's what happens when you build the real thing.

I've built two production MCP (Model Context Protocol) servers over the past few months:

OathScore — 8 tools for AI trading agents. Real-time exchange status, volatility data, economic events, API quality ratings. Live at api.oathscore.dev.
Curistat — 10 tools for volatility forecasting. Regime detection, directional signals, session planning. Launching March 2026.

Both are built with Python, FastMCP, and FastAPI. Both are deployed on Railway. Both are listed in MCP directories. Here's everything I learned that the tutorials don't tell you.

1. Tool Design Matters More Than Code

The hardest part of building an MCP server isn't the code — it's deciding what the tools should be.

AI agents read your tool descriptions to decide when to call them. If the description is vague, the agent won't use it. If you make too many tools, the agent gets confused. Too few, and it can't do anything useful.

What worked: One "dashboard" tool that returns everything in a single call. OathScore's get_now combines exchange status, volatility, events, and data health into one response. An agent asks "what's happening in markets?" and gets a complete answer without chaining 4 separate calls.

@mcp.tool()
def get_now() -> str:
    """Get current world state: exchange status, volatility
    (VIX/VVIX/SKEW/term structure), economic event countdowns,
    and data health. One call replaces 4-6 separate API calls."""
    data = _get("/now")
    return json.dumps(data, indent=2)

The rule: If an agent would always call tools A, B, and C together, combine them into one tool. Agents are better at using fewer, richer tools than many granular ones.

2. Docstrings Are Your API Contract

The tool's docstring is the only thing an AI agent sees before deciding to call it. This is your API documentation, marketing copy, and user manual in one string.

Bad:

def get_data() -> str:
    """Get data."""

Good:

def get_score(api_name: str) -> str:
    """Get OathScore quality rating for a specific API.
    Available APIs: curistat, alphavantage, polygon, finnhub,
    twelvedata, eodhd, fmp. Returns composite score (0-100),
    letter grade, and component breakdown."""

The good version tells the agent:

What APIs are valid inputs
What the response looks like
What the score means

I rewrote every docstring 3-4 times before agents used them reliably.

3. Return JSON Strings, Not Objects

MCP tools return strings. Always return json.dumps(data, indent=2) — not raw dicts, not plain text, not markdown.

Why: Agents can parse JSON reliably. They struggle with unstructured text. And indent=2 makes it readable when the agent shows it to the user.

# Do this
return json.dumps({"score": 85, "grade": "B+"}, indent=2)

# Not this
return "The score is 85 (B+)"

4. HTTP Clients Need Timeouts

This sounds obvious but I shipped without it once. An upstream API hung for 30 seconds, which froze the MCP tool, which froze the agent, which froze the user's Claude Desktop.

_client = httpx.Client(timeout=15)

15 seconds is generous. Most API calls finish in 1-2 seconds. If it takes longer than 15, something is wrong and the agent should get an error, not hang.

5. Deployment: Docker + Railway Is the Fastest Path

My stack for both servers:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD uvicorn src.main:app --host 0.0.0.0 --port ${PORT:-8000}

Railway auto-deploys on git push. $5/month for a hobby project. Custom domain with Cloudflare DNS. The whole deploy pipeline took an afternoon to set up.

For MCP specifically, the server needs to support both:

stdio transport — for Claude Desktop (local)
HTTP transport — for remote agents

FastMCP handles both out of the box.

6. Get Listed in Directories Early

MCP directories are how agents discover your server. I submitted to:

Glama (glama.ai/mcp/servers) — approved, biggest directory
awesome-mcp-servers (GitHub) — PR submitted
mcp.so — submitted
mcpservers.org — submitted

Glama was the most impactful. They verify your server actually works (Docker build, tool inspection) which gives you credibility.

Submit early, even before your server is "done." The review process takes days, and you want to be listed when buyers are searching.

7. Billing Is a Separate Problem (and Worth Solving)

OathScore has three monetization layers:

Free tier — rate-limited (10 calls/day for /now, 5/day for /score)
Stripe API keys — $9/month founding member pricing
x402 micropayments — pay-per-request with USDC (for agents with wallets)

The x402 layer is the interesting one. As AI agents get their own wallets, they'll pay for data directly without human intervention. OathScore is ready for that future.

If you're building an MCP server for a client, billing is where the real engineering challenge is — not the MCP tools themselves.

8. What I'd Do Differently

Start with 3 tools, not 8. I over-built OathScore's first version. Half the tools were decomposed views of the same data (get_exchanges, get_volatility, get_events are all subsets of get_now). Start small, add tools when agents actually need them.

Write the docstrings first. Before any code, write the tool names and descriptions. Share them with someone (or an AI) and ask "would you know when to use each of these?" If not, redesign.

Test with Claude Desktop from day one. Don't wait until the server is "ready." Deploy a single working tool and test the full loop: Claude Desktop config → tool discovery → tool call → response. Finding integration bugs early saves days.

The Template

I extracted a starter template from OathScore: mcp-server-template. It has:

5 example tools showing common patterns
2 standalone examples (weather API, SQLite database)
Dockerfile for production deployment
Claude Desktop integration config
pyproject.toml for pip installation

If you're building your first MCP server, start there instead of from scratch.

The Source

OathScore is open source: github.com/moxiespirit/oathscore

Hit the live API right now: api.oathscore.dev/now

I build production MCP servers for companies and developers who need AI agents to access their APIs and data. If you need one built, find me on Fiverr or GitHub.

State of Financial Data APIs -- March 2026: How Agent-Ready Is Your Data Provider?

laguia — Thu, 05 Mar 2026 05:08:24 +0000

AI agents are the fastest-growing consumers of financial data APIs. They need machine-readable docs, predictable auth, stable schemas, and honest rate limits. We audited 10 of the most popular financial data APIs to find out which ones are ready for the agent era -- and which ones are still stuck in 2022.

This is Report #1 in a monthly series from OathScore. Starting in April, we'll publish full composite quality scores (0-100) based on 30 days of continuous monitoring. This report covers what we found while building the monitoring system.

The 10 APIs We Audited

Alpha Vantage -- Equities, macro, forex (25 req/day free, from $49.99/mo)
Polygon.io / Massive -- Market data (5 req/min free, from $29/mo)
Finnhub -- Multi-asset, calendar, alt data (60 req/min free, from ~$50/mo)
Twelve Data -- Market data, forex, crypto (8 req/min free, from $29/mo)
EODHD -- Historical data (20 req/day free, from EUR 19.99/mo)
Financial Modeling Prep -- Fundamentals (250 req/day free, from $19/mo)
FRED -- Federal Reserve economic data (120 req/min free, 800K+ series)
CoinGecko -- Crypto market data (30 req/min free Demo, from $129/mo Pro)
Alpaca Markets -- Stocks, options, crypto trading + data (200 req/min free)
Yahoo Finance (yfinance) -- Equities, options, fundamentals (unofficial, no API key)

Finding #1: Only 2 Out of 10 Have llms.txt

The llms.txt standard lets AI agents understand what an API does without reading HTML documentation. It's the equivalent of a README for machines.

CoinGecko has it. Full llms.txt and llms-full.txt at docs.coingecko.com. This is the gold standard -- structured context designed for LLM consumption.

Alpaca has it -- though theirs is more of a sitemap pointing to product pages and community forums than a machine-readable API spec.

The other 8 return 404. Financial data providers are still largely invisible to AI agents unless hard-coded.

Finding #2: MCP Servers Are the New Competitive Moat

MCP (Model Context Protocol) server adoption is surprisingly strong:

CoinGecko -- Official (Beta), 76+ tools, SSE + HTTP streaming
Alpaca -- Official, 50+ tools across trading + market data
Polygon / Massive -- Official, 35+ tools
FMP -- Official, 250+ tools
Twelve Data -- Official, WebSocket streaming
EODHD -- Official, OAuth 2.1
Alpha Vantage -- Official
Finnhub -- Community only
FRED -- Community only (2+ implementations)
Yahoo Finance -- Community only (5+ wrappers around yfinance)

All 10 have MCP servers. CoinGecko leads with 76+ tools and a hosted MCP endpoint. Alpaca's 50+ tools cover the full trading lifecycle. If you're building a trading agent in 2026 and your data provider doesn't have an MCP server, you're doing extra work.

Finding #3: The Agent Discovery Stack Is Mostly Empty

We checked 5 standard discovery files (OpenAPI, llms.txt, ai-plugin.json, robots.txt, security.txt).

CoinGecko is the clear leader with an official OpenAPI spec, llms.txt, and robots.txt (3/5). Alpaca matches with official OpenAPI (4 files!), llms.txt, and robots.txt. Polygon has 3/5 with community OpenAPI, ai-plugin.json, and robots.txt.

Nobody has all 5. And security.txt adoption is zero across financial data APIs.

FMP still returns 403 Forbidden on most standard paths. Yahoo Finance has zero discovery infrastructure because it isn't an official API.

Finding #4: Free Tiers Are Wildly Inconsistent

The range is enormous:

API	Rate Limit	Daily/Monthly Cap	Real-Time?	Gotcha
Alpaca	200 req/min	No cap	IEX only (single exchange)	SIP data delayed 15 min on free
FRED	120 req/min	No cap	N/A (economic data)	All 800K+ series free
Finnhub	60 req/min	No daily cap	Yes	Paid pricing not public
CoinGecko	30 req/min	10,000/month (Demo)	Yes	Burns through in ~5.5 hours at max rate
Twelve Data	8 req/min	800/day	US equities only	Credit system on paid tiers
FMP	300 req/min (paid)	250/day	EOD only	Hidden 500MB bandwidth cap
Alpha Vantage	5 req/min	25/day	No	Agent checking 3 symbols hourly burns it by lunch
EODHD	--	20/day	No	1-year max, demo tickers only
Yahoo Finance	~6 req/min	~950 tickers/session	Yes	Can break without notice, sessions expire in 10-20 min

FRED is the most generous overall -- 120 requests/minute with no cap and access to every series. All 800,000+ data points are free because it's a public service of the Federal Reserve.

Alpaca is the most generous for market data -- 200 req/min with no daily cap, though the free tier only gets IEX exchange data (not the full consolidated tape).

Yahoo Finance is the riskiest -- no official API means no guarantees. Yahoo actively tightens anti-scraping measures. The yfinance library has had recurring outages from crumb rotation and session invalidation. Don't build production systems on it.

Finding #5: Auth Is Simple But Not Standardized

Method	APIs
Header only (most secure)	Alpaca (`APCA-API-KEY-ID` + `APCA-API-SECRET-KEY`), CoinGecko (`x-cg-demo-api-key`)
Header or query param	Polygon, Finnhub, Twelve Data, FMP
Query param only	Alpha Vantage (`apikey=`), EODHD (`api_token=`), FRED v1 (`api_key=`)
No auth / session-based	Yahoo Finance (cookie + crumb), CoinGecko (public tier)
FRED v2 (new)	Header only (`Authorization: Bearer`)

For agents, header-based auth is better -- it keeps keys out of URLs (which get logged, cached, and shared). Alpaca requires it. CoinGecko recommends it. FRED's new v2 API switched to it.

No provider uses OAuth for data access (good for agents).

Finding #6: The Crypto and Macro Gaps Are Closing

A year ago, crypto and macroeconomic data were underserved by agent-friendly APIs. That's changing:

CoinGecko now has the most agent-ready crypto API -- official MCP with 76+ tools, llms.txt, OpenAPI spec, and a hosted MCP endpoint. Covers 15,000+ coins plus DEX data via GeckoTerminal.

FRED provides the entire US macroeconomic dataset for free with generous rate limits. The November 2025 v2 API launch added bulk retrieval and header auth.

Alpaca bridges trading and data -- its MCP server covers both market data queries and order execution, which is unique. An agent can check a price and place a trade through the same interface.

Finding #7: Polygon Rebranded and Nobody Noticed

Polygon.io became Massive in October 2025. api.polygon.io still works, but the brand, pricing page, and new features are all at massive.com. If your agent config says "polygon.io", update it.

The Agent-Readiness Scorecard

Scored on discovery, auth, free tier, MCP, and docs (5 points each, 25 max):

Rank	API	Discovery	Auth	Free Tier	MCP	Docs	Total
1	CoinGecko	3	5	4	5	5	22
2	Polygon/Massive	3	5	3	5	5	21
3	Alpaca	3	5	4	5	4	21
4	Finnhub	2	5	5	3	4	19
5	Twelve Data	1	5	4	5	4	19
6	FRED	1	4	5	3	4	17
7	FMP	1	4	4	5	3	17
8	Alpha Vantage	1	3	2	4	3	13
9	EODHD	1	3	1	4	2	11
10	Yahoo Finance	0	1	3	2	1	7

CoinGecko takes the top spot at 22/25 -- the only API with llms.txt, an official hosted MCP server with 76+ tools, header auth, and interactive docs.

Alpaca and Polygon tie for second at 21/25. Alpaca's unique advantage is combining data and trading in one MCP server. Polygon has the best docs.

FRED scores 17/25 -- dragged down by discovery (no official OpenAPI or llms.txt) despite having the most generous free tier of any API in this list.

Yahoo Finance trails at 7/25 -- no official API, no auth system, no discovery, no stability guarantees. It exists because it's free and covers everything, but an agent that depends on it will break.

What This Means for Agent Developers

Check for MCP first. All 10 providers have them. This is the fastest path to integration.
CoinGecko is the model to follow. llms.txt + hosted MCP + OpenAPI + interactive docs. Other providers should take notes.
Don't trust free tier marketing. "Free" ranges from 200 req/min (Alpaca) to 20 req/day (EODHD).
Use header auth when available. Keeps keys out of logs. Alpaca requires it.
Don't build production on yfinance. It works until it doesn't, with no warning and no recourse.
Budget for paid tiers. Most free tiers are demo-grade. Alpaca ($9/mo) or Polygon ($29/mo) at minimum for production.
Watch for Polygon->Massive migration. Update configs and documentation references.

Coming in April

Starting in April, we publish full OathScore quality ratings (0-100) based on 30 days of continuous monitoring across all rated APIs: accuracy (35%), uptime (20%), freshness (15%), latency (15%), schema stability (5%), documentation (5%), trust signals (5%).

Our probes have been running since March 3. April's report will have real numbers.

OathScore monitors financial data APIs and gives AI trading agents the current state of the world in one API call.

API: https://api.oathscore.dev | GitHub: https://github.com/moxiespirit/oathscore

Building the Trust Layer for AI Trading Agents

laguia — Wed, 04 Mar 2026 17:06:47 +0000

The Problem

AI trading agents blindly trust their data sources. They call Alpha Vantage or Polygon, get a number back, and assume it's accurate. But how often is that data actually fresh? What's the real uptime? Is the "real-time" feed actually real-time?

There's no Yelp for data APIs. No credit score. No independent verification.

The Insight

Agents need a "credit bureau" for APIs — an independent third party that continuously monitors quality and publishes transparent scores.

What I Built

OathScore does two things:

1. World State in One Call

The /now endpoint returns everything a trading agent needs to know right now:

Which exchanges are open (CME, NYSE, NASDAQ, LSE, EUREX, TSE, HKEX)
Volatility regime (VIX, VVIX, VIX9D, VIX3M, SKEW, term structure)
Economic events (next event, FOMC/CPI countdowns, weekly high-impact count)
Data health status

One call replaces 4-6 separate API calls. Try it: https://api.oathscore.dev/now

2. Quality Ratings

Independent 0-100 composite scores for 7 financial data APIs:

Metric	Weight
Accuracy	35%
Uptime	20%
Freshness	15%
Latency	15%
Schema stability	5%
Documentation	5%
Trust signals	5%

Currently monitoring: Alpha Vantage, Polygon, Finnhub, Twelve Data, EODHD, FMP, Curistat. Scores publish after 30 days of baseline data.

For AI Agents: MCP Server

OathScore is an MCP (Model Context Protocol) server with 8 tools. Claude, GPT, CrewAI, or any MCP-compatible agent can natively call:

get_now — full world state
get_score — quality rating for any monitored API
compare_apis — side-by-side comparison
get_alerts — active degradation alerts

Micropayments with x402

Instead of API keys and monthly subscriptions, agents can pay per request using USDC stablecoins via the x402 protocol. When rate-limited, the API returns 402 Payment Required with payment instructions. No signup needed.

Try It

Live: https://api.oathscore.dev/now
GitHub: https://github.com/moxiespirit/oathscore
Free tier: 10 calls/day

What data APIs would you want rated? What metrics matter most?