10 MCP Tools Worth Installing from the Official MCP Registry (April 2026)

2filesystem — Official Reference

Best for: giving Claude Desktop or other non-Claude-Code clients scoped file access.

The reference filesystem server. Exposes a configured set of directories with read, write, list, search, and move tools. The permission model is path-based — you specify allowed roots at startup and the server refuses to touch anything outside them.

If you're using Claude Code, you already have native file access and probably don't need this. It shines in Claude Desktop and other MCP clients that don't ship a built-in file tool. Install it once, scope it narrowly, and stop copy-pasting file contents into chat.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/projects"
      ]
    }
  }
}

Warning: scope it narrowly. Giving an MCP filesystem server access to your entire home directory is the kind of mistake that lands in a post-mortem. Allow only the repo roots you actively work in.

3memory — Knowledge Graph Memory

Best for: long-running assistant contexts where facts about the user/project matter across sessions.

A lightweight knowledge graph that the model can read and write. Entities, relations, observations. Facts persist to a local JSON file between sessions. The model learns "Sandeep prefers TypeScript" once, remembers forever.

Honest note: SpecLock's context pack partly overlaps with this for coding-specific decisions (goal, locks, decisions, recent changes). Memory is broader-purpose and more general. If you want free-form "things to remember about the user," install memory. If you want structured engineering constraints, use SpecLock. Both fine, different problems.

{
  "memory": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-memory"]
  }
}

4github — Official GitHub Integration

Best for: issue triage, PR review summaries, cross-repo search without leaving your editor.

Exposes the GitHub REST API through MCP. Create issues, comment on PRs, read repo content, search code, list workflow runs. Authentication via personal access token. Scoped tokens work — give it the minimum permissions the workflow needs.

This is the MCP server I use most after SpecLock. "Summarise the last 20 issues on repo X and cluster them by theme" goes from a 30-minute task to a 10-second prompt. "Find every PR that touched this file in the last year and show the review comments" becomes trivial.

{
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
    }
  }
}

Scope the token aggressively. Don't hand an MCP server a token with admin:org unless you actually need it.

5sqlite — Local Database Access

Best for: ad-hoc data exploration, prototyping, log analysis, any workflow where SQL is faster than writing a script.

Connects to a local SQLite database and exposes query, list-tables, describe-schema, and execute tools. The AI can now explore your data the way a competent analyst would — start with the schema, sample the tables, write a query, iterate. Much better than "paste this CSV into chat."

I use this constantly for log triage. Dump nginx access logs into a SQLite table, connect the MCP server, and ask "what's the distribution of 500s by endpoint over the last hour." You get the answer in one prompt instead of a shell pipeline you have to debug.

{
  "sqlite": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/db.sqlite"]
  }
}

Warning: if the database is production, configure read-only. If you've locked "never delete customer records" in SpecLock, the combination is safe. Without SpecLock, a distracted agent can DROP TABLE you.

6fetch — Web Content Retrieval

Best for: pulling in documentation pages, API specs, and blog posts the model hasn't seen.

A minimal fetcher that takes a URL, retrieves the page, strips the HTML, and returns clean markdown the model can read. No JavaScript execution, no browser automation — just HTTP GET and parse. That's the whole feature and that's why it works.

Use case that changed my workflow: I ask Claude to implement a library I haven't used before. It fetches the docs page, reads the API surface, and writes correct code on the first try instead of hallucinating method names. The knowledge cutoff becomes much less of a problem when the model can look things up.

{
  "fetch": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-fetch"]
  }
}

7brave-search — Web Search API

Best for: giving the model a search engine when fetch isn't enough (i.e. when you don't know the URL).

Wraps the Brave Search API for web and local search. You need a Brave API key (free tier: 2,000 queries/month, which is plenty for personal use). The combination of brave-search (to find the URL) plus fetch (to read it) gives the model something very close to general web access, scoped to on-demand use instead of autonomous browsing.

Brave over Google: no API-key-for-pay-to-play, cleaner terms, respectable result quality in 2026. Kagi is also worth considering if you already pay for it.

{
  "brave-search": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-brave-search"],
    "env": { "BRAVE_API_KEY": "..." }
  }
}

8sequential-thinking — Structured Reasoning

Best for: complex planning tasks where the model benefits from explicit multi-step thought structure.

Exposes a think tool that lets the model produce a structured chain of thoughts before acting — revisable, branchable, with explicit "I was wrong about step 3" correction support. It's a simple idea with a surprisingly big effect on hard problems.

I don't install this everywhere — it adds a lot of token overhead. But for architecture-level planning sessions ("design the data model for a multi-tenant SaaS with these five constraints"), it measurably improves coherence. Install selectively, not by default.

{
  "sequential-thinking": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
  }
}

9puppeteer — Browser Automation

Best for: scraping JS-heavy pages, visual regression checks, "screenshot this URL and describe what's wrong."

Runs a headless Chromium instance that the model can drive. Navigate, click, fill forms, take screenshots, evaluate JS in the page. The fetch server handles static HTML; puppeteer handles anything with JavaScript.

Use case I hit weekly: "visit my deployed preview URL, take a screenshot, and tell me if the button styling broke." The model sees the actual rendered page. Catches CSS regressions that unit tests miss. Also good for quick scraping when you need data that lives behind a JS-rendered grid.

{
  "puppeteer": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
  }
}

Heavy install: puppeteer pulls a Chromium binary (~200 MB). Worth it, but know what you're getting.

10time — Current Time and Timezone Conversion

Best for: fixing the single most persistent bug in LLMs — they don't know what day it is.

The smallest entry on this list and somehow one of the most useful. Exposes current time, timezone conversion, and relative-time formatting. The model asks "what time is it" and gets an actual answer instead of guessing based on training cutoff.

Every AI coding tool I've used has at least once written "the current year is 2024" when it isn't. time server fixes that permanently. Zero overhead, one-line install, stops a whole class of embarrassing mistakes.

{
  "time": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-time"]
  }
}