Skip to main content
All guides

MCP explained

What is an MCP server?

MCP servers are how modern AI coding agents reach beyond their training data - pulling in live tools, data, and context through one standard protocol. Here's what that means, how it works, and how to connect one.

Definition: An MCP (Model Context Protocol) documentation server is a live backend that answers an AI coding agent's questions about a codebase on demand, serving current conventions, architecture, and docs through the open Model Context Protocol. Unlike static .cursorrules or CLAUDE.md files that a human writes once and that go stale, an MCP documentation server re-indexes the repository as it changes, so agents query verified, up-to-date context instead of a frozen snapshot.

Last reviewed: June 2026

Model Context Protocol (MCP) Core Capabilities

Open StandardAnthropic / Industry

1. Tools

Functions

Executable actions the AI agent can invoke to inspect, test, or mutate external systems.

search_code(query)
execute_sql(query)
create_pull_request()

2. Resources

Data & Files

File contents, database schemas, and living documentation attached directly to agent context.

file:///src/index.ts
moxie://conventions.md
schema://postgres/users

3. Prompts

Templates

Pre-engineered workflow prompts exposed by servers for standardized agent tasks.

/review-code-style
/debug-sentry-issue
/friday-cleanup-recap
One standard protocol connects Cursor, Claude Code, Windsurf, and VS Code to any backend.

The short answer

The Model Context Protocol (MCP) is an open standard for connecting AI applications to external tools and data sources. An MCP server is a program that exposes a specific capability - reading files, querying a database, searching documentation, calling an API - in a format any MCP-compatible AI client can use.

Think of it as a universal adapter. Before MCP, every AI tool needed a bespoke integration for every data source. MCP standardizes that connection, so one server works across Claude, Cursor, VS Code, and any other client that speaks the protocol.

Why MCP exists

Large language models are frozen at their training cutoff and isolated from your systems. They don't know your codebase, your database schema, or today's library docs unless something feeds that context in.

MCP, introduced by Anthropic in late 2024 and since adopted across the industry, solves the integration problem the way USB solved peripherals: one protocol instead of a custom connector for every pairing. A tool builder writes one MCP server, and every MCP client can use it.

How an MCP server actually works

An MCP client - your agent - connects to an MCP server over a transport: either a local process over stdio, or a remote server over HTTP. The server advertises what it offers, and the agent calls those capabilities as needed during a task. Servers expose three kinds of things:

  • Tools: Functions the agent can call - search code, run a query, open a pull request.
  • Resources: Data the agent can read - files, records, documentation pages.
  • Prompts: Reusable templates the server exposes for common tasks.

What people use MCP servers for

The fastest-growing category is coding. Developers connect MCP servers so their agent can read the file system, drive a browser, pull production errors, query a database, or fetch current documentation - instead of guessing from stale training data.

A practical caution: connecting many servers at once floods the agent with tools and can degrade its performance. Most teams start with two or three that match their workflow.

Example MCP client configuration

MCP clients configure servers using a standard JSON structure under an mcpServers dictionary. Below is how you connect both a local stdio server (Filesystem) and a remote HTTP server (Moxie Docs) in Cursor (.cursor/mcp.json), Claude Code (~/.claude.json), or Windsurf (mcp_config.json):

  • Client Configuration Block (Cursor, Claude Code & Windsurf)

    JSON
    {
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/repo"]
    },
    "moxie-docs": {
      "url": "https://moxiedocs.com/api/mcp",
      "headers": { "Authorization": "Bearer <YOUR_TOKEN>" }
    }
  }
}

How-to

How to connect an MCP server

  1. 1

    Pick a client and a server

    Choose an MCP-compatible client - Claude Code, Cursor, VS Code, and others - and the server you want, such as a documentation or codebase-context server.

  2. 2

    Add the server to your client config

    Local servers run as a command over stdio; remote servers connect over an HTTP endpoint, usually with an OAuth or token-based sign-in. Add the server's details to your client's MCP configuration.

  3. 3

    Let the agent call it

    Once connected, the agent discovers the server's tools and resources automatically and uses them during tasks - no copy-paste required.

Where Moxie Docs fits

Moxie Docs runs a first-party MCP server for your own codebase. Instead of letting an agent re-crawl your repository on every prompt, it serves your conventions, documentation, doc gaps, and verified commands over MCP - so Cursor, Claude Code, and Codex get accurate, source-cited context in a couple of scoped lookups.

See the Moxie Docs MCP serverCompare plans

FAQ

Frequently asked questions

Quick answers to the questions developers ask about What is an MCP server?.

Keep reading

Related guides

Get started

Give your agents real codebase context.

Connect a repository and Moxie Docs generates living documentation and serves it to your agents over MCP. 14-day free trial, no charge today.

Connect GitHubView pricing