DEV Community: quickpromptco

Claude Code’s WebFetch Can’t Run JavaScript: Firecrawl MCP Gives It Real Web Scraping in 1 Command (No API Key)

quickpromptco — Fri, 09 Oct 2026 14:19:42 +0000

You ask Claude Code to pull the plans from a pricing page, and it hands back a vague summary instead of the table. Its built-in WebFetch doesn’t run JavaScript, and the agent gets a processed summary rather than the page itself. JS-rendered docs, pricing tables, and “read these 30 pages and compare them” jobs are where it falls apart.

Firecrawl MCP fixes that with one command. It gives the agent a proper web toolkit (~7.5k GitHub stars, maintained by the Firecrawl team). It can search the web, scrape any URL into clean markdown or JSON, map every URL on a site, crawl whole doc sections, and parse PDFs. The part most guides miss is that there’s now a hosted keyless endpoint. Search, scrape, and parse work with no API key, no account, and no Node.js install.

Only need library docs? Our Context7 MCP setup is the better tool for that. Firecrawl is for everything else on the web.

Quick Start

One command. No API key, no Node.js:

claude mcp add --transport http --scope user firecrawl https://mcp.firecrawl.dev/v2/mcp

Restart Claude Code, then ask: “Use Firecrawl to scrape https://docs.firecrawl.dev and summarize it”. Total time: about 1 minute.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Skip the manual steps below and hand the whole job to the agent instead:

You have shell access and the `claude mcp` CLI on this machine. Set up the Firecrawl MCP server (hosted, keyless) and report back. Do not tell me it's done unless step 4 actually confirms it:

1. Run `claude mcp list`. If a server named firecrawl already exists, stop and tell me how it's configured instead of adding a second one.
2. Add the hosted keyless server (no API key, no Node.js needed):
   `claude mcp add --transport http --scope user firecrawl https://mcp.firecrawl.dev/v2/mcp`
3. Run `claude mcp list` again and confirm firecrawl shows as Connected.
4. Tell me to restart Claude Code, then after restart use firecrawl_scrape on https://docs.firecrawl.dev and show me the first 10 lines of the markdown it returns.

Never ask me to paste an API key into this chat. If I want the full tool set later, I'll switch to the sign-in URL myself.
If any step fails, give me the exact error and the command that produced it. Do not skip ahead.

The prompt deliberately keeps your API key out of the chat. Firecrawl’s own docs say never to put a key in an agent conversation. The sign-in URL in Step 3 below gets you the full tool set without ever handling a key.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Provides the `claude mcp` command used to register the server	0 min
Nothing else (keyless)	The hosted endpoint runs on Firecrawl’s servers. Search, scrape, and parse are free, rate-limited per IP per day	0 min
Free Firecrawl account (optional)	Unlocks crawl, map, agent, and the rest of the tools. The free plan includes 1,000 credits, no card	~2 min
Node.js 22+ (local mode only)	Only if you run the server on your own machine or point it at a self-hosted Firecrawl	0–3 min

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version.

Step 1 — Add the keyless server

~1 min

--scope user makes it available in every project:

claude mcp add --transport http --scope user firecrawl https://mcp.firecrawl.dev/v2/mcp

This is Firecrawl’s documented Claude Code command with --scope user added. Keyless mode exposes three tools: firecrawl_search, firecrawl_scrape, and firecrawl_parse.

Real run, October 2026, no API key: the keyless endpoint connects straight away.

Step 2 — Restart and run a first test

~1 min

Restart Claude Code so it loads the new tools, then try:

Search the web for the latest Firecrawl release notes and summarize the sources.

That’s Firecrawl’s own suggested first prompt. You should see firecrawl_search in the tool calls.

Step 3 — Unlock the full tool set with sign-in (optional)

~2 min

Crawl, map, agent, and the other tools need an account. The easiest route is browser sign-in, with no API key to copy. Remove the keyless entry first, since Firecrawl’s docs say not to add a second Firecrawl server:

claude mcp remove firecrawl

claude mcp add --transport http --scope user firecrawl https://mcp.firecrawl.dev/v2/mcp-oauth

Then run /mcp inside Claude Code and complete the sign-in in your browser. You can review or revoke the connection later in Firecrawl’s MCP settings.

Step 4 — Or run it locally with an API key (optional)

~3 min

Use this if you’d rather run the open-source server yourself, or point it at a self-hosted Firecrawl via FIRECRAWL_API_URL. It needs Node.js 22+ and a key from your Firecrawl dashboard. Type the key into your terminal, not into a chat:

claude mcp add firecrawl --scope user -e FIRECRAWL_API_KEY=fc-YOUR_API_KEY -- npx -y firecrawl-mcp

Windows:

claude mcp add firecrawl --scope user -e FIRECRAWL_API_KEY=fc-YOUR_API_KEY -- cmd /c npx -y firecrawl-mcp

Running n8n? Start the server with HTTP_STREAMABLE_SERVER=true and point n8n’s MCP client at http://localhost:3000/mcp.

Firecrawl renders JavaScript pages and hands Claude Code clean text, not raw HTML.

What Each Piece Does

Tool	What the Agent Uses It For	Keyless?
`firecrawl_search`	Web search with ranked results, optionally fetching page content in the same call	Yes
`firecrawl_scrape`	One known URL → clean markdown, or JSON matching a schema you give it	Yes
`firecrawl_parse`	PDFs, Word docs, spreadsheets, HTML files → markdown or JSON	Yes
`firecrawl_map`	List every URL on a site without fetching content, which is handy before a crawl	No
`firecrawl_crawl`	Pull content from many pages under a site, bounded by limit and include/exclude paths	No
`firecrawl_interact`	Click, type, or navigate on a page before reading it	No
`firecrawl_agent`	Autonomous multi-source research that returns structured data	No
`firecrawl_monitor_*`	Check the same page on a schedule and get diffs when it changes	No
`firecrawl_credit_usage`	Check remaining credits and monthly consumption	No

With sign-in or an API key, the full profile registers 26 tools, including developer search over GitHub issues and PRs, research-paper search, and crawl/agent status checks. The table covers the ones you’ll actually reach for.

Verify It’s Actually Working

claude mcp list

✔ firecrawl    https://mcp.firecrawl.dev/v2/mcp (HTTP) – Connected

! firecrawl    Needs authentication → sign-in URL: run /mcp and finish the browser sign-in

✘ firecrawl    429 Too Many Requests → keyless daily limit hit; sign in or add a key

“Connected” only confirms the server answered. The real test is a page WebFetch struggles with, such as a JavaScript-heavy page:

Use firecrawl_scrape on [A JS-HEAVY PAGE, e.g. a pricing page] and give me the exact plan names and prices as a markdown table. Quote them verbatim from the scraped content, don't summarize.

If the tool calls show firecrawl_scrape and the table matches what you see in your browser, it’s working end to end.

Common Mistakes to Avoid

Opening the MCP URL in a browser. https://mcp.firecrawl.dev/v2/mcp is a server endpoint for your MCP client, not a web page. Sign-in happens through /mcp in Claude Code.
Pasting your API key into the chat. Firecrawl’s docs are explicit: never put a key in an agent conversation or in the server URL. Use browser sign-in, or pass it with -e / -H in your own terminal.
Adding a second Firecrawl entry to “upgrade”. Remove the keyless server before adding the sign-in one, or Claude Code ends up with duplicate tools.
Expecting crawl or map on keyless. Keyless is limited to search, scrape, and parse. If firecrawl_crawl is missing, that’s why, not a broken install.
Crawling without a limit. Every page costs credits. Run firecrawl_map first, then crawl with limit and includePaths set so a docs crawl doesn’t eat your whole free allowance.

Q&A

Is it really free without an API key?

Yes. The hosted keyless endpoint offers search, scrape, and parse for free, capped per IP address per day by both a request limit and a credit limit. Past that you get a 429. A free account adds 1,000 credits and the full tool set.

How is this different from Claude Code’s built-in WebFetch?

WebFetch fetches a single URL and hands the agent a processed summary. It doesn’t run JavaScript. Firecrawl renders the page and returns the actual content as markdown or structured JSON. It can also search, map, and crawl many pages, which WebFetch can’t.

Do I need Node.js?

Not for the hosted endpoint. Node.js 22+ is only needed if you run firecrawl-mcp locally, for example against a self-hosted Firecrawl.

Can I use it in n8n?

Yes. Run the server locally with HTTP_STREAMABLE_SERVER=true and connect n8n to http://localhost:3000/mcp. curl http://localhost:3000/health should return ok.

How do I remove it?

claude mcp remove firecrawl. If you used sign-in, also revoke the connection in Firecrawl’s MCP settings.

Official Resources

Firecrawl MCP Server on GitHub — source, full tool reference, changelog
Firecrawl MCP docs — keyless, sign-in, and API-key setup
Run Firecrawl MCP locally — stdio, Streamable HTTP, self-hosted API
Rate limits — keyless allowance and plan limits
Claude Code MCP Documentation — the claude mcp command reference

Originally published at quickpromptco.com, where the guide is kept up to date.

Chrome DevTools MCP for Claude Code: Let It Read the Console, Network, and Performance (2-Minute Setup)

quickpromptco — Thu, 08 Oct 2026 13:28:06 +0000

The page is broken, and you’re the middleman: open DevTools, copy the red console error, paste it into Claude Code, go back for the failed network request, paste again, then explain the layout shift in words. Claude Code can read your source, but it’s debugging blind and guessing from whatever you remembered to copy.

Chrome DevTools MCP takes you out of that loop. It’s the official server from the Chrome DevTools team (~52k GitHub stars), and setup is one command. The agent opens a real Chrome, then reads console messages (with source-mapped stack traces), inspects network requests, records performance traces, runs Lighthouse audits, and takes heap snapshots. It then fixes the code based on what it actually saw.

