# MCP servers are just REST APIs in a polite wrapper - here's 5 lines of Python

> Source: <https://dev.to/connerlambden/mcp-servers-are-just-rest-apis-in-a-polite-wrapper-heres-5-lines-of-python-58pn>
> Published: 2026-05-26 22:38:09+00:00

If you've been watching the MCP (Model Context Protocol) ecosystem from the sidelines, here's a quietly important detail: a lot of MCP servers are also just plain REST APIs underneath. The MCP layer is a polite wrapper that says "Claude, here are tools you can call." But the underlying HTTP endpoints are right there, ready to be called from `requests.get(...)`

like any other JSON API.

That matters because **the most interesting MCP servers are useful even if you've never opened Claude Desktop or Cursor.** You can drop them into a Streamlit app, a Jupyter notebook, a Lambda function, a Discord bot, an Airflow DAG, or a cron job. The MCP integration is gravy on top.

I'll show this with a concrete example: pulling per-symbol ML option fair values and 31-dimension news-bias scores into pandas in 5 lines.

I run [Helium MCP](https://github.com/connerlambden/helium-mcp), which started as an MCP server and recently grew a plain REST surface. Both speak the same data:

The MCP endpoint is `https://heliumtrades.com/mcp`

. The REST endpoints live under `https://heliumtrades.com/`

with paths like `/mcp_search/`

, `/mcp_option_price/`

, `/mcp_ticker/`

, `/mcp_url_bias/`

. 50 free queries per IP. No signup, no API key needed for the free tier.

``` python
import requests

r = requests.get(
    "https://heliumtrades.com/mcp_search/",
    params={"q": "apple earnings", "limit": 3},
    timeout=30,
)
print(r.json())
```

You get back a JSON list of articles with full bias scoring across all 31 dimensions per article: `credibility`

, `sensationalism`

, `overconfidence`

, `opinion_vs_fact`

, `scapegoating`

, `ai_authorship_probability`

, `covering_responses`

, `oversimplification`

, and 23 more.

This is where it gets fun. The JSON is already flat enough that pandas just works:

``` python
import pandas as pd, requests

resp = requests.get(
    "https://heliumtrades.com/mcp_search/",
    params={"q": "federal reserve", "limit": 50},
)
df = pd.json_normalize(resp.json())
print(df[["source", "credibility", "sensationalism", "opinion_vs_fact"]].head())
```

Now you can do everything pandas does: groupby source, compute mean credibility, plot a credibility-vs-sensationalism scatter, filter to high-AI-authorship-probability articles, etc.

``` python
import requests

r = requests.get(
    "https://heliumtrades.com/mcp_option_price/",
    params={
        "symbol": "AAPL",
        "strike": 200,
        "expiration": "2026-06-19",
        "option_type": "call",
    },
)
print(r.json())
# {'predicted_price': 20.64, 'prob_itm': 0.52, 'delta': 0.55, 'gamma': 0.02, 'vega': 0.41, ...}
```

You get back a model-derived fair value and prob_ITM next to market price. The diff between the two is a (testable, scorable) prediction.

Once the API returns JSON, building a Streamlit app is essentially a wrapper exercise:

``` python
import streamlit as st, requests, pandas as pd

q = st.text_input("Search query", "tariffs")
limit = st.slider("Results", 1, 50, 10)

if st.button("Go"):
    resp = requests.get(
        "https://heliumtrades.com/mcp_search/",
        params={"q": q, "limit": limit},
    )
    df = pd.json_normalize(resp.json())
    st.dataframe(df[["title", "source", "credibility", "sensationalism", "ai_authorship_probability"]])
    st.bar_chart(df.groupby("source")["credibility"].mean())
```

This is the smallest realistic media-bias dashboard I've ever written. It's about 12 lines.

The point isn't that this one API is special. The point is that **MCP servers with REST surfaces are a quietly powerful new class of API.** They are:

If you're a data scientist who's never installed Claude Desktop and never wants to: that's fine. Treat MCP servers as a directory of unusually well-curated free REST APIs and start with the ones that solve a problem you already have.

For finance and news intelligence specifically, the full Helium MCP REST endpoint list is:

| Endpoint | Purpose | Params |
|---|---|---|
`/mcp_search/` |
News search across 3.2M articles |
`q` , `limit`
|
`/mcp_balanced_search/` |
Multi-perspective news synthesis |
`q` , `limit`
|
`/mcp_source_bias/` |
31-dim bias profile for one source | `source` |
`/mcp_url_bias/` |
31-dim bias profile for one article URL | `url` |
`/mcp_all_source_biases/` |
All scored sources | - |
`/mcp_ticker/` |
Real-time market data for a symbol | `ticker` |
`/mcp_option_price/` |
ML option fair value + Greeks |
`symbol` , `strike` , `expiration` , `option_type`
|
`/mcp_historical_options/` |
Full options chain with ML fair values |
`symbol` , `date`
|
`/mcp_top_strategies/` |
AI-ranked options strategies |
`limit` , `sort`
|
`/mcp_meme_search/` |
Semantic meme search |
`q` , `limit`
|

The MCP server config (for Cursor / Claude Desktop / Windsurf) is:

```
{ "mcpServers": { "helium": { "url": "https://heliumtrades.com/mcp" } } }
```

But honestly - if Python is your thing - just open a notebook and `requests.get`

. The whole point of a public REST surface is that you don't have to care about anything else.

Source, schema, full tool spec: [github.com/connerlambden/helium-mcp](https://github.com/connerlambden/helium-mcp). Page: [heliumtrades.com/mcp-page](https://heliumtrades.com/mcp-page/).

If you build something with it, I'd love to see it. Open an issue, or send a notebook - happy to feature good demos.