How to Use Strapi's Docs MCP Server to Power AI Developer Tools

Strapi is an open-source headless CMS, and its Docs MCP server is a Kapa-hosted Model Context Protocol (MCP) endpoint that lets Cursor, VS Code with GitHub Copilot, Claude Code, and Windsurf search the live Strapi documentation before answering. It needs a single URL and no token, and it sits apart from Strapi's content MCP server. This guide covers what it is, why doc-grounding stops Strapi 4-era hallucinations, how to configure it in each IDE, and how it fits with Strapi's llms.txt files and the content MCP server.

Ask an AI coding assistant to write a Strapi service and there's a fair chance it hands you deprecated Entity Service code keyed on an old numeric identifier, an approach that worked in Strapi 4 and fails in Strapi 5. The Strapi Docs MCP server fixes that by letting your AI developer tools query docs.strapi.io at answer time instead of reconstructing Strapi from training data.

Strapi's own Docs MCP server page describes the result: "Once connected, your AI coding assistant can query the Strapi documentation directly to answer questions, suggest implementations, and verify API usage."

If you've spent an afternoon debugging why a title read from the old nested response shape comes back undefined, or why an obsolete publication-state filter does nothing, you already know the cost of stale suggestions. One workaround is to paste docs pages into every prompt. The Docs MCP server replaces that copy-paste ritual with a retrieval tool your assistant can call on its own.

By the end of this article you'll have the server connected in your IDE, a prompting pattern that reliably triggers a docs lookup, and a clear picture of when to reach for the llms.txt files or the content MCP server instead.

In brief:

• The Docs MCP server is powered by Kapa, the same engine behind the Ask AI button on docs.strapi.io, and it answers questions about Strapi rather than acting on your content.
• Configuration is one URL, https://strapi-docs.mcp.kapa.ai, with no API token and no minimum Strapi version.
• Cursor, VS Code with GitHub Copilot, Claude Code, Windsurf, and any other MCP-compatible tool are supported; each client uses a slightly different config key.
• Prefix docs questions with Use the strapi-docs MCP server to answer:, include the docs page URL, and state that you're on Strapi 5.

These points give you the minimum setup and prompting pattern needed to start using the server.

