MCP Servers: The Beginner's Guide (incl. Server List)

In the fast-moving AI world, there's often a lack of standards that seamlessly connect different systems. MCP (Model Context Protocol) was introduced by Anthropic in late 2024 as an open standard to solve exactly this problem.

It enables AI models like ChatGPT or Claude to connect to external data sources and tools in a standardized way. More and more companies are adopting MCP, showing the growing industry interest in this new standard.

In this blog article, we dive into the world of MCP servers:

What they are, what you need them for, which tools work with them, and how you can set up such a server yourself.

1. What Are MCP Servers and What Are They Used For?

MCP stands for Model Context Protocol. It's an open standard (a protocol) that was introduced by Anthropic in late 2024.

The idea behind it:

AI models (like ChatGPT or Claude from Anthropic) should be able to connect more easily with external data sources and tools – in a standardized way.

You can actually think of MCP like a "USB-C port for AI applications".

Just as USB-C unifies how different devices are connected, MCP standardizes the connection between AI models and various data sources or services. The following graphic by Norah Sakal illustrates this:

An MCP server in this context is a kind of small helper program (server sounds like a huge system, but here it's usually a lightweight program).

This server provides an AI with special capabilities or information. It "speaks" the MCP protocol, so the AI (or rather the MCP client in the AI application) knows how to communicate with the server.

An MCP server can, for example, have access to a specific data source or provide functions that the AI is allowed to use. The AI sends requests according to the MCP standard to the server and receives responses or actions in return – all nicely according to defined rules.

MCP servers act as adapters to remote services (e.g., Slack, Gmail, Google Calendar) or local data sources (e.g., files on your computer).

The MCP client (part of the AI app) sits as a "translator" between the AI host and the MCP servers, ensuring that everyone speaks the same "language".

2. What Are MCP Servers Used For?

They come into play whenever an AI needs context or capabilities that go beyond what it knows by itself (its training data).

But maybe you want it to work with current or personal data – for example, searching your emails, reading appointments from your calendar, accessing a database, or even controlling an application.

MCP servers make exactly that possible without having to reinvent the wheel for every AI tool and data source.

Everything remains modular and secure:

The AI host only talks to the server (according to fixed rules), and the server takes care of the rest. If a new service needs to be integrated, you just need to add an appropriate MCP server instead of completely reprogramming the AI.

Here are some examples of what you can achieve with MCP servers:

• Retrieving information: There are MCP servers connected to external APIs or services. For example, a weather server could provide an AI with current weather information when the AI asks about the weather. Or a web search server could provide internet search results.
• Using files and data: Other servers allow the AI to search local files or cloud storage, e.g.: "Find the PDF with my resume on my PC." An appropriate MCP server could handle this search and deliver the content to the AI. For Google Drive, for example, there's this ready-made MCP server that can find and read files.
• Controlling apps and tools: MCP servers can even perform actions. There's an impressive example called Blender-MCP, where Claude can actually control the 3D software Blender. This shows that MCP servers not only deliver data but can also serve as bridges to programs.
• Querying databases: There are also MCP servers for database access (e.g., for SQLite or PostgreSQL). An AI could ask questions about your data, and the server translates that into a DB query and returns the result.

3. Which Tools Support MCP Servers?

MCP sounds great – but of course only matters if applications actually support it. Since MCP is still relatively new, it's mainly modern AI applications and developer tools that are implementing it.

Here are some well-known tools and platforms that already support MCP:

• Claude Desktop (Anthropic): The desktop version of Claude (an AI chat assistant from Anthropic) offers full MCP support. This means you can let Claude on your computer use local MCP servers. For example, Claude Desktop can be taught to search your files or perform other local actions. (Important: The web version of Claude at claude.ai currently does not support MCP, only the desktop app.)
• Continue (VS Code Extension): Continue is an open-source extension for Visual Studio Code that uses AI for programming. Continue was one of the first clients with full MCP integration.
• Microsoft Copilot Studio: Microsoft's Copilot Studio (part of the Azure/OpenAI/Copilot ecosystem) has also integrated MCP support, and in a beginner-friendly way: You can add ready-made MCP connectors in a graphical interface. According to Microsoft, one click on "Add an action" is enough to search for available MCP servers and add them to your AI agent.
• Cursor: Tools like debuggers, file access, etc. can also be used via MCP with the Cursor code editor.
• Custom applications – Since MCP is an open standard, any application or custom project can in principle be expanded into an "MCP client" if the protocol rules are implemented. There are SDKs in various programming languages (Python, TypeScript, Java, etc.) if you want to build your own tools.

4. Where Can You Find Pre-built MCP Servers?

Now you might be wondering:

Do I have to program such an MCP server myself?

Fortunately, no – unless you want to build something very specific. There are already plenty of pre-built MCP servers that you can use directly or easily customize. You'll find a list with hundreds of MCP servers further below (point 6).

Another resource is Anthropic's official GitHub repository for MCP servers.

There you'll find a huge collection of reference implementations and community servers. Some categories of existing MCP servers include:

• File system and data: Access to local files or databases, e.g., a filesystem server (for file operations on your computer), a Google Drive server (for Google Drive files), or SQLite/PostgreSQL servers (to query databases). With these, you can teach your AI to read files or make database queries without writing code yourself.
• Developer tools: Connections to developer services. These include, for example, a Git server (to read repository contents or find commits), GitHub/GitLab servers (which can retrieve issues or files via the API), or a Sentry server (to read error logs from Sentry). Ideal if you use AI assistants for development tasks.
• Web and APIs: Servers that search or browse the internet. There's a Brave Search server that enables web searching, or a Fetch server that retrieves and processes web pages. A Puppeteer server is also available, which can do browser automation and web scraping – so the AI could, for example, independently visit a page and extract content.
• Productivity and communication: This includes, for example, Slack servers (which give the AI access to Slack channels and messages). In the GitHub repo, you can see logos for Gmail, Calendar, etc. – there are community servers for Gmail or Google Calendar (these often appear in Awesome MCP lists).

Many of these servers have been developed by Anthropic as examples (to demonstrate what's possible), others come from the community.

Some are published as npm packages (for Node.js) or Python packages, which makes installation easy. For example, the filesystem server is provided as the npm package @modelcontextprotocol/server-filesystem.

Similarly, there's mcp-server-sqlite as a Python/Node package. This means you can download and start many servers with a single command (more on that in the next section).

The Continue community also offers a directory for MCP servers. So even if you're not a developer, you can still benefit from the developer community's work:

There might already be an MCP server for what you want to do (whether it's searching Twitter, reading emails, or anything else).

5. How Do You Connect a Tool with an MCP Server? (Examples & Setup)

Now let's get practical:

How do I get my tool to talk to an MCP server? The exact setup can vary slightly depending on the tool, but the basic idea is always:

1. Make the MCP server available – Either install/start the corresponding server (if it runs locally) or have access to it.
2. Configure the tool – Tell your AI tool that it should use an MCP server (often through a configuration or settings dialog).
3. Test the connection and use it – Make sure everything works, then get started.

Let's look at some concrete examples to make this more tangible:

Example 1: Claude Desktop + Filesystem Server

Let's say you want to give Anthropic Claude (desktop version) the ability to access your local files (e.g., to find text in a file or save something to your hard drive). For this, there's the pre-built Filesystem MCP server.

The setup works like this:

1. First, install the Claude Desktop app (if you haven't already) and make sure Node.js is installed on your computer (the filesystem server is a Node-based program).

2. Then go to Claude Desktop settings under Developer and open the configuration file claude_desktop_config.json.

3. Add an entry there that instructs Claude to start the filesystem server at startup. Specifically, it looks something like this (simplified):

"mcpServers": {
  "filesystem": {
    "command": "npx",
    "args": [ "@modelcontextprotocol/server-filesystem", "Path/to/Folder1", "Path/to/Folder2" ]
  }
}

This entry says: Start the package server-filesystem via npx and give it two folder paths (e.g., Desktop and Downloads) that it should have access to.

4. After saving the file, restart Claude Desktop. The app will now start the filesystem MCP server in the background. If everything worked, you'll see a small hammer icon in the Claude interface (bottom right of the input field).

Click on it and it will show you the tools that the filesystem server provides (e.g., operations like "read file" or "write file").

Now you can ask Claude: "Can you show me the first lines from file XYZ?" – Claude recognizes that it needs to use the file reading tool from the server, calls it, and (after your confirmation) returns the content. Pretty cool, right?

Important: Claude always asks for permission before actually making changes, like creating or moving a file. So you stay in control.

Example 2: VS Code Continue + SQLite Server

Let's say you're working as a developer and want to give your AI in the editor access to a database so it can answer questions about it. With Continue (the VS Code extension), this is very easy via MCP. First, make sure the desired MCP server is installed.

In our case, e.g., mcp-server-sqlite – you could do this with pip install mcp-server-sqlite or npm install depending on the implementation (the server's documentation specifies this).

Then open the Continue configuration in VS Code (usually a config.json in your user folder). There, add that Continue should use an MCP server. The Continue blog shows how to integrate the SQLite server:

"experimental": {
  "modelContextProtocolServer": {
    "transport": {
      "type": "stdio",
      "command": "mcp-server-sqlite",
      "args": ["--db-path", "/Users/YOURNAME/test.db"]
    }
  }
}

This means Continue should start a process mcp-server-sqlite and pass it the path to the database test.db. Transport: stdio means the communication runs via the input/output pipelines (the classic way, similar to language servers in VS Code).

When you now use Continue in VS Code, you can type @ in the chat context, select "MCP", and Continue will offer you the resources/tools that the SQLite server provides. The AI could then, for example, automatically execute an SQL query to answer your question and deliver the result from the database.

Example 3: Copilot Studio + Server from the Marketplace

For non-programmers, this might be the easiest way. In Microsoft Copilot Studio (a kind of building kit for AI workflows), MCP has been integrated. Here you don't even need to install anything manually. You go to your agent configuration, click on "Add action", and search for the desired MCP server in the list.

Let's say you want to use an existing "Google Drive" connector – you would find it in the list, add it, and possibly go through an auth step (i.e., allow the app access to your Google Drive).

After that, the Google Drive MCP server is immediately available to your AI agent: In the interface, you'll then see actions like "Search file in Drive" or "Read from Drive", which come exactly from the MCP server. Without a single line of code, you've given your AI new superpowers.

Copilot Studio takes care of securely connecting the MCP server in the background (including all necessary cloud infrastructure, security, etc.).

What You Should Keep in Mind

Regardless of the tool, a few general points are important when connecting MCP servers:

• Access and security: An MCP server can potentially do a lot – it has access to data or is allowed to perform actions. Therefore, you should only use servers from trusted sources and only give them the permissions that are necessary.
• Check prerequisites: As mentioned, some servers require additional software. A Node.js-based MCP server requires Node to be installed, a Python-based one requires Python. Make sure these prerequisites are met, otherwise the startup will fail. The server's documentation usually indicates this. If something doesn't work, check log files or the console – you'll often see if a command wasn't found (e.g., node: command not found).
• Connection type (transport): In the background, client (tool) and server communicate via a so-called transport – often STDIO (i.e., the client starts the server as a subprocess and talks via the input/output pipelines), sometimes also via WebSocket or HTTP. As a user, you rarely need to know this, except when you're manually setting up a server: Then you might need to set a port or ensure that the processes can find each other. The standard reference servers mostly use STDIO, which works automatically when the client starts the process.
• Using multiple servers: You can also connect more than one MCP server in parallel. If your tool allows it, you can configure multiple servers (e.g., one for files, one for web search, one for emails). The AI client treats them separately, and depending on the AI's request, the appropriate server is addressed. So it's definitely possible to build a really powerful setup where the AI can draw from many sources – all modular and extensible.

6. MCP Server List

Here you'll find a large list of available MCP servers for various use cases: