AI & LLMs

Docs for LLMCopy Anchor Link

Serve your docs as Markdown for LLMs and AI agents:

npx @fumadocs/cli feature llms

It enables processed Markdown on your docs collection, adds docsLlms to lib/source.ts, and creates the routes below. The generated files are listed here if you prefer a manual setup.

docsLlmsCopy Anchor Link

llms() renders your docs for LLMs. renderPage turns one page into Markdown, from the processed document rather than the raw file content:

import { llms } from 'fumadocs-core/source';

export const docsLlms = llms(source, {
  renderPage: async (page) => `# ${page.data.title} (${page.url})

${await page.data.getText('processed')}`,
});

renderPage reads the processed Markdown of pages, so enable includeProcessedMarkdown:

import { defineConfig } from 'astro/config';
import fumadocs from '@fumadocs/astro';

export default defineConfig({
  integrations: [
    fumadocs({
      includeProcessedMarkdown: { output: 'function' }, 
    }),
  ],
});

MDX components appear as JSX syntax by default. Render them into meaningful Markdown with the output option.

Runtime content sources like @fumadocs/local-md resolve on demand. Pass their getSource and the CLI generates the same routes:

export const docsLlms = llms(getSource, {
  renderPage: (page) => `# ${page.data.title} (${page.url})

${page.data.content}`,
});

With getSource, index() and indexNode() return a promise instead of a string.

llms.txtCopy Anchor Link

An index of all pages, generated from the page tree.

import type { APIRoute } from 'astro';
import { docsLlms } from '@/lib/source';

export const prerender = true;

export const GET: APIRoute = async () => new Response(await docsLlms.index());

llms-full.txtCopy Anchor Link

The content of all pages in a single file.

import type { APIRoute } from 'astro';
import { docsLlms } from '@/lib/source';

export const prerender = true;

export const GET: APIRoute = async () => new Response(await docsLlms.full());

*.mdCopy Anchor Link

The Markdown of a single page, for AI agents.

import { createGetUrl } from 'fumadocs-core/source';

export const docsRoute = '/docs';

const getDocsUrl = createGetUrl(docsRoute);

export function getPageMarkdownUrl(page: { slugs: string[]; locale?: string }) {
  const segments = [...page.slugs];
  if (segments.length === 0) {
    segments.push('index.md');
  } else {
    segments[segments.length - 1] += '.md';
  }

  return { segments, url: getDocsUrl(segments, page.locale) };
}

AcceptCopy Anchor Link

Docs pages can't serve Markdown based on the Accept header. Astro middleware only runs for pages rendered on request, while docs pages are prerendered.

Page ActionsCopy Anchor Link

Page actions let readers copy the Markdown of a page, or open the page in AI apps. They require the *.md route.

Pass the Markdown URL from your docs page to its React island, and render them in the island:

---
import { getPageMarkdownUrl } from '@/lib/shared';
---

<Docs
  client:load
  markdownUrl={getPageMarkdownUrl(page).url}
  githubUrl={`https://github.com/${owner}/${repo}/blob/main/content/docs/${encodeURI(page.path)}`}
>
  <Content />
</Docs>

MCP ServerCopy Anchor Link

Expose your docs to AI agents through a MCP server, with tools to list, search and read pages.

npx @fumadocs/cli feature mcp

It creates a /api/mcp route with the streamable HTTP transport, on top of the LLM routes above.

The tools come from fumadocs-core/mcp.

import type { APIRoute } from 'astro';
import { createMcpHandler, McpServer } from '@modelcontextprotocol/server';
import { registerSearchTool, registerSourceTools } from 'fumadocs-core/mcp';
import { createFromSource } from 'fumadocs-core/search/server';
import { docsLlms, source } from '@/lib/source';

const handler = createMcpHandler(() => {
  const mcp = new McpServer(
    {
      name: 'docs',
      version: '1.0.0',
    },
    // the tools never change, a stream to watch them would hold a serverless function open
    { capabilities: { tools: { listChanged: false } } },
  );

  registerSourceTools(mcp, source, docsLlms);
  registerSearchTool(mcp, createFromSource(source));

  return mcp;
});

export const prerender = false;

export const GET: APIRoute = async ({ request }) => handler.fetch(request);

export const POST: APIRoute = async ({ request }) => handler.fetch(request);

export const DELETE: APIRoute = async ({ request }) => handler.fetch(request);

The route renders on request, so your project needs an adapter.

Connect an agent to it with:

{
  "mcpServers": {
    "docs": { "url": "https://your-site.com/api/mcp" }
  }
}

WebMCPCopy Anchor Link

Where the MCP server above serves agents connecting to your site, WebMCP exposes tools to the AI agent of the browser, on the page the reader is viewing.

npx @fumadocs/cli feature webmcp

It creates a WebMCP component on top of the LLM routes. Render it inside <RootProvider />.

• search_docs queries the search API route. You can replace fetchClient with other clients.
• read_page fetches the Markdown of a page, from /docs/page.md.

Ask AICopy Anchor Link

You can install the AI chat dialog using Fumadocs CLI.

npx @fumadocs/cli add ai/openrouter

Docs layouts render the chat from their aiChat option. The option takes client state, so create a client component for your layout and use it in place of the original layout:

'use client';
// or the Notebook, Glass and Spacious layouts
import { DocsLayout as Layout, type DocsLayoutProps } from 'fumadocs-ui/layouts/docs';
// the installed components
import { AIChat, AIChatPanel, useAIChat } from './search';

export function DocsLayout(props: DocsLayoutProps) {
  return (
    <AIChat>
      <ChatLayout {...props} />
    </AIChat>
  );
}

function ChatLayout(props: DocsLayoutProps) {
  const { open, setOpen } = useAIChat();

  return (
    <Layout
      {...props}
      aiChat={{ open, onOpenChange: setOpen, panel: <AIChatPanel />, trigger: true }}
    />
  );
}