MCP Servers List: Official, Free and GitHub Directories

Search for an MCP server today and you hit a wall of options. Tens of thousands of listings sit across a dozen sites, and each site defines "listed" in its own way. A few catalogs are curated by the protocol's own maintainers. Most are scraped from GitHub overnight and ranked by whatever signal the site owner prefers.

This MCP servers list sorts that noise into three groups you can act on: official sources, free community directories, and GitHub directories and lists. For each one you get what it is, what it does well, and where it falls short. After that come a short safety routine, a config that runs, and a look at servers that generate images and video.

First, the terms. An MCP server is a small program that exposes tools, data or prompts to an AI client such as Claude, Cursor or VS Code through the Model Context Protocol. Local servers talk over stdio, remote ones over Streamable HTTP. A directory is a catalog of those programs. A registry is a directory with rules about who is allowed to publish.

💡 Short answer: use the official MCP Registry when you need a verified name, Glama or PulseMCP when you want to browse a category, and GitHub when you want to read the source before anything runs on your machine.

The Official Sources

"Official" here means one of two things: run by the MCP project itself, or run by the company that built the service. These sources are small, and that is exactly why you can trust them.

The MCP Registry

The official MCP Registry lives at registry.modelcontextprotocol.io and launched in preview on September 8, 2025. A publisher describes a server in a server.json file and pushes it with the mcp-publisher command line tool. Names use reverse DNS, such as io.github.username/server or com.example/server, and the publisher has to prove they own the GitHub account or the domain behind that namespace.

Two details matter. First, it is a metadata catalog, not a host: an entry points to a package or a remote URL and runs nothing on its own. Second, its documentation describes a preview in which breaking changes or data resets can happen before general availability, so check the current status before you build tooling around its API. Clients and aggregators read it through a REST API, which is why a registry name is the safest string to paste into a client config.

The Reference Servers Repo

The modelcontextprotocol/servers repository has more than 90,000 stars, yet it lists only the handful of servers maintained by the MCP steering group. Think of it as working sample code, not a store.

Older reference servers, including GitHub, Slack, PostgreSQL, Puppeteer, Google Drive, Redis and SQLite, moved to a separate servers-archived repository. The Brave Search server was replaced by Brave's own official version. The repo README itself points people looking for a list to the MCP Registry.

💡 If a tutorial tells you to install one of the archived servers, look for the vendor's current server first. Old install commands still circulate in blog posts long after the code stopped getting updates.

Vendor Servers You Can Trust

A growing number of companies now ship their own server. Examples include GitHub's server in github/github-mcp-server, Microsoft's playwright-mcp for browser automation, and Upstash's Context7 for library documentation. Remote servers from Stripe, Notion, Linear, Sentry, Figma and Cloudflare follow the same pattern.

The rule of thumb is simple: when the vendor ships a server, prefer it over a community clone. The tool list follows the real API, the company patches security problems, and the docs are written by people who know the product. Search the vendor's documentation site for "MCP" before you open any directory.

Free Directories Worth Bookmarking

Community directories trade curation for volume. Every site below is free to browse, though some sell hosting or paid plans on top. Treat the counts as snapshots from mid-2026, because they move daily.

Glama and mcp.so for Volume

Glama listed about 50,800 open-source servers in July 2026, which makes it the largest index in this list. It also hosts servers behind a gateway, so you can connect through an API instead of running the code yourself. mcp.so is a community directory with roughly 19,700 listings and open submissions.

Volume is the point and also the problem. At that size you will meet duplicates, abandoned forks and one-commit weekend projects. Sort by recent updates and stars before you click anything, and ignore any listing without a link to its source.

PulseMCP for Popularity Signals

PulseMCP tracks several thousand servers and leans on popularity and freshness signals. That makes it the right tab to open when you want the most used servers in a category, such as databases, browser automation or search, instead of every server that exists.

Smithery and Docker for Running

A directory tells you what exists. These two help you run it. Smithery is a marketplace with hosting and OAuth handling, so remote servers connect without you wiring credentials by hand. The Docker MCP Catalog packages servers as containers, and Docker's MCP Gateway starts them on demand and injects the credentials they need, which keeps each server isolated from the rest of your machine.

Pick these when you would rather sandbox than trust. The trade-off is another moving part: a platform account, or a Docker install, now sits between your client and the tool.

GitHub Directories and Lists

GitHub is where almost every server lives, so it is also where the most honest listings are. You can read the code, the issues and the commit history before you decide anything.

The GitHub MCP Registry

GitHub launched its own MCP Registry in September 2025 as a curated catalog with one click install into VS Code. At launch it held 39 servers from partners such as Figma, Postman, HashiCorp and Dynatrace, each vetted before listing, and entries can be sorted by GitHub stars. It is small, but every entry is tied to a repository you can open. Expect the number to have grown since the launch.

Awesome Lists on GitHub

The classic format is a single README with links grouped by category. punkpeye/awesome-mcp-servers and wong2/awesome-mcp-servers are two widely used examples.

• Strengths: free, easy to scan, grouped by category, and every change is visible in the commit log.
• Weaknesses: no install metadata, no health checks, and links rot as repositories get renamed or deleted.

Use your browser's find command for the tool you need, then check the date of the last commit on each repo before trusting a link.

Searching GitHub Directly

When the lists miss something, search GitHub itself. The mcp-server topic is where authors tag their projects, and the search syntax lets you filter out stale ones:

topic:mcp-server language:TypeScript stars:>50 pushed:>2026-07-01

