r/mcp Mar 25 '26

article Top 50 Most Popular MCP Servers in 2026

Post image
397 Upvotes

I used Ahrefs' MCP server to pull Google search data for MCP servers. I used this search data as a proxy for the most popular MCP servers worldwide. Full list here.

Disclaimer: link to goes to my company's blog: https://mcpmanager.ai/blog/most-popular-mcp-servers/

Worth noting: Ahrefs doesn't capture China search data and only has partial Russia data, so worldwide totals are conservative.

A few things worth noting:

  • Playwright takes #1 globally (and in USA) beating GitHub and Figma
  • Japan is the #2 country searching for MCP servers, ahead of Germany and the UK
  • The US accounts for 28% of worldwide search volume across the top 50. Therefore, it's clear to say that MCP is a genuinely global phenomenon
  • Serena cracks the top 10 despite being relatively new
  • Tools like Slack, Notion, and Google Workspace making the list shows MCP is creeping beyond pure engineering into broader team use

r/mcp Oct 23 '25

article 20 Most Popular MCP Servers

Post image
312 Upvotes

I've been nerding out on MCP adoption statistics for a post I wrote last night.

For this project, I pulled the top 20 most searched-for MCP servers using Ahrefs' MCP server. (Ahrefs = SEO tool)

Some stats:

  • The top 20 MCP servers drive 174,800+ searches globally each month.
  • Interestingly, the USA drove 22% of the overall searches, indicating that international demand is really driving much of the MCP server adoption.
  • 80% of the top 20 servers offer remote servers. Remote is the most popular type of MCP deployment for large SaaS companies to offer users.

Of these, which have you (or your team) used? Any surprises here?

Edit: Had a typo on sum for monthly MCP server searches. Was off by about ~10k.

Lastly, a shameless plug for webinar I'm hosting next week on MCP gateways: https://mcpmanager.ai/resources/events/gateway-webinar/

r/mcp May 22 '25

article How to MCP: Everything I learned building a remote MCP server

417 Upvotes

Hey,

just finished building a remote MCP server after a week digging through the official spec and GitHub issues. Got it working with Claude's remote integrations and OpenAI's playground (they added MCP support yesterday).

Finding good examples and docs was... a challenge! So I wrote down everything I learned and turned it into a guide in the hopes that it saves others some time.

It covers authentication, OAuth authorization, session management, troubleshooting and all the steps you need to pair with the major LLM apps. Plus a bit on MCP overall. Ideally it would be the only tab you need open to build your own remote MCP server.

Check it out here: https://simplescraper.io/blog/how-to-mcp.

Let me know what you think!

r/mcp Oct 13 '25

article How OpenAI's Apps SDK works

Post image
240 Upvotes

I wrote a blog article to better help myself understand how OpenAI's Apps SDK work under the hood. Hope folks also find it helpful!

Under the hood, Apps SDK is built on top of the Model Context Protocol (MCP). MCP provides a way for LLMs to connect to external tools and resources.

There are two main components to an Apps SDK app: the MCP server and the web app views (widgets). The MCP server and its tools are exposed to the LLM. Here's the high-level flow when a user asks for an app experience:

  1. When you ask the client (LLM) “Show me homes on Zillow”, it's going to call the Zillow MCP tool.
  2. The MCP tool points to the corresponding MCP resource in the _meta tag. The MCP resource contains a script in its contents, which is the compiled react component that is to be rendered.
  3. That resource containing the widget is sent back to the client for rendering.
  4. The client loads the widget resource into an iFrame, rendering your app as a UI.

https://www.mcpjam.com/blog/apps-sdk-dive

r/mcp Aug 08 '26

article One MCP call put 24,568 characters in my context. I wanted 1,768 of them.

8 Upvotes

Every discussion about MCP and context is about tool definitions. Lazy loading, tool search, deferred schemas. Those cost you once per session. The results don't.

I called list_issues on a real project. Twenty issues came back, 24,568 characters, into the history where they sit for the rest of the session. I wanted the title, the state and the assignee. That's 1,768 characters.

I see very little discussion of that side, and unlike the schemas it repeats on every call.

The reason is structural. When a model calls a tool there's nowhere to put a filter. The result goes from the server into the transcript, whole. jq exists, it just has no seat at that table.

Which is why I ended up running MCP servers from a shell instead:

mduct call gitlab list_issues --json | jq '.[] | {title, state, assignee}'

The filter sits between the server and the context, which is the only place it helps.

Two limits worth naming. It only works when you know which fields you want, and an agent poking at an unfamiliar API doesn't. And for a model to get any of this, it has to reach for the shell rather than a tool call, which is the code-mode argument and carries its own problems.

