Module 1: What MCP Is and Why It Matters

The Current MCP Ecosystem

Capsule description

You already know what MCP is and why it matters. Now you're going to explore who uses it, what exists, and where it's headed. The MCP ecosystem isn't a future promise — it's an actively growing reality. AI hosts like Claude Code, Cursor, and Windsurf already support MCP. There are hundreds of open source MCP servers. And the community grows every month.

In this capsule you're going to map the complete ecosystem: which hosts support MCP, which existing servers you can use right now, and which categories of servers are the most popular. By the end, you'll have a clear view of where you're stepping in and what opportunities exist to build your own servers.

AI Hosts that support MCP

Hosts with official support

These AI hosts implement an MCP Client and can connect with any MCP Server:

Hosts with an MCP Client:
├── Claude Code (Anthropic)
│   └── Development CLI with native MCP support
├── Claude Desktop (Anthropic)
│   └── Desktop app with MCP support
├── Cursor (IDE)
│   └── Code editor with integrated AI
├── Windsurf (Codeium)
│   └── IDE with an AI agent
├── Zed (Editor)
│   └── Code editor with MCP support
├── Continue.dev
│   └── Open source extension for VS Code/JetBrains
└── Sourcegraph Cody
    └── AI coding assistant

What does "MCP support" mean for a host?

When a host supports MCP, it means that:

It has an integrated MCP Client — it can establish connections with MCP Servers
It discovers capabilities automatically — when it connects with a Server, it knows which Resources, Tools, and Prompts are available
It can invoke Tools — the model can decide to use the Server's tools
It can read Resources — it can access data exposed by the Server
It can use Prompts — it can run predefined templates

For you as a developer: Your MCP Server works in all of these hosts without changing a line of code. You build once, it works everywhere.

Differences between hosts

Although all of these hosts support MCP, there are differences in how they implement it:

Claude Code:
├── Full support (Resources, Tools, Prompts)
├── Configuration via CLI: claude mcp add ...
├── Scope: user, project, or local
└── Transport: stdio (main), Streamable HTTP

Cursor:
├── Support for Tools (partial Resources)
├── Configuration via settings JSON
└── Transport: stdio

Windsurf:
├── Support for Tools
├── Configuration via settings
└── Transport: stdio

Zed:
├── Support for Tools and Prompts
├── Configuration via settings
└── Transport: stdio

Don't worry about these differences now — in this guide we use Claude Code as the main host. What matters is that the underlying protocol is the same.

Categories of MCP Servers

Development and code servers

Development:
├── GitHub MCP Server
│   └── PRs, issues, repos, code search
├── GitLab MCP Server
│   └── Merge requests, pipelines, repos
├── Linear MCP Server
│   └── Issues, projects, cycles
├── Sentry MCP Server
│   └── Error tracking, issues, events
└── Filesystem MCP Server
    └── Read/write local files

These are the most relevant for you — they connect your development tools directly with Claude Code.

Database servers

Databases:
├── PostgreSQL MCP Server
│   └── Queries, schemas, migrations
├── SQLite MCP Server
│   └── Local queries, schemas
├── MongoDB MCP Server
│   └── Documents, collections, queries
├── Redis MCP Server
│   └── Keys, values, pub/sub
└── Supabase MCP Server
    └── Auth, database, storage

Imagine asking Claude Code "how many active users do we have this week?" and having it run the query directly against your database.

Productivity servers

Productivity:
├── Notion MCP Server
│   └── Pages, databases, search
├── Google Drive MCP Server
│   └── Files, folders, search
├── Slack MCP Server
│   └── Messages, channels, search
├── Google Calendar MCP Server
│   └── Events, calendars
└── Todoist MCP Server
    └── Tasks, projects

Cloud and infrastructure servers

Cloud:
├── AWS MCP Server
│   └── S3, Lambda, EC2, CloudWatch
├── Docker MCP Server
│   └── Containers, images, compose
├── Kubernetes MCP Server
│   └── Pods, services, deployments
├── Vercel MCP Server
│   └── Deployments, projects, domains
└── Cloudflare MCP Server
    └── Workers, KV, R2

AI and data servers

