MCP (Model Context Protocol) is an open protocol that standardizes how AI models connect to external tools and data sources. It was created by Anthropic and is now supported by Claude Desktop, Cursor, VS Code, and a growing number of other tools.

Before MCP, connecting an AI model to your database or internal APIs meant writing custom integration code for each model provider and each IDE separately. MCP replaces that with a single protocol that works across all of them.

As a practical example: say you're working in Cursor and you ask "show me the slowest API endpoints from the last hour." Without MCP, the model can only suggest that you go check your monitoring dashboard. With an MCP server connected to your observability stack, Cursor can actually query your traces, pull the data, and show you the results inline. You write a prompt, the model calls a tool through MCP, and the answer comes back with real data from your system.

What MCP Actually Does

MCP defines a communication protocol between two parties:

• MCP Clients: The AI-powered applications (Claude Desktop, Cursor, VS Code Copilot, your custom AI agent) that need to access external tools and data.
• MCP Servers: Lightweight programs that expose specific capabilities to AI clients. A server might provide access to a database, a file system, a Kubernetes cluster, or a third-party API.

The protocol uses JSON-RPC 2.0 for message passing. A client connects to one or more servers, discovers what capabilities they offer, and uses them during conversations or code generation.

An MCP server can expose three types of capabilities:

Tools

Tools are functions the AI model can call. They take structured input and return structured output. A tool might execute a database query, create a GitHub issue, or fetch data from an API.

{
  "name": "query_database",
  "description": "Run a read-only SQL query against the production database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "SQL query to execute" }
    },
    "required": ["query"]
  }
}

When the AI model decides it needs data from the database, it calls this tool with a SQL query, and the MCP server executes it and returns the results.

Resources

Resources are data the AI can read. They work like files: each resource has a URI and returns content. A resource might expose a configuration file, a log output, or an API schema.

{
  "uri": "config://app/database",
  "name": "Database Configuration",
  "description": "Current database connection settings and schema",
  "mimeType": "application/json"
}

Resources are read-only and help the AI understand the current state of a system without making changes.

Prompts

Prompts are reusable templates that help the AI handle specific tasks. A server can expose pre-built prompts for common operations like "analyze this error log" or "review this pull request."

{
  "name": "analyze_error",
  "description": "Analyze an error log and suggest fixes",
  "arguments": [
    {
      "name": "error_log",
      "description": "The error log content to analyze",
      "required": true
    }
  ]
}

Prompts are optional but useful for guiding the AI toward effective patterns when interacting with your specific tools.

How MCP Communication Works

An MCP session follows a straightforward lifecycle:

1. Connection: The client connects to the server. MCP supports two transport mechanisms:

• stdio: The client spawns the server as a child process and communicates over stdin/stdout. This is the most common approach for local development.
• Streamable HTTP: The client connects to the server over HTTP, with optional server-sent events for streaming responses. This is the primary transport for remote servers and production deployments.

2. Initialization: The client and server exchange capabilities. The client says what protocol version it supports. The server responds with its list of tools, resources, and prompts.

3. Operation: The AI model interacts with the server's capabilities as needed during a conversation. The client sends requests (call this tool, read this resource), and the server responds.

4. Shutdown: Either side can close the connection gracefully.

Here's what the message flow looks like for a tool call:

Client → Server: {"jsonrpc": "2.0", "method": "tools/call", "params": {"name": "query_database", "arguments": {"query": "SELECT count(*) FROM users"}}, "id": 1}
Server → Client: {"jsonrpc": "2.0", "result": {"content": [{"type": "text", "text": "Count: 42,531"}]}, "id": 1}

The AI model sees the tool definition, decides when to use it, formulates the input, and processes the output. The MCP server handles the actual execution.

MCP Servers vs. MCP Clients

Understanding the server/client distinction is important because it determines where code runs and who is responsible for what.

MCP Servers