Already using our Playwright MCP setup? The two are complementary. Playwright is built for driving the browser through flows. DevTools MCP is built for finding out why a page is broken or slow.

Quick Start

One command (needs Node.js LTS and Chrome):

claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest

Restart Claude Code, then ask: “Check the performance of https://developers.chrome.com”. Chrome should open and record a trace. Total time: about 2 minutes.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Skip the manual steps below and hand the whole job to the agent instead:

You have shell access and the `claude mcp` CLI on this machine. Set up the Chrome DevTools MCP server and report back. Do not tell me it's done unless step 5 actually confirms it:

1. Check `node --version`. It needs a current Node.js LTS (20.19+ or 22.12+). If Node is missing or older, install the current LTS using whatever this machine already uses (nvm, Homebrew, winget, or the official installer from nodejs.org), then confirm `node --version` and `npx --version` work in this shell.
2. Confirm Google Chrome (stable) is installed. If it isn't, stop and tell me. Don't substitute another browser.
3. Run `claude mcp list` to see what's already configured.
4. Add the server:
   - macOS / Linux: `claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest`
   - Windows: `claude mcp add chrome-devtools --scope user -- cmd /c npx -y chrome-devtools-mcp@latest`
5. Run `claude mcp list` again and confirm chrome-devtools shows as Connected.

If any step fails, give me the exact error and the command that produced it. Do not skip ahead.

The agent checks Node first because an outdated Node version is the most common reason npx servers fail to start. Step 1 handles that before anything else.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Provides the `claude mcp` command used to register the server	0 min
Node.js LTS (20.19+ or 22.12+)	The server runs through `npx`; the package requires these versions	0–3 min
Google Chrome (stable)	Officially supported browser. Other Chromium browsers may work but aren’t guaranteed	0 min
No API key	Everything runs locally against your own Chrome	0 min

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version.

Step 1 — Check Node.js

~1 min

node --version

You need 20.19+ or 22.12+ (or 23+). Older? Install the current LTS from nodejs.org or your version manager.

Step 2 — Add the server

~1 min

macOS / Linux. --scope user makes it available in every project:

claude mcp add chrome-devtools --scope user npx chrome-devtools-mcp@latest

Windows. The cmd /c wrapper avoids the “MCP error -32000: Connection closed” startup failure:

claude mcp add chrome-devtools --scope user -- cmd /c npx -y chrome-devtools-mcp@latest

Real run, October 2026, Windows 11, Node 24. Connected means the server started; Chrome itself only opens when a browser tool runs.

Step 3 — Or install it as a plugin (MCP + skills)

~2 min

The plugin version bundles the server with extra skills. If you already added it with the CLI in Step 2, remove that first (claude mcp remove chrome-devtools). Then, inside Claude Code:

/plugin marketplace add ChromeDevTools/chrome-devtools-mcp

/plugin install chrome-devtools-mcp@chrome-devtools-plugins

Restart Claude Code and check with /skills.

Step 4 — Restart and run a first test

~1 min

Chrome doesn’t open when the server connects. It opens the first time the agent uses a browser tool. Kick it off with:

Check the performance of https://developers.chrome.com

Step 5 — Pick a browser mode (optional)

~2 min

Flags go after chrome-devtools-mcp@latest. Re-add the server with the one you want (run claude mcp remove chrome-devtools first):

Throwaway profile, wiped when the browser closes:

claude mcp add chrome-devtools --scope user -- npx chrome-devtools-mcp@latest --isolated

No visible window:

claude mcp add chrome-devtools --scope user -- npx chrome-devtools-mcp@latest --headless

Your own running Chrome, handy for debugging pages behind a login. Needs Chrome 144+: open chrome://inspect/#remote-debugging, enable remote debugging, then:

claude mcp add chrome-devtools --scope user -- npx chrome-devtools-mcp@latest --autoConnect

Chrome shows a permission dialog the first time. Click Allow.

Claude Code reads the console, network requests, and performance traces itself.

What Each Piece Does

Tool Group (on by default)	What the Agent Can Do	Tools
Debugging	Read console messages with source-mapped stack traces, screenshots, DOM snapshots, CSS styles, run Lighthouse, evaluate JS	9
Network	List requests and inspect a single request’s headers, status, and body	2
Performance	Record a trace and pull out actionable insights (LCP, layout shifts, long tasks)	3
Memory	Take and compare heap snapshots, find retainers and duplicate strings when hunting leaks	14
Input + Navigation	Click, fill forms, type, upload files, open/switch tabs, wait for content	16
Emulation	Emulate devices/network conditions and resize the viewport	2

Extensions, PWA, WebMCP, and third-party tool groups also exist but are off by default. Each needs its own flag. See the tool reference below.

Flag	What It Does
`--isolated`	Uses a temporary profile that’s deleted when the browser closes
`--headless`	Runs Chrome with no visible window
`--autoConnect`	Attaches to the Chrome you already have open (Chrome 144+) instead of launching a new one
`--slim`	Exposes a reduced tool set for basic browser tasks
`--no-usage-statistics`	Opts out of Google’s usage statistics, which are on by default
`--no-performance-crux`	Stops trace URLs being sent to the CrUX API for real-user field data

Verify It’s Actually Working

claude mcp list

✔ chrome-devtools    Connected

! chrome-devtools    Connected, but Chrome never opens → normal until a browser tool runs

✘ chrome-devtools    MCP error -32000: Connection closed → Windows: use the cmd /c command

“Connected” only confirms the server started. The real test is a debugging task the agent can’t answer from your source code alone:

Open http://localhost:3000 (or [YOUR APP URL]) in Chrome. List any console errors and any network requests that returned 4xx/5xx, then tell me the most likely cause of each, citing the file and line from the stack trace.

If it comes back with real console output and request statuses (not guesses), it’s working end to end.

Common Mistakes to Avoid

Thinking it’s broken because Chrome didn’t open. The browser only launches when the agent calls a tool that needs it. Connecting alone never opens a window.
Skipping the cmd /c wrapper on Windows. Plain npx often fails to launch from inside another process on Windows. That’s the classic “Connection closed” error.
Installing both the CLI version and the plugin. The docs say to remove the CLI-installed server before installing the plugin, or you’ll have two copies fighting over the same browser profile.
Browsing sensitive accounts in the agent’s Chrome. The server exposes the browser’s content to your MCP client. With --autoConnect it can see every open window in that profile. Use --isolated when you don’t need your logins.
Not knowing what gets sent to Google. Usage statistics are on by default, and performance traces can send page URLs to the CrUX API. Add --no-usage-statistics and --no-performance-crux if that matters for your project.

Q&A

How is this different from Playwright MCP?

Playwright MCP is built for driving the browser through flows (click, fill, navigate) across browsers. Chrome DevTools MCP is Chrome-only but adds the DevTools side: performance traces, Lighthouse, network inspection, source-mapped console errors, and heap snapshots. Many people run both.

Is it free?

Yes. It’s open source from the Chrome DevTools team and runs locally. No API key or account needed.

Can it debug pages that need a login?