AI/Data:
├── Brave Search MCP Server
│   └── Web search, news search
├── Puppeteer MCP Server
│   └── Browser automation, screenshots
├── Fetch MCP Server
│   └── HTTP requests, web scraping
└── Memory MCP Server
    └── Persistent memory across sessions

Anatomy of an existing MCP Server

To understand the ecosystem better, let's look at how two typical MCP Servers are built.

Example 1: Filesystem MCP Server

The Filesystem MCP Server is one of Anthropic's official reference servers. It's ideal as an example because it's simple and concrete:

What it exposes:

Filesystem MCP Server:
│
├── Tools:
│   ├── read_file(path)        → Reads a file's contents
│   ├── write_file(path, data) → Writes contents to a file
│   ├── list_directory(path)   → Lists files and folders
│   ├── create_directory(path) → Creates a folder
│   ├── move_file(src, dst)    → Moves/renames a file
│   ├── search_files(pattern)  → Searches files by pattern
│   ├── get_file_info(path)    → File metadata
│   └── read_multiple_files()  → Reads several files at once
│
└── Resources: (none in this case)
└── Prompts: (none in this case)

How it's used in Claude Code:

You: "Read the package.json file and tell me what dependencies I have"

Claude Code:
→ Uses tool read_file("package.json")
→ MCP Server reads the file from disk
→ Returns the contents
→ Claude Code analyzes and responds:
  "You have 12 dependencies: react, next, typescript..."

You: "Search for all .ts files that contain 'TODO'"

Claude Code:
→ Uses tool search_files("**/*.ts")
→ Then read_multiple_files() on the results
→ Filters by 'TODO'
→ Responds with the list of TODOs

Characteristics of the Filesystem Server:

It only exposes Tools (no Resources or Prompts) — it's an example of a simple server
It works with local data (it doesn't need API keys or external authentication)
It requires the user to configure which directories it can access (security boundary)

Example 2: GitHub MCP Server

The GitHub MCP Server is more complex and shows the full power of MCP:

What it exposes:

GitHub MCP Server:
│
├── Tools:
│   ├── create_issue(repo, title, body)     → Creates an issue
│   ├── list_issues(repo, state, labels)    → Lists issues
│   ├── create_pull_request(repo, ...)      → Creates a PR
│   ├── search_repositories(query)          → Searches repos
│   ├── get_file_contents(repo, path)       → Reads repo files
│   ├── create_or_update_file(repo, ...)    → Modifies files
│   ├── push_files(repo, files, message)    → Pushes multiple files
│   ├── search_code(query)                  → Searches code
│   ├── list_commits(repo)                  → Lists commits
│   └── create_branch(repo, branch)         → Creates a branch
│
├── Resources: (depends on the implementation)
│   └── Some expose repo contents as resources
│
└── Prompts: (depends on the implementation)

How it's used in Claude Code:

You: "Create an issue for the bug we found in login,
     with label 'bug' and high priority"

Claude Code:
→ Uses tool create_issue(
    repo="my-company/my-app",
    title="Bug: Login fails with special characters in email",
    body="Steps to reproduce: ...",
    labels=["bug", "high-priority"]
  )
→ GitHub API creates the issue
→ Returns: { "number": 234, "url": "..." }
→ Claude Code: "I created issue #234 in my-company/my-app."

Differences from the Filesystem Server:

It requires authentication (GitHub Personal Access Token)
It communicates with a remote service (GitHub API) rather than the local filesystem
It has more tools and capabilities
It can expose Resources (repo contents as browseable data)

This is MCP in practice — the AI host uses the Server's tools as if they were native capabilities, whether the server works with local files or remote APIs.

MCP Servers that YOU could build

One of the most exciting parts of the MCP ecosystem is that it's full of opportunities. These are examples of servers you could build — some already exist as basic versions, others are open opportunities:

Ideas for personal productivity servers

📊 Toggl/Clockify MCP Server
   → track_time(project, description, duration)
   → get_weekly_report()
   → "How many hours did I work this week on project X?"

📧 Gmail MCP Server
   → search_emails(query, date_range)
   → draft_email(to, subject, body)
   → "Search John's emails about last week's deployment"

📝 Obsidian MCP Server
   → search_notes(query)
   → create_note(title, content, tags)
   → "Create a note with a summary of what I learned today"

Ideas for development servers

🐳 Docker Compose MCP Server
   → list_services()
   → restart_service(name)
   → get_logs(service, lines)
   → "Show me the last 50 logs of the api service"

📈 Grafana/Datadog MCP Server
   → get_dashboard(name)
   → query_metrics(metric, time_range)
   → "How is the response time of the /api/users endpoint?"

🔧 Internal API MCP Server
   → deploy(service, environment)
   → rollback(service)
   → get_health(service)
   → "Deploy the latest commit of auth-service to staging"

Ideas for creative servers

🎵 Spotify MCP Server
   → currently_playing()
   → search_tracks(query)
   → create_playlist(name, tracks)
   → "Create a focus playlist with instrumental music"

📐 Figma MCP Server
   → get_components(file_id)
   → export_assets(component_ids, format)
   → "Export all the design's icons as SVG"

The key point: If you use a service that doesn't have an MCP server (or whose existing server doesn't cover your use case), you have the opportunity to build it. In modules 4-5 you'll learn exactly how. Your final project in module 8 could be one of these.