What the Docs MCP Server Is (and Isn't)

Strapi's Docs MCP server page opens by distinguishing its two MCP servers: the Docs MCP server covered on that page and the Strapi MCP server for content management covered on its dedicated feature page.

The Docs MCP server is the documentation one. It is "Powered by Kapa, the same service behind the Ask AI button on the documentation website. It draws from the full Strapi documentation, including guides, API references, and code examples." The server lives at https://strapi-docs.mcp.kapa.ai, hosted by Kapa rather than by any Strapi instance you run. Because of that, it has no Strapi version requirement; you can point a Strapi 5.52.2 project or a half-migrated Strapi 4 codebase at it and get the same answers.

Under the hood it's a standard remote MCP server. The MCP client-host-server model works like this: your IDE is the host, it spins up a client per server, and the server exposes tools the model can call.

What it isn't: a way to touch your content. That job belongs to the content MCP server, which can create, update, publish, and delete entries; it runs at /mcp on your own Strapi instance, requires Strapi 5.47.0 or later, and authenticates with an Admin token. Mixing up the two is the single most common setup failure in the community threads, and the config differences in the comparison section below explain why.

Why Ground Your AI Tools in the Docs

Strapi's AI for developers page names the problem directly: the prefix tip exists so the tool "queries docs.strapi.io instead of using potentially outdated training data." Strapi 4 has a far longer history on the public web than Strapi 5, so models trained on that corpus default to Strapi 4 patterns.

The Strapi 4 to Strapi 5 breaking changes list reads like a catalogue of what AI assistants get wrong:

Entity Service is gone. "The Entity Service API is deprecated and replaced by the Document Service API." The migration reference shows the correct Strapi 5 shape:

// Strapi 5 Document Service API usage
strapi.documents(uid).update({ documentId, data: { name: "John Doe" } });

documentId replaces id. In Strapi 5, per the Document Service reference, "documentId, a 24-character alphanumeric string, is a unique and persistent identifier for a content entry." Code that passes an integer id to findOne, update, or delete in a core service is wrong; those methods now receive a documentId.

REST responses are flat. The REST API reference states that "attributes are no longer nested in a data.attributes object and are directly accessible at the first level of the data object." A frontend written for the nested Strapi 4 response shape can silently return undefined. If you're mid-migration, the response format page documents a Strapi-Response-Format: v4 header that restores the old shape while you convert.

Smaller traps that compound. The Entity Service deprecation page lists more: the former publication-state option became status, with new publish(), unpublish(), and discardDraft() methods; findMany() always returns an array now, even for single types; findPage() no longer exists; Entity Service decorators are replaced by Document Service middlewares. Separately, helper-plugin is deprecated, which breaks a lot of copied Admin Panel plugin code.

An assistant that hits any of these produces code that runs, or at least compiles, and then fails in a way that looks like your bug. Grounding changes the mechanism: the model reads the current Document Service page before it writes strapi.documents(uid).

For Cursor users, an MCP server configured in .cursor/mcp.json is the way to keep Strapi docs in the loop.

Compatible Tools

The Docs MCP server page lists five options:

1. Cursor
2. VS Code with GitHub Copilot
3. Claude Code
4. Windsurf
5. Any other MCP-compatible IDE or tool

That last entry matters more than it looks. The server is plain remote MCP over HTTP; the VS Code snippet on the Strapi page sets "type": "http", and Streamable HTTP transport replaces the older HTTP+SSE transport. Any client that speaks Streamable HTTP and accepts a URL-based server entry should work, including agents you build yourself.

One gap to know about before you start: the Strapi page provides manual config blocks for Cursor, VS Code, and Windsurf only. Claude Code appears in the compatible list without a snippet. The next section fills that in using Anthropic's documented CLI pattern.

Connecting the Docs MCP Server to Your IDE

Every client connects the same way: one server entry pointing at https://strapi-docs.mcp.kapa.ai. For the hosted Strapi Docs MCP endpoint, the official setup is client-side only and does not show an API token, an Authorization header, or anything to enable on your Strapi side; Strapi's product MCP server, by contrast, must be enabled in Strapi and uses an Admin token in the Authorization header. The MCP specification makes this legal: "Authorization is OPTIONAL for MCP implementations," which is why a public documentation server can ship as a bare URL.

Contrast that with the content MCP server, where the Cursor entry uses "type": "streamable-http" plus a Bearer header. If you copy a content-server snippet and swap in the Kapa URL, or vice versa, the connection fails in confusing ways. Keep the two configs mentally separate and setup takes a couple of minutes.

You have two routes: click through the Ask AI window on docs.strapi.io, or paste a config block yourself.

Connect Through the Ask AI Dropdown

The docs page describes the guided path:

1. Open the Ask AI window on docs.strapi.io.
2. Click the Use MCP dropdown in the top right corner of that window. The docs include a screenshot captioned "Ask AI modal with Use MCP options highlighted" if you're hunting for it.
3. Choose your tool from the list: Cursor, VS Code (with GitHub Copilot), Claude Code, Windsurf, or any other MCP-compatible IDE or tool.

The dropdown also has a Copy MCP URL option that copies https://strapi-docs.mcp.kapa.ai to your clipboard for manual setup. Strapi's docs page does not document one-click deep-link installs beyond tool selection and Copy MCP URL, so expect to land in your IDE's config either way. The release notes mention that an "Install Strapi Docs MCP entry to the toolbar dropdown" was added, which gives you a second entry point from any docs page.

Configure It Manually

The three documented clients disagree on field names. This table saves you a round of "why isn't it connecting":

Cursor, in .cursor/mcp.json at your project root:

// .cursor/mcp.json
{
  "mcpServers": {
    "strapi-docs": {
      "url": "https://strapi-docs.mcp.kapa.ai"
    }
  }
}

No type field here. Cursor infers the remote transport from the URL for this server.

VS Code with Copilot, in .vscode/mcp.json:

// .vscode/mcp.json
{
  "servers": {
    "strapi-docs": {
      "type": "http",
      "url": "https://strapi-docs.mcp.kapa.ai"
    }
  }
}

The VS Code schema uses the top-level key servers, not mcpServers. VS Code's MCP config schema differs from a Cursor block.

Windsurf, in ~/.codeium/windsurf/mcp_config.json:

// ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "strapi-docs": {
      "serverUrl": "https://strapi-docs.mcp.kapa.ai"
    }
  }
}

