How to Turn Any Documentation URL into a Live MCP Endpoint (No Code)

There's a GitHub discussion that keeps getting asked in different forms: "What's the fastest way to make documentation queryable by AI agents?" The answers usually involve RAG pipelines, vector databases, embedding models, and a lot of infrastructure. This post describes the path that doesn't.

You can take any public documentation URL and have a live, cited MCP endpoint — one that Claude Desktop, Cursor, or any MCP-compatible client can query — in under two minutes, with no code and no infrastructure to manage. Here's exactly how.

What "MCP endpoint" means here

An MCP endpoint is a URL that speaks the Model Context Protocol. When your AI client (Claude Desktop, Cursor, Windsurf, etc.) connects to it, the endpoint exposes tools the AI can call during a conversation. For documentation, the main tool is an ask tool: you pass a question, the endpoint searches the indexed docs and returns a cited answer.

The result is that instead of the AI guessing from training data — and hallucinating about your specific API version or configuration — it reads the actual current documentation and tells you exactly where it found the answer.

Step 1: Index the documentation

Go to agentready.it.com and paste the root URL of the documentation you want to index. AgentReady crawls the site, extracts the text content from every page, splits it into chunks, and generates vector embeddings — all automatically.

For most documentation sites this takes 30–90 seconds. You'll see a live progress counter as pages are crawled. When it finishes, the site gets a permanent ID and is immediately queryable.

Works on any publicly accessible site: ReadTheDocs, GitBook, Mintlify, Docusaurus, custom static sites, API references, GitHub wikis. The only requirement is that the content is server-rendered HTML — JavaScript-only SPAs won't work without a specific docs page URL to start from.

Step 2: Get the MCP connection details

After indexing, go to agentready.it.com/connect. You'll see three connection options:

HTTP MCP URL — a direct HTTPS endpoint you can add to any MCP client that supports remote servers. This is the cleanest option for most users.

npx command — a one-line command that runs a local stdio bridge, forwarding to the hosted endpoint. Use this for Claude Desktop, which requires stdio transport.

WebMCP — if you're on Chrome 149+ with the WebMCP origin trial enabled, the browser itself can connect without any local process.

Step 3: Connect Claude Desktop

Open ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) and add:

{
  "mcpServers": {
    "agentready": {
      "command": "npx",
      "args": ["-y", "@agentreadyweb/mcp"]
    }
  }
}

Restart Claude Desktop. The connection is to the global AgentReady index — all sites you've indexed (and all sites in the public directory) are queryable through the same endpoint.

Step 4: Connect Cursor

In Cursor, go to Settings → MCP and add a new server. Choose HTTP transport and paste the MCP URL from the connect page:

https://www.agentready.it.com/api/mcp

Cursor will immediately discover the available tools: ask_site, list_sites, and submit_site. You can now ask Cursor: "Using the Supabase docs, how do I set up row-level security?" and it will query the index directly.

What the AI actually does when it queries

When Claude or Cursor calls ask_site, here's the chain:

1. Your question is embedded into a vector. 2. That vector is compared against the embeddings for every chunk in the indexed site. 3. The top matching chunks are retrieved. 4. The AI reads those chunks and synthesizes an answer, citing the specific source URLs. 5. You get a grounded answer with links to the exact docs pages.

The key difference from web search: the AI isn't reading the live page in real time (which would be slow and inconsistent). It's querying a pre-indexed semantic representation, so responses are fast and the AI controls exactly what context it reads.

Which documentation sites are worth indexing?

Any site where you or your team regularly looks things up. A few high-value examples that aren't in the public directory yet:

— Internal wikis or Notion spaces (if publicly accessible) — the AI has no training data for these.

— Your own product's documentation — your users' AI agents will benefit from this immediately.

— Niche frameworks or libraries the AI regularly hallucinates about — a quick index makes those queries accurate.

— Changelogs and release notes — training data is always behind; indexed changelogs stay current.

Sites like Stripe, Supabase, Vercel, Next.js, Tailwind, React, Anthropic, and OpenAI docs are already in the public AgentReady directory — so if you're using any of those, you can query them immediately without indexing them yourself.

For site owners: make your own docs queryable

If you own the documentation site, indexing it in AgentReady means your users' AI agents get accurate, cited answers about your product — instead of hallucinations from stale training data.

Once indexed, the site gets a permanent MCP endpoint at agentready.it.com/api/sites/{siteId}/mcp and an llms.txt file you can download and host at your domain root. Both make your documentation discoverable and queryable by the growing ecosystem of AI clients.

The weekly digest feature emails you a summary of what AI agents are asking about your docs — useful for identifying documentation gaps your users are hitting.

Limitations to know about

JavaScript-rendered content — Sites that render content entirely in the browser (React SPAs without SSR) can't be crawled. Start from a specific docs page URL, or use the site's static docs subdomain if one exists.

Freshness — The index is a snapshot. If the documentation changes frequently, re-submitting the URL triggers a fresh crawl. The indexed timestamp is shown on each site's detail page.

Private docs — AgentReady only indexes publicly accessible content. Authentication-gated documentation can't be crawled.