docusaurus-plugin-mcp-server 0.5.0

package/dist/adapters-entry.mjs

@@ -0,0 +1,908 @@
+import fs from 'fs-extra';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { z } from 'zod';
+import FlexSearch from 'flexsearch';
+
+// src/mcp/server.ts
+var FIELD_WEIGHTS = {
+  title: 3,
+  headings: 2,
+  description: 1.5,
+  content: 1
+};
+function englishStemmer(word) {
+  if (word.length <= 3) return word;
+  return word.replace(/ing$/, "").replace(/tion$/, "t").replace(/sion$/, "s").replace(/([^aeiou])ed$/, "$1").replace(/([^aeiou])es$/, "$1").replace(/ly$/, "").replace(/ment$/, "").replace(/ness$/, "").replace(/ies$/, "y").replace(/([^s])s$/, "$1");
+}
+function createSearchIndex() {
+  return new FlexSearch.Document({
+    // Use 'full' tokenization for substring matching
+    // This allows "auth" to match "authentication"
+    tokenize: "full",
+    // Enable caching for faster repeated queries
+    cache: 100,
+    // Higher resolution = more granular ranking (1-9)
+    resolution: 9,
+    // Enable context for phrase/proximity matching
+    context: {
+      resolution: 2,
+      depth: 2,
+      bidirectional: true
+    },
+    // Apply stemming to normalize word forms
+    encode: (str) => {
+      const words = str.toLowerCase().split(/[\s\-_.,;:!?'"()[\]{}]+/);
+      return words.filter(Boolean).map(englishStemmer);
+    },
+    // Document schema
+    document: {
+      id: "id",
+      // Index these fields for searching
+      index: ["title", "content", "headings", "description"],
+      // Store these fields in results (for enriched queries)
+      store: ["title", "description"]
+    }
+  });
+}
+function searchIndex(index, docs, query, options = {}) {
+  const { limit = 5 } = options;
+  const rawResults = index.search(query, {
+    limit: limit * 3,
+    // Get extra results for better ranking after weighting
+    enrich: true
+  });
+  const docScores = /* @__PURE__ */ new Map();
+  for (const fieldResult of rawResults) {
+    const field = fieldResult.field;
+    const fieldWeight = FIELD_WEIGHTS[field] ?? 1;
+    const results2 = fieldResult.result;
+    for (let i = 0; i < results2.length; i++) {
+      const item = results2[i];
+      if (!item) continue;
+      const docId = typeof item === "string" ? item : item.id;
+      const positionScore = (results2.length - i) / results2.length;
+      const weightedScore = positionScore * fieldWeight;
+      const existingScore = docScores.get(docId) ?? 0;
+      docScores.set(docId, existingScore + weightedScore);
+    }
+  }
+  const results = [];
+  for (const [docId, score] of docScores) {
+    const doc = docs[docId];
+    if (!doc) continue;
+    results.push({
+      route: doc.route,
+      title: doc.title,
+      score,
+      snippet: generateSnippet(doc.markdown, query),
+      matchingHeadings: findMatchingHeadings(doc, query)
+    });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+function generateSnippet(markdown, query) {
+  const maxLength = 200;
+  const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (queryTerms.length === 0) {
+    return markdown.slice(0, maxLength) + (markdown.length > maxLength ? "..." : "");
+  }
+  const lowerMarkdown = markdown.toLowerCase();
+  let bestIndex = -1;
+  let bestTerm = "";
+  const allTerms = [...queryTerms, ...queryTerms.map(englishStemmer)];
+  for (const term of allTerms) {
+    const index = lowerMarkdown.indexOf(term);
+    if (index !== -1 && (bestIndex === -1 || index < bestIndex)) {
+      bestIndex = index;
+      bestTerm = term;
+    }
+  }
+  if (bestIndex === -1) {
+    return markdown.slice(0, maxLength) + (markdown.length > maxLength ? "..." : "");
+  }
+  const snippetStart = Math.max(0, bestIndex - 50);
+  const snippetEnd = Math.min(markdown.length, bestIndex + bestTerm.length + 150);
+  let snippet = markdown.slice(snippetStart, snippetEnd);
+  snippet = snippet.replace(/^#{1,6}\s+/gm, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/!\[([^\]]*)\]\([^)]+\)/g, "").replace(/```[a-z]*\n?/g, "").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").trim();
+  const prefix = snippetStart > 0 ? "..." : "";
+  const suffix = snippetEnd < markdown.length ? "..." : "";
+  return prefix + snippet + suffix;
+}
+function findMatchingHeadings(doc, query) {
+  const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const allTerms = [...queryTerms, ...queryTerms.map(englishStemmer)];
+  const matching = [];
+  for (const heading of doc.headings) {
+    const headingLower = heading.text.toLowerCase();
+    const headingStemmed = headingLower.split(/\s+/).map(englishStemmer).join(" ");
+    if (allTerms.some(
+      (term) => headingLower.includes(term) || headingStemmed.includes(englishStemmer(term))
+    )) {
+      matching.push(heading.text);
+    }
+  }
+  return matching.slice(0, 3);
+}
+async function importSearchIndex(data) {
+  const index = createSearchIndex();
+  for (const [key, value] of Object.entries(data)) {
+    await index.import(
+      key,
+      value
+    );
+  }
+  return index;
+}
+
+// src/mcp/tools/docs-search.ts
+function executeDocsSearch(params, index, docs) {
+  const { query, limit = 5 } = params;
+  if (!query || typeof query !== "string" || query.trim().length === 0) {
+    throw new Error("Query parameter is required and must be a non-empty string");
+  }
+  const effectiveLimit = Math.min(Math.max(1, limit), 20);
+  const results = searchIndex(index, docs, query.trim(), {
+    limit: effectiveLimit
+  });
+  return results;
+}
+function formatSearchResults(results, baseUrl) {
+  if (results.length === 0) {
+    return "No matching documents found.";
+  }
+  const lines = [`Found ${results.length} result(s):
+`];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (!result) continue;
+    lines.push(`${i + 1}. **${result.title}**`);
+    if (baseUrl) {
+      const fullUrl = `${baseUrl.replace(/\/$/, "")}${result.route}`;
+      lines.push(`   URL: ${fullUrl}`);
+    }
+    lines.push(`   Route: ${result.route}`);
+    if (result.matchingHeadings && result.matchingHeadings.length > 0) {
+      lines.push(`   Matching sections: ${result.matchingHeadings.join(", ")}`);
+    }
+    lines.push(`   ${result.snippet}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/mcp/tools/docs-get-page.ts
+function executeDocsGetPage(params, docs) {
+  const { route } = params;
+  if (!route || typeof route !== "string") {
+    throw new Error("Route parameter is required and must be a string");
+  }
+  let normalizedRoute = route.trim();
+  if (!normalizedRoute.startsWith("/")) {
+    normalizedRoute = "/" + normalizedRoute;
+  }
+  if (normalizedRoute.length > 1 && normalizedRoute.endsWith("/")) {
+    normalizedRoute = normalizedRoute.slice(0, -1);
+  }
+  const doc = docs[normalizedRoute];
+  if (!doc) {
+    const altRoute = normalizedRoute.slice(1);
+    if (docs[altRoute]) {
+      return docs[altRoute] ?? null;
+    }
+    return null;
+  }
+  return doc;
+}
+function formatPageContent(doc, baseUrl) {
+  if (!doc) {
+    return "Page not found. Please check the route path and try again.";
+  }
+  const lines = [];
+  lines.push(`# ${doc.title}`);
+  lines.push("");
+  if (doc.description) {
+    lines.push(`> ${doc.description}`);
+    lines.push("");
+  }
+  if (baseUrl) {
+    const fullUrl = `${baseUrl.replace(/\/$/, "")}${doc.route}`;
+    lines.push(`**URL:** ${fullUrl}`);
+  }
+  lines.push(`**Route:** ${doc.route}`);
+  lines.push("");
+  if (doc.headings.length > 0) {
+    lines.push("## Contents");
+    lines.push("");
+    for (const heading of doc.headings) {
+      if (heading.level <= 3) {
+        const indent = "  ".repeat(heading.level - 1);
+        lines.push(`${indent}- [${heading.text}](#${heading.id})`);
+      }
+    }
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  lines.push(doc.markdown);
+  return lines.join("\n");
+}
+
+// src/processing/heading-extractor.ts
+function extractSection(markdown, headingId, headings) {
+  const heading = headings.find((h) => h.id === headingId);
+  if (!heading) {
+    return null;
+  }
+  return markdown.slice(heading.startOffset, heading.endOffset).trim();
+}
+
+// src/mcp/tools/docs-get-section.ts
+function executeDocsGetSection(params, docs) {
+  const { route, headingId } = params;
+  if (!route || typeof route !== "string") {
+    throw new Error("Route parameter is required and must be a string");
+  }
+  if (!headingId || typeof headingId !== "string") {
+    throw new Error("HeadingId parameter is required and must be a string");
+  }
+  let normalizedRoute = route.trim();
+  if (!normalizedRoute.startsWith("/")) {
+    normalizedRoute = "/" + normalizedRoute;
+  }
+  if (normalizedRoute.length > 1 && normalizedRoute.endsWith("/")) {
+    normalizedRoute = normalizedRoute.slice(0, -1);
+  }
+  const doc = docs[normalizedRoute];
+  if (!doc) {
+    return {
+      content: null,
+      doc: null,
+      headingText: null,
+      availableHeadings: []
+    };
+  }
+  const availableHeadings = doc.headings.map((h) => ({
+    id: h.id,
+    text: h.text,
+    level: h.level
+  }));
+  const heading = doc.headings.find((h) => h.id === headingId.trim());
+  if (!heading) {
+    return {
+      content: null,
+      doc,
+      headingText: null,
+      availableHeadings
+    };
+  }
+  const content = extractSection(doc.markdown, headingId.trim(), doc.headings);
+  return {
+    content,
+    doc,
+    headingText: heading.text,
+    availableHeadings
+  };
+}
+function formatSectionContent(result, headingId, baseUrl) {
+  if (!result.doc) {
+    return "Page not found. Please check the route path and try again.";
+  }
+  if (!result.content) {
+    const lines2 = [`Section "${headingId}" not found in this document.`, "", "Available sections:"];
+    for (const heading of result.availableHeadings) {
+      const indent = "  ".repeat(heading.level - 1);
+      lines2.push(`${indent}- ${heading.text} (id: ${heading.id})`);
+    }
+    return lines2.join("\n");
+  }
+  const lines = [];
+  const fullUrl = baseUrl ? `${baseUrl.replace(/\/$/, "")}${result.doc.route}#${headingId}` : null;
+  lines.push(`# ${result.headingText}`);
+  if (fullUrl) {
+    lines.push(`> From: ${result.doc.title} - ${fullUrl}`);
+  } else {
+    lines.push(`> From: ${result.doc.title} (${result.doc.route})`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push(result.content);
+  return lines.join("\n");
+}
+
+// src/mcp/server.ts
+function isFileConfig(config) {
+  return "docsPath" in config && "indexPath" in config;
+}
+function isDataConfig(config) {
+  return "docs" in config && "searchIndexData" in config;
+}
+var McpDocsServer = class {
+  config;
+  docs = null;
+  searchIndex = null;
+  mcpServer;
+  initialized = false;
+  constructor(config) {
+    this.config = config;
+    this.mcpServer = new McpServer(
+      {
+        name: config.name,
+        version: config.version ?? "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.registerTools();
+  }
+  /**
+   * Register all MCP tools using the SDK's registerTool API
+   */
+  registerTools() {
+    this.mcpServer.registerTool(
+      "docs_search",
+      {
+        description: "Search the documentation for relevant pages. Returns matching documents with snippets and relevance scores. Use this to find information across all documentation.",
+        inputSchema: {
+          query: z.string().min(1).describe("The search query string"),
+          limit: z.number().int().min(1).max(20).optional().default(5).describe("Maximum number of results to return (1-20, default: 5)")
+        }
+      },
+      async ({ query, limit }) => {
+        await this.initialize();
+        if (!this.docs || !this.searchIndex) {
+          return {
+            content: [{ type: "text", text: "Server not initialized. Please try again." }],
+            isError: true
+          };
+        }
+        const results = executeDocsSearch({ query, limit }, this.searchIndex, this.docs);
+        return {
+          content: [
+            { type: "text", text: formatSearchResults(results, this.config.baseUrl) }
+          ]
+        };
+      }
+    );
+    this.mcpServer.registerTool(
+      "docs_get_page",
+      {
+        description: "Retrieve the complete content of a documentation page as markdown. Use this when you need the full content of a specific page.",
+        inputSchema: {
+          route: z.string().min(1).describe('The page route path (e.g., "/docs/getting-started" or "/api/reference")')
+        }
+      },
+      async ({ route }) => {
+        await this.initialize();
+        if (!this.docs) {
+          return {
+            content: [{ type: "text", text: "Server not initialized. Please try again." }],
+            isError: true
+          };
+        }
+        const doc = executeDocsGetPage({ route }, this.docs);
+        return {
+          content: [{ type: "text", text: formatPageContent(doc, this.config.baseUrl) }]
+        };
+      }
+    );
+    this.mcpServer.registerTool(
+      "docs_get_section",
+      {
+        description: "Retrieve a specific section from a documentation page by its heading ID. Use this when you need only a portion of a page rather than the entire content.",
+        inputSchema: {
+          route: z.string().min(1).describe("The page route path"),
+          headingId: z.string().min(1).describe(
+            'The heading ID of the section to extract (e.g., "installation", "api-reference")'
+          )
+        }
+      },
+      async ({ route, headingId }) => {
+        await this.initialize();
+        if (!this.docs) {
+          return {
+            content: [{ type: "text", text: "Server not initialized. Please try again." }],
+            isError: true
+          };
+        }
+        const result = executeDocsGetSection({ route, headingId }, this.docs);
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatSectionContent(result, headingId, this.config.baseUrl)
+            }
+          ]
+        };
+      }
+    );
+  }
+  /**
+   * Load docs and search index
+   *
+   * For file-based config: reads from disk
+   * For data config: uses pre-loaded data directly
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      if (isDataConfig(this.config)) {
+        this.docs = this.config.docs;
+        this.searchIndex = await importSearchIndex(this.config.searchIndexData);
+      } else if (isFileConfig(this.config)) {
+        if (await fs.pathExists(this.config.docsPath)) {
+          this.docs = await fs.readJson(this.config.docsPath);
+        } else {
+          throw new Error(`Docs file not found: ${this.config.docsPath}`);
+        }
+        if (await fs.pathExists(this.config.indexPath)) {
+          const indexData = await fs.readJson(this.config.indexPath);
+          this.searchIndex = await importSearchIndex(indexData);
+        } else {
+          throw new Error(`Search index not found: ${this.config.indexPath}`);
+        }
+      } else {
+        throw new Error("Invalid server config: must provide either file paths or pre-loaded data");
+      }
+      this.initialized = true;
+    } catch (error) {
+      console.error("[MCP] Failed to initialize:", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle an HTTP request using the MCP SDK's transport
+   *
+   * This method is designed for serverless environments (Vercel, Netlify).
+   * It creates a stateless transport instance and processes the request.
+   *
+   * @param req - Node.js IncomingMessage or compatible request object
+   * @param res - Node.js ServerResponse or compatible response object
+   * @param parsedBody - Optional pre-parsed request body
+   */
+  async handleHttpRequest(req, res, parsedBody) {
+    await this.initialize();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      // Stateless mode - no session tracking
+      enableJsonResponse: true
+      // Return JSON instead of SSE streams
+    });
+    await this.mcpServer.connect(transport);
+    try {
+      await transport.handleRequest(req, res, parsedBody);
+    } finally {
+      await transport.close();
+    }
+  }
+  /**
+   * Handle a Web Standard Request (Cloudflare Workers, Deno, Bun)
+   *
+   * This method is designed for Web Standard environments that use
+   * the Fetch API Request/Response pattern.
+   *
+   * @param request - Web Standard Request object
+   * @returns Web Standard Response object
+   */
+  async handleWebRequest(request) {
+    await this.initialize();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      // Stateless mode
+      enableJsonResponse: true
+    });
+    await this.mcpServer.connect(transport);
+    try {
+      return await transport.handleRequest(request);
+    } finally {
+      await transport.close();
+    }
+  }
+  /**
+   * Get server status information
+   *
+   * Useful for health checks and debugging
+   */
+  async getStatus() {
+    return {
+      name: this.config.name,
+      version: this.config.version ?? "1.0.0",
+      initialized: this.initialized,
+      docCount: this.docs ? Object.keys(this.docs).length : 0,
+      baseUrl: this.config.baseUrl
+    };
+  }
+  /**
+   * Get the underlying McpServer instance
+   *
+   * Useful for advanced use cases like custom transports
+   */
+  getMcpServer() {
+    return this.mcpServer;
+  }
+};
+
+// src/adapters/vercel.ts
+function createVercelHandler(config) {
+  let server = null;
+  function getServer() {
+    if (!server) {
+      server = new McpDocsServer(config);
+    }
+    return server;
+  }
+  return async function handler(req, res) {
+    if (req.method === "GET") {
+      const mcpServer = getServer();
+      const status = await mcpServer.getStatus();
+      return res.status(200).json(status);
+    }
+    if (req.method !== "POST") {
+      return res.status(405).json({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32600,
+          message: "Method not allowed. Use POST for MCP requests, GET for status."
+        }
+      });
+    }
+    try {
+      const mcpServer = getServer();
+      await mcpServer.handleHttpRequest(req, res, req.body);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("MCP Server Error:", error);
+      return res.status(500).json({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32603,
+          message: `Internal server error: ${errorMessage}`
+        }
+      });
+    }
+  };
+}
+
+// src/adapters/netlify.ts
+function eventToRequest(event) {
+  const url = event.rawUrl || `https://localhost${event.path || "/"}`;
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(event.headers)) {
+    if (value) {
+      headers.set(key, value);
+    }
+  }
+  let body = event.body;
+  if (body && event.isBase64Encoded) {
+    body = Buffer.from(body, "base64").toString("utf-8");
+  }
+  return new Request(url, {
+    method: event.httpMethod,
+    headers,
+    body: event.httpMethod !== "GET" && event.httpMethod !== "HEAD" ? body : void 0
+  });
+}
+async function responseToNetlify(response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  const body = await response.text();
+  return {
+    statusCode: response.status,
+    headers,
+    body: body || void 0
+  };
+}
+function createNetlifyHandler(config) {
+  let server = null;
+  function getServer() {
+    if (!server) {
+      server = new McpDocsServer(config);
+    }
+    return server;
+  }
+  return async function handler(event, _context) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (event.httpMethod === "GET") {
+      const mcpServer = getServer();
+      const status = await mcpServer.getStatus();
+      return {
+        statusCode: 200,
+        headers,
+        body: JSON.stringify(status)
+      };
+    }
+    if (event.httpMethod !== "POST") {
+      return {
+        statusCode: 405,
+        headers,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32600,
+            message: "Method not allowed. Use POST for MCP requests, GET for status."
+          }
+        })
+      };
+    }
+    try {
+      const mcpServer = getServer();
+      const request = eventToRequest(event);
+      const response = await mcpServer.handleWebRequest(request);
+      return await responseToNetlify(response);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("MCP Server Error:", error);
+      return {
+        statusCode: 500,
+        headers,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32603,
+            message: `Internal server error: ${errorMessage}`
+          }
+        })
+      };
+    }
+  };
+}
+
+// src/adapters/cloudflare.ts
+function createCloudflareHandler(config) {
+  let server = null;
+  const serverConfig = {
+    docs: config.docs,
+    searchIndexData: config.searchIndexData,
+    name: config.name,
+    version: config.version,
+    baseUrl: config.baseUrl
+  };
+  function getServer() {
+    if (!server) {
+      server = new McpDocsServer(serverConfig);
+    }
+    return server;
+  }
+  return async function fetch(request) {
+    const headers = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type"
+    };
+    if (request.method === "OPTIONS") {
+      return new Response(null, { status: 204, headers });
+    }
+    if (request.method === "GET") {
+      const mcpServer = getServer();
+      const status = await mcpServer.getStatus();
+      return new Response(JSON.stringify(status), {
+        status: 200,
+        headers: { ...headers, "Content-Type": "application/json" }
+      });
+    }
+    if (request.method !== "POST") {
+      return new Response(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32600,
+            message: "Method not allowed. Use POST for MCP requests, GET for status."
+          }
+        }),
+        {
+          status: 405,
+          headers: { ...headers, "Content-Type": "application/json" }
+        }
+      );
+    }
+    try {
+      const mcpServer = getServer();
+      const response = await mcpServer.handleWebRequest(request);
+      const newHeaders = new Headers(response.headers);
+      Object.entries(headers).forEach(([key, value]) => {
+        newHeaders.set(key, value);
+      });
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("MCP Server Error:", error);
+      return new Response(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32603,
+            message: `Internal server error: ${errorMessage}`
+          }
+        }),
+        {
+          status: 500,
+          headers: { ...headers, "Content-Type": "application/json" }
+        }
+      );
+    }
+  };
+}
+
+// src/adapters/generator.ts
+function generateAdapterFiles(options) {
+  const { platform, name, baseUrl } = options;
+  switch (platform) {
+    case "vercel":
+      return generateVercelFiles(name, baseUrl);
+    case "netlify":
+      return generateNetlifyFiles(name, baseUrl);
+    case "cloudflare":
+      return generateCloudflareFiles(name, baseUrl);
+    default:
+      throw new Error(`Unknown platform: ${platform}`);
+  }
+}
+function generateVercelFiles(name, baseUrl) {
+  return [
+    {
+      path: "api/mcp.js",
+      description: "Vercel serverless function for MCP server",
+      content: `/**
+ * Vercel API route for MCP server
+ * Deploy to Vercel and this will be available at /api/mcp
+ */
+
+const { createVercelHandler } = require('docusaurus-plugin-mcp-server/adapters');
+const path = require('path');
+
+const projectRoot = path.join(__dirname, '..');
+
+module.exports = createVercelHandler({
+  docsPath: path.join(projectRoot, 'build/mcp/docs.json'),
+  indexPath: path.join(projectRoot, 'build/mcp/search-index.json'),
+  name: '${name}',
+  version: '1.0.0',
+  baseUrl: '${baseUrl}',
+});
+`
+    },
+    {
+      path: "vercel.json",
+      description: "Vercel configuration (merge with existing if present)",
+      content: `{
+  "functions": {
+    "api/mcp.js": {
+      "includeFiles": "build/mcp/**"
+    }
+  },
+  "rewrites": [
+    {
+      "source": "/mcp",
+      "destination": "/api/mcp"
+    }
+  ]
+}
+`
+    }
+  ];
+}
+function generateNetlifyFiles(name, baseUrl) {
+  return [
+    {
+      path: "netlify/functions/mcp.js",
+      description: "Netlify serverless function for MCP server",
+      content: `/**
+ * Netlify function for MCP server
+ * Deploy to Netlify and this will be available at /.netlify/functions/mcp
+ */
+
+const { createNetlifyHandler } = require('docusaurus-plugin-mcp-server/adapters');
+const path = require('path');
+
+const projectRoot = path.join(__dirname, '../..');
+
+exports.handler = createNetlifyHandler({
+  docsPath: path.join(projectRoot, 'build/mcp/docs.json'),
+  indexPath: path.join(projectRoot, 'build/mcp/search-index.json'),
+  name: '${name}',
+  version: '1.0.0',
+  baseUrl: '${baseUrl}',
+});
+`
+    },
+    {
+      path: "netlify.toml",
+      description: "Netlify configuration (merge with existing if present)",
+      content: `[build]
+  publish = "build"
+  command = "npm run build"
+
+[functions]
+  directory = "netlify/functions"
+  included_files = ["build/mcp/**"]
+
+[[redirects]]
+  from = "/mcp"
+  to = "/.netlify/functions/mcp"
+  status = 200
+`
+    }
+  ];
+}
+function generateCloudflareFiles(name, baseUrl) {
+  return [
+    {
+      path: "workers/mcp.js",
+      description: "Cloudflare Worker for MCP server",
+      content: `/**
+ * Cloudflare Worker for MCP server
+ *
+ * Note: This requires bundling docs.json and search-index.json with the worker,
+ * or using Cloudflare KV/R2 for storage.
+ *
+ * For bundling, use wrangler with custom build configuration.
+ */
+
+import { createCloudflareHandler } from 'docusaurus-plugin-mcp-server/adapters';
+
+// Option 1: Import bundled data (requires bundler configuration)
+// import docs from '../build/mcp/docs.json';
+// import searchIndex from '../build/mcp/search-index.json';
+
+// Option 2: Use KV bindings (requires KV namespace configuration)
+// const docs = await env.MCP_KV.get('docs', { type: 'json' });
+// const searchIndex = await env.MCP_KV.get('search-index', { type: 'json' });
+
+export default {
+  fetch: createCloudflareHandler({
+    name: '${name}',
+    version: '1.0.0',
+    baseUrl: '${baseUrl}',
+    // docsPath and indexPath are used for file-based loading
+    // For Workers, you'll need to configure data loading differently
+    docsPath: './mcp/docs.json',
+    indexPath: './mcp/search-index.json',
+  }),
+};
+`
+    },
+    {
+      path: "wrangler.toml",
+      description: "Cloudflare Wrangler configuration",
+      content: `name = "${name}-mcp"
+main = "workers/mcp.js"
+compatibility_date = "2024-01-01"
+
+# Uncomment to use KV for storing docs
+# [[kv_namespaces]]
+# binding = "MCP_KV"
+# id = "your-kv-namespace-id"
+
+# Static assets (the Docusaurus build)
+# [site]
+# bucket = "./build"
+`
+    }
+  ];
+}
+
+export { createCloudflareHandler, createNetlifyHandler, createVercelHandler, generateAdapterFiles };
+//# sourceMappingURL=adapters-entry.mjs.map
+//# sourceMappingURL=adapters-entry.mjs.map