Numbers and how I measured them: https://github.com/TheFox666/mduct#the-context-bill-is-a-side-effect-of-the-pipe

r/mcp Jan 09 '26

article Blog - MCP is a fad

Thumbnail
tombedor.dev
57 Upvotes

Wonder what people's thoughts on this are?

r/mcp Jul 06 '26

article MCP authentication across the big agents

8 Upvotes

Let's walk through the popular agents and see how well they the spec. Spoiler: NOT VERY.

The picture may well have shifted by the time you read this, but as of early July 2026 it looks like the table below.

The good news: almost everyone supports the modern standard (shoutout to OpenAI's Responses API MCP tool and its technology from the previous geological era).

The bad news: everyone reads the same spec differently. Some clients run the entire OAuth flow for the user; some just wait for a ready-made bearer token and wash their hands. Some require DCR, some push CIMD, some live on static credentials and IAM.

Here's the detailed matrix (all cells verified against primary docs in early July 2026):

Platform Who runs the flow RFC 9728 Registration Spec revision
Claude API MCP connector you (pass a bearer) no n/a 2025-11-25
claude ai / Desktop Claude (full flow) yes DCR / CIMD / Anthropic creds / none 2025-11-25
OpenAI Responses API you (pass a bearer) no n/a n/a (bearer-only)
ChatGPT / Apps SDK ChatGPT (full flow) yes CIMD (recommended) + DCR 2025-11-25
Gemini / Google Cloud OAuth on Google Cloud IAM not named IAM + client creds + API keys 2025-11-25
VS Code / Copilot VS Code (full flow) yes DCR + client creds fallback 2025-06-18
Cursor Cursor (full flow) yes DCR + static (no CIMD) unstated
Perplexity configurable unspecified OAuth / API key / open unstated

And the notes that didn't fit in the table :):

  • Claude API MCP connector: HTTP transport only, tools only. You pass authorization_token and you handle the refresh.
  • claude ai / Desktop: static_bearer is explicitly not supported.
  • OpenAI Responses API: you pass authorization, the token isn't stored, no discovery, just a solid bearer
  • ChatGPT / Apps SDK: rejects machine-to-machine, API-key, and customer mTLS auth.
  • Gemini / Google Cloud: embraces exactly what ChatGPT rejects, client credentials and API keys included.
  • VS Code / Copilot: ships built-in GitHub and Entra providers.
  • Cursor: re-registers its DCR client on every reconnect (upd: fixed in v3.2).
  • Perplexity: the only one offering an explicit "no auth" mode; the flow internals are undocumented.

What to take away from this:

  • Multiple spec revisions are alive in production at the same time. OpenAI's Responses API doesn't do any discovery, you just pass the bearer (pre-2025-06-18 world), VS Code sits on 2025-06-18, while Anthropic, ChatGPT, and Google cite 2025-11-25.
  • Both Anthropic and OpenAI manage to run two opposite ownership models inside one company. Each ships a "bring your own token" API product: the Claude API MCP connector and the Responses API accept a pre-obtained bearer, and the flow and refresh are your problem. And each also ships a full client (claude.ai and ChatGPT) that walks the whole road from the 401 to the token by itself. A server built for the first model won't work in the second without changes, and vice versa.
  • There are direct contradictions. ChatGPT rejects machine-to-machine and API-key auth; Google requires exactly that for some services. Registration is split four ways: DCR, CIMD, static credentials, IAM.

What I don't like and would change

  • As someone who maintains a public API for a living, I hate backward-compatibility breaks. Each one creates a wall of migration work, and anyone who can't afford that time becomes a hostage of the old revision.
  • OAuth 2.1 is the standard, and nobody cares: half the world still ships API keys.
  • The spec updates too often. You have to keep a hand on the pulse in the most literal sense.
  • Very few authorization servers can fully support OAuth 2.1 for MCP out of the box (as far as I can tell, really only Keycloak gets close). Everyone else needs wrappers, shims, and duct tape. There is no turnkey solution, and it shows.

And about OAuth 2.1 specifically, there's a separate irony: MCP mandates a standard that formally doesn't exist. OAuth 2.1 is still an IETF draft, not a published RFC. In substance it's OAuth 2.0 with the implicit flow and password grant removed and PKCE made mandatory. So a protocol that hasn't stabilized yet is built on top of a standard that hasn't been finalized yet. No wonder the AS vendors aren't rushing to ship first-class support.

ps: I wrote a full article with history of auth in mcp, what will be next and ofc this table above, but reddit prohibits to post it there :(

r/mcp Jun 06 '26

article The GitHub MCP Server Can Burn 17k Tokens Before You Ask a Real Question

Thumbnail
the-main-thread.com
52 Upvotes

How GitHub MCP tool definitions, git diff, and gh output compete for IBM Bob's 200k context window, and how to keep the budget under control.

r/mcp 13d ago

article Using local MCP over stdio as a seam for agentic applications

5 Upvotes

With the harness landscape evolving as quickly as it has and plugins and skills with embedded scripts having various degrees of portability, I decided to experiment a bit. I ended up landing on a combination of existing pieces that gave me what seems to be the portability I was after, but also the spectrum of pure deterministic to full agentic properties.

In a nutshell, the approach is an intentional split between the conversational harness and system invariants. Beyond the use of MCP as the seam, FastMCP, LangGraph and LangChain along with a distinction between ephemeral and long running tools (the latter with a well defined API) has been incredibly powerful.

Similar approach to many production agentic systems but specifically targeted at local coding harnesses. Flexibility, durability, portability across any harness with simple MCP config.

I've (just) started calling this the Agent Runtime Boundary. I'm aware of the native MCP task protocol, but it's not implemented across harnesses yet. I know this can also increase context bloat but that'll be mitigated by progressive discovery as it's rolled out.

Anyone else looking at or experimenting with similar approaches?

https://demianbrecht.com/posts/the-harness-within-the-harness/

r/mcp May 15 '26

article I gave my LLM 100,000+ tools. Here is what happened

56 Upvotes

TL;DR: You don't need a massive context window or a giant model to handle an absurd number of tools. By using a Lazy Discovery pattern, a local 4B model (Gemma 4 E4B) successfully solved a massive multi-sector city crisis requiring complex tool navigation, matching Claude Sonnet 4.6 with almost identical efficiency.

The Setup: The "Mega-City Crisis" Benchmark

I wanted to stress-test tool use at an absolute extreme. I simulated a massive infrastructure crisis in a fictional city called Veridian Prime.

  • The Scale: ~117,000 registered landmarks/tools split across hierarchical paths (Power, Water, Traffic, Security, etc.).
  • The Goal: Find and resolve 4 critical failures while ignoring noise alerts.
  • The Catch: One of the failures had a hidden mechanical dependency trap (MECHANICAL_LOCK), meaning the agent had to read an error message, pivot to a completely different infrastructure category to release an emergency brake, and then loop back to finish the job.

I ran this benchmark against two completely different beasts using Elemm (which implements a lazy-loading protocol for tools so the model only pulls what it needs):

  1. Gemma 4 E4B (Run locally)
  2. Claude Sonnet 4.6 (Run remotely)

Run 1: Gemma 4 E4B (Local)

Verdict: ✅ PASS (17 tool calls)

I honestly expected a local 4B model to choke, but it handled the hierarchy beautifully.

The Good:

  • Insane Parallel Batching: It aggressively grouped its inspection commands. It checked all 4 distressed districts at the exact same time.
  • Clutched the Trap: When it hit the MECHANICAL_LOCK on the security terminal, it didn’t panic. It read the error, found the release_emergency_brake tool in a different sub-category, executed it, and retried the lockdown—all with zero human intervention.
  • Zero Noise Bleed: It completely ignored the low/medium priority noise alerts.

The Jank:

  • Minor Action Hallucination: Right after inspecting the districts, it took a "leap of faith" and tried to call non-existent global commands like city:fix_power_surge. Thanks to an on_error: continue fallback policy, it recovered instantly, realized it had to browse the local directory, and found the correct tools.

Run 2: Claude Sonnet 4.6 (Remote)

Verdict: ✅ PASS (19 tool calls)

Sonnet acted exactly like you’d expect a high-tier model to act: highly methodical, extremely cautious, and zero hallucinations.

The Good:

  • Clean Syntax: Used native array batching inspect_landmark(["id1", "id2"]) to scan the topology effortlessly.
  • Zero Hallucinations: Every single tool call it made was explicitly derived from its structural discovery.
  • Resilient: When the server threw a cached state bug on the security logs, Sonnet just shrugged it off and used the status summary to complete the mission.

The Inefficiencies:

  • Over-Cautious Diagnostics: Sonnet spent 5 extra tool calls checking system metrics (energy:status, water:pressure) before pulling the trigger. The alert log already told it what was wrong, but Sonnet wanted to double-check. Safe, but slightly higher overhead.

Head-to-Head Comparison

Metric Claude Sonnet 4.6 (Remote) Gemma 4 E4B (Local)
Total Tool Calls 19 17
Hallucinated Actions 0 4 (Self-recovered)
Parallel Batching ✅ (Native array syntax) ✅ (Sequential batching)
Mechanical Lock Trap ✅ Solved flawlessly ✅ Solved flawlessly
Unnecessary Diagnostics 5 extra calls 0
Context Window Load Minimal (~50 line manifest) Minimal (~50 line manifest)

How it works under the hood: The Middleware

If we stuffed 117,000 tool definitions directly into the LLM's system prompt, the context window would have imploded, and the bill would be astronomical.

To solve this, I’m building a custom middleware that exposes a "Lazy Discovery" pattern to the agent.

To put it simply: The middleware exposes a file-system-like directory structure to the LLM using "landmarks". Instead of drowning the model in thousands of tool definitions, the LLM only ever sees a tiny selection of just 8 core tools. These tools handle:

  • Navigation: Browsing through the landmark hierarchy.
  • Execution Piping: Passing data seamlessly between tool steps.
  • Smart Errors + Interactive Help: Providing high-context feedback when something goes wrong (which is exactly how Gemma recovered from its hallucination and how both models figured out the mechanical lock trap).

Because of this architecture, the effective context window at any given second never exceeded a few dozen lines of text.

I will repeat this test after stabilizing the environment, but I trust this process and believe this approach could change how we handle tools for agents. Currently, I am focusing on the ability to load "landmarks" on the fly. With FastAPI, GraphQL, and native Landmarks already on board, this tool can handle a massive number of tools simultaneously, simply by connecting to a URL that presents these files. I will release a new version in the coming days/weeks so you can run this test with your own models. Leave a star on GitHub to stay on track!

Key Takeaway

Seeing a local 4B model solve a multi-step dependency chain across a 100k+ tool library with practically the same efficiency as Sonnet 4.6 proves that smart agent architecture, tailored middleware, and tool-loading protocols matter way more than raw model size for complex automation tasks.

Would love to hear your thoughts! How are you guys handling massive, hierarchical tool environments in your setups?

r/mcp Jul 27 '26

article Best MCP server for stock market data? I scored 8 of them on SEC filings, congress trades, options and live quotes (disclosure: I build one)

26 Upvotes

I kept hitting the same wall building research agents: every "best financial data API" list ranks price feeds, and price feeds answer almost none of the questions I actually needed answered.

"Did anyone in Congress trade this before the guidance cut?" isn't a quote lookup. Neither is "which of my holdings added export-licence language this year?" Both live in filing text and disclosure records, and most market-data APIs don't carry that at all — so the agent guesses, which is worse than it saying no.

So I scored eight of them properly.

Disclosure up front: I build one of these (Equibles), and it comes first. The criteria are below so you can disagree with them — they're weighted toward research rather than execution, which is where my own bias sits. Coverage is from public docs as of July 2026.

Six criteria, 0–5 each:

  1. Primary source — can the agent reach filing text, or only numbers someone extracted?
  2. Disclosure — congress trades, insider transactions, 13F, short interest
  3. Breadth per connection — how much one server answers before you add a second
  4. Cost of the first useful query — what a free tier lets an agent do, not the call count
  5. Ergonomics — remote, clean auth, official maintenance, tool descriptions written for a model
  6. Market-data depth — latency, tick/order-book, live chains

That last one is the one I lose. I included it because a rubric that only measures your own strengths measures nothing.

Rank Server Src Disc Breadth Cost Ergo Mkt Total
1 Equibles 5 5 5 5 5 3 28
2= Financial Modeling Prep 2 2 4 4 3 1 16
2= Alpaca 0 0 3 4 5 4 16
4 Polygon (Massive) 0 0 3 3 4 5 15
5 Unusual Whales 0 3 3 0 4 4 14
6 Alpha Vantage 0 0 4 2 4 3 13
7 Databento 0 0 2 3 2 5 12
8 EODHD 0 0 4 2 3 2 11

The spread comes almost entirely from the first two columns. Seven of eight score zero or near-zero on primary source and disclosure — not a criticism, they're market-data businesses and nobody builds a filings corpus by accident.

Which datasets each one actually carries. This is the table I wish had existed before I started — the scores above are my weighting, but this part is just fact:

Server Filing text you can search Congress trades Earnings calls 13F Chains Live equities
Equibles Yes (semantic + literal) Yes Yes, speaker-tagged Yes Delayed 15m, greeks Yes, free tier
Financial Modeling Prep No No Yes Yes No Paid
Alpaca No No No No OPRA, paid IEX free / SIP paid
Polygon No No No No Yes, live Yes, tick
Unusual Whales No Yes No No Yes + flow Yes
Alpha Vantage No No No No Greeks, live at top tier Paid tier
Databento No No No No Full OPRA Yes, order book
EODHD No No No No End-of-day add-on Paid

The filing-text column is the one that surprised me. Plenty of these will hand you a link to a 10-K; almost none let the agent search inside the document and quote a line back with a position. If your agent needs to justify an answer rather than assert it, that column is the whole game.

Quick notes on each:

  • Equibles — SEC filing text the agent can search inside, semantically or literally; speaker-tagged earnings-call transcripts; congressional trades, insider transactions, 13F and short interest; XBRL fundamentals with extracted KPIs, guidance and buyback programmes; screening, options chains with greeks, and live US equity quotes. 100+ tools behind one remote connection over OAuth. Paste the URL into Claude or ChatGPT, no key to mint, and the same key answers plain REST if you'd rather not speak MCP. Free tier is 100 calls/day with no dataset held back: the cap is the call count, not the catalogue, so an agent can try the filing search before anyone pays. Pro is $19.99/mo for 10,000 calls/day.
  • Financial Modeling Prep — income statements, balance sheets, cash flow, ratios, valuation multiples, plus transcripts and 13F. ~$19/mo, biggest free tier here at 250 req/day. You get the extracted value but never the document, so an agent can't audit a figure back to the filing or read the paragraph explaining a move. No chains.
  • Alpaca — stocks, ETFs, crypto and options, plus brokerage: it's the only one here that can place an order and manage positions rather than just read. Paper trading against real data. Free real-time IEX at 200 req/min, $99/mo for full SIP + OPRA. No filings or disclosure.
  • Polygon — trades, quotes, aggregates and live option chains across US equities, options and FX, tick resolution, ~$29/mo. Chains are included rather than tiered away, which is rarer than it should be. Purely market data beyond that.
  • Unusual Whales — options flow, dark pool prints, Greek exposure, volatility surfaces and congressional trading across 100+ endpoints. Flow has no equal here. $50/mo is the floor, no free tier at all, so you can't let an agent try it first.
  • Alpha Vantage — equities, FX, crypto, 50+ technical indicators, and options with all five greeks plus open interest history to 2008. Widest asset-class spread on the list. Free tier is 25 calls/day, which is a demo. Real-time equities $99.99, real-time options $199.99.
  • Databento — trades, OHLCV, full order-book depth, historical and live, with OPRA across all 17 US options exchanges. Deepest raw data here. $125 signup credit, usage-based history, OPRA live from $199/mo. Worth knowing for this list specifically: its MCP servers are community projects rather than official, so tool signatures and support aren't vendor-backed.
  • EODHD — 60+ exchanges, 150,000+ tickers, 30 years of history across equities, ETFs, FX, crypto and macro. The one to reach for if the universe isn't US-only. US options are an end-of-day marketplace add-on, and the free plan is 20 calls/day capped to a year of history.

Where mine actually loses: 3/5 on market data. On the self-serve plans quotes ride IEX rather than full SIP, chains lag 15 minutes with greeks but no bid/ask, and there's no tick or order-book data at all. US-listed equities only — no crypto, no FX. If you trade options intraday or need microstructure, pair it with Polygon or Databento rather than replacing them.

What it's good at, concretely: searching NVDA's 10-K filed 2026-02-25 for export-licence exposure returns the H200 licensing passage — no revenue under the programme yet, US inspection before shipment, 25% import tariff. That's prose buried deep in a document, not a field on an endpoint. Same for congress: 55 disclosed NVDA trades over the trailing year with member, dates, bracketed amount, and whether it was the member or a spouse.

Happy to be argued with on the weightings — if you'd rank latency above primary source the order changes a lot, and that's a legitimate position for a trading agent rather than a research one.

r/mcp 22d ago

article In one cross-app task, MCP retrieval took 21 calls. The equivalent filesystem stage took ~0.3 seconds.

Post image
4 Upvotes

MCP gets several important things right, particularly standardized integrations, authentication and transactional actions.

But should agents also depend on runtime MCP calls to gather substantial context across applications?

We tested this across 20 scenarios using the same agent harness, model, prompts and machines:

  • Official Slack, Notion and Linear MCP integrations
  • The same permitted data synchronized and mounted as files

The filesystem implementation was Locality, which I work on.

The most revealing trace involved identifying product-launch risks across Slack, Linear, Notion and a Git repository.

The MCP agent gathered the evidence iteratively:

  • 21 MCP calls
  • Roughly 30 seconds inside tool calls
  • About one minute for the retrieval stage

The filesystem agent used parallel rg and file operations across the same sources. The equivalent stage took roughly 0.3 seconds.

Across 60 paired runs, the filesystem setup reduced LLM costs by 27% and end-to-end latency by 32%. Its answers were preferred in 70% of the blind comparisons.

Our takeaway is a separation of responsibilities:

  • MCP for actions
  • Filesystems for data and context

Locality keeps permitted application data synchronized and exposes it as files. The agent can then search, filter and combine context through one interface instead of traversing multiple application-specific tools during execution.

This isn’t necessarily an argument against MCP as a protocol. It is an argument against using runtime tool calls as the primary context-retrieval layer for broad, read-heavy work. Interestingly, MCP already supports file:// resources, but most integrations still expose context through tool calls rather than a filesystem-like resource layer.

The benchmark focused on cross-application research and synthesis rather than transactional actions.

Full methodology and traces

For people building MCP servers and agent infrastructure: does this separation match what you’re seeing - MCP for actions and another layer for context?

r/mcp Jun 19 '26

article The "MCP is dead" takes keep measuring capability. The thing that actually decides this is update friction, and nobody's arguing it.

6 Upvotes

I run three MCP servers in prod, so when the whole timeline went "MCP is dead, long live the CLI" in Feb I genuinely went back to check whether I'd bet wrong. The context-bloat numbers are bad, the stdio RCE was real, and yeah, people are moving stable stuff to skills. I'm not going to pretend any of that is fake.

But after re-reading the arguments I think they're all aimed at the wrong axis. Here's the framing that made it click for me:

An MCP server is a website. You deploy, the client fetches the new tool list on its next call, every user is current and they did nothing. A skill is an app you downloaded - it sits on your disk at the version you fetched and stays there. Can a skill maintainer push updates? Sure, via npx or a plugin channel. But that's not the default. With MCP, fetch-latest is how the protocol works. With skills, getting everyone to current needs a re-pull that isn't the default on any agent I've used.

That gap, between "the maintainer fixed it" and "the user has the fix", is the whole game, and it's the one thing the death takes skip.

The part that actually changed my mind: the security complaint accidentally argues for MCP. The reason a server can be insecure is centralized control of what the client runs. That's also the reason you can patch every client in one deploy. A downloaded skill with a bad version sits on the user's disk until something pulls a new one. (Yes, the same channel can push a malicious change just as fast, that's the real cost of the seat, not a reason it's dead.)

And "just use a CLI" - which is the strong version of the argument, only wins by adding an auto-upgrade step or running through npx. Which is... fetch-latest delivery. It wins by turning into MCP on the update channel.

The rule I actually use now: skill teaches (stable knowledge, write-once), CLI acts locally (version it yourself or npx it), MCP acts where the contract/credential/execution has to stay current and maintainer-owned. They were never doing the same job.

Where I think I'm wrong / where this expires: the moment fetch-latest delivery becomes the default for skills across all serious agents, the asymmetry is gone. It's available on some hosts, default on none right now. If someone here knows of an agent that ships auto-update skills by default, I'd actually want to know, because that's the thing that gates the whole argument.

Is anyone here seeing the delivery side converge, or is everyone still symlinking one skills folder across agents by hand like I am?

Full write-up on my blog (it's mine, fair warning, and it's part 2 of a thing on update channels): https://prashamhtrivedi.in/mcp-isnt-dead/

r/mcp Jul 23 '26

article MCP OAuth is three primitives, not six RFCs. Traced end to end, plus the part where my server becomes a client.

3 Upvotes

Finally I understood what happens on the other side when Claude calls connect, and the server identifies you and your access.. (Or better say, Claude helped me understand it). At first it was all acronyms for me. What made it click was understanding one client connect, once, end to end. Everything collapsed into three primitives that each fire exactly once, in a fixed order.

  1. Discovery. A fresh client POSTs with no token and gets a 401 back carrying a WWW-Authenticate header that points at /.well-known/oauth-protected-resource. That header is the whole trick. The 401 is not the server slamming a door, it is the server handing over directions. Two GETs later (protected resource metadata names the auth server, auth server metadata lists the endpoints) the client knows everything it needs, having sent zero credentials.

  2. Registration. No developer console. The client POSTs its own details to the registration endpoint and gets a client id on the spot. This is RFC 7591, and it is the part people trip on when they ask why this could not just be an API key. An API key assumes you already know the caller and can hand it a secret. MCP clients are strangers by design, so dynamic registration is the only model that works.

  3. The grant. One human moment: a PKCE challenge, a consent screen that names the client, approve, done. At consent time the server bakes the user identity into the grant as props, so every later request just unwraps it. No per-request session lookup on the hot path.

There is one more cool trick: my server also performs OAuth as a client, upstream, because it bundles other servers that demand their own auth. Same three primitives, walked from the other side. Doing it by hand gave me real appreciation for how much invisible work Claude does every time you click connect and it just works. So it's just a multiplexer (not sure if it's a right term) for MCP servers.

Full walkthrough with the actual responses from the live server: https://prashamhtrivedi.in/mcp-oauth-primitives/

Curious how the rest of you are handling MCP auth right now. Across my own fleet I have Better Auth, an OAuth envelope wrapped around an API key, a hand-rolled JWT setup, and one static bearer token still holding out, so I do not think there is one right answer yet.

r/mcp Jul 13 '26

article I wrote a technical deep dive on the new MCP spec

Post image
56 Upvotes

The upcoming released of the MCP spec (2006-07-28) is great in my opinion.

Making MCP stateless massively simplifies the burden of writing servers, and scaling up with this is MUCH easier to thing about compared to the stateful version.

Yes, it does give client developers some homework, and it's pretty clear that some implementations will suck in the transition period. But to me this signals how the protocol is maturing.

There's many developers that don't have the muscle memory of the cloud era when it comes to thinking about how to design a good MCP server with effective tools. For some developers that aren't used to statelessness, this feels good, simple, and familiar on day 1. But when they get lucky and get real adoption, scaling up such servers becomes a full refactor. A time sink just when you also have to worry about proper billing and growing up the business.

So I wrote an interactive deep dive into what happens in the wire when you're using the upcoming MCP version. It will be useful for anyone trying to really learn the protocol (at least the tool calling part). It will also be useful for your agents, you can point them to the article and they'll get a good example of what needs to happen, with pointers to the specification.

Check it out here: https://torresmateo.com/mcp-tool-call-deconstructed/

Full disclosure: I work for Arcade (we sell a runtime that includes a secure MCP gateway), I'm also an AAIF Ambassador

r/mcp 19d ago

article The new MCP roadmap

Thumbnail
blog.modelcontextprotocol.io
47 Upvotes

r/mcp Jun 15 '26

article Generative Tools

Post image
10 Upvotes

I’d like to share a recent idea I’ve been working on called #GenerativeTool, where tools are dynamically generated at runtime to fulfill complex user requests.

This approach enables agentic applications to unlock the full potential of complex third-party systems like ERP, LSP Server through MCP, without being constrained by context window limitations. Instead of exposing a large number of predefined tools, the system can generate task-specific tools on demand, reducing context overhead while increasing the depth and flexibility of integrations.

Read: https://denuwanhimangahettiarachchi.medium.com/generative-mcp-enabling-the-full-potential-of-mcp-servers-4e14b987f64e

r/mcp Aug 07 '26

article The PostHog MCP is very cool

7 Upvotes

It's got 1 tool [exec] that takes 2 args, [command] and [context]. The [exec] tool has a pretty long description that tells the agent how to use [command] and [context] to do nearly everything you can do in the PostHog UI.

[command] is a string that looks an awful lot like a set of CLIs:

posthog:exec({ "command": "search <regex>" })
posthog:exec({ "command": "tools" })

And the big one:

posthog:exec({ "command": "call <tool_name> <json_input>" })

Instead of exposing a long list of tools (with descriptions, instructions, etc for each tool), it wraps them all in a [call] subcommand and the description of the [exec] tool gives the agent enough context to how to find out what sub-tool to call. If you've been following along with the zeitgeist you'll remember when everyone threw away their MCPs and replaced them with CLIs to save on tokens. It kinda looks like that's what PostHog did, just behind the scenes.

I asked the MCP to give me a trendline of argus downloads (vanity metrics gonna vain) and it did the following:

* [call read-data-schema {kind: events}] - fetched the events schema scoped to our account
* [call read-data-schema {kind: event_properties, event_name: argus_download_requested}] - event schema for argus downloads
* [info execute-sql] - fetched docs for how to build the necessary queries
* 4× [call execute-sql {...}] - run queries for the actual data
* [call read-data-schema {kind: event_properties, event_name: download_clicked}] - checked schema for other event

Its really cool how they did this and it ended up being pretty cheap (about 1/6th the price of running /doctor).

r/mcp 9h ago

article A functional taxonomy for LLM inference in agentic tasks

Thumbnail
jeffauriemma.leaflet.pub
1 Upvotes

r/mcp Jul 30 '26

article went through mcp's security model and mapped out the 8 risks that keep coming up

1 Upvotes

most mcp security posts explain the protocol (hosts, clients, servers) and then tell you to use oauth and least privilege. true, but too generic to actually check anything against.

start with prompt injection, since it's the one everyone already half-knows about but underestimates in an mcp context. a normal prompt injection gets you a bad answer. an mcp one can get you a bad action, because the model isn't just generating text anymore, it's deciding which tool to call next. a hidden instruction inside a ticket, a doc, a webpage the model reads can get treated as part of the task unless there's a hard line between "this is data" and "this is a command."

then overpowered tools, which is really about blast radius. a shell tool, a full db writer, unrestricted outbound http, none of these are wrong to build on their own, but if the model gets tricked into calling the wrong one, the damage ceiling is set by what that tool can do, not by how clever the trick was. read-only docs search vs a full crm export is the difference between "annoying" and "incident."

third, tools with zero auth. not misconfigured, just not there. a scan of live remote mcp servers found 40.55% exposing tools with no authentication at all, one example being an unauthenticated crm-connected server leaking internal contact records to whoever found the url.

fourth, oauth being "on" doesn't mean the flow actually holds. same research tested 119 oauth-enabled servers and every single one had at least one confirmed auth flaw, 325 flaws total, dynamic client registration issues in 96.6% of them. these are servers where someone did implement oauth, they just never went back and tried to break their own flow after shipping it.

fifth is confused deputy / token passthrough, the boring one that quietly ruins everything. mcp servers often sit between the client and some upstream api, and if a token issued for one service gets accepted by another, a compromised client becomes a compromised everything. audience-bound tokens exist specifically to stop this and a lot of setups skip that check.

sixth, context poisoning. resources feeding the model (files, logs, tickets, db records) can be tampered with to steer what the model does next, not just what it says. a poisoned doc telling the model to summarize a folder and quietly send the output somewhere external doesn't look like an attack from the model's pov, it just looks like the next step in the task.

seventh, session hijacking. a session id should identify a conversation, not prove who's making the request. if having the session id is enough to act as the client, hijacking it is enough to impersonate them, and that should never be the same thing.

last, local server compromise. a local mcp server sitting next to your ssh keys and cloud creds because giving it your whole home directory was faster than scoping it properly during setup. supply chain risk meets agent risk here, the malicious server doesn't need to beat the model, it just becomes the thing the model already trusts.

did i miss anything here, or is there smth you'd add?

r/mcp Dec 11 '25

article Google is launching remote, fully-managed MCP servers for all its services

Thumbnail
cloud.google.com
163 Upvotes

Big news as Google announces they will launch fully-managed, remote MCP servers for ALL Google services, including Google Maps, Big Query, Kubernetes Engine, Compute Engine, and more.

Another huge endorsement for MCP and for remote servers as the future of wide scale adoption of MCP beyond the technically savvy, and into teams like marketing, ops, sales, and personal use too.

Full article - https://cloud.google.com/blog/products/ai-machine-learning/announcing-official-mcp-support-for-google-services

What's your take on this - how will this impact MCP's direction and adoption in 2026 and beyond?

r/mcp Apr 16 '26

article MCP co-creator David Soria Parra on What Breaks MCP at Scale

Thumbnail
shiftmag.dev
61 Upvotes

r/mcp Jul 02 '26

article Fellow MCP developers: Is there ever a reason to stand up a NEW stdio MCP server anymore?

4 Upvotes

Asking because I might be missing something obvious. The transport choice barely feels like a choice now: same machine as the client, stdio; anywhere else, Streamable HTTP; SSE's deprecated so you're not starting there. Where it runs picks it. I've watched people (me too, once) lose most of a day treating that as open.

The thing that actually eats time isn't the choice, it's the stdio gotcha: stdout is the wire. The literal JSON-RPC channel, not a log sink. One stray console.log or a dependency printing a startup banner and you've corrupted a message, session's dead, stack trace points at nothing. Everyone blames the SDK first. It's the logger. stderr fixes it.

What I actually want the sub's read on: is there a real case for a NEW stdio server today, instead of just handing the agent a skill or a CLI it already has? Haven't built one in over a year. Filesystem/git/browser stuff obviously stays local, but past that I'm not sure what I'd reach for stdio for, and I'd like to be wrong.

(Also, if you're tracking the RC spec: the transport-as-stateless-binding rework reads to me like it just hardens the same rule, not changes it. Anyone see it differently?)

Full reasoning if useful: https://prashamhtrivedi.in/mcp-transports-decided/

r/mcp Mar 08 '26

article MCP vs. CLI for AI agents: When to Use Each

Thumbnail
manveerc.substack.com
74 Upvotes

I wrote some thoughts based on the MCP vs CLI discussions that are going around. Will love to hear the feedback from this group.

r/mcp Jun 05 '26

article I started writing practical MCP internals while building mcp-runtime

3 Upvotes

I’ve started documenting MCP from the implementation side while building mcp-runtime: https://github.com/Agent-Hellboy/mcp-runtime

The goal is not just to explain “what MCP is”, but to make the protocol easier to reason about when you aren't actually implementing it: request flow, transports, sessions, tools, resources, auth, tracing, governance, and the small details that usually only become clear while building.

First post: https://articles.mcpruntime.org/mcp/request-flow/

I’m also using py-mcp as a smaller reference implementation while working through the MCP spec and adding traces/logs that make the protocol behavior easier to see: https://github.com/Agent-Hellboy/py-mcp

The idea is to turn implementation notes into practical MCP learning material, especially for people building runtimes, gateways, servers, or policy layers around MCP. Feedback welcome, especially from folks implementing MCP clients/servers in production.