MCP vs API: What's the Difference, and How Do You Build an MCP Server?

If you've been building with AI lately, you've probably come across MCP (Model Context Protocol). At first glance, it might look like just another API. But there's an important difference.

Let's break it down with a practical example.

What is an API?

An API is how one piece of software talks to another.

Say you're building a dashboard that shows your server's CPU usage. Your application calls a monitoring API, gets the data back, and displays it on the screen.

You write the integration, handle authentication, process the response, and decide what to do with the data.

Most applications you use every day rely on APIs in some form.

What is MCP?

MCP is an open protocol that gives AI applications a standard way to connect to external tools, services, and data.

Imagine asking an AI assistant:

"Check my server's CPU usage, look at the recent logs, and tell me why the application is slow."

The AI can't access your infrastructure on its own. You need to give it a way to interact with those systems.

MCP helps standardize that connection. An MCP server can expose tools that a compatible AI client discovers and calls when needed.

Instead of building a separate integration for every AI client, you can provide a common interface for your tools.

MCP vs API: What's the difference?

Feature	API	MCP
Main purpose	Lets software communicate	Standardizes how AI clients access tools and context
Typical users	Applications, services, developers	AI assistants and compatible agents
Integration	Often requires client-specific implementation	Provides a common protocol for supported clients
Tool discovery	Depends on the API and its documentation	Supports standardized tool discovery
Can they work together?	Yes	Yes, MCP can use APIs behind the scenes

MCP doesn't magically give an AI access to everything. Developers still need to expose the right tools, configure permissions, and decide what the AI is allowed to do.

Does MCP replace APIs?

No. Think of MCP as a layer that can make existing functionality accessible to AI.

Suppose you already have an API that returns the number of active WebSocket connections on your server.

You could expose that functionality through an MCP server. A compatible AI assistant could then use it to answer:

"How many users are connected to my application right now?"

Your existing API can continue doing the actual work. MCP provides a standardized way for the AI client to access that capability.

This is especially useful for AI agents that need to interact with multiple services instead of simply generating text.

How to build your own MCP server

Building a basic MCP server is easier than you might expect. You don't need to rewrite your existing backend. You can start by exposing one useful function as an MCP tool.

Here's a simple example using Node.js and the official TypeScript MCP SDK.

1. Create a project

Install a recent version of Node.js, then create a project and install the dependencies:

mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript tsx @types/node

2. Create the MCP server

Create a file named index.ts:

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

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

server.registerTool(
  "get_server_status",
  {
    title: "Get Server Status",
    description: "Returns the current server status.",
    inputSchema: {
      serverName: z.string().describe("Name of the server"),
    },
  },
  async ({ serverName }) => {
    // Replace this with a real monitoring API call.
    const status = {
      server: serverName,
      status: "healthy",
      uptime: "3 days",
    };

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(status, null, 2),
        },
      ],
    };
  }
);

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

This server exposes a tool called getserverstatus. An MCP-compatible client can discover the tool, provide a server name, and receive the result.

For now, the example returns sample data. In a real implementation, you would call your monitoring API or query your infrastructure.

3. Run the server

Run it using tsx:

npx tsx index.ts

This example uses stdio transport, which is useful when an MCP client launches the server as a local process. For a remotely hosted MCP server, you would typically use Streamable HTTP transport instead.

When using stdio, keep standard output reserved for MCP protocol messages. Send diagnostic logs to standard error so they don't interfere with communication.

4. Connect an AI client

Configure an MCP-compatible client to launch your server using the appropriate command and arguments. The exact configuration depends on the client.

Once connected, the client can discover getserverstatus and make it available to the AI model.

You can now ask a question such as:

"Check the status of my production server."

The AI can decide whether to call the tool, pass the required input, and explain the returned result.

Before connecting real infrastructure, add proper authentication where applicable, validate inputs, limit access to sensitive data, and require confirmation for destructive operations.

For remote deployments, also configure transport security and appropriate authorization.

When should you use MCP or an API?

Use an API when you're building a website, mobile app, backend service, or conventional software integration.

Use MCP when you want AI assistants to discover and interact with your tools and data through a standardized protocol.

You don't have to choose one over the other. Many systems will use APIs for their core functionality and MCP to make selected capabilities available to AI clients.

The takeaway

APIs let applications communicate. MCP standardizes how AI applications discover and use tools and context.

If you're building developer tools, consider supporting both. Keep your core functionality accessible through APIs, then use MCP to make useful capabilities available to AI assistants and agents.

That's how you can move from an AI that only answers questions to one that can actually interact with your software.