If you use modern AI tools for more than five minutes, you bump into MCP. It stands for Model Context Protocol, and it is basically a standard way for AI apps to talk to tools, APIs, and data sources without a pile of custom glue code.

In this post, we will walk through:

What MCP servers and clients actually are
How Drupal fits in through Drupal MCP
How to find from thousands of servers already out there
How to pick good ones, with an eye on token efficiency
How to install them in Claude Desktop, Claude Code, Cursor, and ChatGPT

All in normal human language.

Quick recap: MCP, servers, and clients

At a high level, MCP defines a common way for AI tools to:

Discover what a system can do
Call tools and read resources in a structured way
Reuse the same integrations from multiple clients

The official docs describe it as a protocol for connecting LLM apps with external tools and data, similar to having a standard USB-C port for your AI stack.

The pieces look like this:

MCP server
A small program that wraps a system, such as a filesystem, CMS, database, or SaaS API, and exposes:
- Resources (things to read)
- Tools (things to do)
- Prompts (reusable prompt templates)
MCP client
The host app that connects to servers and lets the model use them. Examples:

Once you understand that split, everything else is just configuration and taste.

There really are tens of thousands of MCP servers

If you feel like MCP servers are everywhere now, you are not wrong.

A few public directories alone list thousands of servers:

PulseMCP tracks over six thousand servers and is updated daily.
MCP Market curates servers that connect apps like Claude and Cursor to tools such as Figma, Databricks, and Storybook.
mcpservers.org is an “awesome list” style directory of official and community servers.
mcp.so is a community-driven directory with tags, FAQs, and remote server listings.
mcpservers.com and MCP Server Directory add more curated lists on top.
The official MCP servers repo collects reference and community servers from across GitHub.

When you add all of that together with the long tail of GitHub projects and private internal servers, it is entirely reasonable to say there are tens of thousands of MCP servers and variants you can install or fork today. The problem is no longer “are there servers,” it is “which ones are worth my time.”

Filesystem servers, plus a nice upgrade for Windows

The classic Filesystem MCP server

The original Filesystem MCP server for Claude Desktop gives the model structured tools to:

List directories
Read files
Write and update files
Move things around inside a sandboxed root

This is what lets you say things like:

“Refactor the React components in src/components to share a layout,”

and let the model discover the files and apply the changes directly, without you dragging and dropping code.

Filesystem Plus: especially nice on Windows

If you are on Windows, the stock filesystem extension can struggle with UNC paths and mapped network drives. A MCP server built by Shawn McNeece, Filesystem Plus extension is a drop-in replacement that focuses on better Windows support and safer file operations.

Filesystem Plus adds:

Support for drive roots and UNC paths that the original extension has trouble with
Granular permissions with read-only directories instead of “all or nothing” access
Performance tweaks that help reduce how much content needs to be streamed or re-read, which in turn helps with token usage

For cross-drive or network-heavy setups, especially with large monorepos on mapped shares, this can make Claude feel a lot less “I tried, but I timed out again.”

Drupal MCP: turning Drupal into an AI-friendly backend

If your world involves Drupal, there is a very nice story evolving around Drupal MCP.

Drupal as an MCP server

The main Drupal MCP module on drupal.org turns a Drupal 10 or 11 site into an MCP-capable endpoint. Once installed with Composer, Drupal can expose content and actions to clients like Claude Desktop and Cursor through both STDIO and HTTP SSE transports.

The companion site drupalmcp.io explains the architecture and gives you recipes for:

Exposing nodes, users, and other entities as resources
Exposing operations such as “create content,” “update fields,” or “run custom workflows” as tools
Controlling which bundles, fields, and operations are visible to AI agents

Recent releases added:

A streaming HTTP version that lets Drupal itself act as a full MCP server
A plugin system so you can ship your own “MCP plugins” to expose new capabilities
Sub modules for nodes, AI function calling, and more advanced configuration options

Companion servers and dev-focused tools

On top of the core module, there are several Drupal-focused MCP servers and tools:

mcp-server-drupal is a TypeScript companion server for the Drupal MCP module, useful when you want an STDIO server for clients that prefer that transport.
Drupal FastMCP uses FastMCP to provide AI-powered tools for generating Drupal code.
drupal-tools-mcp and drupal-modules-mcp focus on module discovery and development workflows.

Put this together, and your Drupal site becomes an AI-ready backend:

Claude can audit and edit content across nodes
Cursor can introspect Drupal APIs while you code
Custom agents can orchestrate multi-step workflows that touch Drupal as just one of several MCP servers

Many servers, similar features, very different behavior

Once you browse a few directories, you will notice something:

There are often multiple servers for the same system.

Examples:

Several GitHub servers, with different tradeoffs in how they fetch and summarize data
Multiple web scraping servers, some that pull raw HTML, others that do heavy preprocessing
Variants of the filesystem, like the official extension and Filesystem Plus

This is where evaluation matters. Two servers can claim to “do the same thing,” but differ a lot in:

Token efficiency
- Some servers stream entire documents every time.
- Others chunk, cache, or summarize to keep context much leaner.
- Directories such as PulseMCP and MCP Market often highlight how a server behaves.
Read vs write behavior
- Some are read-only by design.
- Others can create, update, and delete resources.
- For sensitive systems, prefer read-only first and add write tools slowly.
Authentication model
- Does it use API keys, OAuth, or local credentials?
- Does it store secrets locally or rely on the client to inject them?
Safety and scoping
- Can you limit which projects, directories, or entities it can see?
- For Drupal, this might mean scoping to a particular site, environment, or bundle.
Documentation and maintenance
- Check the README, last commit date, and issue activity on GitHub or the directory listing.
- The official MCP servers repo and curated lists like mcpservers.org are a good starting point here.

You will almost always want to try two or three servers for a given task, then stick with the one that feels best in your actual workflow.

Installing MCP servers in common clients

Let us walk through how to actually use these servers in the tools you likely have open already.

Claude Desktop

Claude Desktop supports MCP through “desktop extensions” and connectors.

For local and custom servers:

Install the MCP server (for example, clone a repo and run a Node or Python process, or use a packaged .mcpb extension).
In Claude Desktop, go to Settings → Extensions.
Under Advanced settings, use Install extension and select the extension file, or follow the local MCP server guide.

For non-technical users, Anthropic also has a Connectors Directory inside Claude that lets you install prebuilt connectors to tools like Google Drive or Slack without touching config files.

Once installed, Claude will list available tools and resources for each server in the right side panel so you can see what it is about to call.

Claude Code

Claude Code uses a .mcp.json configuration file to define servers that are available in your coding workspace.

Highlights:

You can define local or remote MCP servers and share configs with your team.
Environment variable expansion lets you keep secrets out of version control while still sharing the same .mcp.json.
Recent updates added built-in support for remote MCP servers with OAuth, so you can connect to hosted services without manually managing API keys.

If you are building Drupal projects, this is a great place to add your Drupal MCP server alongside filesystem and CI servers so Claude Code can see both your code and your live content.

Cursor

Cursor leans heavily into MCP for “connect my IDE to everything.”

The main ways to configure servers:

Use the Cursor MCP docs to understand how the client discovers tools and context.
Configure global servers in ~/.cursor/mcp.json.
Configure project-specific servers in .cursor/mcp.json within your repo.

That mcp.json file is where you point Cursor at things like:

The official filesystem server or Filesystem Plus
A Drupal MCP server for your staging site
Project-specific tools such as observability backends or CI services

Cursor also supports terminal-style commands and variable interpolation from within MCP configs, which makes it very flexible, but also something to treat with the same care as any automation that can run shell commands.

ChatGPT (Developer Mode and connectors)

OpenAI has added full MCP support to ChatGPT through Developer Mode and connectors.

Two key places to look:

The official “Building MCP servers” docs show how to build servers that work with ChatGPT connectors, Deep Research, and the API.
The Developer Mode and full MCP connectors guide explains availability, how to enable Developer Mode for Business and Enterprise workspaces, and how admins can control who can use which connectors.

From a user perspective, once Developer Mode is enabled for your workspace, you can:

Create or install MCP connectors in ChatGPT
Configure them to talk to servers such as Drupal MCP, GitHub, or internal APIs
Use those tools directly in ChatGPT chats, similar to how you would in Claude Desktop or Cursor

This means you can have the same Drupal or filesystem servers wired into multiple AI frontends and pick whichever interface you prefer for a given task.

A simple way to evaluate new servers

Whenever you find a promising MCP server in a directory, I like to put it through a quick checklist:

Read the README and examples
- Look for clear explanations, input examples, and limits.
- Bonus points if it links to official MCP docs or client-specific guides.
Check maintenance signals
- Recent commits or releases.
- Issues getting responded to.
Start in read-only mode
- Especially for filesystem, Git, and CMS servers.
- For Drupal, begin with content listing and read operations only.
Watch token usage
- Use the client’s token inspector, where available.
- Prefer servers that chunk or stream data rather than dumping entire datasets into context every time.
Test on a scratch environment
- For Drupal, that means staging or a local site.
- For file-based workflows, a small test repo before you point it at your main monorepo.

It takes a little time up front, but once you have a short list of reliable servers for your stack, you can reuse that configuration across Claude, Cursor, ChatGPT, and other clients.

For more reading

If you want to dig deeper, here are some solid starting points:

Official MCP resources
- Model Context Protocol GitHub org
- MCP official docs and examples
Drupal MCP
Clients and configuration
MCP server discovery

Once you wire up a few MCP servers that match your stack, the whole experience shifts from “copy paste between ten tabs” to “tell the AI what you want and let the servers handle the plumbing.” That is when it starts to feel fun.

#Claude

PostsBlog Posts (2)

What is an MCP server and how does it work?

How to Configure Drupal MCP with Claude Desktop