An MCP server is a program that wraps some capability and exposes it through the MCP protocol. Servers are typically:

• Small and focused. One server per integration (a Postgres server, a GitHub server, a Slack server).
• Running locally. Most MCP servers run on the developer's machine, which means data doesn't leave the local environment.
• Stateless or lightly stateful. Each request is typically independent. The server might maintain a database connection pool but doesn't need to track conversation state.

There are MCP servers for most common development tools: databases (Postgres, MySQL, SQLite), version control (GitHub, GitLab), infrastructure (AWS, Kubernetes), monitoring (Datadog, Sentry), and many more. The community maintains a growing registry at mcp.so.

MCP Clients

An MCP client is the AI application that connects to servers and uses their capabilities. The client handles:

• Server lifecycle. Starting, connecting, and shutting down MCP servers.
• Capability discovery. Learning what tools, resources, and prompts each server offers.
• Tool approval. In most implementations, the user must approve tool calls before execution (especially for destructive operations).
• Context management. Deciding which server capabilities are relevant for the current conversation.

The major AI coding tools all support MCP as clients: Claude Desktop, Cursor, VS Code with Copilot, Windsurf, Zed, and others. When you configure an MCP server in one of these tools, it shows up as available tools the AI can use during your session.

Why MCP Matters for Developers

One Integration, Many Clients

Before MCP, if you wanted an AI tool to interact with your internal API, you had to build a separate integration for each AI client. A Cursor extension, a VS Code extension, a ChatGPT plugin, each with its own format and lifecycle.

With MCP, you build one server, and it works everywhere. Any MCP-compatible client can connect to it. Build an MCP server for your internal deployment system, and it works in Claude Desktop, Cursor, and any other MCP client without changes.

Local-First by Default

MCP servers typically run on your machine. Your database credentials, API keys, and data stay local. The AI model sends structured requests to the MCP server, and the server handles the actual system access. This is fundamentally different from cloud-based plugins where your credentials are sent to a third-party server.

For enterprise environments, this matters. Compliance teams are more comfortable with a model that queries data through a local intermediary than one that needs direct access to production systems.

Composable Architecture

A single client can connect to multiple MCP servers simultaneously. You might have:

• A Postgres server for database access
• A GitHub server for repository operations
• A custom server for your internal deployment API
• A monitoring server for log queries

The AI model sees all the tools from all connected servers and can use them together in a single conversation. "Check the error rate in the monitoring dashboard, look at the relevant code in GitHub, and suggest a fix" becomes possible when the model has access to all three systems.

Type-Safe Tool Definitions

MCP tool definitions use JSON Schema for input validation. This means the AI model knows exactly what parameters a tool expects, what types they should be, and which ones are required. The server validates inputs before execution. This reduces hallucinated tool calls and catches errors before they reach your systems.

Building an MCP Server

Here's a complete MCP server in TypeScript that provides read access to a PostgreSQL database:

import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import pg from "pg";

const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL,
});

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

// Expose a tool for running read-only queries
server.tool(
  "query",
  "Run a read-only SQL query against the database",
  {
    sql: { type: "string", description: "SQL SELECT query to execute" },
  },
  async ({ sql }) => {
    // Block non-SELECT statements
    const normalized = sql.trim().toLowerCase();
    if (!normalized.startsWith("select")) {
      return {
        content: [{ type: "text", text: "Error: Only SELECT queries are allowed" }],
        isError: true,
      };
    }

    try {
      const result = await pool.query(sql);
      return {
        content: [{
          type: "text",
          text: JSON.stringify(result.rows, null, 2),
        }],
      };
    } catch (err: any) {
      return {
        content: [{ type: "text", text: `Query error: ${err.message}` }],
        isError: true,
      };
    }
  }
);

