The most useful MCPs in production are Filesystem, Memory, and a database MCP (SQLite or PostgreSQL). Filesystem gives Claude read/write access to local files; Memory solves the "starting fresh every session" problem; a database MCP turns Claude into a live data analyst. Stack all three and you have the foundation of a real agent workflow, not just a chat session.
MCP — the Model Context Protocol — is an open standard introduced by Anthropic that lets Claude connect to external tools, data sources, and services in a structured, secure way. [1] Instead of copy-pasting data into a conversation or building custom API wrappers from scratch, you attach an MCP server and Claude can read files, query databases, browse the web, or call APIs — all inside the same reasoning loop. [2]
The architectural implication is significant: Claude stops being a chat interface and starts behaving like an agent. The difference between a Claude instance with the right MCPs and one without is like the difference between a talented analyst with no data access and one sitting in front of a live dashboard, your CRM, and a browser. Every MCP you add is a new capability layer. This question came up in a recent r/ClaudeAI thread, and the practitioner answers there — along with my own experience building production agents — are what this page is based on.
If you're new to the broader MCP ecosystem, this roundup of MCP servers practitioners actually use is a good place to orient yourself before going deeper.
---The MCPs worth running in production are the ones that hold up under real workloads, not just demos. Here is an honest breakdown from hands-on use building Buddy, an open-source Google Ads agent built on Claude.
Filesystem MCP gives Claude read and write access to directories on your local machine or server. It sounds mundane, but it is foundational — almost every agent workflow eventually needs to read an input file or write an output file.
In practice, Filesystem MCP handles:
/projects/claude-workspace — rather than your root. This keeps file access auditable and prevents accidental overwrites outside the intended scope.Claude's context window is large but finite, and every new session starts blank. Memory MCP solves this by giving Claude a structured external memory — typically a local knowledge graph of entities, relationships, and observations — that it reads from and writes to across sessions.
For ongoing account management or agency work, this is transformative. Claude can remember that a specific client has brand-safety restrictions, that a campaign has a history of performance issues in certain geos, or that you prefer a specific reporting format — without you restating it every time.
Database MCPs let Claude write and execute SQL queries against a live database. You can point Claude at a SQLite file containing campaign performance data, describe what you're trying to understand in plain English, and it will write the queries, execute them, interpret the results, and surface the "so what" — not just a table of numbers.
Browser MCPs (Puppeteer and Playwright are the most common) let Claude control a headless browser: navigate URLs, extract page content, fill forms, and take screenshots. Playwright generally handles dynamic JavaScript-heavy sites and single-page applications better than Puppeteer, so if you've tried browser MCPs and found them struggling with SPAs, switching to a Playwright-based server is often the fix.
Real use cases beyond demos:
The tradeoff: browser MCPs are slower and more resource-intensive than pure API calls. For research and audit workflows where you'd otherwise spend two to three hours manually, they are a significant multiplier. For sub-500ms response requirements, they are the wrong tool.
Fetch MCP lets Claude make direct HTTP requests to external APIs and parse the responses. This is useful when you want Claude to pull live data without building a full custom MCP server. In advertising workflows, it can hit a REST API endpoint, parse JSON, and fold the results into its reasoning — for example, pulling Google Ads API reports with auth tokens handled outside Claude, or hitting webhook endpoints to trigger downstream automation from within a session.
GitHub MCP gives Claude access to repositories: read files, create branches, open pull requests, and search code. If you're building or maintaining AI agents — or any non-trivial automation codebase — this collapses a lot of iterative friction. Claude can review its own prior code before generating additions (which dramatically reduces contradictions between modules), search for existing functions before writing new ones, and pull open issues as task context. For more on this specific setup, see how Claude, MCP, and GitHub work together.
Individual MCPs are useful, but stacking two or three together is where agent-level workflows become possible. The table below maps combinations to practical use cases.
| MCP Combination | What It Enables | Practical Use Case |
|---|---|---|
| Filesystem + SQLite | Read raw data, analyze with SQL, write reports | Automated campaign performance analysis from CSV exports |
| Browser + Filesystem | Scrape web data, save structured results | Competitor ad copy audit saved to a working file |
| Fetch + Memory | Pull live API data, retain context across sessions | Weekly account check-ins with persistent client history |
| GitHub + Filesystem | Read codebase, write files, push changes | AI-assisted agent development with full code context |
| All five | Full autonomous agent: memory, data, code, and web | End-to-end campaign monitoring and reporting agent |
There is a consistent gap between MCPs people know about and MCPs people actually deploy. Three that are worth evaluating sooner than most practitioners do:
If your team runs on Slack, this MCP lets Claude read channel history, post messages, and search conversations. For marketing teams it opens up workflows like: Claude monitoring a client-feedback channel, summarizing it weekly, and drafting a response. It also means Claude can push alerts or summaries to Slack without you manually copying outputs from a chat window.
Most marketing and advertising teams live in spreadsheets. MCPs that connect Claude directly to Google Sheets or Airtable let it read live data from planning docs, budget trackers, or content calendars — and write results back in a format the broader team can use without touching any code.
If you've tried browser MCPs and found them breaking on JavaScript-heavy or asynchronously loaded pages, switching to a Playwright-based server is usually the fix. It handles modern SPAs more reliably and is the better default for new browser automation setups.
---MCPs add capability, but they also add real constraints that matter in production deployments.
If you're running MCPs inside Claude Code specifically, this guide to setting up MCP servers in Claude Code covers the setup nuances that catch most people.
---Not for the most common servers. Filesystem, SQLite, and Memory MCPs have straightforward setup processes and are documented clearly. Browser and GitHub MCPs require a bit more configuration — installing Node.js dependencies and setting auth tokens — but are well within reach for a technically comfortable non-developer following a step-by-step guide.
Technically, there is no hard cap on how many MCP servers you can run simultaneously. Practically, each active MCP adds latency and context overhead. Most production workflows run two to four MCPs concurrently. Running all available MCPs at once without a clear reason for each one is counterproductive and will slow down your sessions noticeably.
Claude's mobile app has begun adding MCP support, though the experience and available servers differ from the desktop Claude app. For production agent workflows that depend on local filesystem access or database connections, desktop or server deployments remain the more reliable environment. Mobile MCP support is an evolving area worth monitoring.
Yes. Claude Code is a command-line coding agent with its own built-in tool access (bash, file editing, web search). MCP is a protocol that any Claude integration — including Claude Code — can use to connect additional external services. They are complementary, not competing approaches. MCP extends what Claude can reach; Claude Code is a specific deployment context that can itself use MCPs.
Yes, and this is one of the most valuable things an advanced practitioner can do. Anthropic's MCP specification is open and well-documented, and community-built servers already cover dozens of platforms. [1] If your stack includes a proprietary internal tool or a niche ad platform without an existing server, building a lightweight custom MCP is often faster than any other integration approach.
MCP tool calls and their responses consume context window space just like text does. Returning large database tables or full web pages through an MCP can fill your window quickly. The mitigation is to use MCP tools to query specific, scoped slices of data rather than pulling everything in at once — treat it like a SELECT with a WHERE clause, not a SELECT *.
More answers in this topic: Claude & Anthropic