Windsurf's remote-server schema uses serverUrl. Windsurf configuration scope is user-level rather than per-project.

Claude Code has no snippet on the Strapi page, so use Anthropic's documented pattern for remote HTTP servers from the Claude Code MCP docs:

claude mcp add --transport http strapi-docs https://strapi-docs.mcp.kapa.ai

For Claude Code MCP setup, use the documented MCP config locations instead of putting the MCP server entry in ~/.claude/settings.json. Strapi's Claude Code guide notes that Claude Code silently ignores MCP entries there; the CLI or a project-root .mcp.json are the paths that work. The Claude Code MCP docs recommend running /mcp inside Claude Code after adding the server to confirm it reports as connected, the same check the content MCP server docs recommend for their server. The Claude Code MCP documentation covers the remaining setup options in more detail if you hit friction.

All four configurations share one property: the URL is the whole credential. If a snippet you find elsewhere asks for a token against strapi-docs.mcp.kapa.ai, it's pointing at the wrong server.

Prompting the Docs MCP Server Well

Connecting the server doesn't guarantee the model uses it. Assistants often answer from memory when they think they know the answer, which for Strapi means Strapi 4 code. Strapi's AI for developers page documents five habits that change that:

1. Prefix docs questions. Start with Use the strapi-docs MCP server to answer:. The Docs MCP server page repeats this as a callout: "This will ensure the tool queries docs.strapi.io instead of returning answers based on its training data, which can be outdated."
2. Include the page URL. Pasting https://docs.strapi.io/cms/api/document-service into the prompt anchors retrieval to the right section instead of a loosely related one.
3. State your Strapi version. Say "Strapi 5" explicitly. The docs list this specifically "to avoid outdated suggestions."
4. Pair code examples with their source page. When you feed the assistant snippets from llms-code.txt, keep the Source: URL attached so it can distinguish a Strapi 5 example from something you pulled off an old gist.
5. Prefer documented APIs. Ask for code that uses documented APIs over private internals. The model will happily reach for strapi.db.query when strapi.documents is the supported path.

A prompt that applies all of this looks like:

Use the strapi-docs MCP server to answer: I'm on Strapi 5. Using
https://docs.strapi.io/cms/api/document-service, write a service
method that publishes an article by documentId and returns only
published entries. Use documented APIs only.

For Claude Code specifically, Strapi's Claude Code guide adds a persistent fix: a CLAUDE.md in the project root stating that the project uses Strapi 5, that documentId replaces the numeric id, and where your Content-Types live. In the guide's words, "This helps prevent Claude from generating v4-style code." You can apply the same idea in Cursor rules or Copilot instructions: make the version assumption explicit once rather than in every prompt.

The Rest of Strapi's AI Tools for Developers

The Docs MCP server is one piece of a wider set on the AI for developers page. Strapi's own recommendation is unambiguous: "Use the Docs MCP server in your IDE for the fastest developer experience." The other tools cover the cases MCP doesn't.

Three llms*.txt files sit at the root of docs.strapi.io:

The docs describe each plainly. llms.txt: "Use this to give an AI model an overview of what Strapi documentation covers, without consuming too many tokens. Ideal for RAG (Retrieval-Augmented Generation) systems or as a first pass before diving deeper." llms-full.txt: "Use this when you need the AI to have access to the complete documentation content. This is a large file; make sure your model's context window can handle it." llms-code.txt: "Use this when you're working on code and want to give an AI all of Strapi's documented code examples. Each snippet includes the source page URL and anchor for traceability." Strapi does not publish byte or line counts for these files, so budget context on your own before pasting llms-full.txt anywhere.

