MCP Is Winning the Agent Tool Protocol War

Building an MCP Server

The fastest path to production is the official TypeScript or Python SDK. An MCP server is a process that speaks JSON-RPC 2.0 over one of the supported transports and exposes tools, resources, or prompts (or any combination of the three).

TypeScript Example — A Database Query Server:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import Database from "better-sqlite3";

const server = new McpServer({
  name: "sqlite-query",
  version: "1.0.0",
});

const db = new Database("/path/to/your.db", { readonly: true });

// Expose a tool for running read-only SQL queries
server.tool(
  "query",
  "Execute a read-only SQL query against the database",
  {
    sql: z.string().describe("The SQL SELECT query to execute"),
  },
  async ({ sql }) => {
    // Safety: only allow SELECT statements
    if (!sql.trim().toUpperCase().startsWith("SELECT")) {
      return {
        content: [{ type: "text", text: "Error: Only SELECT queries allowed" }],
        isError: true,
      };
    }
    const rows = db.prepare(sql).all();
    return {
      content: [{ type: "text", text: JSON.stringify(rows, null, 2) }],
    };
  }
);

// Expose the database schema as a resource
server.resource(
  "schema",
  "db://schema",
  "The database schema for all tables",
  async () => {
    const tables = db
      .prepare("SELECT sql FROM sqlite_master WHERE type='table'")
      .all();
    return {
      contents: [{
        uri: "db://schema",
        mimeType: "text/plain",
        text: tables.map((t: any) => t.sql).join("\n\n"),
      }],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Python Example — A Web API Connector:

from mcp.server.fastmcp import FastMCP
import httpx

mcp = FastMCP("github-issues", version="1.0.0")

@mcp.tool()
async def list_issues(
    repo: str,
    state: str = "open",
    limit: int = 10,
) -> str:
    """List GitHub issues for a repository.

    Args:
        repo: Repository in owner/name format (e.g. 'anthropics/mcp')
        state: Filter by state — open, closed, or all
        limit: Maximum number of issues to return
    """
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f"https://api.github.com/repos/{repo}/issues",
            params={"state": state, "per_page": limit},
            headers={"Accept": "application/vnd.github.v3+json"},
        )
        resp.raise_for_status()
        issues = resp.json()

    lines = []
    for issue in issues:
        lines.append(f"#{issue['number']} [{issue['state']}] {issue['title']}")
    return "\n".join(lines) if lines else "No issues found."

@mcp.tool()
async def create_issue(
    repo: str,
    title: str,
    body: str = "",
) -> str:
    """Create a new GitHub issue.

    Args:
        repo: Repository in owner/name format
        title: Issue title
        body: Issue body in markdown
    """
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"https://api.github.com/repos/{repo}/issues",
            json={"title": title, "body": body},
            headers={
                "Accept": "application/vnd.github.v3+json",
                "Authorization": f"Bearer {os.environ['GITHUB_TOKEN']}",
            },
        )
        resp.raise_for_status()
        issue = resp.json()
    return f"Created issue #{issue['number']}: {issue['html_url']}"

if __name__ == "__main__":
    mcp.run(transport="stdio")

Transport Mechanisms

MCP supports three transports, and choosing the right one determines how your server deploys:

stdio is the original transport. The MCP client launches the server as a child process and communicates over standard input/output. Best for: local development tools, CLI integrations, desktop applications. Claude Desktop, Claude Code, and Cursor all use stdio for local MCP servers. Zero network configuration required.

Streamable HTTP is the recommended transport for remote deployments (introduced in the 2025-03-26 spec revision). The client sends JSON-RPC requests via HTTP POST to a single endpoint. The server can respond with a single JSON response or upgrade to a Server-Sent Events stream for progress updates and multi-part results. This replaced the older SSE transport and is now the preferred production mechanism.

// Remote MCP server using Streamable HTTP transport
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from
  "@modelcontextprotocol/sdk/server/streamableHttp.js";
import express from "express";

const app = express();
app.use(express.json());

const server = new McpServer({ name: "remote-api", version: "1.0.0" });

// ... register tools, resources, prompts ...

const transport = new StreamableHTTPServerTransport({ endpoint: "/mcp" });
app.use("/mcp", async (req, res) => {
  await transport.handleRequest(req, res);
});

await server.connect(transport);
app.listen(3001);

SSE (deprecated) was the original remote transport. It used one endpoint for client-to-server messages (POST) and another for server-to-client events (GET with SSE). Still supported for backward compatibility, but new servers should use Streamable HTTP.

Authentication for Remote Servers

The spec now includes an OAuth 2.1 authorization flow for remote MCP servers. When a client connects to a remote server that requires auth, the server responds with a 401 and an RFC 8414 authorization server metadata URL. The client then performs a standard OAuth flow — authorization code with PKCE — and attaches the resulting Bearer token to subsequent requests. This means your MCP server can integrate with existing identity providers (Auth0, Okta, Cognito) without inventing a custom auth scheme.

Key Tool Categories in the Ecosystem

The 2,000+ MCP servers in the ecosystem cluster into predictable categories:

• Databases: PostgreSQL, MySQL, SQLite, MongoDB, Redis, Elasticsearch — each exposing query, schema inspection, and (optionally) write tools.
• Developer tools: GitHub, GitLab, Jira, Linear, Sentry — issue management, code search, deployment status.
• Web and search: Brave Search, Google Search, web scraping (Firecrawl, Browserbase), URL fetching.
• Communication: Slack, Discord, email (via SMTP or Resend/SendGrid APIs), calendar management.
• Cloud infrastructure: AWS, GCP, Cloudflare, Vercel, Kubernetes — resource management, log queries, deployment triggers.
• Enterprise systems: Salesforce, HubSpot, Notion, Confluence, Google Workspace — CRM data, document access, knowledge bases.
• File and storage: Local filesystem, S3, Google Drive, Dropbox — file read/write, search, and organization.

Platform Dynamics

MCP creates a two-sided marketplace dynamic. On one side, tool and API providers who ship MCP servers make their products instantly accessible to every AI agent. On the other side, agent frameworks that support MCP as a client get access to the entire tool ecosystem without bilateral integration work. This is the classic platform flywheel: more servers attract more clients, which attract more servers.

Winners:

• Anthropic gains ecosystem influence without direct revenue. By controlling the spec (even as an open standard), Anthropic shapes the conventions that every agent builder follows. Claude’s tool-use capabilities were designed around MCP’s primitives, giving it a subtle home-field advantage in how tools are described and invoked.
• SaaS companies that ship MCP servers early. If your product has an MCP server in the community registry, every Claude, ChatGPT, and Gemini user can connect to it by adding a single config block. This is a new distribution channel — tool discovery via agent, not via app store. Companies like Stripe, Sentry, and Cloudflare that published official MCP servers in 2025 are seeing organic agent-driven API usage they never marketed for.
• Agent framework developers. LangChain, CrewAI, and similar frameworks become more valuable as the MCP ecosystem grows — they are the middleware layer that connects arbitrary agents to arbitrary tools.
• Enterprise integration platforms. Companies building managed MCP server hosting and governance (server registries, access controls, audit logging) are filling a real gap. The protocol defines the wire format; it does not define the management plane.

Losers:

• Proprietary tool-calling ecosystems. OpenAI’s custom GPT Actions, Google’s Vertex Extensions, and similar proprietary integration formats are being deprioritized by builders in favor of “build once with MCP, deploy everywhere.” Products that only support one vendor’s integration format are limiting their addressable market.
• Traditional iPaaS platforms (Zapier, Make, Workato) face a strategic challenge. MCP allows agents to call APIs directly with structured, schema-aware tool interfaces — exactly the problem iPaaS platforms solve for human-in-the-loop workflows. The integration layer is moving from human-configured workflows to agent-discovered tools.
• Tool providers that ignore MCP. The integration tax is real and growing. If a developer must write custom tool definitions to connect your API to an agent — instead of pointing at your MCP server — they will choose a competitor that publishes one. This is the same dynamic that punished SaaS companies without REST APIs in the 2010s.

The Open Question: Who Governs the Spec?

MCP is currently maintained by Anthropic with community input via GitHub. There is no independent standards body. This mirrors the early days of Docker (company-controlled spec) before the Open Container Initiative formed. As MCP adoption deepens and enterprise budgets depend on it, expect pressure for either a formal foundation or multi-vendor governance structure. The spec’s evolution — particularly around security, auth, and server verification — will increasingly have financial consequences for the ecosystem.