Who builds MCP Servers

Anthropic (official servers)

Anthropic maintains a set of reference servers that serve as examples and for direct use:

Filesystem (filesystem access)
GitHub (GitHub integration)
GitLab (GitLab integration)
Google Drive (document access)
PostgreSQL (database queries)
Slack (Slack integration)
Memory (persistent memory)
Fetch (HTTP requests)
Puppeteer (browser automation)
Brave Search (web search)

These servers are in the official repo: github.com/modelcontextprotocol/servers

Open source community

Most MCP servers are created by the community:

Contributions by type:
├── Individual developers (60%)
│   └── Servers for services they use in their work
├── Companies (25%)
│   └── Servers for their own products
└── Anthropic (15%)
    └── Reference servers and examples

Opportunity for you: If you use a service that doesn't have an MCP Server, you can build it. The community values contributions and many developers have gained visibility by building useful MCP servers.

Ecosystem growth

Growing adoption

MCP ecosystem timeline:

Nov 2024: Anthropic announces MCP
         → Spec v1.0, initial SDKs in TypeScript and Python
         → ~10 official reference servers
         → The concept is new, few know it

Dec 2024: First adopters
         → Cursor adds MCP support (a strong signal)
         → First community servers start to appear
         → Curious developers start experimenting

Jan-Mar 2025: Rapid growth
         → 100+ community servers published
         → Windsurf, Zed, Continue.dev add support
         → SDKs mature (TypeScript, Python)
         → First tutorials and guides appear
         → The term "MCP server" starts appearing in job postings

Apr-Dec 2025: Established ecosystem
         → 500+ servers in directories
         → MCP Apps with interactive UI (new primitive)
         → Companies adopt MCP internally
         → Spec evolves with community feedback
         → Debugging and testing tools mature

2026: Maturity
         → MCP is the de facto standard for AI integrations
         → Most AI hosts support it natively
         → Thousands of servers available
         → Companies publish official MCP servers for their products
         → Certifications and best practices established

Ecosystem metrics

Key indicators (estimated for 2026):
├── AI Hosts with MCP support:  10+
├── Published MCP Servers:      1,000+
├── Server categories:          15+
├── Official SDK languages:     TypeScript, Python
├── Community SDK languages:    Go, Rust, Java, C#, Ruby
├── GitHub stars (spec):        30,000+
├── Contributors to official repos: 500+
└── Companies with internal MCP: Hundreds

Why adoption is accelerating

Network effects: More hosts with MCP → more incentive to create servers → more servers → more incentive for hosts to adopt MCP. It's a virtuous cycle.
Open source: Anyone can contribute, there's no gatekeeping or centralized approval process.
Low barrier: Creating a basic MCP server takes hours, not weeks. A functional server can be 30-50 lines of code.
Real value: Servers solve real productivity problems — they're not demos. A developer who connects their database with Claude Code saves measurable time every day.
Composability: Each new server adds value not just individually but in combination with other servers. A GitHub server + a Slack server = the ability to notify the team about PRs automatically.

How to find MCP Servers

Main directories

