The Model Context Protocol (MCP) has become one of the most interesting developments in AI tooling. After contributing to the ecosystem and building with it, here's my map of the landscape.

What MCP Actually Is

MCP is a standardized protocol for connecting AI assistants to external tools and data sources. Think of it as a common language that lets any AI model talk to any tool — file systems, databases, APIs, design tools, whatever.

Before MCP, every AI integration was custom. Want to connect Claude to your codebase? Build a custom integration. Want to connect GPT to your database? Different integration. MCP standardizes this: build one server, any MCP-compatible client can use it.

The protocol itself is simple: JSON-RPC over stdio or HTTP. Servers expose "tools" (functions the AI can call) and "resources" (data the AI can read). Clients connect and use them.

The Core Repositories

modelcontextprotocol/typescript-sdk — The reference implementation for building MCP servers and clients in TypeScript/JavaScript. If you're building a server, start here. The API is clean:

import { Server } from '@modelcontextprotocol/sdk/server';
 
const server = new Server({
  name: 'my-server',
  version: '1.0.0',
});
 
server.setRequestHandler('tools/call', async (request) => {
  // Handle tool calls
});

modelcontextprotocol/python-sdk — Python equivalent. Slightly different ergonomics but same protocol.

modelcontextprotocol/servers — A collection of official and community servers. Good examples to learn from, some useful as-is.

Notable MCP Servers

The ecosystem has exploded with servers for different use cases:

Developer Tools

  • Figma-Context-MCP — Connects Figma designs to AI coding assistants. Great for building UIs from designs.
  • GitHub MCP Server — Issues, PRs, repository management
  • Linear MCP Server — Task and project tracking integration

Data & APIs

  • PostgreSQL MCP — Query databases directly from AI
  • Filesystem MCP — Read/write local files (careful with this one)
  • Web Search MCP — Brave, Google, etc.

Specialized

  • Slack MCP — Channel and message management
  • Notion MCP — Document and database access
  • Memory MCP — Persistent memory across sessions

Building Your First Server

The barrier to entry is low. A minimal server:

import { Server } from '@modelcontextprotocol/sdk/server';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio';
 
const server = new Server({
  name: 'hello-world',
  version: '1.0.0',
});
 
server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'greet',
    description: 'Greet someone',
    inputSchema: {
      type: 'object',
      properties: {
        name: { type: 'string' }
      },
      required: ['name']
    }
  }]
}));
 
server.setRequestHandler('tools/call', async (request) => {
  if (request.params.name === 'greet') {
    return { content: [{ type: 'text', text: `Hello, ${request.params.arguments.name}!` }] };
  }
});
 
const transport = new StdioServerTransport();
await server.connect(transport);

That's a working MCP server. Configure it in your client, and your AI can now greet people.

Where the Ecosystem is Heading

Authentication is the next frontier. Most servers today assume local/trusted environments. As MCP moves into production, OAuth and API key management will become critical.

Composition is underexplored. Servers calling other servers. Chaining tools. Building higher-level abstractions. The protocol supports it; the tooling doesn't make it easy yet.

Discovery needs work. Finding the right server for your use case is still manual browsing. Expect registries and package managers.

Performance varies wildly. Some servers are blazing fast. Others block for seconds. Async patterns and streaming will become more important.

Getting Started

  1. Install an MCP client — Claude Desktop, Cursor, Continue, or others
  2. Try a simple server — The filesystem server is a good first test
  3. Read the TypeScript SDK — The code is cleaner than most docs
  4. Build something small — A server for your specific workflow

The best way to understand MCP is to build with it. Pick a tool you use daily and make it accessible to AI.

My Take

MCP reminds me of early web APIs — a little rough, standards still forming, but clearly the right direction. The teams building on it now will have significant advantages when AI-assisted development becomes the default.

The protocol is simple enough that building a basic server takes an afternoon. The hard part is figuring out what to expose and how to structure it for AI consumption.

If you're doing anything with AI tooling, MCP is worth understanding. Not because it's perfect, but because it's the emerging standard and the ecosystem is growing fast.

I've contributed to the MCP TypeScript SDK and built tools on top of the protocol. Happy to discuss specifics if you're exploring this space.

React to this post: