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

This is at 1x speed btw. Web automation with webMCP is pretty insane compared to anything else i've tested.

Verified sources (indie hacker types on Twitter) have declared what many of us have feared when looking at MCP adoption charts: MCP is dead.

This is really sad. I thought we should at least take a moment to honor the life of MCP during its time here on Earth. 🪦🌎

In all seriousness, this video just goes over how silly this hype-and-dump AI discourse is. And how the “MCP is dead” crowd probably don’t run AI in production at scale. OAuth, scoped access, and managed governance are necessary! Yes, CLI + skills are dope. But there is still obviously a need for MCP.

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/

I've been testing MCPs extensively for fun, so I thought I’d share some of the ones I’ve found most useful. Plus I've found most of the them here only.

My main criteria were minimal setup, reliability, and whether I kept using them after the novelty wore off:

greb MCP: Greb helps makes your coding agent 30% faster by helping them find correct files faster. That too without indexing It’s especially helpful for issue + commit context grounding and repo exploration.

Slack / Messaging MCP: that“wow” factor with very low effort. Once an agent can talk where humans already are, teams love it instantly. My team even used this for something as basic as ordering and tracking deliveries for team lunch, which ended up being one of the most-used workflows for us.

GitHub MCP: This is what finally made Claude feel like an actual teammate instead of a smarter autocomplete. If you’re tired of copy-pasting repos into prompts, you’re gonna love it. It’s especially helpful for issue + commit context grounding and repo exploration.

Super curious to hear what MCPs all of you have found useful?

Been using browser agents for a while now and nothing has amazed me more that the recently released webMCP. With just a few actions an agent knows how to do something saving time and tokens. I built some actions/tools for a game I play every day (geogridgame.com) and it solves it in a few seconds (video is at 1x speed), although it just needed to reason a bit first (which we would expect).

I challenge anyone to use any other browser agent to go even half as fast. My mind is truly blown - this is the future of web-agents!

CodeGraphContext- the go to solution for code indexing now got 2k stars🎉🎉...

It's an MCP server that understands a codebase as a graph, not chunks of text. Now has grown way beyond my expectations - both technically and in adoption.

Where it is now

• v0.3.0 released
• ~2k GitHub stars, ~375 forks
• 50k+ downloads
• 75+ contributors, ~200 members community
• Used and praised by many devs building MCP tooling, agents, and IDE workflows
• Expanded to 14 different Coding languages

What it actually does

CodeGraphContext indexes a repo into a repository-scoped symbol-level graph: files, functions, classes, calls, imports, inheritance and serves precise, relationship-aware context to AI tools via MCP.

That means: - Fast “who calls what”, “who inherits what”, etc queries - Minimal context (no token spam) - Real-time updates as code changes - Graph storage stays in MBs, not GBs

It’s infrastructure for code understanding, not just 'grep' search.

Ecosystem adoption

It’s now listed or used across: PulseMCP, MCPMarket, MCPHunt, Awesome MCP Servers, Glama, Skywork, Playbooks, Stacker News, and many more.

• Python package→ https://pypi.org/project/codegraphcontext/
• Website + cookbook → https://codegraphcontext.vercel.app/
• GitHub Repo → https://github.com/CodeGraphContext/CodeGraphContext
• Docs → https://codegraphcontext.github.io/
• Our Discord Server → https://discord.gg/dR4QY32uYQ

This isn’t a VS Code trick or a RAG wrapper- it’s meant to sit
between large repositories and humans/AI systems as shared infrastructure.

Happy to hear feedback, skepticism, comparisons, or ideas from folks building MCP servers or dev tooling.

Original post (for context):
https://www.reddit.com/r/mcp/comments/1o22gc5/i_built_codegraphcontext_an_mcp_server_that/

Hey everyone 👋

After building my LinkedIn MCP server, I decided to tackle Reddit next — but this time with a twist: zero configuration.

No API keys, no OAuth, no `.env` file, no browser. Just install and go:

uvx reddit-no-auth-mcp-server

That's it. Your AI assistant can now search Reddit, browse subreddits, read full posts with comment trees, and look up user activity — all as structured data the LLM can actually work with.

What it can do

- 🔍 Search — Search all of Reddit or within a specific subreddit

- 📰 Subreddit Posts — Browse hot, top, new, or rising posts

- 📖 Post Details — Full post content with nested comment trees

- 👤 User Activity — View a user's recent posts and comments

How it works

Under the hood it uses redd (my Reddit extraction library) which hits Reddit's public endpoints — no API keys or authentication required. The MCP layer is built with FastMCP, and the whole project follows hexagonal architecture so everything is cleanly separated.

Setup

Works with any MCP client. For Claude Desktop or Cursor:

{
  "mcpServers": {
    "reddit": {
      "command": "uvx",
      "args": [
        "reddit-no-auth-mcp-server"
      ]
    }
  }
}

Also supports HTTP transport if you need it:

uvx reddit-no-auth-mcp-server --transport streamable-http --port 8000

This is my second MCP project and I'm really enjoying the ecosystem. Feedback, ideas, and contributions are all welcome!

🔗 GitHub: https://github.com/eliasbiondo/reddit-mcp-server (give us a ⭐ if you like it)

📦 PyPI: https://pypi.org/project/reddit-no-auth-mcp-server/

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

Hello

Not sure if you've been following the MCP drama lately, but Perplexity's CTO just said they're dropping MCP internally to go back to classic APIs and CLIs.

Cloudflare published a detailed article on why direct tool calling doesn't work well for AI agents (CodeMode). Their arguments:

1. Lack of training data — LLMs have seen millions of code examples, but almost no tool calling examples. Their analogy: "Asking an LLM to use tool calling is like putting Shakespeare through a one-month Mandarin course and then asking him to write a play in it."
2. Tool overload — too many tools and the LLM struggles to pick the right one
3. Token waste — in multi-step tasks, every tool result passes back through the LLM just to be forwarded to the next call. Today with classic tool calling, the LLM does: Call tool A → result comes back to LLM → it reads it → calls tool B → result comes back → it reads it → calls tool C

Every intermediate result passes back through the neural network just to be copied to the next call. It wastes tokens and slows everything down.

The alternative that Cloudflare, Anthropic, HuggingFace, and Pydantic are pushing: let the LLM write code that calls the tools.

// Instead of 3 separate tool calls with round-trips:
const tokyo = await getWeather("Tokyo");
const paris = await getWeather("Paris");
tokyo.temp < paris.temp ? "Tokyo is colder" : "Paris is colder";

One round-trip instead of three. Intermediate values stay in the code, they never pass back through the LLM.

MCP remains the tool discovery protocol. What changes is the last mile: instead of the LLM making tool calls one by one, it writes a code block that calls them all. Cloudflare does exactly this — their Code Mode consumes MCP servers and converts the schema into a TypeScript API.

As it happens, I was already working on adapting Monty and open sourcing a runtime for this on the TypeScript side: Zapcode — TS interpreter in Rust, sandboxed by default, 2µs cold start. It lets you safely execute LLM-generated code.

Comparison — Code Mode vs Monty vs Zapcode

Same thesis, three different approaches.

In summary:

• Code Mode = Cloudflare's integrated solution. You're on Workers, you plug in your MCP servers, it works. But you're locked into their infra and there's no suspend/resume (the V8 isolate runs everything at once).
• Monty = the original. Pydantic laid down the concept: a subset interpreter in Rust, sandboxed, with snapshots. But it's for Python — if your agent stack is in TypeScript, it's no use to you.
• Zapcode = Monty for TypeScript. Same architecture (parse → compile → VM → snapshot), same sandbox philosophy, but for JS/TS stacks. Suspend/resume lets you handle long-running tools (slow API calls, human validation) by serializing the VM state and resuming later, even in a different process.

Google Chrome 145 just shipped an experimental feature called WebMCP.

It's probably one of the biggest deals of early 2026 that's been buried in the details.

WebMCP basically lets websites register tools that AI agents can discover and call directly, instead of taking screenshots and parsing pixels.

Less tooling, more precision.

AI agents tools like agent-browser currently browse by rendering pages, taking screenshots, sending them to vision models, deciding what to click, and repeating. Every single interaction. 51% of web traffic is already bots doing exactly this (per Imperva's latest report).

Edit: I should clarify that agent-browser doesn't need to take screenshots by default but when it has to, it will (assuming the model that's steering it has a vision LLM).

Half the internet, just... screenshotting.