Official MCP Servers repo: github.com/modelcontextprotocol/servers
- Reference servers maintained by Anthropic
- Guaranteed quality, a good starting point
Awesome MCP Servers: github.com/punkpeye/awesome-mcp-servers
- Curated community directory
- Categorized by type
- Includes stars and maintenance
MCP Hub: Online directory with search
- Filters by category, language, popularity
NPM / PyPI:
- Search for packages with the prefix @modelcontextprotocol/ or mcp-server-

Criteria for choosing an MCP Server

Before using a community Server, evaluate it with these criteria:

✅ Strong signals:
├── Actively maintained (commits in the last 4 weeks)
├── Complete README with installation instructions
├── Tests included (unit and/or integration)
├── Issues answered in <1 week
├── >50 stars on GitHub
├── Stable version (v1.0+)
├── Changelog or release notes
└── Clear open source license (MIT, Apache 2.0)

⚠️ Caution signals:
├── No commits in 3+ months
├── Incomplete or outdated README
├── No tests
├── Unanswered issues (>5 open with no response)
├── Only a proof-of-concept (README says "WIP" or "experimental")
├── No defined license
└── Outdated dependencies with vulnerabilities

🚫 Red flags:
├── Asks for credentials insecurely (hardcoded in the code)
├── Access that's too broad without justification
├── No visible source code (closed binary)
└── Nonexistent documentation

Quick evaluation checklist

When you find an MCP server that interests you, ask yourself these questions in this order:

Does it solve my problem? — The server has the tools/resources I need
Is it safe? — I can review the source code and understand what it does
Is it maintained? — It has recent activity and responds to issues
Is it documented? — I can install it by following the README
Does it have tests? — It has some level of automated testing

If the answers are yes to all 5, use it. If it fails on 1-2, evaluate the risk. If it fails on 3+, look for an alternative or build your own.

Comparison: official MCP Server vs community

Aspect	Official Servers	Community Servers
Maintenance	Anthropic team	Volunteers/companies
Quality	High, tested	Variable
Coverage	~15 core services	500+ services
Documentation	Complete	Variable
Update speed	Moderate	Can be fast or slow
Customization	Limited (general purpose)	Specific to use cases
Support	Issues answered	Depends on the maintainer
Security review	Yes	Not guaranteed

Recommendation: Start with official servers to learn. Use community servers when you need specific services. Build your own when none of the existing ones fit your exact needs.

Troubleshooting

"There are so many servers, where do I start?"

Start with 1-2 official servers that solve a real problem for you:

If you work with code: GitHub MCP Server or Filesystem
If you use databases: PostgreSQL or SQLite
If you do research: Brave Search or Fetch

In the next capsule (05) you'll configure your first MCP Server in Claude Code.

"Do MCP Servers have access to my whole system?"

Not automatically. Servers have the access you configure for them. The Filesystem server, for example, only accesses the directories you specify in the configuration. Claude Code asks for confirmation before executing sensitive operations. A server never silently obtains root access to your system.

"Can I use community MCP Servers in production?"

With caution. Evaluate the quality with the criteria above, read the source code, and test before using in production. For personal development use, most community servers work well. For production, consider making a fork and maintaining your own version with the customizations you need.

"Can an MCP server break something in my system?"

It depends on the server. A read-only server (like Brave Search) can't modify anything. A write server (like Filesystem with write access) can create or modify files. That's why it's important to:

Review which capabilities the server exposes before configuring it
Limit the access (specific directories, read-only when possible)
Claude Code asks for confirmation before write operations

"Are there MCP servers that cost money?"

The servers are free open source programs. But the services they connect to can have costs. An AWS MCP server is free, but the AWS resources you use through it do cost money. A Brave Search MCP server is free, but the Brave Search API has free usage limits and paid plans for heavy use.

Exercises

Exercise 1: Explore the official directory (Easy)

Go to the official MCP Servers repo (github.com/modelcontextprotocol/servers) and:

List 5 servers you found
Identify what type of capabilities each one exposes (Resources, Tools, Prompts)
Which would be most useful for your daily work?

See example solution

5 servers from the official repo:

