This is Part 3 of the MCP Rubber Duck series. If you're new here, start with Part 1: Stop Copy-Pasting Between AI Tabs and Part 2: Stop Feeding DOM Snapshots to Claude.
You've given your ducks Chrome DevTools MCP access. They can navigate pages, take screenshots, inspect the DOM. Powerful stuff.
But then you ask: "Hey duck, check the OpenAI API docs for the chat completions endpoint."
And you wait. And wait.
The duck launches Chrome. Renders the entire page. Executes JavaScript. Takes a screenshot. Processes pixels. Finally returns your answer.
10 seconds to fetch what's essentially a text file.
That's not a browser problem — it's a "using a sledgehammer to hang a picture frame" problem.
The Problem: Chrome is Overkill for Documentation
Chrome DevTools MCP is designed for:
- Debugging JavaScript-heavy SPAs
- Inspecting DOM elements
- Taking screenshots for visual context
- Interacting with dynamic content
It's not designed for:
- Fetching static documentation
- Grabbing API responses
- Reading markdown files
- Quick lookups that don't need JS rendering
When all you need is to grab some docs, Chrome DevTools is like driving a semi-truck to pick up groceries.
The cost:
| Operation | Chrome DevTools | Direct Fetch |
|---|---|---|
| Fetch API docs | ~10-15 seconds | ~200ms |
| Token overhead | Screenshots, DOM | Clean text |
| Resource usage | Full browser | HTTP request |
The Solution: A Fast Lane for Simple Fetches
Two lightweight MCP servers. No browser. No JavaScript rendering. Just fetch and go.
| Server | Purpose |
|---|---|
| mcp-server-fetch | Grab content from a known URL |
| duckduckgo-mcp-server | Search the web to find URLs |
Together, they give your ducks the ability to search and fetch without the Chrome overhead.
┌────────────────────────────────────────────────────────┐
│ Claude Code │
│ │ │
│ ask_duck() │
│ ▼ │
│ ┌──────────────────┐ │
│ │ Rubber Duck │ │
│ │ Server │ │
│ └────────┬─────────┘ │
│ │ │
│ ┌─────────────┼─────────────┐ │
│ ▼ ▼ ▼ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Chrome │ │ Fetch │ │ DuckDuck │ │
│ │ DevTools │ │ Server │ │ Go │ │
│ │ (slow) │ │ (fast) │ │ (search) │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │ │ │ │
│ JS-heavy Static docs Find URLs │
│ pages API calls No API key │
└────────────────────────────────────────────────────────┘
The duck picks the right tool for the job. Heavy debugging? Chrome. Quick lookup? Direct fetch.
Setup
Prerequisites:
- MCP Rubber Duck installed (Part 1)
- MCP Bridge enabled (Part 2)
- Python/uvx available (comes with most systems, or brew install uv)
Step 1: Add the Fetch Server
In your Claude Code config ~/.claude.json), add these to the mcpServers.rubber-duck.env section:
"MCP_SERVER_FETCH_TYPE": "stdio",
"MCP_SERVER_FETCH_COMMAND": "uvx",
"MCP_SERVER_FETCH_ARGS": "mcp-server-fetch,--ignore-robots-txt",
"MCP_SERVER_FETCH_ENABLED": "true",
"MCP_TRUSTED_TOOLS_FETCH": "*"
This gives your ducks the fetch tool — direct HTTP access to any URL.
Step 2: Add DuckDuckGo Search
"MCP_SERVER_DDGSEARCH_TYPE": "stdio",
"MCP_SERVER_DDGSEARCH_COMMAND": "uvx",
"MCP_SERVER_DDGSEARCH_ARGS": "duckduckgo-mcp-server",
"MCP_SERVER_DDGSEARCH_ENABLED": "true",
"MCP_TRUSTED_TOOLS_DDGSEARCH": "*"
This gives your ducks the ability to search the web. No API key required. Free forever.
Step 3: Restart Claude Code
# Check that both servers connected
mcp_status
You should see fetch and ddgsearch in the connected servers list.
See It In Action
Before: Chrome DevTools for Everything
Me: "Find the OpenAI chat completions API parameters"
Duck: [Launches Chrome]
Duck: [Navigates to openai.com]
Duck: [Waits for JS to render]
Duck: [Takes screenshot]
Duck: [Processes 500KB of pixels]
Duck: "Here are the parameters..."
Time: 12 seconds
After: Fast Fetch for Documentation
Me: "Find the OpenAI chat completions API parameters"
Duck: [Searches DuckDuckGo: "OpenAI chat completions API"]
Duck: [Finds platform.openai.com/docs/...]
Duck: [Fetches URL directly, 200ms]
Duck: [Parses markdown/HTML]
Duck: "Here are the parameters..."
Time: 2 seconds
The duck still has Chrome DevTools available. It just doesn't need to use it for simple lookups.
Why --ignore-robots-txt?
The official mcp-server-fetch respects robots.txt by default. This is polite, but often counterproductive:
Duck: "I'd love to fetch those docs, but robots.txt said no"
Me: "It's documentation. For developers. To read."
Duck: "Rules are rules"
Me: "I AM the developer"
Duck: "Should've thought about that earlier"
For rubber duck debugging, you typically want unrestricted access to documentation. The --ignore-robots-txt flag enables that.
Note: Be respectful. Don't use this to scrape sites at scale. Your ducks are researchers, not bots.
When to Use What
| Scenario | Tool |
|---|---|
| Debug a React component | Chrome DevTools |
| Fetch API documentation | mcp-server-fetch |
| Find where the docs are | duckduckgo-mcp-server |
| Inspect DOM elements | Chrome DevTools |
| Read a GitHub README | mcp-server-fetch |
| Take a screenshot | Chrome DevTools |
| Check library changelogs | mcp-server-fetch |
Rule of thumb: If you need JavaScript execution or visual inspection, use Chrome. For everything else, use fetch.
Alternatives Considered
| Server | Runtime | Notes |
|---|---|---|
| mcp-server-fetch (official) | Python/uvx | More features, chose this |
| mcp-fetch-server | Node.js/npx | Simpler, no robots.txt handling |
| mcp-server-fetch-typescript | Node.js | Playwright support, heavier |
| Serper/SerpAPI | API | Requires payment |
| Tavily | API | Requires signup |
| duckduckgo-mcp-server | Python/uvx | Free, no API key, chose this |
I chose the official fetch server + DuckDuckGo for simplicity and zero ongoing cost.
Gotchas
1. uvx Must Be Available
The fetch and DuckDuckGo servers use uvx (from the uv package manager). If you don't have it:
# macOS
brew install uv
# Or via pip
pip install uv
2. One Tool Per Prompt Still Applies
Just like with Chrome DevTools (Part 2), ducks work best with focused prompts:
❌ "Search for React hooks docs, fetch them, and summarize"
✅ "Search DuckDuckGo for 'React useState hook documentation'"
Then follow up:
✅ "Fetch https://react.dev/reference/react/useState and summarize"
3. Some Sites Still Need Chrome
Dynamic SPAs, sites behind auth, or pages that render content via JavaScript won't work with direct fetch. The duck will figure this out and can fall back to Chrome if needed.
The Bottom Line
Chrome DevTools MCP is powerful. But power has overhead.
For quick documentation lookups, API checks, and general web research, mcp-server-fetch + duckduckgo-mcp-server gives your ducks a fast lane that:
- Responds in milliseconds, not seconds
- Uses minimal tokens (text, not screenshots)
- Requires zero API keys or subscriptions
- Works alongside Chrome DevTools, not instead of it
Your ducks now have two speeds: precise and thorough (Chrome) or fast and lightweight (fetch). Use both.
Try It Now
GitHub: github.com/nesquikm/mcp-rubber-duck
The setup takes 30 seconds. Add the env vars, restart Claude Code, and your ducks gain web superpowers without the browser baggage.
Your Turn
What heavy MCP tools are you running through the rubber duck bridge? I'm curious what other "middleware" use cases people are finding.
Drop a comment or open an issue on the repo — the ducks are listening. 🦆
P.S. — Yes, I'm aware of the irony of using DuckDuckGo search for rubber ducks. The namespace collision brings me joy.
Top comments (0)