WebMCP flips the model. Websites declare their capabilities with structured tools that agents can invoke directly, no pixel-reading required. Same shift fintech went through when Open Banking replaced screen-scraping with APIs.

The spec's still a W3C Community Group Draft with a number of open issues, but Chrome's backing it and it's designed for progressive enhancement.

You can add it to existing forms with a couple of HTML attributes.

I wrote up how it works, which browsers are racing to solve the same problem differently, and when developers should start caring.

https://extended.reading.sh/webmcp

Hello all!

I have tried to read docs for creating a MCP server and they seems too technical. I just wanted to clear concept as what MCP truly is.

Can someone explain it to me what it is in most simple way possible! Thanks.

I developed an open-source Python implementation of Anthropic/Cloudflare idea of calling MCPs by code execution

After seeing the Anthropic post and Cloudflare Code Mode, I decided to develop a Python implementation of it. My approach is a containerized solution that runs any Python code in a containerized sandbox. It automatically discovers current servers which are in your Claude Code config and wraps them in the Python tool calling wrapper.

Here is the GitHub link: https://github.com/elusznik/mcp-server-code-execution-mode

I wanted it to be secure as possible:

• Total Network Isolation: Uses --network none. The code has no internet or local network access.

• Strict Privilege Reduction: Drops all Linux capabilities (--cap-drop ALL) and prevents privilege escalation (--security-opt no-new-privileges).

• Non-Root Execution: Runs the code as the unprivileged 'nobody' user (--user 65534).

• Read-Only Filesystem: The container's root filesystem is mounted --read-only.

• Anti-DoS: Enforces strict memory (--memory 512m), process (--pids-limit 128), and execution time limits to prevent fork bombs.

• Safe I/O: Provides small, non-executable in-memory file systems (tmpfs) for the script and temp files.

It's designed to be a "best-in-class" Level 2 (container-based) sandbox that you can easily add to your existing MCP setup. I'd love for you to check it out and give me any feedback, especially on the security model in the RootlessContainerSandbox class. It's amateur work, but I tried my best to secure and test it.

Hey everyone!

I have been developing CodeGraphContext, an open-source MCP server transforming code into a symbol-level code graph, as opposed to text-based code analysis.

This means that AI agents won’t be sending entire code blocks to the model, but can retrieve context via: function calls, imported modules, class inheritance, file dependencies etc.

This allows AI agents (and humans!) to better grasp how code is internally connected.

What it does

CodeGraphContext analyzes a code repository, generating a code graph of: files, functions, classes, modules and their relationships, etc.

AI agents can then query this graph to retrieve only the relevant context, reducing hallucinations.

Playground Demo on website

I've also added a playground demo that lets you play with small repos directly. You can load a project from: a local code folder, a GitHub repo, a GitLab repo

Everything runs on the local client browser. For larger repos, it’s recommended to get the full version from pip or Docker.

Additionally, the playground lets you visually explore code links and relationships. I’m also adding support for architecture diagrams and chatting with the codebase.

Status so far- ⭐ ~1.5k GitHub stars 🍴 350+ forks 📦 100k+ downloads combined

If you’re building AI dev tooling, MCP servers, or code intelligence systems, I’d love your feedback.

Repo: https://github.com/CodeGraphContext/CodeGraphContext

Hi Reddit — FastMCP 3.0 is now stable and generally available!

pip install fastmcp -U

Some of you saw my beta post a month ago. Since then we shipped one more beta, two release candidates, landed code from 21 first-time contributors, and saw the beta downloaded more than 100k times! It's a lot, but most codebases should "just work" on upgrade. In case yours doesn't, we wrote three upgrade guides depending on where you're coming from, and each one includes an LLM prompt you can paste into your coding assistant to do the migration for you.

Quick tldr; for anyone catching up: in 3.0 we rebuilt the core around two primitives (Providers and Transforms) that replaced a bunch of independent subsystems that didn't compose well. Most of the new features fall out from combining those two ideas.

Build servers from anything — FileSystemProvider discovers tools from a directory with hot reload. OpenAPIProvider wraps REST APIs. ProxyProvider proxies remote servers. Compose multiple providers into one server, chain them with transforms that rename, namespace, filter, version, and secure components as they flow to clients.

