# Best MCP Servers on GitHub for Daily Work: Files, Git, Browser, Databases

> Four MCP server repos on GitHub that cover files, Git, GitHub, a browser and databases, with install commands, licenses, and how to connect them to Claude Code safely.

Source: https://www.epifive.com/blog/best-mcp-servers-github-daily-work · Published 2026-11-19 · EpiFive

## Key takeaways

- The reference servers in modelcontextprotocol/servers (Filesystem, Git, Fetch, Memory, Time) are the safest place to start with MCP.
- GitHub's official MCP server supports a read-only flag and selectable toolsets, so you can limit what the assistant is able to do.
- Playwright MCP gives an assistant a real browser, and its own README says it is not a security boundary.
- MCP Toolbox for Databases connects an assistant to PostgreSQL, MySQL, SQL Server and many other databases through one server.
- Add servers one at a time, with the narrowest scope, and check each with claude mcp list.

The most useful MCP servers for everyday work are the reference servers from the Model Context Protocol project (files, Git, web fetch), GitHub's own server for repositories and issues, Microsoft's Playwright server for browser tasks, and Google's MCP Toolbox for databases. All four are open source on GitHub, and each installs with a single command or a short JSON block. This guide lists what each one does, how to install it, its license, and how to connect it to Claude Code without handing over more access than you need.

## Who this is for and what you will have at the end

This is for developers, IT admins and technical founders who already use an AI assistant such as Claude Code and want it to touch real tools: a project folder, a Git history, a browser or a database. By the end you will have a short list of vetted repos, working install commands, a project-level `.mcp.json` you can share with a team, and a checklist for deciding whether to trust any other MCP server you come across.