Yes. Use --autoConnect to attach to your own running Chrome (Chrome 144+, remote debugging enabled at chrome://inspect/#remote-debugging), so the agent works in your already-signed-in session.

Does it work with Edge or Brave?

Only Google Chrome and Chrome for Testing are officially supported. Other Chromium browsers may work, but that isn’t guaranteed.

How do I remove it?

claude mcp remove chrome-devtools. Its default browser profile lives in ~/.cache/chrome-devtools-mcp/ if you want to delete that too.

Official Resources

Chrome DevTools MCP on GitHub — source, changelog, issues
Tool reference — every tool and the flag that enables it
Configuration guide — all server flags
Troubleshooting — Windows, WSL, sandbox issues
Claude Code MCP Documentation — the claude mcp command reference

Originally published at quickpromptco.com, where the guide is kept up to date.

Serena MCP: IDE-Level Symbol Navigation for Claude Code (3 Commands, 40+ Languages)

quickpromptco — Wed, 07 Oct 2026 15:53:39 +0000

You ask Claude Code to change one function, and it greps for the name, opens a 900-line file, reads half of it, opens three more files, and your context window is gone before the first edit. Then the rename it does is a dozen fragile find-and-replace edits that still miss a call site.

Serena fixes that by giving the agent the tools your IDE already has. It can jump straight to a symbol, list every reference to it, rename it across the project, or replace one function body without reading the rest of the file. Under the hood it runs real language servers (LSP) for 40+ languages. It’s free and open source (by Oraios AI, ~30k GitHub stars, updated daily), and setup is three commands.

Quick Start

With uv installed, these three commands do the whole setup:

uv tool install -p 3.13 serena-agent
serena init
serena setup claude-code

Restart Claude Code and run /mcp. You should see serena listed. Total time: about 5 minutes.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Skip the manual steps below and hand the whole job to the agent instead:

You have shell access and the `claude mcp` CLI on this machine. Set up the Serena MCP server and report back. Do not tell me it's done unless step 5 actually confirms it:

1. Check `uv --version`. If uv is missing, install it with the official installer for my OS:
   - macOS / Linux: `curl -LsSf https://astral.sh/uv/install.sh | sh`
   - Windows (PowerShell): `powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"`
   The installer puts uv in `~/.local/bin`, which may not be on this shell's PATH yet. Add it for this session (or call uv by its full path), then confirm `uv --version` works before continuing.
2. Install Serena: `uv tool install -p 3.13 serena-agent`, then run `serena init`.
3. Register it with Claude Code: `serena setup claude-code`. If that fails, fall back to: `claude mcp add --scope user serena -- serena start-mcp-server --context claude-code --project-from-cwd`
4. From my project root, run `serena project health-check` and show me the output.
5. Run `claude mcp list` and confirm serena shows as Connected.

If any step fails, give me the exact error and the command that produced it. Do not skip ahead.

Step 4 is the important one. A health check proves the language server actually parses your code, not just that the config entry exists.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Provides the `claude mcp` command Serena registers itself with	0 min
`uv` (Python package manager)	Serena is installed and managed through uv; it’s the only hard prerequisite	~1 min
A real codebase	Serena shines on medium-to-large projects; on a 3-file script it adds little	0 min
Language-specific extras (sometimes)	A few languages need an extra toolchain for their language server; see Serena’s language support page	0–5 min

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version.

Step 1 — Install uv

~1 min

macOS / Linux:

curl -LsSf https://astral.sh/uv/install.sh | sh

Windows (PowerShell):

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Open a new terminal afterward so uv is on your PATH.

Step 2 — Install Serena

~2 min

The package is called serena-agent. The -p 3.13 flag pins the Python version uv uses for it:

uv tool install -p 3.13 serena-agent

When it finishes, the serena command should be available in your shell.

Step 3 — Initialise Serena

~1 min

Creates Serena’s global config and sets the free language-server backend as the default:

serena init

You should get a success message. (JetBrains users can run serena init -b JetBrains to use the paid IDE-plugin backend instead.)

Step 4 — Register it with Claude Code

~1 min

The one-command way:

serena setup claude-code

Or add it manually. Global (every project, Serena picks up whichever folder you launch Claude Code from):

claude mcp add --scope user serena -- serena start-mcp-server --context claude-code --project-from-cwd

Per-project (only the current repo):

claude mcp add serena -- serena start-mcp-server --context claude-code --project "$(pwd)"

Real run, October 2026, Windows 11, Serena 1.7.0. serena setup claude-code only runs the claude mcp add --scope user line it prints, so the manual command in Step 4 gives the same result.

Step 5 — Index a large project (optional)

~1–5 min

From the project root, pre-build the symbol cache so the first queries aren’t slow:

serena project index

Step 6 — Make Claude Code actually use it (recommended)

~2 min

Serena’s own docs flag this: Claude Code’s long built-in tool descriptions create a strong bias toward its native grep/read tools, so the agent often ignores Serena even when it’s connected. Serena ships a system-prompt override that counteracts that. Launch Claude Code with it (bash/zsh, or Git Bash on Windows):

claude --system-prompt="$(serena prompts print-cc-system-prompt-override)"

Step 7 — Add Serena’s reminder hooks (optional)

~2 min

For long sessions, Serena provides hooks that nudge the agent back to its symbolic tools, activate the project at session start, and auto-approve Serena calls in permissive modes. Add the hooks you want to ~/.claude/settings.json (global) or .claude/settings.json (project):

{
  "hooks": {
    "PreToolUse": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks remind --client=claude-code" }] },
      { "matcher": "mcp__serena__*", "hooks": [{ "type": "command", "command": "serena-hooks auto-approve --client=claude-code" }] }
    ],
    "SessionStart": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks activate --client=claude-code" }] }
    ],
    "SessionEnd": [
      { "matcher": "", "hooks": [{ "type": "command", "command": "serena-hooks cleanup --client=claude-code" }] }
    ]
  }
}

Serena labels hooks as an alpha feature. New to hooks? Our Claude Code hooks guide explains how PreToolUse and SessionStart work.

Serena lets Claude Code jump to the exact symbol instead of reading whole files.

What Each Piece Does

Piece	What It Does
`serena init`	Writes the global config and picks the analysis backend (free LSP by default)
`serena setup claude-code`	Registers the MCP server with Claude Code for you
`--context claude-code`	Loads a tool set tuned for Claude Code; basic file/shell tools it already has are switched off to avoid overlap
`--project-from-cwd`	Uses whatever directory you start Claude Code in as the active project
`serena project index`	Pre-caches symbols so lookups on big repos are fast from the first call
System-prompt override	Counteracts Claude Code’s bias toward its built-in tools so Serena actually gets used
`serena-hooks`	Optional reminder / activation / auto-approve hooks for long sessions

The tools the agent gets

Serena Tool	Replaces This Slow Pattern
`find_symbol`	Grepping for a function name and reading every match
`get_symbols_overview`	Opening a whole file just to see what’s defined in it
`find_referencing_symbols`	Searching text for call sites and hoping none were missed
`replace_symbol_body`	Line-number-based edits that break when the file shifts
`rename_symbol`	Find-and-replace across files (and accidentally renaming the wrong thing)
`insert_after_symbol` / `insert_before_symbol`	Guessing the right line to add a new method

Verify It’s Actually Working

claude mcp list

✔ serena    Connected

! serena    Timed out during startup → raise MCP_TIMEOUT (see mistakes below)

✘ serena    Failed to connect → usually serena not found on PATH

“Connected” only proves the server started. Check that the language server can read your code:

serena project health-check

Then give the agent a task that needs symbol-level understanding, and watch which tools it calls:

Activate the current project with Serena. Then use Serena's tools (not grep) to find every place that calls [A FUNCTION IN YOUR CODE] and summarize how each caller uses it.

If the tool calls show mcp__serena__find_symbol and find_referencing_symbols instead of Grep and Read, it’s working end to end.

Common Mistakes to Avoid

Installing it from an MCP or plugin marketplace. Serena’s README explicitly warns that marketplace listings carry outdated install commands. Use uv tool install as shown above.
Assuming “Connected” means “used”. Claude Code often keeps reaching for its built-in grep/read tools. Use the system-prompt override (Step 6) and, for long sessions, the hooks (Step 7).
Startup timeouts on big projects. If Serena doesn’t come up in time, raise the MCP timeout: export MCP_TIMEOUT=60000 in your shell profile (Windows: setx MCP_TIMEOUT 60000, then open a new terminal).
serena not found by Claude Code. Even when it works in your terminal, the client may not see it on PATH. Replace serena in the claude mcp add command with the full path (which serena on macOS/Linux, where serena on Windows).
Forgetting to activate the project with a global install. With --project-from-cwd, start Claude Code from the project root. Otherwise ask it to “activate the current directory as a project using Serena”.

Q&A

Is Serena free?

Yes. The default language-server backend is free and open source (GPL-3.0). There’s an optional paid JetBrains plugin backend (free trial) that adds extras like move/inline refactors and interactive debugging.

Which languages does it support?

40+ through language servers, including Python, TypeScript/JavaScript, Go, Rust, Java, C#, C/C++, PHP, Ruby, Kotlin, Swift, and more. A few need an extra toolchain installed; check the language support page.

Does it replace Claude Code’s built-in tools?

No, it adds to them. In the claude-code context, Serena turns off its own basic file/shell tools because Claude Code already has them, and focuses on symbol-level retrieval and editing.

Global or per-project install?

Global with --project-from-cwd is the simplest if you work across many repos. Per-project pins Serena to one folder and never switches.

How do I remove it?

claude mcp remove serena removes it from Claude Code, and uv tool uninstall serena-agent removes the package.

Official Resources

Serena on GitHub — source, README, issue tracker
Serena client setup docs — Claude Code, Codex, IDEs
Serena language support — per-language requirements
uv installation docs
Claude Code MCP Documentation — the claude mcp command reference

Originally published at quickpromptco.com, where the guide is kept up to date.

Anthropic’s Own Postgres MCP Server Is Archived and Has a Read-Only Bypass: 5 Database & Backend MCP Servers to Trust Instead (2026)

quickpromptco — Tue, 06 Oct 2026 12:56:50 +0000

You connect Claude Code to your database through the Postgres MCP server every list recommends, assuming read-only means read-only. That server is Anthropic’s own reference implementation, it’s archived, and it has a documented read-only bypass. The same lists rank a “1.7k-star” MongoDB integration above an official server that ships weekly.

We ran the same maintenance check from our first curation guide against the database and backend category. Two names got cut for being stale or unsafe; five made it through.

Quick Start

Install any of these with the Claude Code CLI. Swap in your own credentials before running.

claude mcp add supabase -- npx -y @supabase/mcp-server-supabase@latest --access-token=$SUPABASE_ACCESS_TOKEN
claude mcp add redis -- uvx --from git+https://github.com/redis/mcp-redis.git redis-mcp-server --url redis://localhost:6379/0
claude mcp add mongodb -- npx -y mongodb-mcp-server --connectionString="$MDB_URI"
claude mcp add postgres -- uvx postgres-mcp --access-mode=restricted "$DATABASE_URI"
claude mcp add clickhouse -- uvx mcp-clickhouse

⚡ Copy This Prompt

Paste this into Claude Code to let it install only what your stack actually uses:

I work with [Postgres / Supabase / Redis / MongoDB / ClickHouse -- name your stack].
Install only the matching MCP server(s) from this list, using the credentials I have
available in my environment variables. After installing, run one safe read-only
command through each server (e.g. list tables, list keys, or list databases) to
confirm the connection actually works. Tell me plainly if a connection or a
permission check fails -- don't guess or paper over an error.

What You’ll Need	Notes
Claude Code CLI installed	Any recent version supports `claude mcp add`
Connection string or access token per database	Never paste raw credentials into chat — use environment variables
`uv` / `uvx` installed	Required for the Redis, Postgres, and ClickHouse servers (Python-based)
Node.js + npm	Required for the Supabase and MongoDB servers (JS-based, run via `npx`)

1. Supabase MCP (supabase-community/supabase-mcp)

Official · ~2.6k stars

Supabase’s own team maintains this server, and it’s the one we’d point most readers to first — it covers the whole BaaS surface (Postgres tables, auth, storage, edge functions) through one connection instead of stitching together separate tools.