Copy Prompt

Swap the language for Python, Go or Rust depending on what your team can maintain. A server you can read and patch yourself is worth more than a slightly more popular one you cannot.

Pick the Right Source

Every source above answers a different question. This table puts them side by side.

A Fast Decision Path

1. Need a verified name for a client config? Start with the official MCP Registry.
2. Need a server for a specific product? Check the vendor's docs first, then the GitHub MCP Registry.
3. Need every option in a category? Search Glama or mcp.so and sort by recent updates.
4. Need to know what people actually use? Open PulseMCP.
5. Want sandboxing or hosting? Use the Docker catalog, Smithery or the Glama gateway.

Most people end up using two sources: one to find candidates and one, usually GitHub, to check them.

Check a Server Before Installing

An MCP server runs with your permissions, and everything it returns lands in front of your model. A careless one can read files it should not touch, leak tokens, or slip instructions into the conversation. Treat each server like a dependency that has shell access.

Five Fast Safety Checks

1. Read the source. If a listing has no repository link, skip it. Closed code with shell access is a bad trade.
2. Check freshness. Look for a commit in the last six months and maintainers who answer issues.
3. Match tools to purpose. A weather server that asks for file access is a red flag. The tool list should fit the job.
4. Pin the version. Install a fixed version or commit hash, not "latest", so an update cannot change behavior overnight.
5. Prefer verified namespaces. Registry names tied to a GitHub account or a domain are harder to fake than a name on a free-for-all directory.

Permissions and Tokens

Give each server the narrowest access that works. Use a read-only database user, a scoped GitHub token, and a single project folder instead of your whole home directory. Keep tokens in environment variables, never in a config file you commit.

Run unknown servers inside Docker or a throwaway virtual machine first. Tool descriptions are read by the model, so a malicious server can try prompt injection through them. Keep human approval switched on for any tool that writes, deletes or sends.

⚠️ Watch for tool name collisions. Two servers that both expose a tool called search or read_file can confuse the model about which one to call. Install fewer servers, and disable the tools you never use.

Install One in Five Minutes

Pick a harmless server for your first run. The reference Filesystem server is a good choice because you control exactly which folder it can see.

A Config That Works

Most desktop clients read a JSON file with an mcpServers object. Each entry names the command to run and its arguments:

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

Copy Prompt

The last argument is the only folder the server may read and write. Save the file, restart the client fully, and the tools appear in the tool menu. Remote servers skip the command entirely: you add their URL in the client's connector or server settings, and sign in through OAuth when it asks.

To test a server on its own before you attach it to a client, run the MCP Inspector with npx @modelcontextprotocol/inspector. It lists the server's tools, lets you call them by hand and shows the raw messages.

Common errors and quick fixes:

• spawn npx ENOENT: Node.js is not on the PATH your client sees. Install Node, or put the full path to npx in the command field.
• Server connects, then drops at once: a stdio server must write only protocol messages to standard output. Logging belongs on standard error.
• No tools appear: check the JSON for a trailing comma, then quit the client entirely instead of closing the window.
• Windows paths fail: escape every backslash in JSON, or use forward slashes.

MCP Servers for Images and Video

Image and video generation are two of the busiest categories in every directory above. A server in this group wraps a model API as a few tools: generate, check status, fetch the result.

What to Look For

• Asynchronous jobs. Images take seconds and video takes minutes. A good server returns a job ID and offers a status tool instead of freezing the chat while it waits.
• Output type. A public URL is the easiest to drop into an article or a page. Base64 data and local file paths both need extra handling.
• Model choice. The server should say which models it can call. For images, compare Seedream 5 Pro, Flux 2 Pro and GPT Image 2. For video, compare Seedance 2.0, Veo 3.1 and Kling 3.
• Limits and cost. Look for a concurrency limit, a timeout and some way to see what a generation costs before you queue ten of them.

The model on the client side matters too. Tool calling quality varies, so test your servers with a few candidates such as Claude Sonnet 5, GPT-5.6 Sol, Gemini 3.5 Flash or Kimi K2.6 before you commit to one.

How PicassoIA Fits In

PicassoIA exposes its generation models in two ways: a REST API at api.picassoia.com/v1 and a connector for MCP clients such as claude.ai. The API follows the familiar asynchronous pattern. You create a prediction, poll it until it finishes, then fetch the result. The connector turns the same models into tools:

As of October 2026, up to five predictions can run at once per account, and that limit is shared between API access and MCP connections. Plan requirements for API and MCP access are listed on picassoia.com/en/api, so read that page before you build a workflow around it.

💡 Video tip: start from a strong still image and animate it. A clean first frame gives the video model a fixed composition, so you spend fewer retries on shaky results.

Build Your Shortlist

You do not need fifty servers. Most working setups run on three to six: a file or Git server, a browser or search tool, one or two vendor servers for the products you use every day, and a generation server if you make media.

A routine that keeps the list healthy:

1. Find candidates in the official registry, the vendor docs or Glama.
2. Run the five safety checks on each one.
3. Test it alone with the MCP Inspector, then attach it to your client.
4. Review the list monthly and remove anything you have not called in weeks.

If you make visuals, the quickest way to see an MCP workflow pay off is to try one. Open Picasso IA, pick a model from the full model list, and write your first prompt. Generate a few images with Seedream 5 Pro, animate the best one with Seedance 2.0, and then connect the same models to your AI client so the next batch runs from a single chat. Start small, experiment with different prompts and models, and keep the shortlist that works for you.