Filesystem — Tools: read_file, write_file, list_directory, search_files
GitHub — Tools: create_issue, search_repos, create_pull_request; Resources: repo contents
PostgreSQL — Tools: query; Resources: schema information
Brave Search — Tools: brave_web_search, brave_local_search
Memory — Tools: store_memory, retrieve_memory; Resources: stored memories

Most useful for me: Depends on your workflow. A backend developer would probably say PostgreSQL or GitHub. A researcher would say Brave Search.

Exercise 2: Map your stack to MCP Servers (Medium)

List the 5 tools/services you use most in your daily work. For each one, search whether an MCP Server exists (official or community). Create a table:

Service	Does an MCP Server exist?	Official or Community?	Link

See example solution

Service	Does it exist?	Type	Notes
GitHub	✅ Yes	Official	Anthropic reference server
PostgreSQL	✅ Yes	Official	Anthropic reference server
Notion	✅ Yes	Community	Several options in awesome-mcp-servers
Vercel	⚠️ Partial	Community	They exist but are limited
Figma	❌ No	—	Opportunity to create one

Insight: If a service you use doesn't have an MCP Server, that's an opportunity to build it yourself at the end of this guide.

Exercise 3: Evaluate an MCP Server (Medium)

Choose a community MCP Server from Awesome MCP Servers and evaluate it against the quality criteria:

Does it have recent commits?
Does it have a README with instructions?
Does it have tests?
Does it have answered issues?
How many stars does it have?

Would you use it in your setup?

See example solution

Evaluated server: Notion MCP Server (hypothetical example)

Recent commits: ✅ Last commit 2 weeks ago
README: ✅ Clear installation and configuration instructions
Tests: ⚠️ Basic tests but not comprehensive
Issues: ✅ Maintainer responds in <48 hrs
Stars: ✅ 230 stars

Verdict: Yes, I'd use it for personal development. For production, I'd review the code more thoroughly and add my own tests.

Exercise 4: Identify opportunities (Hard)

Think of 3 services or APIs you use regularly that DON'T have an MCP Server. For each one, briefly describe what capabilities an MCP Server would expose:

See example solution

1. Spotify (doesn't have a complete MCP Server)

Tools: search_tracks(query), get_playlist(id), currently_playing()
Resources: spotify://playlists — list of the user's playlists
Use: "Put on some focus music" or "what am I listening to?"

2. Stripe (doesn't have a complete MCP Server)

Tools: get_balance(), list_payments(date_range), search_customers(query)
Resources: stripe://dashboard — key dashboard metrics
Use: "How many payments failed this week?"

3. The work's internal API

Tools: deploy(environment), get_metrics(service), list_incidents()
Resources: internal://services — list of microservices
Use: "Deploy the latest commit to staging" or "Are there active incidents?"

Key point: If you identified services without an MCP Server, you have the opportunity to build them at the end of this guide. Your capstone project could be exactly this.

Summary

In this capsule you learned:

Hosts with MCP: Claude Code, Cursor, Windsurf, Zed, Continue.dev, and more — all with an integrated MCP Client
Server categories: Development (GitHub, GitLab), databases (PostgreSQL, MongoDB), productivity (Notion, Slack), cloud (AWS, Docker), and AI/data
Server anatomy: You saw how the Filesystem server (simple, local) and the GitHub server (complex, remote) are built
Servers you could build: Concrete ideas for personal productivity, development, and creative projects
Official vs community servers: Official ones are ~15 and high-quality; community ones are 500+ and of variable quality
Evaluation criteria: How to evaluate a server before using it (maintenance, docs, tests, security)
The ecosystem grows fast: Network effects, open source, and a low barrier to entry drive adoption
Where to find servers: Official repo, Awesome MCP Servers, NPM/PyPI
Opportunity: Services without an MCP Server are opportunities to build and contribute

Next capsule: First contact with MCP — you're going to configure and use an existing MCP Server in Claude Code. From theory to practice.

Additional resources

Official MCP Servers Repository - Anthropic reference servers
Awesome MCP Servers - Curated community directory
MCP Specification - Technical specification of the protocol
Claude Code MCP Documentation - How to configure MCP in Claude Code
Cursor MCP Documentation - MCP in Cursor
MCP TypeScript SDK - To build your own servers

← PreviousMCP: The USB-C of AI Next →First Contact: Using an MCP Server in Claude Code