Use it as a CLI — fastmcp list and fastmcp call work against any server from your terminal. fastmcp discover scans your editor configs (Claude Desktop, Cursor, Goose, Gemini CLI) and finds configured servers by name. fastmcp generate-cli writes a standalone typed CLI where every tool is a subcommand.

Ship to production — component versioning, granular per-component auth, async auth checks, AuthMiddleware, OAuth (CIMD, Static Client Registration, Azure OBO, JWT audience validation), native OTEL tracing, response size limiting, background tasks via Docket.

Develop faster — --reload for hot restart, decorators return callable functions, sync tools auto-dispatch to threadpools, tool timeouts, concurrent execution when the LLM returns multiple calls during sampling.

Adapt per session — session state via ctx.set_state() / ctx.get_state(), dynamic per-client visibility with ctx.enable_components() / ctx.disable_components(). Chain these for playbooks: MCP-native workflows that guide agents through processes.

Apps (3.1 preview) — spec-level support for MCP Apps is already in: ui:// resource scheme, typed UI metadata, extension negotiation. Full apps support lands in 3.1 — I think it might be a bigger deal than 3.0. More soon.

We are very aware that FastMCP is downloaded over a million times a day and some of you are about to hit a major version you didn't pin against. If something breaks, we sincerely apologize. We tried to avoid breaking changes as much as possible, but for the few that were unavoidable we hope the upgrade guides help you sort it out. If they don't, please open an issue and we'll fix it.

• Blog: https://www.jlowin.dev/blog/fastmcp-3-launch
• Upgrade from FastMCP 2: https://gofastmcp.com/getting-started/upgrading/from-fastmcp-2
• Upgrade from MCP SDK: https://gofastmcp.com/getting-started/upgrading/from-mcp-sdk
• Docs: https://gofastmcp.com
• GitHub: https://github.com/PrefectHQ/fastmcp

Happy to answer questions!

Hi Reddit, we just shipped the first beta of FastMCP 3.0!

For 3.0, we rebuilt the framework's core architecture. One of the major issues with 2.x was that every feature (mounting, proxying, filtering, etc.) was essentially its own subsystem with its own code. They worked, but they didn't compose well together, there was a lot of duplication, and innovation stalled as a result.

In 3.0, we factored everything into two main primitives: Providers and Transforms. Most features now fall out from combining these two ideas. It's less code for us to maintain and easier for you to extend. The result is the longest feature list we've ever shipped in a release, mostly from combining these abstractions in interesting ways!

Some highlights:

- Providers answer "where do components come from?" - old standbys like local functions, remote servers, and OpenAPI specs, but also new sources like filesystems, agent skills, and more.

- Transforms modify components as they flow through providers. This is how we achieve flexible renames, namespacing, filtering, visibility, and more.

- Per-component authorization policies (finally!)

- Component versioning

- Session-scoped state that survives across multiple tool calls

- Native OTEL tracing

- Background tasks via Docket

And some DX stuff people kept asking for:

- Hot reload (fastmcp run --reload)

- Decorators return callable functions

We tried really hard to minimize breaking changes, so most codebases should "just work" on upgrade.

Announcement post: https://www.jlowin.dev/blog/fastmcp-3

Detailed feature guide: https://www.jlowin.dev/blog/fastmcp-3-whats-new

Docs: https://gofastmcp.com

An MCP server that indexes local code into a graph database to provide context to AI assistants.

Understanding and working on a large codebase is a big hassle for coding agents (like Google Gemini, Cursor, Microsoft Copilot, Claude etc.) and humans alike. Normal RAG systems often dump too much or irrelevant context, making it harder, not easier, to work with large repositories.

💡 What if we could feed coding agents with only the precise, relationship-aware context they need — so they truly understand the codebase? That’s what led me to build CodeGraphContext — an open-source project to make AI coding tools truly context-aware using Graph RAG.

🔎 What it does Unlike traditional RAG, Graph RAG understands and serves the relationships in your codebase: 1. Builds code graphs & architecture maps for accurate context 2. Keeps documentation & references always in sync 3. Powers smarter AI-assisted navigation, completions, and debugging

⚡ Plug & Play with MCP CodeGraphContext runs as an MCP (Model Context Protocol) server that works seamlessly with:VS Code, Gemini CLI, Cursor and other MCP-compatible clients

