nuxt-ai-ready 0.0.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Harlan Wilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# Nuxt AI Ready
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+> Best practice AI & LLM discoverability for Nuxt sites 
+
+## Why Nuxt AI Ready?
+
+Search is changing. Outside of search engines, people now get answers directly from [ChatGPT](https://chatgpt.com/), [Claude](https://claude.ai/), and other AI assistants. When these LLMs answer questions about topics related to your site, you want your content to be the source they cite
+to drive traffic and engagement back to you.
+
+For that to happen, AI systems need to understand your content. New standards are being shaped like [llms.txt](https://llmstxt.org/) for discoverability and [MCP](https://modelcontextprotocol.io/) for letting agents query your site directly. But these standards are still evolving, and implementing them correctly
+can be complex and time-consuming.
+
+- **📈 Increase citations by LLMs**: AI assistants pull from sources they can parse easily. Structured, AI-friendly content gets referenced more often.
+- **🔗 Direct site queries for LLMs**: MCP support means assistants can pull live data from you, not just static snippets from their training.
+
+Nuxt AI Ready converts your indexable pages into clean markdown that AI systems can consume, generates the right artifacts at build time, and serves AI-friendly formats to bots automatically.
+
+## Features
+
+- 📄 **llms.txt Generation**: Auto-generates `llms.txt` and `llms-full.txt` at build time
+- 🚀 **On-Demand Markdown**: Any route available as `.md` (e.g., `/about` → `/about.md`)
+- 🤖 **Smart Bot Detection**: Serves markdown to AI crawlers automatically
+- 📡 **Content Signals**: Help AI systems understand how to use your pages
+- 📦 **RAG-Ready Output**: Chunked content for semantic search and AI chat pipelines
+- ⚡ **MCP Integration**: Let AI agents query your site directly
+
+## Installation
+
+Install `nuxt-ai-ready` dependency to your project:
+
+```bash
+npx nuxi@latest module add nuxt-ai-ready
+```
+
+## Documentation
+
+[📖 Read the full documentation](https://nuxtseo.com/ai-ready) for more information.
+
+## Sponsors
+
+<p align="center">
+  <a href="https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg">
+    <img src='https://raw.githubusercontent.com/harlan-zw/static/main/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+This module requires a [Nuxt SEO Pro license](https://nuxtseo.com/pro), see [LICENSE](https://github.com/harlan-zw/nuxt-ai-ready/blob/main/LICENSE) for full details.
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/nuxt-ai-ready/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://npmjs.com/package/nuxt-ai-ready
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/nuxt-ai-ready.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://npmjs.com/package/nuxt-ai-ready
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,62 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { ModuleOptions, BulkChunk } from '../dist/runtime/types.js';
+export { BulkChunk, ModuleOptions } from '../dist/runtime/types.js';
+import { ProcessedFile } from 'mdream/llms-txt';
+
+/**
+ * Hook payload for mdream:llms-txt
+ * Called after mdream has generated llms.txt, before writing to disk
+ *
+ * IMPORTANT: This uses a mutable pattern. Hooks should modify the content
+ * and fullContent properties directly rather than returning values.
+ *
+ * @example
+ * nuxt.hooks.hook('mdream:llms-txt', async (payload) => {
+ *   payload.content += '\n\n## Custom Section\n\nAdded by hook!'
+ *   payload.fullContent += '\n\n## Custom Section (Full)\n\nAdded by hook!'
+ * })
+ */
+interface LlmsTxtGeneratePayload {
+    /** Current llms.txt content - modify this directly */
+    content: string;
+    /** Current llms-full.txt content - modify this directly */
+    fullContent: string;
+    /** All routes with their metadata (read-only) */
+    pages: ProcessedFile[];
+}
+
+interface ModuleHooks {
+    /**
+     * Hook to modify llms.txt content before final output
+     * Other modules can append their own API endpoints here
+     */
+    'ai-ready:llms-txt': (payload: LlmsTxtGeneratePayload) => void | Promise<void>;
+    /**
+     * Hook to add routes to the AI ready
+     * Other modules can register their own API routes
+     */
+    'ai-ready:routes': (payload: {
+        routes: Record<string, string>;
+    }) => void | Promise<void>;
+    /**
+     * Hook called for each chunk generated during prerendering for bulk export
+     */
+    'ai-ready:chunk': (context: {
+        chunk: BulkChunk;
+        route: string;
+        title: string;
+        description: string;
+        headings: Array<Record<string, string>>;
+    }) => void | Promise<void>;
+}
+interface ModulePublicRuntimeConfig {
+    bulkRoute: string | false;
+    debug: boolean;
+    version: string;
+    mdreamOptions: ModuleOptions['mdreamOptions'];
+    markdownCacheHeaders: Required<NonNullable<ModuleOptions['markdownCacheHeaders']>>;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleHooks, ModulePublicRuntimeConfig };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "nuxt-ai-ready",
+  "compatibility": {
+    "nuxt": ">=4.0.0"
+  },
+  "configKey": "aiReady",
+  "version": "0.0.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,406 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync, createWriteStream } from 'node:fs';
+import { useLogger, useNuxt, defineNuxtModule, createResolver, addTypeTemplate, hasNuxtModule, addServerHandler, addPlugin } from '@nuxt/kit';
+import defu from 'defu';
+import { TagIdMap } from 'mdream';
+import { extractionPlugin } from 'mdream/plugins';
+import { htmlToMarkdownSplitChunksStream } from 'mdream/splitter';
+import { useSiteConfig, installNuxtSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
+import { relative, resolve, dirname } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { estimateTokenCount } from 'tokenx';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { consola } from 'consola';
+import { generateLlmsTxtArtifacts } from 'mdream/llms-txt';
+
+const logger$1 = useLogger("nuxt-ai-ready");
+
+function normalizeLink(link) {
+  const parts = [];
+  parts.push(`- [${link.title}](${link.href})`);
+  if (link.description) {
+    parts.push(`  ${link.description}`);
+  }
+  return parts.join("\n");
+}
+function normalizeSection(section) {
+  const parts = [];
+  parts.push(`## ${section.title}`);
+  parts.push("");
+  if (section.description) {
+    const descriptions = Array.isArray(section.description) ? section.description : [section.description];
+    parts.push(...descriptions);
+    parts.push("");
+  }
+  if (section.links?.length) {
+    parts.push(...section.links.map(normalizeLink));
+  }
+  return parts.join("\n");
+}
+function normalizeLlmsTxtConfig(config) {
+  const parts = [];
+  if (config.sections?.length) {
+    parts.push(...config.sections.map(normalizeSection));
+  }
+  if (config.notes) {
+    parts.push("## Notes");
+    parts.push("");
+    const notes = Array.isArray(config.notes) ? config.notes : [config.notes];
+    parts.push(...notes);
+  }
+  return parts.join("\n\n");
+}
+
+const logger = consola.withTag("nuxt-mdream");
+function setupPrerenderHandler() {
+  const nuxt = useNuxt();
+  nuxt.options.aiReady || {};
+  const pages = [];
+  nuxt.hooks.hook("nitro:init", async (nitro) => {
+    nitro.hooks.hook("prerender:generate", async (route) => {
+      if (!route.fileName?.endsWith(".md")) {
+        return;
+      }
+      const { markdown, title, description } = JSON.parse(route.contents || "{}");
+      const page = {
+        filePath: route.fileName,
+        url: route.route,
+        title,
+        content: markdown,
+        metadata: {
+          description,
+          title
+        }
+      };
+      pages.push(page);
+      route.contents = markdown;
+    });
+    nitro.hooks.hook("prerender:done", async () => {
+      if (pages.length === 0) {
+        return;
+      }
+      const startTime = Date.now();
+      const siteConfig = useSiteConfig();
+      const artifacts = await generateLlmsTxtArtifacts({
+        origin: siteConfig.url,
+        files: pages,
+        generateFull: true,
+        siteName: siteConfig.name || siteConfig.url,
+        description: siteConfig.description
+      });
+      logger.success(`Generated markdown for ${pages.length} pages`);
+      const hookPayload = {
+        content: artifacts.llmsTxt || "",
+        fullContent: artifacts.llmsFullTxt || "",
+        pages
+      };
+      const llmsTxtConfig = nuxt.options.runtimeConfig["nuxt-ai-ready"].llmsTxt;
+      const normalizedContent = normalizeLlmsTxtConfig(llmsTxtConfig);
+      if (normalizedContent) {
+        hookPayload.content = `${hookPayload.content}
+
+${normalizedContent}
+`;
+      }
+      await nuxt.hooks.callHook("ai-ready:llms-txt", hookPayload);
+      const finalLlmsTxt = hookPayload.content;
+      const finalLlmsFullTxt = hookPayload.fullContent;
+      const generatedFiles = [];
+      if (finalLlmsTxt) {
+        const llmsTxtPath = join(nitro.options.output.publicDir, "llms.txt");
+        await writeFile(llmsTxtPath, finalLlmsTxt, "utf-8");
+        const sizeKb = (Buffer.byteLength(finalLlmsTxt, "utf-8") / 1024).toFixed(2);
+        generatedFiles.push({ path: "llms.txt", size: `${sizeKb}kb` });
+        nitro._prerenderedRoutes.push({
+          route: "/llms.txt",
+          fileName: llmsTxtPath,
+          generateTimeMS: 0
+        });
+      }
+      if (finalLlmsFullTxt) {
+        const llmsFullTxtPath = join(nitro.options.output.publicDir, "llms-full.txt");
+        await writeFile(llmsFullTxtPath, finalLlmsFullTxt, "utf-8");
+        const sizeKb = (Buffer.byteLength(finalLlmsFullTxt, "utf-8") / 1024).toFixed(2);
+        generatedFiles.push({ path: "llms-full.txt", size: `${sizeKb}kb` });
+        nitro._prerenderedRoutes.push({
+          route: "/llms-full.txt",
+          fileName: llmsFullTxtPath,
+          generateTimeMS: 0
+        });
+      }
+      if (generatedFiles.length > 0) {
+        const elapsed = Date.now() - startTime;
+        const fileList = generatedFiles.map((f) => `${f.path} (${f.size})`).join(" and ");
+        logger.info(`Generated ${fileList} in ${elapsed}ms`);
+      }
+    });
+  });
+}
+
+function generateVectorId(route, chunkIdx) {
+  const hash = createHash("sha256").update(route).digest("hex").substring(0, 48);
+  return `${hash}-${chunkIdx}`;
+}
+const module = defineNuxtModule({
+  meta: {
+    name: "nuxt-ai-ready",
+    compatibility: {
+      nuxt: ">=4.0.0"
+    },
+    configKey: "aiReady"
+  },
+  moduleDependencies: {
+    "@nuxtjs/robots": {
+      version: ">=5.6.0",
+      defaults: {
+        groups: [
+          {
+            userAgent: "*",
+            contentUsage: ["train-ai=y"],
+            contentSignal: ["ai-train=yes", "search=yes", "ai-input=yes"]
+          }
+        ]
+      }
+    },
+    "nuxt-site-config": {
+      version: ">=3"
+    },
+    "@nuxtjs/mcp-toolkit": {
+      version: ">=0.4.0",
+      optional: true
+    }
+  },
+  defaults() {
+    return {
+      enabled: true,
+      debug: false,
+      bulkRoute: "/content.jsonl",
+      mdreamOptions: {
+        preset: "minimal"
+      },
+      markdownCacheHeaders: {
+        maxAge: 3600,
+        // 1 hour
+        swr: true
+      }
+    };
+  },
+  async setup(config, nuxt) {
+    const { resolve: resolve$1 } = createResolver(import.meta.url);
+    const { version } = await readPackageJSON(resolve$1("../package.json"));
+    logger$1.level = config.debug || nuxt.options.debug ? 4 : 3;
+    if (config.enabled === false) {
+      logger$1.debug("Module is disabled, skipping setup.");
+      return;
+    }
+    await installNuxtSiteConfig();
+    nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
+    nuxt.options.alias["#ai-ready"] = resolve$1("./runtime");
+    if (!nuxt.options.mcp?.name) {
+      nuxt.options.mcp = nuxt.options.mcp || {};
+      nuxt.options.mcp.name = useSiteConfig().name;
+    }
+    nuxt.options.nitro.scanDirs = nuxt.options.nitro.scanDirs || [];
+    nuxt.options.nitro.scanDirs.push(
+      resolve$1("./runtime/server/utils"),
+      resolve$1("./runtime/server/mcp")
+    );
+    addTypeTemplate({
+      filename: "module/nuxt-ai-ready.d.ts",
+      getContents: (data) => {
+        const typesPath = relative(resolve$1(data.nuxt.options.rootDir, data.nuxt.options.buildDir, "module"), resolve$1("runtime/types"));
+        const nitroTypes = `  interface NitroRuntimeHooks {
+    'ai-ready:markdown': (context: import('${typesPath}').MarkdownContext) => void | Promise<void>
+    'ai-ready:mdreamConfig': (config: import('mdream').HTMLToMarkdownOptions) => void | Promise<void>
+  }`;
+        return `// Generated by nuxt-ai-ready
+declare module 'nitropack/types' {
+${nitroTypes}
+}
+
+declare module 'nitropack' {
+${nitroTypes}
+}
+
+export {}
+`;
+      }
+    }, {
+      nitro: true
+    });
+    const defaultLlmsTxtSections = [];
+    if (config.bulkRoute !== false) {
+      const resolvedBulkRoute = withSiteUrl(config.bulkRoute);
+      defaultLlmsTxtSections.push({
+        title: "AI Tools",
+        links: [
+          {
+            title: "Bulk Data",
+            href: resolvedBulkRoute,
+            description: `\`\`\`bash
+curl "${resolvedBulkRoute}"
+\`\`\`
+
+Returns JSONL (newline-delimited JSON) with all indexed content.`
+          }
+        ]
+      });
+    }
+    const hasMCP = hasNuxtModule("@nuxtjs/mcp-toolkit");
+    if (hasMCP) {
+      nuxt.hook("mcp:definitions:paths", (paths) => {
+        const mcpRuntimeDir = resolve$1("./runtime/server/mcp");
+        paths.tools = paths.tools || [];
+        paths.resources = paths.resources || [];
+        paths.prompts = paths.prompts || [];
+        paths.tools.push(`${mcpRuntimeDir}/tools`);
+        paths.resources.push(`${mcpRuntimeDir}/resources`);
+        paths.prompts.push(`${mcpRuntimeDir}/prompts`);
+      });
+      const mcpLink = {
+        title: "MCP",
+        href: withSiteUrl(nuxt.options.mcp?.route || "/mcp")
+      };
+      if (config.bulkRoute !== false && defaultLlmsTxtSections[0]) {
+        defaultLlmsTxtSections[0].links.push(mcpLink);
+      } else {
+        defaultLlmsTxtSections.push({
+          title: "AI Tools - API Endpoints",
+          links: [mcpLink]
+        });
+      }
+    }
+    const mergedLlmsTxt = config.llmsTxt ? {
+      sections: [
+        ...defaultLlmsTxtSections,
+        ...config.llmsTxt.sections || []
+      ],
+      notes: config.llmsTxt.notes
+    } : { sections: defaultLlmsTxtSections };
+    nuxt.options.runtimeConfig["nuxt-ai-ready"] = {
+      version: version || "0.0.0",
+      debug: config.debug || false,
+      bulkRoute: config.bulkRoute,
+      mdreamOptions: config.mdreamOptions || {},
+      markdownCacheHeaders: defu(config.markdownCacheHeaders, {
+        maxAge: 3600,
+        swr: true
+      }),
+      llmsTxt: mergedLlmsTxt
+    };
+    addServerHandler({
+      middleware: true,
+      handler: resolve$1("./runtime/server/middleware/mdream")
+    });
+    if (nuxt.options.build) {
+      addPlugin({ mode: "server", src: resolve$1("./runtime/nuxt/plugins/prerender") });
+    }
+    if (nuxt.options.dev) {
+      addServerHandler({ route: "/llms.txt", handler: resolve$1("./runtime/server/routes/llms.txt.get") });
+    }
+    const isStatic = nuxt.options.nitro.static || nuxt.options._generate || false;
+    if (isStatic || nuxt.options.nitro.prerender?.routes?.length) {
+      setupPrerenderHandler();
+    }
+    if (config.bulkRoute !== false) {
+      nuxt.options.nitro.routeRules = nuxt.options.nitro.routeRules || {};
+      nuxt.options.nitro.routeRules[config.bulkRoute] = {
+        headers: {
+          "Content-Type": "application/x-ndjson; charset=utf-8"
+        }
+      };
+    }
+    const isBuildMode = !nuxt.options._prepare && !nuxt.options.dev;
+    nuxt.hooks.hook("modules:done", () => {
+      nuxt.hook("nitro:init", async (nitro) => {
+        if (!isBuildMode) {
+          logger$1.debug("Dev mode: skipping llms.txt generation");
+          return;
+        }
+        if (config.bulkRoute === false) {
+          logger$1.debug("Bulk route disabled, skipping bulk generation");
+          return;
+        }
+        const bulkPath = resolve(nitro.options.output.dir, `public${config.bulkRoute}`);
+        let bulkStream = null;
+        let bulkStreamEntries = 0;
+        nitro.hooks.hook("prerender:route", async (route) => {
+          const isHtml = route.fileName?.endsWith(".html") && route.contents.startsWith("<!DOCTYPE html");
+          if (!isHtml || !route._sitemap || !route.contents) {
+            return;
+          }
+          let title = "";
+          let description = "";
+          const headings = [];
+          const extractPlugin = extractionPlugin({
+            title(el) {
+              title = el.textContent;
+            },
+            'meta[name="description"]': (el) => {
+              description = el.attributes.content || "";
+            },
+            "h1, h2, h3, h4, h5, h6": (el) => {
+              const text = el.textContent?.trim();
+              const level = el.name.toLowerCase();
+              if (text)
+                headings.push({ [level]: text });
+            }
+          });
+          const options = {
+            origin: useSiteConfig().url,
+            ...config.mdreamOptions || {}
+          };
+          options.plugins = [extractPlugin, ...options.plugins || []];
+          const chunksStream = htmlToMarkdownSplitChunksStream(route.contents, {
+            ...options,
+            headersToSplitOn: [TagIdMap.h1, TagIdMap.h2, TagIdMap.h3],
+            origin: useSiteConfig().url,
+            chunkSize: 256,
+            stripHeaders: false,
+            lengthFunction(text) {
+              return estimateTokenCount(text);
+            }
+          });
+          if (!bulkStream) {
+            mkdirSync(dirname(bulkPath), { recursive: true });
+            bulkStream = createWriteStream(bulkPath);
+            logger$1.info(`Bulk JSONL stream created at ${relative(nuxt.options.rootDir, bulkPath)}`);
+          }
+          let idx = 0;
+          for (const chunk of chunksStream) {
+            const bulkChunk = {
+              id: generateVectorId(route.route, idx),
+              route: route.route,
+              chunkIndex: idx,
+              content: chunk.content,
+              headers: chunk.metadata?.headers,
+              loc: chunk.metadata?.loc,
+              title,
+              description
+            };
+            await nuxt.hooks.callHook("ai-ready:chunk", {
+              chunk: bulkChunk,
+              route: route.route,
+              title,
+              description,
+              headings
+            });
+            bulkStream.write(`${JSON.stringify(bulkChunk)}
+`);
+            bulkStreamEntries++;
+            idx++;
+          }
+        });
+        nitro.hooks.hook("prerender:done", () => {
+          if (bulkStream) {
+            bulkStream.end();
+            logger$1.success(`Bulk JSONL exported ${bulkStreamEntries} entries.`);
+          }
+        });
+      });
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/nuxt/plugins/prerender.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/nuxt/plugins/prerender.js

@@ -0,0 +1,20 @@
+import { defineNuxtPlugin, prerenderRoutes } from "nuxt/app";
+export default defineNuxtPlugin({
+  setup(nuxtApp) {
+    if (!import.meta.prerender) {
+      return;
+    }
+    nuxtApp.hooks.hook("app:rendered", (ctx) => {
+      let url = ctx.ssrContext?.url || "";
+      if (url.endsWith(".md")) {
+        return;
+      }
+      if (url.endsWith("/")) {
+        url = `${url}index.md`;
+      } else {
+        url = `${url}.md`;
+      }
+      prerenderRoutes(url);
+    });
+  }
+});

package/dist/runtime/server/logger.d.ts

@@ -0,0 +1 @@
+export declare const logger: import("consola").ConsolaInstance;

package/dist/runtime/server/logger.js

@@ -0,0 +1,4 @@
+import { createConsola } from "consola";
+export const logger = createConsola({
+  defaults: { tag: "nuxt-ai-ready" }
+});

package/dist/runtime/server/mcp/prompts/explain-concept.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/prompts/explain-concept.js

@@ -0,0 +1,62 @@
+import { defineMcpPrompt } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpPrompt({
+  name: "explain_concept",
+  description: "Get a detailed explanation of a concept by finding and reading relevant pages",
+  arguments: [
+    {
+      name: "concept",
+      description: "The concept or feature to explain",
+      required: true
+    },
+    {
+      name: "level",
+      description: "Explanation level: beginner, intermediate, or advanced",
+      required: false
+    }
+  ],
+  handler: async ({ concept, level = "intermediate" }) => {
+    const searchLower = concept.toLowerCase();
+    const seenRoutes = /* @__PURE__ */ new Set();
+    const relevantPages = [];
+    for await (const doc of streamBulkDocuments()) {
+      if (seenRoutes.has(doc.route))
+        continue;
+      const matches = doc.title?.toLowerCase().includes(searchLower) || doc.description?.toLowerCase().includes(searchLower) || doc.route?.toLowerCase().includes(searchLower);
+      if (matches) {
+        seenRoutes.add(doc.route);
+        relevantPages.push({
+          route: doc.route,
+          title: doc.title,
+          description: doc.description
+        });
+        if (relevantPages.length >= 10)
+          break;
+      }
+    }
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Please explain "${concept}" at a ${level} level.
+
+Here are the relevant pages found: ${JSON.stringify(relevantPages, null, 2)}
+
+Please:
+1. Use get_page to read the most relevant pages (top 2-3)
+2. Synthesize the information to create an explanation that:
+   - Provides clear definitions
+   - Includes practical examples from the pages
+   - Explains use cases
+   - Mentions related concepts
+   - References the specific pages used
+
+Tailor the explanation for a ${level} audience.`
+          }
+        }
+      ]
+    };
+  }
+});

package/dist/runtime/server/mcp/prompts/find-information.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;