Where the files beat the MCP server: chat interfaces where you are not using MCP, RAG pipelines where you own the retrieval layer, and offline or batch work. Where the MCP server wins: anything interactive inside an IDE, because the model fetches only the chunks a given question needs.

A few more pieces round out the page:

• The AI toolbar on every docs page offers Copy Markdown, View as Markdown, Open with ChatGPT, Open with Claude, and direct links to each llms*.txt file.
• Per-page Markdown URLs: append .md to any docs URL, so docs.strapi.io/cms/api/rest.md returns clean Markdown for that page, per the What's New page.
• AGENTS.md files in the strapi/strapi and strapi/documentation repositories, which the docs say to "Use them to guide your AI-based tools when developing Strapi features or updating documentation."
• Inki, a Claude Code plugin bundling prompts and authoring guides, described as "LLM-agnostic, so you can point any AI agent (Cursor, GitHub Copilot, Cline, Windsurf, and others) at the plugin's folder and reuse its prompts, templates, authoring guides, and editorial rules."

Together, these options cover IDE retrieval, full-context workflows, and repository-specific guidance.

Docs MCP Server vs. the Content MCP Server

One server answers questions about Strapi; the other acts on your content. The AI for developers page lists them side by side. The Strapi MCP server connects AI clients to your Strapi instance to manage content through natural language. The Docs MCP server connects the Strapi documentation to your IDE for up-to-date, reliable information.

The content server docs describe it as a feature that "Lets AI clients create, read, update, delete, publish, and unpublish content directly through Strapi's Content Manager. All operations are gated by Admin token permissions." It ships disabled; you turn it on in config/server.js or config/server.ts:

// config/server.js
module.exports = ({ env }) => ({
  mcp: {
    enabled: true,
  },
});

Then restart Strapi. The /mcp endpoint doesn't exist until the config reloads, a detail Strapi's Cursor connection guide flags as a frequent first-run confusion. Tokens come from Settings → Administration Panel → Admin Tokens, not the API Tokens screen; Content API tokens get a 401 at /mcp.

Once connected, each Collection Type generates up to eight tools (list, get, create, update, delete, plus publish, unpublish, and discard_draft when Draft and Publish is enabled), and Strapi narrows the exposed tools and schemas to what the Admin token can access. Plugin authors can add their own tools through strapi.ai.mcp.registerTool(...), covered in Strapi's custom tools guide.

Many teams run both, and the pairing is the interesting part. Picture a Cursor session on a travel blog project. You ask how to add a status filter to a custom controller; the assistant calls the Docs MCP server, reads the Document Service page, and writes Strapi 5-correct code.

Then you ask it to publish the three draft destination entries from yesterday; it calls the content server's publish tool against your local instance, scoped by whatever the Admin token allows. Two servers, two config entries, and no overlap in what either one touches. The docs server never sees your data, and the content server never has to know how Strapi works, since your assistant already looked that up.

From Stale Suggestions to Doc-Grounded Answers

The Strapi Docs MCP server turns the "which version is this code for" guessing game into a lookup. Your assistant reads the current Document Service, REST, and migration pages before it writes strapi.documents() or documentId, and it does so from a single URL entry with no token to manage. Pair it with the Use the strapi-docs MCP server to answer: prefix and a version note in CLAUDE.md or your IDE rules, and Strapi 4-shaped suggestions mostly stop showing up.

Setup is one config block. Open the Docs MCP server page, copy the snippet for Cursor, VS Code, or Windsurf, or run the claude mcp add command for Claude Code, and ask your first Strapi 5 question. If you're also automating content operations, the content MCP server is the free, Admin-token-gated counterpart, and the GA announcement covers what landed in 5.49.0. Everything else Strapi offers for AI-assisted development, from the llms.txt files to Inki, is indexed on the AI for developers page, and the product itself lives on the Strapi website.