Why it made the cut: official repo, consistent commit cadence (roughly 20+ commits/month in recent audits), and it ranks near the top of every independent “best database MCP” comparison we checked.

Watch out for: by default it can run destructive operations against your project. Pass --read-only if you’re pointing it at anything other than a scratch/dev project.

2. Redis MCP (redis/mcp-redis)

Official · Redis Inc.

Smaller star count than the others on this list, but it’s the vendor’s own server, not a community reimplementation — and an unofficial alternative with more stars (GongRzhe/REDIS-MCP-Server) was archived in March 2026, which makes this the safer long-term pick despite the lower number.

Why it made the cut: actively released by Redis Inc. itself; covers strings, hashes, streams, and pub/sub through one consistent tool surface.

Watch out for: star count alone would make this look like the “unpopular” option. Don’t let that fool you — vendor backing matters more than stars for a cache/session-store integration you’re trusting with production data.

3. MongoDB MCP (mongodb-js/mongodb-mcp-server)

Official · GA · ~1,000 stars

MongoDB’s official server is now generally available, with 41+ tools spanning database operations, Atlas cluster management, and performance advisory — and it ships new releases roughly every 1-2 weeks.

Why it made the cut: vendor-official, GA status, and read-only mode plus environment-variable credentials are the security defaults, not an opt-in.

Watch out for: several older community MongoDB servers still show up in search results with similar names. If the repo isn’t under the mongodb-js or mongodb-developer org, you’re looking at an unofficial fork with a smaller maintenance team behind it.

4. Postgres MCP Pro (crystaldba/postgres-mcp)

Community · ~3.2k stars

This is the one with the asterisk. It’s the most popular general-purpose Postgres server, with index tuning, EXPLAIN plan analysis, and health checks built in — genuinely useful tools the official (now-archived) Anthropic server never had. But development has slowed: our check found roughly one commit in the last 12 weeks and a backlog of open issues, some unanswered since early 2025.

Why it made the cut anyway: “slower” is not “abandoned” — it’s still shipping, still the most feature-complete option, and it beats the alternative of using Anthropic’s archived reference server, which has a documented read-only bypass and receives no security patches at all.

Watch out for: if you need a strict read-only default for a production database, look at HenkDz/postgresql-mcp-server instead — smaller (~200 stars) but built specifically so writes, DDL, and arbitrary SQL all require an explicit opt-in flag.

5. ClickHouse MCP (ClickHouse/mcp-clickhouse)

Official · ~800 stars

The odd one out on most “top 5 database MCP” lists, and that’s exactly why it’s here — if your backend does analytics or event logging at scale, a transactional-database server won’t help you. ClickHouse’s own team maintains this one, distributed as a Docker Hub Verified Publisher image.

Why it made the cut: official, actively maintained, and it’s the only analytics-database option that passed our maintenance check — most of the community ClickHouse servers we found were single-author projects with no recent activity.

Watch out for: it expects ClickHouse-specific connection env vars (host, port, user, password) rather than a single connection-string argument like the others on this list.

Five maintained database servers, each connected with only the access it needs.

Verify Each One Actually Works

$ claude mcp list

✓ supabase — connected

✓ redis — connected

✓ mongodb — connected

✓ postgres — connected

✓ clickhouse — connected

Then ask Claude Code to run one read-only action through each — list tables, list keys, list databases — before you trust it with anything that writes.

Common Mistakes to Avoid