If you want to build your own server instead of installing one, see [Build Your First MCP Server in Python](https://www.epifive.com/blog/model-context-protocol-mcp-server-python-tutorial). If you are looking for Claude Skills rather than MCP servers, see [Best Claude Skills GitHub Repos](https://www.epifive.com/blog/best-claude-skills-github-repos).

## How MCP servers connect to your AI app

MCP is a protocol that lets an AI app call tools exposed by a separate program. There are two common ways a server is reached:

| Transport | How it runs | Typical use |
|---|---|---|
| stdio | The AI app starts the server as a local process and talks to it over standard input and output | Local tools: files, Git, a local browser |
| HTTP (remote) | The AI app connects to a URL | Hosted servers, such as GitHub's |

The Model Context Protocol README notes that servers default to stdio, so running one directly in a terminal looks like it hangs: it is waiting for a client to talk to it. That is normal.

## Prerequisites

- Claude Code installed. The commands below use its `claude mcp` command; the JSON blocks also work in most other MCP clients.
- Node.js, for servers started with `npx`.
- `uv`, for servers started with `uvx` (the Git and Fetch reference servers use it).
- Docker, only if you choose the Docker route for the GitHub server.

## How to add a server in Claude Code

Claude Code's MCP documentation gives two forms. Remote HTTP servers:

```bash
claude mcp add --transport http <name> <url>
```

Local stdio servers:

```bash
claude mcp add [options] <name> -- <command> [args...]
```

The `--` matters for stdio servers. Per the documentation, it separates Claude's own options (`--transport`, `--env`, `--scope`) from the command that runs the server, and everything after it is passed to the server untouched.

Servers are stored by scope:

| Scope | Loads in | Shared with team | Stored in |
|---|---|---|---|
| Local (default) | Current project only | No | `~/.claude.json` |
| Project | Current project only | Yes, via version control | `.mcp.json` in the project root |
| User | All your projects | No | `~/.claude.json` |

Choose with `--scope local`, `--scope project` or `--scope user`. To see what is configured, run `claude mcp list`. Inside Claude Code, `/mcp` shows server status and handles sign-in for remote servers that use OAuth.

## 1. modelcontextprotocol/servers: the reference servers

**What it does.** This is the project's collection of reference servers. According to its README (checked 2026-11-19), the maintained ones are Everything (a test server), Fetch (web content fetching and conversion), Filesystem (file operations with configurable access controls), Git (read, search and manipulate repositories), Memory (a knowledge-graph memory), Sequential Thinking and Time.

**Who it is for.** Anyone starting with MCP. These are the most common first servers and the ones other guides assume you have seen.

**Install commands from the README:**

```bash
# Filesystem: only the folder you list is accessible
npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/files

# Git
uvx mcp-server-git

# Fetch
uvx mcp-server-fetch

# Memory
npx -y @modelcontextprotocol/server-memory
```

Connecting the Filesystem server to Claude Code, limited to one folder:

```bash
claude mcp add --transport stdio files -- npx -y @modelcontextprotocol/server-filesystem /home/you/projects/contoso-site
```

The folder argument is the access control. Give it the one project folder, not your home directory.

**Windows note.** The README says to wrap `npx` commands with `cmd /c` in client configs.

**License.** The README states Apache License 2.0 for new contributions, with existing code remaining under MIT. GitHub's license field for the repository reads NOASSERTION, because of that mix.

**Repo facts (GitHub API, 2026-11-19):** about 92,091 stars, last push 2026-11-18, not archived.

### What moved out of this repo

Many servers people remember from older tutorials are no longer here. The README lists these as archived and moved to the `servers-archived` repository: AWS KB Retrieval, Brave Search, EverArt, GitHub, GitLab, Google Drive, Google Maps, PostgreSQL, Puppeteer, Redis, Sentry, Slack and SQLite. If a tutorial tells you to run `@modelcontextprotocol/server-github` or the PostgreSQL server, use the maintained replacements below instead. The README says Brave Search is replaced by the official `@brave/brave-search-mcp-server` and that Slack is now maintained by Zencoder.

## 2. github/github-mcp-server: repositories, issues and pull requests

**What it does.** GitHub's official MCP server lets an assistant work with repositories, issues and pull requests. Its default toolsets, per the README, are `context`, `repos`, `issues`, `pull_requests` and `users`.

**Who it is for.** Developers who want to ask an assistant to summarize an issue, review a pull request or search a repo without leaving the terminal.

**Install options from the README:**

- Remote server hosted by GitHub, URL `https://api.githubcopilot.com/mcp/`, with `"type": "http"` in your host config. Authentication can be OAuth or a personal access token.
- Docker, local:

```bash
docker run -i --rm \
  -e GITHUB_PERSONAL_ACCESS_TOKEN=<your-token> \
  ghcr.io/github/github-mcp-server
```

- A local binary built with `go build -o github-mcp-server ./cmd/github-mcp-server`, run as `github-mcp-server stdio` with the token set in the environment.

For Claude Code, the remote route follows the HTTP pattern above:

```bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
```

Then run `/mcp` inside Claude Code to complete authentication. This command combines GitHub's URL with Claude Code's documented HTTP syntax; the exact authentication prompts depend on your account and Claude Code version, so check `/mcp` for status.

**Limit what it can do.** The README describes two controls. `--toolsets repos,issues,pull_requests` (or the `GITHUB_TOOLSETS` environment variable, which takes precedence) exposes only the toolsets you name. `--read-only` skips all write tools, and the README says it takes priority even over tools requested explicitly with `--tools`. For a first trial, enable read-only.

**Token advice from the README.** Minimum suggested scopes are `repo`, `read:packages` (for Docker image access) and `read:org` (for team access). It also recommends separate tokens per project, periodic rotation, and keeping tokens out of version control.

**License.** MIT. **Repo facts (2026-11-19):** about 34,576 stars, last push 2026-11-18, not archived.

## 3. microsoft/playwright-mcp: a real browser for the assistant

**What it does.** Playwright MCP lets an assistant drive a browser: open pages, read what is on them and interact. It is useful for checking a staging site, reproducing a front-end bug or filling a form during testing.

**Who it is for.** Developers and QA engineers testing web apps.

**Install, from the README:**

```json
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "@playwright/mcp@latest"
      ]
    }
  }
}
```

For Claude Code the README gives:

```bash
claude mcp add playwright npx @playwright/mcp@latest
```

**Security.** The README says plainly that "Playwright MCP is not a security boundary." A browser that can open arbitrary pages can read content from those pages, and Claude Code's documentation warns that servers that fetch external content can expose you to prompt injection. Point it at sites you control, avoid logged-in sessions for sensitive systems, and do not combine it with a server that can write to production.

**License.** Apache-2.0. **Repo facts (2026-11-19):** about 39,868 stars, last push 2026-11-18, not archived.

## 4. googleapis/mcp-toolbox: databases

**What it does.** MCP Toolbox for Databases is an open source MCP server for databases. Per its README it offers prebuilt generic tools such as `list_tables` and `execute_sql`, and a framework for custom tools defined in a `tools.yaml` file. Listed supported databases include Google Cloud options (AlloyDB, BigQuery, Cloud SQL, Spanner, Firestore) and others such as PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, MongoDB, Redis, Elasticsearch, CockroachDB, ClickHouse, Couchbase, Neo4j, Snowflake and Trino.

**Who it is for.** Analysts and developers who want an assistant to explore a schema and draft queries.

**Install, from the README:**

```json
{
  "mcpServers": {
    "toolbox-postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@toolbox-sdk/server",
        "--prebuilt=postgres",
        "--stdio"
      ]
    }
  }
}
```

Set the database connection environment variables described in the project's Prebuilt Tools Reference. For custom tools, the README shows `npx @toolbox-sdk/server --config tools.yaml`.

**Rename.** The repository was formerly `googleapis/genai-toolbox` (originally "Gen AI Toolbox for Databases") and is now `googleapis/mcp-toolbox`. Older tutorials and bookmarks may use the previous name. Update a local clone with `git remote set-url origin https://github.com/googleapis/mcp-toolbox.git`.

**Safety.** `execute_sql` can run whatever SQL the database user is allowed to run. Connect with a read-only database account, ideally against a replica or a copy, never a production primary with a write-capable user.

**License.** Apache-2.0. **Repo facts (2026-11-19):** about 16,905 stars, last push 2026-11-19, not archived.

## Share a setup with your team

To give a whole project the same servers, add them with project scope so they are written to `.mcp.json`:

```bash
claude mcp add --transport http github --scope project https://api.githubcopilot.com/mcp/
```

The resulting file uses the format from Claude Code's documentation:

```json
{
  "mcpServers": {
    "shared-server": {
      "type": "http",
      "url": "https://example.com/mcp"
    }
  }
}
```

`.mcp.json` supports `${VAR}` and `${VAR:-default}` expansion in `command`, `args`, `env`, `url` and `headers`, so tokens can stay out of the committed file. Claude Code prompts for approval in interactive sessions before using project-scoped servers from `.mcp.json`.

## Verify the setup

Run:

```bash
claude mcp list
```

Claude Code's documentation says the list shows health statuses such as `Connected`, `Needs authentication` and `Failed to connect`. Inside a session, `/mcp` shows the same status and handles OAuth sign-in. Then ask the assistant for something harmless and observable, such as listing the files in the allowed folder or listing open issues in a public repo.

## Troubleshooting

| Symptom | Likely cause | Fix |
|---|---|---|
| Server runs in a terminal but nothing happens | stdio servers wait for a client | Run it through your MCP client instead |
| Status shows `Needs authentication` | Remote server needs OAuth | Run `/mcp` and sign in |
| Status shows `Failed to connect` | Missing Node.js or `uv`, or a typo in the command | Run the command by hand to see the error |
| `npx` fails on Windows | Client cannot launch `npx` directly | Wrap with `cmd /c`, as the README advises |
| CLI treats your server name as an environment variable | `--env` swallowed the name | Put another option, such as `--transport stdio`, between `--env` and the name |
| Old tutorial's server package not found | Server was archived | Use the maintained replacements above |

## Before you trust any other MCP server

- Open its repository and check the license, the last commit date and whether it is archived.
- Read what tools it exposes. A server that can write, delete or send is a larger risk than one that reads.
- Prefer the vendor's own server (GitHub, Microsoft, Google) over a lookalike with a similar name.
- Start with the narrowest scope and read-only credentials.
- Remember that content fetched by a server can contain instructions aimed at the model.

## Summary checklist

- Start with Filesystem limited to one folder, plus Git.
- Add GitHub's server in read-only mode before enabling writes.
- Use Playwright MCP on sites you control only.
- Use MCP Toolbox with a read-only database account.
- Verify with `claude mcp list` and `/mcp` after each addition.

## What we checked

- Opened the README of modelcontextprotocol/servers on github.com on 2026-11-19 and copied the maintained-server list, the install commands and the archived-server list from it.
- Queried the GitHub API for modelcontextprotocol/servers, github/github-mcp-server, microsoft/playwright-mcp and googleapis/mcp-toolbox on 2026-11-19: stars, last push date, license field and archived flag are as stated above. Star counts change daily.
- Cross-checked license wording: the GitHub API reports NOASSERTION for modelcontextprotocol/servers, while its README states Apache-2.0 for new contributions and MIT for existing code.
- Confirmed the repository rename from genai-toolbox to mcp-toolbox: the GitHub API returned the full name googleapis/mcp-toolbox when queried by the old name, and the README carries a rename notice.
- Read Claude Code's MCP documentation (code.claude.com/docs/en/mcp) on 2026-11-19 for the `claude mcp add` syntax, scopes, `.mcp.json` format and the security warning. The page redirected from docs.claude.com.
- Not tested hands-on: we did not run any of these servers or connect them to a live Claude Code session; the one command that combines GitHub's URL with Claude Code's HTTP syntax is assembled from the two documents, not run. The first 100,000 characters of the long Claude Code and GitHub README pages were read; the remainder was not.

Last tested: 2026-11-19

## References

- https://github.com/modelcontextprotocol/servers
- https://github.com/github/github-mcp-server
- https://github.com/microsoft/playwright-mcp
- https://github.com/googleapis/mcp-toolbox
- https://code.claude.com/docs/en/mcp

## Frequently asked questions

### What is an MCP server?

An MCP (Model Context Protocol) server is a small program that exposes tools, such as reading files or running a query, to an AI app like Claude Code. The app decides when to call a tool, and the server performs the action and returns the result.

### Are the official GitHub MCP server and the reference servers the same thing?

No. The reference servers live in modelcontextprotocol/servers and cover generic tasks such as files, Git and fetching web pages. The GitHub MCP server is a separate repository, github/github-mcp-server, maintained by GitHub for working with repositories, issues and pull requests.

### Why did the old GitHub and PostgreSQL MCP servers disappear from the main repo?

The README of modelcontextprotocol/servers lists them, along with several others, as archived and moved to a separate servers-archived repository. For GitHub, use GitHub's own server; for databases, see MCP Toolbox below.

### Is it safe to connect any MCP server to my AI assistant?

Not automatically. Anthropic's Claude Code documentation says to verify you trust each server before connecting it, and warns that servers that fetch external content can expose you to prompt injection. Start with read-only access and the narrowest scope you can.

