The best MCP servers for Claude Code, tested

# Seven MCP servers you might add to Claude Code, started the way Claude Code starts them and run on the tasks
# each is for: (A) read a documentation page, (B) read a page built by JavaScript, (C) answer a library question.
# Also measured: how many tokens each server's tool definitions add to every request Claude Code makes.
# pip install mcp tiktoken    export SKRYP_API_KEY=... FIRECRAWL_API_KEY=...    (needs Node.js and uv)
# timeout: 900
import asyncio
import json
import os
import re
import time
from contextlib import AsyncExitStack

import tiktoken
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from mcp.client.streamable_http import create_mcp_http_client, streamable_http_client

API = os.environ.get("SKRYP_API_URL", "https://api.skryp.dev")
ENC = tiktoken.get_encoding("cl100k_base")
DOCS = "https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/404"
JS = "https://quotes.toscrape.com/js/"
CHECK = {  # text that must be in the reply for the task to count as done
    "A": ["cannot find the requested resource"],
    "B": ["The world as we have created it", "It is our choices, Harry", "only two ways to live your life"],
    "C": ["cleanup"],
}


def text_of(result) -> str:
    return "\n".join(getattr(c, "text", "") for c in result.content)


async def page_reader(s, tool, args):  # one call that returns the page
    return text_of(await s.call_tool(tool, args))


async def playwright(s, url):
    await s.call_tool("browser_navigate", {"url": url})
    await asyncio.sleep(1)
    return text_of(await s.call_tool("browser_snapshot", {}))


async def devtools(s, url):
    pages = text_of(await s.call_tool("new_page", {"url": url}))  # "2: Quotes to Scrape (https://…) [selected]"
    page_id = int(re.search(r"(\d+):[^\n]*\[selected\]", pages).group(1))
    return text_of(await s.call_tool("take_snapshot", {"pageId": page_id}))


async def context7(s, _):
    found = text_of(await s.call_tool("resolve-library-id", {"libraryName": "react", "query": "useEffect cleanup"}))
    lib = re.search(r"(/[\w.-]+/[\w.-]+)", found).group(1)
    return text_of(await s.call_tool("query-docs", {"libraryId": lib, "query": "What does the useEffect cleanup function do?"}))


async def deepwiki(s, _):
    return text_of(await s.call_tool("ask_wiki_question", {"repoName": "facebook/react",
                                                          "question": "What does the cleanup function returned from useEffect do?"}))


def stdio(cmd, *args, env=None):
    return StdioServerParameters(command=cmd, args=list(args), env={**os.environ, **(env or {})})


# name: (how to start it, {task: how to run it})
SERVERS = {
    "Playwright MCP": (stdio("npx", "-y", "@playwright/mcp@latest", "--headless"), {"A": playwright, "B": playwright}),
    "Chrome DevTools MCP": (stdio("npx", "-y", "chrome-devtools-mcp@latest", "--headless", "--isolated"), {"A": devtools, "B": devtools}),
    "Fetch": (stdio("uvx", "mcp-server-fetch"), {t: (lambda s, u: page_reader(s, "fetch", {"url": u, "max_length": 20000})) for t in "AB"}),
    "Firecrawl": (stdio("npx", "-y", "firecrawl-mcp", env={"FIRECRAWL_API_KEY": os.environ.get("FIRECRAWL_API_KEY", "")}),
                  {t: (lambda s, u: page_reader(s, "firecrawl_scrape", {"url": u, "formats": ["markdown"]})) for t in "AB"}),
    "Skryp (ours)": (("http", f"{API}/mcp", {"Authorization": f"Bearer {os.environ.get('SKRYP_API_KEY', '')}"}),
                     {t: (lambda s, u: page_reader(s, "scrape", {"url": u})) for t in "AB"}),
    "Context7": (stdio("npx", "-y", "@upstash/context7-mcp"), {"C": context7}),
    "DeepWiki": (("http", "https://mcp.deepwiki.com/mcp", {}), {"C": deepwiki}),
}


async def run(name):
    how, tasks = SERVERS[name]
    row = {"name": name}
    async with AsyncExitStack() as stack:
        if isinstance(how, tuple):  # ("http", url, headers)
            client = await stack.enter_async_context(create_mcp_http_client(headers=how[2]))
            r, w = await stack.enter_async_context(streamable_http_client(how[1], http_client=client))
        else:
            r, w = await stack.enter_async_context(stdio_client(how, errlog=open(os.devnull, "w")))
        async with ClientSession(r, w) as s:
            await s.initialize()
            tools = (await s.list_tools()).tools
            defs = [{"name": t.name, "description": t.description, "input_schema": t.input_schema} for t in tools]
            row["tools"], row["def_tokens"] = len(tools), len(ENC.encode(json.dumps(defs), disallowed_special=()))
            for task, url in (("A", DOCS), ("B", JS), ("C", None)):
                if task not in tasks:
                    continue
                t0 = time.monotonic()
                try:
                    out = await tasks[task](s, url)
                except Exception as e:
                    out = f"error: {type(e).__name__}"
                ok = all(c.lower() in out.lower() for c in CHECK[task])
                row[task] = (ok, time.monotonic() - t0, len(ENC.encode(out, disallowed_special=())))
    return row


async def main():
    rows = [await run(n) for n in SERVERS]
    print(f"{'server':<22}{'tools':>6}{'definition tokens':>19}   {'A: docs page':<20}{'B: JavaScript page':<20}{'C: library question':<20}")
    for r in rows:
        cells = []
        for t, width in (("A", 20), ("B", 20), ("C", 20)):
            if t in r:
                ok, secs, tok = r[t]
                cells.append(f"{'done' if ok else 'missed'} {secs:.0f}s {tok:,}t".ljust(width))
            else:
                cells.append("-".ljust(width))
        print(f"{r['name']:<22}{r['tools']:>6}{r['def_tokens']:>19,}   {''.join(cells)}")
    print("\nper task: done or missed, seconds, tokens in the reply (t)")


asyncio.run(main())