Judging by star count alone. Redis’s official server has a fraction of the stars of some abandoned forks. Vendor backing and commit recency matter more than the number.
Pointing a write-capable server at production on day one. Test every new MCP connection against a dev/staging database first.
Assuming “modelcontextprotocol/*” means officially supported. Anthropic archived 13 of its 20 original reference servers in 2025, including Postgres, SQLite, and Redis — those repos still run, but they get no security patches.
Skipping the read-only flag on Supabase. Without it, the server can alter schema and data in your connected project.

Q&A

Why is Postgres MCP Pro included if development slowed down?

Because “slower than ideal” still beats the alternative: Anthropic’s own reference Postgres server is archived and has a known read-only bypass vulnerability. If you need a stricter security posture, we also name a smaller alternative (HenkDz/postgresql-mcp-server) in that section.

Should I use the official or community server when both exist?

Default to official when the vendor maintains one — as with Redis, Supabase, MongoDB, and ClickHouse here. Community servers can still be worth using, but check commit recency first; we cover that process on our Methodology page.

Can I install more than one of these at once?

Yes — each runs as an independent MCP connection. If you use Playwright or GitHub MCP alongside these, see our Playwright MCP guide and GitHub MCP guide for the same install pattern.

Official Resources

Originally published at quickpromptco.com, where the guide is kept up to date.

Stop Installing Abandoned MCP Servers: 5 Community-Built Picks That Passed a 2026 Maintenance Check (and 2 Popular Ones That Failed)

quickpromptco — Mon, 05 Oct 2026 14:02:54 +0000

You install a popular MCP server, it breaks, and then you find out the repo was archived months ago. Most “top MCP servers” lists are just GitHub star counts copy-pasted into a listicle. That’s a bad filter. A popular Obsidian MCP project (jacksteamdev/obsidian-mcp-tools, 800+ stars) is now archived — read-only, no more fixes. Mem0’s own self-hosted MCP server (mem0ai/mem0-mcp) is archived — the README opens with a notice that it’s no longer maintained, and Mem0 now points users to its cloud-hosted server instead. Stars measure past hype, not whether a project still works.

We checked five servers instead of just ranking them: recent commit activity, how open issues get handled, and whether the practical claim (“free search,” “read-only by default”) actually holds up in the current version. These five passed.

Quick Start

Install all five with Claude Code’s CLI. Each is a separate claude mcp add call — run only the ones you actually need:

claude mcp add --transport stdio desktop-commander -- npx -y @wonderwhy-er/desktop-commander
claude mcp add --transport stdio n8n-mcp -- npx -y n8n-mcp
claude mcp add --transport stdio slack -- npx -y slack-mcp-server
claude mcp add --transport stdio duckduckgo -- uvx duckduckgo-mcp-server
claude mcp add --transport stdio mysql -- npx -y @benborla29/mcp-server-mysql

Restart Claude Code after adding — MCP connections load at session startup. Total time: about 5 minutes for all five, or under a minute each.

⚡ Copy This Prompt: Let Claude Code Pick and Verify the Right Ones For You

I want to install MCP servers from this list, but only the ones relevant to my actual workflow: Desktop Commander (terminal + filesystem control), n8n-mcp (build n8n workflows via natural language), Slack MCP (read/post to Slack), DuckDuckGo MCP (free web search, no API key), MySQL MCP (read-only database access).

1. Ask me which 1-3 of these match what I actually do day to day.
2. Run the "claude mcp add" command for only those.
3. After I restart, run one real action through each newly connected server (not just a connection check) and show me the output.
4. If any server fails to connect or the real-action test fails, tell me exactly what's wrong instead of saying it worked.

This matters because installing all five “just in case” is the exact mistake every 2026 MCP guide warns against — more servers means more standing access an agent can act through, and no one uses half of it.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	All five connect via `claude mcp add`	0 min
Node.js or `uv`/`uvx`	Each server ships as an npx or uvx package	~2 min if missing
Per-server credentials (Slack token, MySQL connection string)	Only Slack and MySQL need them — the other three need none	varies

The Five, One at a Time

1. Desktop Commander — terminal + filesystem control

~9.7k stars · MIT

github.com/wonderwhy-er/DesktopCommanderMCP

Gives Claude direct terminal control, file search, and diff-based file editing — the thing people actually reach for instead of chaining together separate read/write/bash tools.

claude mcp add --transport stdio desktop-commander -- npx -y @wonderwhy-er/desktop-commander

Why it made the cut: commit activity through September 2026, cross-platform (macOS/Windows/Linux), works with 15+ AI clients beyond Claude.

Watch out for: it’s terminal access — same blast-radius reasoning as giving Claude Code Bash. Don’t run it in a context you wouldn’t give shell access to.

2. n8n-mcp — build n8n workflows in natural language

~22.8k stars

github.com/czlonkowski/n8n-mcp

If you followed our n8n setup guide, this is the complementary piece: instead of clicking nodes together manually, you describe the workflow and Claude builds it in n8n directly.

claude mcp add --transport stdio n8n-mcp -- npx -y n8n-mcp

Why it made the cut: largest install base on this list by a wide margin, and the maintainer has published multiple security advisories (GHSA) in 2026 — a sign of active review, not neglect.

Watch out for: solo-maintained project; the author has been open that maintaining it competes with paid work, so response times on issues can be slow.

3. Slack MCP Server — the community server that replaced the official one

~1.8k stars

github.com/korotovsky/slack-mcp-server

Anthropic’s own reference Slack server was retired to an archive repo in 2026. If you want Slack in your agent today, this is the de facto replacement, not an official one.

claude mcp add --transport stdio slack -- npx -y slack-mcp-server

Why it made the cut: it’s the specific project the official docs now point to, with active 2026 development.

Watch out for: you’re trusting a community maintainer with a Slack token — scope that token’s permissions down before connecting.

4. DuckDuckGo MCP Server — free web search, no API key

~1.4k stars

github.com/nickclyde/duckduckgo-mcp-server

Every other search MCP wants a paid API key (Brave, Google, Bing). This one doesn’t — it’s DuckDuckGo search plus page-content fetching, free.

claude mcp add --transport stdio duckduckgo -- uvx duckduckgo-mcp-server

Why it made the cut: concrete proof of active maintenance — DuckDuckGo started fingerprint-blocking the default HTTP client in mid-2026, and the maintainer shipped a fallback within the same release cycle. That’s the difference between “still maintained” and “still has a green checkmark on npm.”

Watch out for: free tier of a scraped search engine — expect occasional rate-limiting under heavy use, not an SLA.

5. MySQL MCP Server — read-only by default

~1.7k stars

github.com/benborla/mcp-server-mysql

Lets Claude inspect schemas and run queries against a real MySQL database. The reason it’s on this list instead of a dozen equivalents: writes are opt-in via an explicit env flag, not the default.

claude mcp add --transport stdio mysql -- npx -y @benborla29/mcp-server-mysql

Why it made the cut: the safe-by-default design is the right call for a database an agent can reach — you have to deliberately turn on write access.

Watch out for: last major commit was March 2026 — still maintained, but slower-moving than the others on this list. Fine for read-only schema inspection; verify current behavior before enabling writes in production.

Five community servers passed the maintenance check. Two popular ones didn’t.

Verify Each One Actually Works

Connection status isn’t proof. Run one real action through each:

✔ desktop-commander    ran ls in project root, got real output

✔ n8n-mcp    listed existing workflows from a live n8n instance

✔ slack    posted a test message to a private test channel

✔ duckduckgo    searched a query, got real result URLs back

✔ mysql    ran SHOW TABLES against a real (non-production) schema

If a server shows “connected” in claude mcp list but fails on a real action, the connection succeeded and the tool call is what’s broken — usually a missing credential or a stale cached version.

Common Mistakes to Avoid

Installing all five because the list exists. Every 2026 MCP guide converges on the same warning: more connected servers means more standing access, most of it idle. Install what matches your actual workflow.
Trusting star count alone. A popular Obsidian MCP project with 800+ stars is archived, and its star badge looks exactly the same as before. Check the commit date, not just the badge.
Assuming “official” beats “community.” Slack’s official server is gone; the community one is now the standard. Vendor-backed isn’t always current.
Skipping the credential scoping step. Slack and MySQL both need real credentials — scope them to the minimum before connecting, not after.

Q&A

Why isn’t Playwright, GitHub, or Context7 MCP on this list?

They already have their own dedicated setup guides — see Playwright MCP, GitHub MCP, and Context7 MCP.

What got excluded and why?

A popular Obsidian MCP project (jacksteamdev/obsidian-mcp-tools, archived) and Mem0’s self-hosted MCP server (archived in favor of Mem0’s hosted version) both looked like obvious picks by star count and both failed the maintenance check.

Is a solo-maintained project (n8n-mcp, Slack MCP) too risky to depend on?

It’s a real tradeoff, not a dealbreaker — check for recent commits and how issues get triaged before depending on any single-maintainer tool, the same way you’d vet any dependency.

Official Resources

Originally published at quickpromptco.com, where the guide is kept up to date.

Your Prompt Rules Are Just Suggestions: Claude Code Hooks Auto-Format Every Edit and Block Dangerous Commands (2-Minute Setup)

quickpromptco — Sun, 04 Oct 2026 13:28:27 +0000

You told Claude Code “always run the formatter after editing” and “never run rm -rf”. It listened, until it didn’t. A rule in a prompt is a request — it can be forgotten, skipped, or missed after a context compaction.

A hook is not a request. It’s a shell command that runs automatically at a specific point in the agent’s workflow, and it can actually block an action before it happens. This guide covers real, practical hook setups you can have running in about 2 minutes, not just the concept.

Quick Start

The single most useful starter hook: auto-format every file Claude Code edits, so formatting is never something you have to ask for. Add this to .claude/settings.json in your project root:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          { "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write" }
        ]
      }
    ]
  }
}

Save the file. Claude Code watches its settings files and picks up the hook in the running session (run /hooks to confirm it’s listed). The hook reads the edited file’s path from the JSON Claude Code sends on stdin, so it needs jq installed. Every file Claude writes or edits now gets auto-formatted, no reminder needed. Total time: about 2 minutes.

⚡ Copy This Prompt: Let Claude Code Write and Verify the Hook For You

Skip the manual JSON editing and hand the whole thing to the agent instead:

Add a PostToolUse hook to this project's .claude/settings.json that runs [DESCRIBE WHAT YOU WANT, e.g. "prettier --write on every file the Write or Edit tool touches" or "eslint on every .ts file after it's edited"]. Then do the following to prove it actually works, not just that the JSON is valid:

1. Show me the exact hooks block you added.
2. Make a small test edit to a real file in this project.
3. Show me the hook actually ran (its output or the resulting file change) as a direct result of that edit.
4. If it didn't fire, tell me why (wrong matcher, wrong event, syntax error in settings.json) instead of claiming it worked.

This works because Claude Code can edit its own settings file, then immediately trigger the hook by making a real edit and checking the result — it verifies the hook fires, not just that the config parses.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Hooks are a built-in Claude Code feature — no extra install	0 min
A `.claude/settings.json` file	Where project-scoped hooks live; create it if it doesn’t exist yet	~1 min
The command your hook runs	A formatter, linter, or shell script already available on your system	varies

Step-by-Step Setup

Prefer to build your own hook from scratch instead of the starter above? Here’s how the pieces fit together.

Step 1 — Pick where the hook lives

~1 min

~/.claude/settings.json applies to every project on your machine. .claude/settings.json in a repo root is project-scoped and can be committed to git, so your whole team gets the same automation. Both levels combine rather than override — every matching hook from every scope runs.

Step 2 — Pick the event

~1 min

Two events cover most real use cases: PreToolUse runs before a tool executes and can block it; PostToolUse runs after and can only react. Use PreToolUse for guardrails, PostToolUse for automation like formatting or logging.

Step 3 — Write a blocking guardrail (PreToolUse)

~2 min

A hook script that inspects a Bash command and exits with code 2 blocks it before it runs. Matchers are case-sensitive tool names — Bash works, bash does not:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "/path/to/block-dangerous-commands.sh" }
        ]
      }
    ]
  }
}

Inside that script, checking stdin for a pattern like rm -rf and exiting 2 if found is enough to stop the tool call outright — exit code 1 or any other non-zero code is just logged as an error and doesn’t block anything.

Step 4 — Confirm it loaded

~1 min

Claude Code watches its settings files and applies hook edits to the running session. Run /hooks to confirm the hook is listed. If it isn’t there after a few seconds, check the JSON for trailing commas, then restart the session to force a reload.

Hooks run every time: tidy each edit, and stop the dangerous command before it runs.

What Each Piece Does

Piece	What It Does
`matcher`	Regex matched against the tool name (case-sensitive) — controls which tool calls trigger the hook
`PreToolUse`	Fires before a tool runs; exit code 2 blocks the call entirely
`PostToolUse`	Fires after a tool already ran; exit code 2 surfaces a blocking error to Claude, but the action already happened
`type: "command"`	Runs a shell command, receiving JSON context about the event on stdin
`timeout`	Optional field, in seconds — command hooks default to 10 minutes, so set a shorter one for anything that might hang

Verify a Hook Actually Fires

Config validity is not proof it works. Trigger the exact tool the matcher targets and confirm the side effect happened:

echo "test" >> some-file.txt && cat some-file.txt

✔ PostToolUse hook fired on Write    formatter output shown

✘ Hook did not fire    check matcher casing and event name

! Hook fired but silent    check the command’s own exit code and stderr

If nothing happens, check three things in order: the matcher’s exact casing, whether you restarted the session after editing settings.json, and whether the command itself runs correctly when you paste it into a terminal directly.

Common Mistakes to Avoid

Reading the file path from an environment variable. Claude Code passes the tool call as JSON on stdin; extract the path with jq -r '.tool_input.file_path'.
Wrong matcher casing. Tool names are case-sensitive: Write matches, write does not.
Expecting exit code 1 to block anything. Only exit code 2 blocks a PreToolUse call — any other non-zero code is just logged as an error while the tool still proceeds.
Assuming PostToolUse hooks run in order. Multiple hooks matching the same event run simultaneously, not sequentially — don’t rely on one finishing before another starts.
Forgetting subagents inherit hooks too. If Claude spawns a subagent via the Agent tool, your PreToolUse/PostToolUse hooks fire for every tool call the subagent makes as well.

Q&A

Can a hook actually stop Claude from running a command?

Yes — a PreToolUse hook that exits with code 2 blocks the tool call before it executes. This is the only way to get a hard guarantee, versus a prompt instruction the agent might not always follow.

What’s the difference between project and user scope?

User-level (~/.claude/settings.json) applies everywhere on your machine. Project-level (.claude/settings.json) is scoped to one repo and can be committed so your whole team shares the same automation. Both run together, not one-or-the-other.

Do hooks slow down every tool call?

Only for the tools their matcher targets, and only by however long the command takes — keep hook commands fast, and set an explicit timeout for anything that might run long.

Can I log every tool call without blocking anything?

Yes — a PostToolUse hook that just appends to a log file and always exits 0 records activity without affecting the agent’s behavior at all.

Where can I see all the available hook events?

The official reference at code.claude.com/docs/en/hooks lists the full set beyond PreToolUse/PostToolUse, including events for prompt submission and session lifecycle.

Official Resources

Claude Code Hooks Reference — full list of events, matchers, and exit code behavior
Claude Code Settings Documentation — where hooks fit into settings.json overall

Originally published at quickpromptco.com, where the guide is kept up to date.

Context7 MCP for Claude Code: Current, Version-Matched Docs Instead of Outdated API Code (2-Minute Setup)

quickpromptco — Sat, 03 Oct 2026 16:23:32 +0000

Claude Code writes the code with confidence, you run it, and it fails: the method was renamed a few versions ago, or the config flag no longer exists. It answers from training data by default, so library APIs, framework syntax, and CLI flags can be months or years out of date.

Context7 fixes that by fetching current, version-matched documentation for whatever library you’re actually using, on demand, instead of relying on what the model memorized during training. Setup takes about 2 minutes.

Quick Start

Connect the remote server (no local install needed):

claude mcp add --scope user --transport http context7 https://mcp.context7.com/mcp

Restart Claude Code, then ask something like “show me a FastAPI example with async endpoints” — if it’s working, the answer will reference current syntax instead of guessing. Total time: about 2 minutes.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Skip Steps 1-3 below and hand the whole thing to the agent instead:

You have access to the `claude mcp` CLI in this project. Do the following and report back — do not tell me it's done unless step 3 actually confirms it:

1. Run `claude mcp list` to see what's already configured.
2. Add Context7: `claude mcp add --scope user --transport http context7 https://mcp.context7.com/mcp`
3. Run `claude mcp list` again and confirm context7 shows as Connected.
4. Prove it works: use the context7 tools to look up current documentation for [NAME A LIBRARY YOU ACTUALLY USE, e.g. "Next.js" or "Prisma"] and summarize one recent API detail. If step 3 or 4 fails, tell me the exact error instead of reporting success.

This works because Claude Code can run its own CLI commands and then immediately use the newly connected server — so it proves it can actually pull fresh docs instead of just confirming the config exists.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Provides the `claude mcp` command used to register the server	0 min
Nothing else for basic use	The remote server works unauthenticated at low volume	0 min
A free API key (optional)	Removes rate limits and unlocks private-repo lookups — get one at context7.com/dashboard	~1 min

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version.

Step 1 — Add the remote server

~1 min

--scope user makes it available in every project on your machine, not just the current one:

claude mcp add --scope user --transport http context7 https://mcp.context7.com/mcp

Step 2 — Add an API key to raise the rate limit (optional)

~1 min

Get a free key at context7.com/dashboard, then pass it as a header on the same command:

claude mcp add --scope user --header "CONTEXT7_API_KEY: YOUR_API_KEY" --transport http context7 https://mcp.context7.com/mcp

Step 3 — Or run it locally via npx instead

~1 min

If you’d rather not send lookups to the hosted endpoint, run the same server as a local stdio process:

claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY

Step 4 — Restart and use it

~1 min

Run claude to start a fresh session, then just ask a normal question about a library — Context7 kicks in automatically when it’s relevant, no special syntax required.

Current, version-matched docs instead of whatever the model remembers.

What Each Piece Does

Piece	What It Does
Remote HTTP endpoint (`mcp.context7.com/mcp`)	Hosted server, no local process to keep running
`CONTEXT7_API_KEY` header	Raises your rate limit and enables private-repo documentation lookups
Local npx alternative	Same tools, self-hosted — useful if you can’t send traffic to the hosted endpoint
`--scope user`	Makes the server available in every project on your machine, not just one repo

Verify It’s Actually Pulling Fresh Docs

claude mcp list

✔ context7 Connected

✘ context7 Failed to connect

“Connected” only confirms the handshake. The real test is asking about a library you know has changed recently and checking the answer reflects that:

What's the current recommended way to set up middleware in [a framework you use]? Use Context7 to check current docs before answering, and tell me which version the docs you pulled are for.

If the answer cites a specific version and matches what’s actually in that library’s current docs (not what an older training cutoff would guess), it’s working end to end.

Common Mistakes to Avoid

Assuming it’s used automatically every time. Claude decides when a query needs current docs versus when its own knowledge is sufficient — if you want to force it, say “use Context7” explicitly in the prompt.
Hitting rate limits on the free unauthenticated tier. Add an API key (Step 2) if you’re using it heavily — it’s free and takes about a minute.
Confusing this with a general web search tool. It’s scoped to library/framework/API documentation, not general current events or arbitrary web content.
Not restarting after adding the server. Claude Code needs a fresh session or an /mcp panel refresh to pick up a newly added server.

Q&A

Do I need an API key to use it at all?

No — it works unauthenticated at low volume. A free key from context7.com/dashboard just raises the rate limit and adds private-repo access.

How is this different from just asking Claude directly?

Claude’s own knowledge has a training cutoff and can be wrong about recent API changes. Context7 fetches the library’s actual current documentation at query time, so the answer reflects what’s true right now, not what was true when the model was trained.

Does it work for any library?

It covers a large and growing index of popular libraries and frameworks. For very obscure or brand-new packages, coverage may be incomplete — in that case Claude falls back to its own knowledge.

Can I remove it later?

Yes — claude mcp remove context7 deletes it from the config.

Official Resources

Context7 Documentation — setup guides for every MCP client
Context7 Dashboard — create a free API key
Claude Code MCP Documentation — the claude mcp command reference

Originally published at quickpromptco.com, where the guide is kept up to date.

GitHub MCP Server for Claude Code: Direct Repo, PR, and CI Access in 3 Minutes

quickpromptco — Thu, 01 Oct 2026 12:02:23 +0000

A CI run fails, and you’re back to being the messenger: check which job failed, copy the details into Claude Code, then go fetch the issue it relates to and the PR that touched that file. Every piece of context has to pass through your clipboard.

The GitHub MCP server cuts that out. It gives Claude Code direct access to your repositories — issues, pull requests, commits, CI status, and code search. GitHub maintains an official remote server, so there’s nothing to build or run locally: you authenticate once with a personal access token and Claude Code talks to it over HTTP. Setup takes about 3 minutes, including creating the token.

Quick Start

Connect the official remote server with one command, once you have a token (see Step 1 below if you don’t have one yet):

claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer YOUR_GITHUB_PAT"

Restart Claude Code, then run /mcp to confirm it shows as connected. Total time: about 3 minutes, including creating the token.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Once you have a token, skip the manual steps below and hand the rest to the agent:

You have access to the `claude mcp` CLI in this project. Do the following and report back — do not tell me it's done unless step 3 actually confirms it:

1. Run `claude mcp list` to see what's already configured.
2. Add the GitHub MCP server: `claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer [MY GITHUB PAT]"` (I'll paste my actual token in place of the bracket).
3. Run `claude mcp list` again and confirm github shows as Connected.
4. Prove it works: list the open issues in this repository using the GitHub MCP tools. If step 3 or 4 fails, tell me the exact error and the most likely cause (bad token, missing scope, wrong URL) instead of reporting success.

This works because Claude Code can run its own claude mcp commands and then immediately call the newly connected server — so it proves real repo access instead of just confirming a config entry exists.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Provides the `claude mcp` command used to register the server	0 min
A GitHub personal access token (PAT)	Authenticates every request — the remote server has no browser-based OAuth login yet	~2 min
Repo access on that token	The token needs to actually see the repos you want Claude Code to work with	included above

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version.

Step 1 — Create a GitHub personal access token

~2 min

In GitHub, go to Settings → Developer settings → Personal access tokens → Fine-grained tokens, and generate one scoped to the specific repositories you want Claude Code to access (avoid granting it every repo on your account unless you actually need that).

Step 2 — Add the remote server

~1 min

Note the trailing slash on the URL — leaving it off is a common source of connection errors:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer YOUR_GITHUB_PAT"

Step 3 — Or run the local Docker version instead

~2 min

If you’d rather not send requests to GitHub’s hosted endpoint, GitHub also publishes an official Docker image you can run locally:

claude mcp add github -e GITHUB_PERSONAL_ACCESS_TOKEN=YOUR_GITHUB_PAT \
  -- docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server

The remote version above is faster to set up and updates automatically, so it’s the better default unless you have a specific reason to self-host.

Step 4 — Restart and approve

~1 min

Run claude to start a fresh session. Newly added servers need a restart (or the /mcp panel refresh) before Claude Code can see their tools.

Issues, pull requests, and CI status, read straight from GitHub.

What Each Piece Does

Piece	What It Does
Remote HTTP endpoint	GitHub-hosted server at `api.githubcopilot.com/mcp/` — no local process, always up to date
`Authorization: Bearer` header	Passes your PAT with every request — this is what scopes what Claude Code can actually see and do
Fine-grained token scope	Limits access to specific repos instead of your whole account — the safer default
Local Docker alternative	Same tools, but self-hosted — useful if you can’t send traffic to GitHub’s hosted endpoint

Verify the Connection

claude mcp list

✔ github    Connected

! github    Needs authentication

✘ github    Failed to connect

A “Connected” status only confirms the handshake, not that the token can actually see your repos. Confirm real access with an in-session prompt:

Using the GitHub MCP tools, list the 5 most recently updated issues in [owner/repo].

If it comes back with real issue titles instead of an auth or permissions error, the token and scope are both working.

Common Mistakes to Avoid

Dropping the trailing slash on the URL. /mcp without the final / is a frequent cause of connection failures on the remote endpoint.
Granting a classic token full account access. Use a fine-grained token scoped to only the repos Claude Code actually needs to touch.
Hardcoding the token directly in a committed .mcp.json. Keep it in an environment variable or add the server at user scope instead of project scope if the config would otherwise be shared.
Assuming “Connected” means full repo access. The handshake can succeed while the token still lacks scope for a specific repo — test with a real query, not just claude mcp list.
Not restarting after adding the server. Claude Code needs a fresh session or an /mcp panel refresh to pick up a newly added server.

Q&A

Can I use browser-based OAuth instead of a token?

Not yet for GitHub’s remote server — unlike some other MCP servers, it currently requires a personal access token rather than a one-click OAuth login inside Claude Code.

Should I use the remote server or the Docker version?

Remote is the better default — it’s faster to set up, needs no local process, and updates automatically. Use Docker only if you specifically can’t send traffic to GitHub’s hosted endpoint.

What can Claude Code actually do with this connected?

Read and search code, open and comment on issues and pull requests, check CI/workflow status, and browse commit history — scoped to whatever your token can access.

Why does it show “Needs authentication”?

Usually a missing, expired, or incorrectly scoped token. Regenerate it in GitHub settings and re-run the claude mcp add command with the new value.

Can I remove it later?

Yes — claude mcp remove github deletes it from the config.

Official Resources

github/github-mcp-server on GitHub — source and full installation docs
Official Claude Code Installation Guide — GitHub’s own setup instructions
Claude Code MCP Documentation — the claude mcp command reference

Originally published at quickpromptco.com, where the guide is kept up to date.

Playwright MCP for Claude Code: Let It Open a Real Browser and Click Through Flows (2-Minute Setup)

quickpromptco — Wed, 30 Sep 2026 12:35:42 +0000

You ask Claude Code why the signup flow breaks, and it can only guess from the source. So you open the page, click through it yourself, copy what you see, and describe it back in words. The agent is working from your summary, not the page.

Playwright MCP takes you out of that loop. It’s Microsoft’s official browser automation server: it lets Claude Code open a real browser, click through a page, read the actual rendered text, and fill in forms, using accessibility snapshots instead of pixel screenshots. It’s become one of the most-installed MCP servers because it turns “describe this page to me” from a guess into an actual read. Setup takes about 2 minutes.

Quick Start

Add it as a local stdio server — no separate install step, npx handles it on first run.

claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest

Restart Claude Code, then run /mcp inside a session to confirm it shows as connected. Total time: about 2 minutes.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Skip Steps 1-4 below and hand the whole thing to the agent instead:

You have access to the `claude mcp` CLI in this project. Do the following and report back — do not tell me it's done unless step 4 actually confirms it:

1. Run `claude mcp list` to see what's already configured.
2. Add the Playwright MCP server: `claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest`
3. Run `claude mcp list` again and confirm playwright shows as Connected.
4. Open a real page to prove it works: navigate to https://example.com and read back the page's main heading text. If step 4 fails, tell me the exact error instead of reporting success.

This works because Claude Code can run its own CLI commands and then immediately use the newly connected server — so the agent proves the browser actually works instead of just confirming the config exists.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Provides the `claude mcp` command used to register the server	0 min
Node.js	Playwright MCP runs via `npx` — no separate download needed beyond this	~5 min if missing
~300MB free disk space	First run downloads a Chromium build for Playwright to drive	~1 min

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version.

Step 1 — Add the server

~1 min

The -- separates Claude’s own flags from the command that launches the server:

claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest

Step 2 — Run it headless (optional, faster in CI or background use)

~1 min

By default the browser runs headed (a visible window). For faster, invisible runs — especially useful when Claude Code is doing background verification work — add --headless and --isolated so each session starts from a clean profile instead of reusing saved cookies:

claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest --headless --isolated

Step 3 — Pick a specific browser engine (optional)

~1 min

Defaults to Chromium. To test against Firefox or WebKit instead, pass --browser:

claude mcp add --transport stdio playwright -- npx -y @playwright/mcp@latest --browser firefox

Step 4 — Restart and approve

~1 min

Run claude to start a fresh session. Newly added servers need a restart (or the /mcp panel refresh) before Claude Code can see their tools.

Claude Code drives a real browser: it clicks, types, and reads the rendered page.

What Each Flag Does

Flag	What It Does
`--headless`	Runs the browser with no visible window — headed (visible) is the default
`--isolated`	Keeps the browser profile in memory only, so every session starts fresh instead of reusing saved logins/cookies
`--browser`	Chooses the engine: `chromium`, `firefox`, `webkit`, or `msedge`
`--vision`	Switches from accessibility snapshots to actual screenshots — slower and less reliable, only use it if a page genuinely needs visual inspection
`--device`	Emulates a specific device, e.g. `"iPhone 15"`, for responsive/mobile testing

Verify the Connection

Check that it’s registered and healthy:

claude mcp list

✔ playwright Connected

✘ playwright Failed to connect

A config entry showing up is not the same as it working — the real test is asking Claude Code to actually drive the browser. In a session, ask it to navigate to a real page and read something back:

Navigate to https://example.com using the playwright MCP tools and tell me the exact text of the page's main heading.

If it comes back with the actual heading text (“Example Domain”), the browser is genuinely working end to end — not just listed as connected.

Common Mistakes to Avoid

Forgetting the -- separator. Without it, Claude Code can’t tell where its own flags end and the server’s launch command begins.
Assuming “Connected” means the browser itself works. The MCP handshake can succeed even if the first real navigation later fails — always test with an actual page load, not just claude mcp list.
Running headed by default in a CI or background context. If there’s no display available, add --headless or the browser launch will fail.
Reaching for --vision by default. Accessibility snapshots (the default) are faster and more reliable than screenshots for almost every task — only switch to --vision when a page’s layout genuinely can’t be understood from its accessibility tree.
Not restarting after adding the server. Claude Code needs a fresh session or an /mcp panel refresh to pick up a newly added server.

Q&A

Does this take screenshots of every page?

No, by default it reads the page’s accessibility tree (an accessibility snapshot) rather than capturing pixels — that’s faster and lets Claude read actual text and structure instead of interpreting an image. Screenshots are only used if you pass --vision.

Will this affect my regular browser’s saved logins?

Not if you use --isolated — that keeps each session’s profile in memory only. Without it, Playwright MCP uses a persistent profile stored in a separate cache directory, not your regular browser’s profile.

Can I have the agent test my own site with this?

Yes — that’s one of the most common uses: ask Claude Code to navigate your local dev server or a staging URL, click through a flow, and report back what it actually saw rendered.

Why does it fail in a CI environment?

Usually a missing display for headed mode — add --headless, and if Chromium itself is missing in the CI image, its first-run download step needs network access.

Can I remove it later?

Yes — claude mcp remove playwright deletes it from the config.

Official Resources

microsoft/playwright-mcp on GitHub — source, full flag reference, and issue tracker
Playwright MCP Documentation — official getting-started guide
Claude Code MCP Documentation — the claude mcp command reference

Originally published at quickpromptco.com, where the guide is kept up to date.

How to Build a Claude Code Skill That Loads Itself (5-Minute SKILL.md Setup)

quickpromptco — Wed, 30 Sep 2026 01:00:28 +0000

Every new session starts the same way: you paste your code review checklist again, re-explain your team’s API conventions again, walk the agent through the release process again. Forget once, and Claude Code falls back to generic habits.

A Skill ends the repetition. It’s a folder with one SKILL.md file that teaches Claude Code a repeatable task or a piece of standing knowledge. Claude reads the description and pulls the skill in automatically whenever it’s relevant, no manual invocation needed. This guide builds one from scratch in about 5 minutes.

Quick Start

Create a personal skill that works across every project on your machine:

mkdir -p ~/.claude/skills/api-conventions

Then create ~/.claude/skills/api-conventions/SKILL.md with a frontmatter block and instructions (see Step 2 below). Claude Code picks it up on its next session start — no restart command needed. Total time: about 5 minutes.

⚡ Copy This Prompt: Let Claude Code Build the Skill For You

Skip Steps 1-4 below entirely and hand the whole thing to the agent instead — Claude Code can create the folder, write the SKILL.md, and validate it in one session:

You have file access in this project. Do the following and report back — do not tell me it's done unless step 4 actually confirms it:

1. Ask me what recurring task or piece of knowledge this skill should cover, and whether it should be personal (~/.claude/skills/) or project-scoped (.claude/skills/).
2. Create the skill folder and a SKILL.md file at the right path.
3. Write the frontmatter (name, and a description phrased the way I'd naturally ask for this task) plus the instructions body, based on what I told you.
4. Run `ls .claude/skills/*/SKILL.md` (or the personal-path equivalent) to confirm the file exists, then run `claude plugin validate .claude/skills` to confirm the frontmatter parses cleanly.
5. If validation fails, do not report success — tell me the exact error and fix it.

The agent writes the file, then re-checks it exists and parses cleanly before telling you it’s done — instead of you writing the frontmatter by hand.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	Skills are a built-in feature — no extra package to add	0 min
A text editor	To write the SKILL.md file’s frontmatter and instructions	0 min
A recurring task in mind	Skills are worth building for anything you’d otherwise re-explain repeatedly	~2 min to define

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version of the same steps.

Step 1 — Choose personal or project scope

~1 min

Personal skills live in ~/.claude/skills/ and apply to every project you open. Project skills live in .claude/skills/ at your repo root and are loaded for anyone working in that repo (and its subdirectories, all the way down). Use project scope for team conventions, personal scope for your own habits.

Step 2 — Create the skill folder and file

~1 min

Each skill gets its own folder containing exactly one SKILL.md:

mkdir -p .claude/skills/api-conventions
touch .claude/skills/api-conventions/SKILL.md

Step 3 — Write the frontmatter and instructions

~2 min

The opening --- must be the very first line of the file for the frontmatter to parse. description is what Claude matches against your requests, so write it the way you’d naturally ask for the task:

---
name: api-conventions
description: REST API design conventions for our services
---
# API Conventions
- Use kebab-case for URL paths
- Use camelCase for JSON properties
- Always include pagination for list endpoints
- Version APIs in the URL path (/v1/, /v2/)

Optional frontmatter fields: disable-model-invocation: true makes it callable only via /api-conventions, never triggered automatically; allowed-tools restricts which tools Claude can use while the skill is active.

Step 4 — Test it

~1 min

Start (or restart) a Claude Code session in the project, then ask a question that matches the description naturally — Claude should pull the skill in on its own. To force it regardless of description matching, call it directly:

/api-conventions

A Skill loads itself when the task matches, so you stop repeating the same instructions.

What Each Piece Does

Piece	What It Does
`name`	Sets the skill’s invocation name; without it, Claude falls back to the folder name
`description`	What Claude matches against your requests to decide when to auto-trigger the skill
`disable-model-invocation`	Turns off automatic triggering, leaving only manual `/name` invocation
`allowed-tools`	Limits which tools are available while this skill’s instructions are active
Skill body (below frontmatter)	The actual instructions Claude follows once the skill is loaded

Verify the Installation

Confirm the file exists and the frontmatter parses cleanly:

$ ls .claude/skills/*/SKILL.md

.claude/skills/api-conventions/SKILL.md

$ claude plugin validate .claude/skills

✔ api-conventions: valid

Run the same two commands yourself:

ls .claude/skills/*/SKILL.md
ls ~/.claude/skills/*/SKILL.md

claude plugin validate .claude/skills

Inside a Claude Code session, ask “What skills are available?” — your skill should appear in the list. If the frontmatter has a YAML syntax error, the skill still loads but with no description to match against, so it’ll only work via manual /name invocation.

Common Mistakes to Avoid

Opening --- isn’t on line 1. Any blank line or comment before it means the frontmatter won’t parse at all.
Vague description. “Helps with APIs” won’t match much. Write it the way you’d phrase the actual request, with the keywords you’d naturally use.
More than one SKILL.md per folder. Each skill needs its own dedicated folder — don’t stack multiple skills’ instructions into one file.
Expecting a skill below your working directory to load automatically. Claude Code loads project skills from where you started up through parent directories to the repo root — not from subdirectories below that, unless you explicitly add that directory to the session.
Assuming /name working means the description-matching works too. A skill with a broken frontmatter is still manually callable, which can mask the real problem — run the validator instead of just testing the slash command.

Q&A

Do I need to restart Claude Code after adding a skill?

Personal and project skills are picked up on the next session start. Skills in directories added mid-session (via /add-dir) also load at that point without a full restart.

Can I just have the agent build the skill for me?

Yes — that’s what the copy-paste prompt above is for. Claude Code can create the folder, write the SKILL.md, and run the validator itself instead of you writing the frontmatter by hand.

Can a skill call other tools automatically?

Yes, unless allowed-tools restricts it — by default a skill’s instructions run with the same tool access as the rest of the session.

What’s the difference between a skill and a slash command?

A skill can trigger automatically based on its description matching your request. A plain slash command only runs when you type it explicitly — skills with disable-model-invocation: true behave like slash commands.

Can I share a skill with my team?

Yes — put it under .claude/skills/ in the repo and commit it. Anyone who clones the repo gets it automatically.

Official Resources

Claude Code Skills Documentation — full frontmatter reference and troubleshooting
Plugins Documentation — bundling multiple skills for distribution
Claude Code Best Practices — real-world skill examples

Originally published at quickpromptco.com, where the guide is kept up to date.

How to Connect Any MCP Server to Claude Code With One Command (claude mcp add, 2 Minutes)

quickpromptco — Tue, 29 Sep 2026 14:23:26 +0000

You find an MCP server that would save you hours, then the setup instructions send you hunting for the right config file to hand-edit JSON and guess which scope it belongs in. One typo and the server doesn’t load, and you’re left guessing why.

You don’t need to touch that file. MCP (Model Context Protocol) servers give Claude Code access to outside tools and data — a Notion workspace, a Playwright browser, a private API — and Claude Code’s built-in claude mcp command adds, checks, and removes them for you. This guide walks through both connection types and how to confirm one actually works, in about 2 minutes.

Quick Start

Connect a remote HTTP-based MCP server in one line — no local install, no package to run.

claude mcp add --transport http notion https://mcp.notion.com/mcp

Restart Claude Code, then run /mcp inside a session to see it listed as connected. Total time: about 2 minutes.

⚡ Copy This Prompt: Let Claude Code Install and Verify It For You

Skip Steps 1-5 below entirely and hand the whole thing to the agent instead. Fill in the bracketed line with the server you want, paste the rest as-is:

You have access to the `claude mcp` CLI in this project. Do the following and report back — do not tell me it's done unless step 3 actually confirms it:

1. Run `claude mcp list` to see what's already configured.
2. Add this MCP server: [PASTE THE SERVER'S NAME, URL/PACKAGE, AND TRANSPORT TYPE HERE — e.g. "notion, https://mcp.notion.com/mcp, http" or "airtable, npx -y airtable-mcp-server, stdio with AIRTABLE_API_KEY=..."]
3. Run `claude mcp list` again and confirm the server shows as Connected.
4. If it does NOT show Connected, do not report success. Tell me: the exact status shown, the most likely cause (missing auth, wrong URL/package name, missing prerequisite), and the specific command to fix it.

This works because Claude Code can run its own CLI commands in a session — it adds the server, re-checks the connection, and only tells you it’s done once claude mcp list actually agrees.

What You’ll Need

Requirement	Why You Need It	Time
Claude Code installed	The `claude mcp` command ships with it — nothing extra to install	0 min
An MCP server URL or package name	What you’re actually connecting to (remote HTTP endpoint or local npm package)	~1 min to find
Node.js (for local servers only)	Most stdio MCP servers run via `npx`	~5 min if missing
API key or token (some servers)	Private servers need auth headers or env vars to connect	~2 min

Step-by-Step Setup

Prefer to do it by hand instead of delegating to the agent? Here’s the manual version of the same steps.

Step 1 — Pick a connection type

~1 min

Remote HTTP is the recommended default — the server runs elsewhere and Claude Code just connects over the network. Local stdio runs the server as a process on your own machine, usually via npx. Use HTTP whenever the tool offers it; fall back to stdio for local-only tools like a filesystem or browser server.

Step 2 — Add a remote HTTP server

~1 min

Basic syntax, plus a real example connecting to Notion:

claude mcp add --transport http notion https://mcp.notion.com/mcp

If the server needs a bearer token, pass it with --header:

claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

Step 3 — Or add a local stdio server

~2 min

Use -- to separate Claude’s own options from the command that launches the server. Example: adding the Airtable server with an API key passed as an environment variable:

claude mcp add --env AIRTABLE_API_KEY=YOUR_KEY --transport stdio airtable \
  -- npx -y airtable-mcp-server

Step 4 — Choose a scope

~1 min

User scope makes the server available across every project on your machine. Project scope writes the server definition into a .mcp.json file in the project root, so it can be committed and shared with teammates:

claude mcp add --scope user --transport http claude-code-docs https://code.claude.com/docs/mcp
claude mcp add --scope project --transport http claude-code-docs https://code.claude.com/docs/mcp

A project-scoped server can also be defined directly in .mcp.json:

{
  "mcpServers": {
    "claude-code-docs": { "type": "http", "url": "https://code.claude.com/docs/mcp" },
    "playwright": { "type": "stdio", "command": "npx", "args": ["-y", "@playwright/mcp@latest"] }
  }
}

Step 5 — Approve and start using it

~1 min

Run claude to start an interactive session. On first launch, project-scoped servers from .mcp.json show a one-time approval prompt — accept it, and the server’s tools become available in that session.

One command plugs a new server into Claude Code, and /mcp shows what’s connected.

What Each Piece Does

Piece	What It Does
Transport (http / stdio)	How Claude Code talks to the server — over the network, or as a local process
Scope (user / project / local)	Who can see the server — just you everywhere, or a shared project team
`.mcp.json`	The project-level config file that lists shared servers, meant to be committed
`--header` / `--env`	Passes auth tokens or API keys to the server without hardcoding them in the command
`/mcp` panel	In-session view of every connected server and its live status

Verify the Connection

List every configured server and its health at a glance:

claude mcp list

Here’s what the status column actually looks like, and what each one means:

✔ notion    Connected

! secure-api    Needs authentication

✘ airtable    Failed to connect

⏸ claude-code-docs    Pending approval (run claude to approve)

✔ Connected is the only state that means “working.” Everything else needs action: ! Needs authentication (add the missing token), ✘ Failed to connect (check the URL or package name), ⏸ Pending approval (run claude interactively and accept it). For one server’s full detail:

claude mcp get notion

Common Mistakes to Avoid

Forgetting the -- separator on stdio servers. Without it, Claude Code can’t tell where its own flags end and the server’s launch command begins.
Hardcoding API keys directly in the URL or command. Use --header or --env instead, so secrets aren’t sitting in your shell history or a committed .mcp.json.
Assuming a listed server is actually working. A server appears in claude mcp list as soon as it’s configured — always check the status column, don’t assume “listed” means “connected.”
Not restarting after adding a server. Claude Code needs a fresh session (or the /mcp panel refresh) to pick up a newly added server.
Ignoring a pending-approval status. Project-scoped servers from a teammate’s .mcp.json sit unapproved until you run claude interactively and accept the prompt.

Q&A

What’s the difference between user scope and project scope?

User scope is private to you and active in every project. Project scope lives in .mcp.json in the repo, so it’s shared with anyone who clones it — useful for team-standard tools.

Do I need to know how to code to use MCP servers?

No. Adding one is a single CLI command, and once connected, Claude Code calls its tools automatically when relevant — no manual invocation required.

Can I just have the agent do the whole setup?

Yes — that’s what the copy-paste prompt above is for. Claude Code can run its own claude mcp commands in a session, so it can add a server and re-check the connection itself instead of you typing each command.

Can I remove a server later?

Yes — claude mcp remove <name> deletes it from config, and for remote servers it also clears any stored OAuth tokens.

Why does a server show “Failed to connect”?

Usually a wrong URL, a missing auth header, or the local package failing to start. Run claude mcp get <name> for the specific error before troubleshooting further.

Official Resources

Claude Code MCP Documentation — full command reference and transport options
MCP Quickstart — official getting-started walkthrough
Model Context Protocol — the open spec MCP servers implement

Originally published at quickpromptco.com, where the guide is kept up to date.