// Expose the database schema as a resource
server.resource(
  "schema",
  new ResourceTemplate("schema://tables/{table}", { list: undefined }),
  async (uri, { table }) => {
    const result = await pool.query(
      `SELECT column_name, data_type, is_nullable
       FROM information_schema.columns
       WHERE table_name = $1
       ORDER BY ordinal_position`,
      [table]
    );

    return {
      contents: [{
        uri: uri.href,
        mimeType: "application/json",
        text: JSON.stringify(result.rows, null, 2),
      }],
    };
  }
);

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

To use this server with Claude Desktop, you'd add it to your configuration:

{
  "mcpServers": {
    "my-database": {
      "command": "npx",
      "args": ["tsx", "/path/to/server.ts"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/myapp"
      }
    }
  }
}

Now when you chat with Claude, it can query your database and read table schemas. You can ask "What are the most common error types in the last hour?" and Claude will write a SQL query, execute it through the MCP server, and interpret the results.

Security Considerations

A few things to keep in mind when building MCP servers:

• Input validation is your responsibility. The JSON Schema validates types, but business logic validation (like the SELECT-only check above) is up to you.
• Least privilege. Create a read-only database user for the MCP server. Don't use your admin credentials.
• Rate limiting. AI models can be chatty with tool calls. Consider adding rate limiting to prevent runaway queries.
• Audit logging. Log every tool call with its parameters. You want to know what the AI executed on your systems.

MCP in practice with Encore.ts

The usefulness of an MCP server depends on how much it knows about your system. A generic Postgres MCP server gives the AI raw SQL access. An MCP server that understands your service architecture, API schemas, database schemas, and request traces gives it significantly more to work with.

Encore.ts ships with a built-in MCP server that exposes all of this. Because Encore's framework uses typed constructs for services, APIs, databases, and Pub/Sub topics, the MCP server can expose your entire backend architecture to AI tools without any configuration.

Setting it up

Enable the Encore MCP server in your AI tool's config. For Claude Desktop:

{
  "mcpServers": {
    "encore": {
      "command": "encore",
      "args": ["mcp"]
    }
  }
}

For Cursor, add the same config in your MCP settings. That's it. No API keys, no setup scripts. The MCP server reads your Encore project and exposes its architecture.

What the AI can see

Once connected, your AI tool gets access to:

• Service graph: Which services exist, how they depend on each other
• API schemas: Every endpoint with its typed request/response parameters
• Database schemas: Tables, columns, and types from your migration files
• Pub/Sub topics: Topic names, event types, and which services subscribe
• Distributed traces: Real request traces showing how requests flow through services, including timing and errors

What this looks like in practice

Say you have an Encore backend with an orders service, a payments service, and a notifications service. You're working in Cursor and you type:

Add a refund endpoint to the orders service that reverses the payment and notifies the customer

Because the MCP server exposes your architecture, the AI knows that orders already has a database with an orders table, that payments has a charge endpoint it can reference, and that notifications subscribes to events on specific topics. The generated code follows your existing patterns, uses your actual database schema, and publishes to the right topics.

Without MCP, the AI would guess at your project structure and produce code that might not match your actual services or database.

You can also ask questions about your running system: "Which endpoints had the highest error rate today?" or "Show me the trace for request X." The AI queries your distributed traces through MCP and gives you real data.

For the full setup guide, see Encore's MCP documentation. For a broader comparison of how frameworks support AI-assisted development, see the best frameworks for AI-assisted development.

The MCP Ecosystem

MCP adoption has grown rapidly since Anthropic open-sourced the specification. As of early 2026, the ecosystem includes:

AI Clients with MCP Support

• Claude Desktop: Anthropic's desktop app. Full MCP support with tool approval UI.
• Claude Code: Anthropic's CLI agent. Uses MCP servers for system access.
• Cursor: AI code editor. MCP servers appear as available tools during chat and composition.
• VS Code + Copilot: GitHub's Copilot supports MCP servers for workspace-specific tools.
• Windsurf (Codeium): MCP support for connecting to external tools.
• Zed: Built-in MCP support in the editor.