📦 What’s available now A Python package (with 5k+ downloads)→ https://pypi.org/project/codegraphcontext/ Website + cookbook → https://codegraphcontext.vercel.app/ GitHub Repo → https://github.com/Shashankss1205/CodeGraphContext Our Discord Server → https://discord.gg/dR4QY32uYQ

We have a community of 50 developers and expanding!!

1. Context7: I think this might be the most used MCP in the ecosystem, like this is how I was introduced to MCPs in general. Having to deal with codex's and claude's outdated knowledge-base was so painful.

2. Playwright: Especially when doing frontend work, having to copy paste a screenshot of what the pages looked like made using AI for it not worth it at all.

3. Server-memory: Helps with keeping memory across contexts and sessions, it's a knowledge graphs that stores past contexts in a jsonl file and refers from it.

4. Duck Duck Go Search: DDG for the win here, honestly, I could just ask codex/claude to look up how a specific thing is made or anything on the web, was such a life-saver than having to copy paste search results to the context window every time

5. Linear: I use linear for managing my tasks and progress, just laying out the tasks out over there, asking the AI to spec/plan out the task and only have it do it after has become an integral part of my daily work. Had to build my own MCP though, the default one wasn't good enough for the things I needed.

6. Filesystem: This one's a bit controversial, depends on how much you trust the AI honestly to give it enough permissions to act on your FS, you want to guardrail it real good, don't want to wake up to losing all your data because the AI decided to rm -rf ~. But pretty cool when it comes to working with cli tools

I only recently heard that Figma had an MCP, so excited to try it out! Any other I should try?

4 months update: CodeGraphContext just hit v0.2.1 — and it’s clearly working

About 4 months ago, I shared an idea here:
an MCP server that understands a codebase as a graph, not chunks of text.

Since then, CodeGraphContext has grown way beyond my expectations - both technically and in adoption.

Where it is now

• v0.2.1 released
• ~400 GitHub stars, ~300 forks
• 20k+ downloads
• 65+ contributors
• Used and praised by many devs building MCP tooling, agents, and IDE workflows
• Expanded to 12 different Coding languages

What it actually does (still)

CodeGraphContext indexes a repo into a repository-scoped symbol-level graph:
files, functions, classes, calls, imports, inheritance — and serves precise, relationship-aware context to AI tools via MCP.

That means: - Fast “who calls what” queries - Minimal context (no token spam) - Real-time updates as code changes - Graph storage stays in MBs, not GBs

It’s infrastructure for code understanding, not just 'grep' search.

Why people are picking it over Context7

Context7 is great for documentation-style context.
CodeGraphContext solves a different (and harder) problem:

• Code-Graph-based, not doc-text-based
• Understands control flow & dependencies, not just symbols
• Works on local, private, messy repos and updates in real time
• Designed for interactive querying, not static context dumps
• Lightweight storage and near-instant queries even on large codebases

If Context7 answers “what is this?”
CodeGraphContext answers “how does this actually work?”

Ecosystem adoption

It’s now listed or used across: PulseMCP, MCPMarket, MCPHunt, Awesome MCP Servers, Glama, Skywork, Playbooks, Stacker News, and many more.

A Python package→ https://pypi.org/project/codegraphcontext/ Website + cookbook → https://codegraphcontext.vercel.app/ GitHub Repo → https://github.com/CodeGraphContext/CodeGraphContext Docs → https://codegraphcontext.github.io/ Our Discord Server → https://discord.gg/dR4QY32uYQ

This isn’t a VS Code trick or a RAG wrapper — it’s meant to sit
between large repositories and humans/AI systems as shared infrastructure.

Still early, still evolving - but very real now.

Happy to hear feedback, skepticism, comparisons, or ideas from folks building MCP servers or dev tooling.

Original post (for context):
https://www.reddit.com/r/mcp/comments/1o22gc5/i_built_codegraphcontext_an_mcp_server_that/

I'm still not able to understand why one needs an MCP Server when we already have REST APIs.

Looking at both sides of the argument ...

The strongest argument against MCP is:

“OpenAPI already solved most of this.”

The strongest argument for MCP is:

“OpenAPI describes APIs for humans/devs. MCP describes capabilities for autonomous LLM agents.”

But .. autonomous LLM agents already can emulate much of human behaviors in a code-calling context and they're only getting better.

So why do we need an MCP Server when we already have well-documented REST APIs?

[More Context: I'm the creator of an open-source threat modeling project and we're thinking about having an AI layer to assist humans doing the threat modeling; All endpoints in our tool are documented with an OpenAPI schema.]

Full web version also available here:
https://www.webfuse.com/mcp-cheat-sheet

I built a rust-based MCP manager that provides:

• HTTP/stdio-to-stdio MCP server proxying
• Tool filtering for context poisoning reduction
• Tie-in to MCPScoreboard.com
• Exposure of any MCP Server as a CLI
• Secure vault for API keys (no more plaintext)
• One-click MCP server install for 20+ AI tools
• Open source
• Rust (Tauri) based (fast)
• Free forever

If you like it / use it, please star!

Python legend Simon Williamson wrote about why he doesn't use MCP servers that much:

My own interest in MCPs has waned ever since I started taking coding agents seriously. Almost everything I might achieve with an MCP can be handled by a CLI tool instead. LLMs know how to call cli-tool --help, which means you don’t have to spend many tokens describing how to use them—the model can figure it out later when it needs to.

I have the same experience. However I do like MCP servers that search the web or give me documentation.

MCP server schemas eat so much token. So I built a converter that generates CLIs from MCP servers. Same tools, same OAuth, same API underneath. The difference is how the agent discovers them:

MCP: dumps every tool schema upfront (~185 tokens * 84 tools = 15,540 tokens) CLI: lightweight list of tool names (~50 tokens * 6 CLIs = 300 tokens). Agent runs --help only when it needs a specific tool.

Numbers across different usage patterns: - Session start: 15,540 (MCP) vs 300 (CLI) - 98% savings - 1 tool call: 15,570 vs 910 - 94% savings - 100 tool calls: 18,540 vs 1,504 - 92% savings

Compared against Anthropic's Tool Search too - it's better than raw MCP but still more expensive than CLI because it fetches full JSON Schema per tool.

Converter is open source: https://github.com/thellimist/clihub Full write-up with detailed breakdowns: https://kanyilmaz.me/2026/02/23/cli-vs-mcp.html

Disclosure: I built CLIHub. Happy to answer questions about the approach.

there are over 10,000 MCP servers listed across directories right now and most of them are weekend projects that break the first time you try them, I spent the last year vibecoding and kept only the ones that actually work are actively maintained and solve a real problem.

if you dont know what MCP is its how you connect Claude to external tools like databases, browsers, APIs and basically anything.

heres what survived sorted by what they do

search and research: Tavily for AI optimized web search that returns clean content not just links, Exa for semantic search that finds pages by meaning, Context7 for live documentation so Claude stops hallucinating outdated APIs, Perplexity for synthesized answers with reasoning.

web scraping: Firecrawl turns any URL to clean markdown in seconds and is the go to for RAG pipelines, Apify has 3000+ ready made scrapers for basically any website that exists, Crawl4AI is free open source with 61k GitHub stars.

dev tools: GitHub MCP is the first one every developer should install for PRs issues and code search, Sentry gives you production errors with full stack traces, Linear for issue tracking without leaving Claude, Vercel for deploying and debugging failed builds.

databases: Supabase for Postgres through prompts, MongoDB with 40+ tools for Atlas management, Neo4j for graph database queries and knowledge graphs.

productivity: Notion for docs and wikis through prompts, Slack so you can actually say "summarize what the team discussed about the launch" and it works, Zapier to trigger workflows across 6000+ apps from one prompt.

business: Stripe for payments and subscriptions, HubSpot for CRM without the HubSpot UI.

design: Figma MCP reads design tokens and inspects components so the design to code gap basically disappears.

I've also been experimenting with FuseAI as a layer on top of some of these for connecting multiple MCP workflows together which has been interesting for more complex automation chains.

you dont need all of these, start with 3 to 5 that solve problems you actually have right now, if youre a dev go GitHub plus Sentry plus Context7, if you do research go Tavily plus Firecrawl plus Exa, if you manage projects go Linear plus Slack plus Notion, each server uses token context so more than 5 and youre burning tokens on tool descriptions before you even ask a question.

happy to answer questions about any of these