Popular MCP Servers

• Filesystem: Read and write files on the local machine.
• GitHub: Repository operations (issues, PRs, code search).
• Postgres / MySQL / SQLite: Database querying and schema inspection.
• Kubernetes: Cluster management and pod inspection.
• Slack: Read and send messages.
• Sentry: Error tracking and issue lookup.
• AWS: Cloud resource management.
• Encore: Backend service architecture, traces, and API schemas.

The community maintains directories of available servers at mcp.so and on GitHub. Most servers are open source and can be adapted for specific needs.

Building vs. Using

For most common integrations (databases, GitHub, Slack), a pre-built MCP server exists and works well. Building a custom server makes sense when:

• You need to expose an internal API or proprietary system.
• You want to add business-specific guardrails (query restrictions, approval workflows).
• The available server doesn't expose the capabilities you need.
• You want to combine multiple data sources into a single, coherent interface.

Getting Started with MCP

As a User

The fastest way to start using MCP is through an AI client that already supports it:

1. Install Claude Desktop from claude.ai/download.
2. Configure an MCP server. Edit your Claude Desktop config to add a server (the filesystem server is a good starting point).
3. Chat and use tools. When you ask a question that requires tool access, Claude will request permission to call the relevant tool.

As an Encore.ts User

If you're already using Encore.ts, MCP is built in. Run encore mcp or add it to your AI tool's config as shown in the Encore.ts section above. Your service graph, APIs, databases, and traces are exposed automatically. See the Encore MCP docs for the full setup guide.

As a Builder

To build your own MCP server:

1. Install the SDK. npm install @modelcontextprotocol/sdk for TypeScript, or use the Python SDK (pip install mcp).
2. Define your tools and resources. What capabilities should the AI have access to?
3. Implement the handlers. Write the code that executes when the AI calls a tool or reads a resource.
4. Test locally. Connect your server to Claude Desktop or the MCP Inspector tool for testing.

The official documentation is at modelcontextprotocol.io. Anthropic's TypeScript SDK is at github.com/modelcontextprotocol/typescript-sdk. The Python SDK is at github.com/modelcontextprotocol/python-sdk.

MCP Inspector

The MCP Inspector is a developer tool for testing MCP servers without needing a full AI client. It connects to your server, lists capabilities, and lets you call tools and read resources interactively. It's useful for debugging during development.

Where MCP is Heading

MCP is still evolving. A few directions to watch:

• Remote servers. Most MCP servers run locally today, but the protocol supports HTTP transport for remote servers. This enables hosted MCP servers that teams can share, and opens the door to production-grade tool access for AI agents.
• Authentication and authorization. The current spec is minimal on auth. As remote servers become more common, expect standardized auth flows (OAuth, API keys) to be added to the spec.
• Agent workflows. As AI agents become more autonomous (running multi-step tasks without human approval for each step), MCP servers become the execution layer. The agent plans, the MCP servers execute.
• Streaming. Some MCP operations are long-running (large queries, complex deployments). Streaming support in the protocol allows servers to send partial results and progress updates.

Conclusion

MCP solves a real problem: AI models need to interact with external systems, and before MCP, every integration was custom. The protocol standardizes that interaction, making it possible to build one integration that works with any MCP-compatible AI client.

For backend developers, MCP is particularly relevant because it determines how well AI tools can understand and work with your systems. Frameworks that provide machine-readable architecture metadata, like Encore.ts, enable richer AI interactions because the MCP server has more context to expose.

If you're building tools for AI agents, MCP is the interface to target. If you're using AI for development, enabling MCP servers for your stack gives the AI direct access to your systems instead of relying on copy-paste.

Explore Encore's MCP integration

Related Resources

• Best Frameworks for AI-Assisted Development 2026
• How to Build Microservices with TypeScript
• Best TypeScript Backend Frameworks 2026
• How to Build a RAG Pipeline with TypeScript and PostgreSQL