@juspay/neurolink 9.13.0 → 9.15.0

package/docs-site/mcp-server/index.js

@@ -0,0 +1,165 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { randomUUID } from "node:crypto";
+import { DocsSearch } from "./search.js";
+import { createToolDefinitions } from "./tools.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function resolveIndexPath() {
+  const localPath = path.resolve(__dirname, "../static/search-index.json");
+  if (fs.existsSync(localPath)) return localPath;
+
+  const pkgPath = path.resolve(
+    __dirname,
+    "../../docs-site/static/search-index.json",
+  );
+  if (fs.existsSync(pkgPath)) return pkgPath;
+
+  throw new Error(
+    "search-index.json not found. Run docs-site build first: cd docs-site && pnpm build",
+  );
+}
+
+function initSearch() {
+  const indexPath = resolveIndexPath();
+  const raw = fs.readFileSync(indexPath, "utf-8");
+  const indexData = JSON.parse(raw);
+
+  const search = new DocsSearch();
+  search.loadIndex(indexData);
+
+  return search;
+}
+
+function createServer(search) {
+  const server = new McpServer({
+    name: "neurolink-docs",
+    version: "1.0.0",
+  });
+
+  const tools = createToolDefinitions(search);
+
+  for (const tool of Object.values(tools)) {
+    server.tool(
+      tool.name,
+      tool.description,
+      tool.paramsSchema,
+      async (args) => {
+        return tool.handler(args);
+      },
+    );
+  }
+
+  return server;
+}
+
+async function startStdio(server) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+async function startHttp(server, port) {
+  const { StreamableHTTPServerTransport } = await import(
+    "@modelcontextprotocol/sdk/server/streamableHttp.js"
+  );
+  const http = await import("http");
+
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID(),
+  });
+
+  await server.connect(transport);
+
+  const httpServer = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (req.url === "/mcp" && req.method === "POST") {
+      try {
+        await transport.handleRequest(req, res);
+      } catch (err) {
+        console.error("MCP transport error:", err);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+    } else if (req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok" }));
+    } else {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+
+  const host = process.env.BIND_HOST || "127.0.0.1";
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(port, host, () => {
+      httpServer.removeListener("error", reject);
+      console.error(
+        `NeuroLink MCP Docs Server listening on http://${host}:${port}/mcp`,
+      );
+      console.error(`Health check: http://${host}:${port}/health`);
+      resolve();
+    });
+  });
+}
+
+export async function startDocsServer(args) {
+  const search = initSearch();
+  const server = createServer(search);
+  const transport = args.transport || "stdio";
+  const port = args.port || 3001;
+
+  console.error(
+    `NeuroLink MCP Docs Server — ${search.documentCount} docs indexed`,
+  );
+
+  if (transport === "http") {
+    await startHttp(server, port);
+  } else {
+    await startStdio(server);
+  }
+}
+
+const isDirectExecution =
+  typeof process !== "undefined" &&
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === process.argv[1];
+
+if (isDirectExecution) {
+  const args = process.argv.slice(2);
+  const transportFlag = args.includes("--transport")
+    ? args[args.indexOf("--transport") + 1]
+    : "stdio";
+  if (transportFlag !== "stdio" && transportFlag !== "http") {
+    console.error(
+      `Invalid transport "${transportFlag}". Must be "stdio" or "http".`,
+    );
+    process.exit(1);
+  }
+  const portRaw = args.includes("--port")
+    ? parseInt(args[args.indexOf("--port") + 1], 10)
+    : 3001;
+  const portFlag =
+    Number.isNaN(portRaw) || portRaw < 1 || portRaw > 65535 ? 3001 : portRaw;
+
+  startDocsServer({ transport: transportFlag, port: portFlag }).catch((err) => {
+    console.error("Failed to start MCP docs server:", err);
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=index.js.map

package/docs-site/mcp-server/search.d.ts

@@ -0,0 +1,13 @@
+import type { IndexDocument, SearchIndex, SearchResult, SectionInfo } from "./types.js";
+export declare class DocsSearch {
+    private miniSearch;
+    private documents;
+    private sections;
+    constructor();
+    loadIndex(indexData: SearchIndex): void;
+    search(query: string, limit?: number, section?: string): SearchResult[];
+    getPage(docPath: string): IndexDocument | undefined;
+    listSections(): SectionInfo[];
+    getBySection(section: string): IndexDocument[];
+    get documentCount(): number;
+}

package/docs-site/mcp-server/search.js

@@ -0,0 +1,81 @@
+import MiniSearch from "minisearch";
+
+const MINISEARCH_CONFIG = {
+  fields: ["title", "description", "content", "tags"],
+  storeFields: ["title", "description", "section", "path"],
+  searchOptions: {
+    boost: { title: 3, description: 2, tags: 1.5 },
+    fuzzy: 0.2,
+    prefix: true,
+  },
+};
+
+export class DocsSearch {
+  miniSearch;
+  documents = new Map();
+  sections = new Map();
+
+  constructor() {
+    this.miniSearch = new MiniSearch(MINISEARCH_CONFIG);
+  }
+
+  loadIndex(indexData) {
+    this.documents.clear();
+    this.sections.clear();
+    this.miniSearch = new MiniSearch(MINISEARCH_CONFIG);
+    for (const doc of indexData.documents) {
+      this.documents.set(doc.id, doc);
+    }
+    for (const doc of this.documents.values()) {
+      const sectionDocs = this.sections.get(doc.section) || [];
+      sectionDocs.push(doc);
+      this.sections.set(doc.section, sectionDocs);
+    }
+    this.miniSearch.addAll(Array.from(this.documents.values()));
+  }
+
+  search(query, limit = 10, section) {
+    const options = section
+      ? {
+          filter: (result) => result["section"] === section,
+        }
+      : undefined;
+    const results = this.miniSearch.search(query, options);
+    return results.slice(0, limit).map((r) => ({
+      id: String(r.id),
+      title: String(r["title"] ?? ""),
+      description: String(r["description"] ?? ""),
+      section: String(r["section"] ?? ""),
+      path: String(r["path"] ?? ""),
+      score: r.score,
+    }));
+  }
+
+  getPage(docPath) {
+    return (
+      this.documents.get(docPath) ||
+      this.documents.get(docPath.replace(/^\//, ""))
+    );
+  }
+
+  listSections() {
+    const result = [];
+    for (const [name, docs] of this.sections) {
+      result.push({
+        name,
+        pageCount: docs.length,
+        pages: docs.map((d) => ({ title: d.title, path: d.path })),
+      });
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  getBySection(section) {
+    return this.sections.get(section) || [];
+  }
+
+  get documentCount() {
+    return this.documents.size;
+  }
+}
+//# sourceMappingURL=search.js.map

package/docs-site/mcp-server/tools.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import type { DocsSearch } from "./search.js";
+export declare function createToolDefinitions(search: DocsSearch): {
+    search_docs: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            query: z.ZodString;
+            limit: z.ZodOptional<z.ZodNumber>;
+            section: z.ZodOptional<z.ZodString>;
+        };
+        handler: (args: {
+            query: string;
+            limit?: number;
+            section?: string;
+        }) => {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+        };
+    };
+    get_page: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            path: z.ZodString;
+        };
+        handler: (args: {
+            path: string;
+        }) => {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+        };
+    };
+    list_sections: {
+        name: string;
+        description: string;
+        paramsSchema: {};
+        handler: () => {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+        };
+    };
+    get_api_reference: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            method: z.ZodOptional<z.ZodString>;
+        };
+        handler: (args: {
+            method?: string;
+        }) => {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+        };
+    };
+    get_examples: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            topic: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+        };
+        handler: (args: {
+            topic?: string;
+            provider?: string;
+        }) => {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+        };
+    };
+    get_changelog: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            limit: z.ZodOptional<z.ZodNumber>;
+        };
+        handler: (args: {
+            limit?: number;
+        }) => {
+            content: {
+                type: "text";
+                text: string;
+            }[];
+        };
+    };
+};

package/docs-site/mcp-server/tools.js

@@ -0,0 +1,342 @@
+import { z } from "zod";
+
+export function createToolDefinitions(search) {
+  return {
+    search_docs: {
+      name: "search_docs",
+      description:
+        "Full-text search across all NeuroLink documentation. Returns ranked results with title, description, section, and path.",
+      paramsSchema: {
+        query: z
+          .string()
+          .describe(
+            "Search query (e.g. 'RAG pipeline', 'MCP configuration', 'streaming')",
+          ),
+        limit: z
+          .number()
+          .int()
+          .min(1)
+          .max(50)
+          .optional()
+          .describe("Max results to return (default: 10, max: 50)"),
+        section: z
+          .string()
+          .optional()
+          .describe(
+            "Filter by section (e.g. 'features', 'sdk', 'cli', 'mcp', 'rag', 'examples')",
+          ),
+      },
+      handler: (args) => {
+        const limit = Math.max(1, Math.min(args.limit || 10, 50));
+        const results = search.search(args.query, limit, args.section);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  query: args.query,
+                  resultCount: results.length,
+                  results: results.map((r) => ({
+                    title: r.title,
+                    description: r.description,
+                    section: r.section,
+                    path: r.path,
+                    url: `https://docs.neurolink.ink/docs/${r.path}`,
+                    score: Math.round(r.score * 100) / 100,
+                  })),
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      },
+    },
+
+    get_page: {
+      name: "get_page",
+      description:
+        "Get the full content of a specific documentation page by its path.",
+      paramsSchema: {
+        path: z
+          .string()
+          .describe(
+            "Document path (e.g. 'getting-started/installation', 'features/multimodal')",
+          ),
+      },
+      handler: (args) => {
+        const doc = search.getPage(args.path);
+        if (!doc) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "Page not found",
+                  path: args.path,
+                  hint: "Use search_docs or list_sections to find valid paths",
+                }),
+              },
+            ],
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  title: doc.title,
+                  description: doc.description,
+                  section: doc.section,
+                  path: doc.path,
+                  url: `https://docs.neurolink.ink/docs/${doc.path}`,
+                  content: doc.content,
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      },
+    },
+
+    list_sections: {
+      name: "list_sections",
+      description: "List all documentation sections and their pages.",
+      paramsSchema: {},
+      handler: () => {
+        const sections = search.listSections();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  totalSections: sections.length,
+                  totalPages: sections.reduce((sum, s) => sum + s.pageCount, 0),
+                  sections: sections.map((s) => ({
+                    name: s.name,
+                    pageCount: s.pageCount,
+                    pages: s.pages.map((p) => ({
+                      title: p.title,
+                      path: p.path,
+                    })),
+                  })),
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      },
+    },
+
+    get_api_reference: {
+      name: "get_api_reference",
+      description:
+        "Get SDK API reference documentation. Optionally filter by method name.",
+      paramsSchema: {
+        method: z
+          .string()
+          .optional()
+          .describe(
+            "Filter by method name (e.g. 'generate', 'stream'). Omit for full reference.",
+          ),
+      },
+      handler: (args) => {
+        if (args.method) {
+          const results = search.search(args.method, 5, "sdk");
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    query: args.method,
+                    results: results.map((r) => ({
+                      title: r.title,
+                      path: r.path,
+                      url: `https://docs.neurolink.ink/docs/${r.path}`,
+                    })),
+                  },
+                  null,
+                  2,
+                ),
+              },
+            ],
+          };
+        }
+        const sdkDocs = search.getBySection("sdk");
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  section: "sdk",
+                  pageCount: sdkDocs.length,
+                  pages: sdkDocs.map((d) => ({
+                    title: d.title,
+                    description: d.description,
+                    path: d.path,
+                    url: `https://docs.neurolink.ink/docs/${d.path}`,
+                  })),
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      },
+    },
+
+    get_examples: {
+      name: "get_examples",
+      description:
+        "Get code examples from the documentation. Optionally filter by topic or provider.",
+      paramsSchema: {
+        topic: z
+          .string()
+          .optional()
+          .describe(
+            "Filter by topic (e.g. 'rag', 'streaming', 'agents', 'mcp')",
+          ),
+        provider: z
+          .string()
+          .optional()
+          .describe(
+            "Filter by provider (e.g. 'openai', 'anthropic', 'google')",
+          ),
+      },
+      handler: (args) => {
+        const query = [args.topic, args.provider].filter(Boolean).join(" ");
+        if (!query) {
+          const exampleDocs = [
+            ...search.getBySection("examples"),
+            ...search.getBySection("cookbook"),
+            ...search.getBySection("demos"),
+          ];
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    pageCount: exampleDocs.length,
+                    pages: exampleDocs.map((d) => ({
+                      title: d.title,
+                      description: d.description,
+                      section: d.section,
+                      path: d.path,
+                      url: `https://docs.neurolink.ink/docs/${d.path}`,
+                    })),
+                  },
+                  null,
+                  2,
+                ),
+              },
+            ],
+          };
+        }
+        const exampleSections = ["examples", "cookbook", "demos"];
+        const allResults = exampleSections.flatMap((section) =>
+          search.search(query, 10, section),
+        );
+        const seen = new Map();
+        for (const r of allResults) {
+          const existing = seen.get(r.id);
+          if (!existing || r.score > existing.score) {
+            seen.set(r.id, r);
+          }
+        }
+        const results = Array.from(seen.values())
+          .sort((a, b) => b.score - a.score)
+          .slice(0, 10);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  query,
+                  results: results.map((r) => ({
+                    title: r.title,
+                    description: r.description,
+                    section: r.section,
+                    path: r.path,
+                    url: `https://docs.neurolink.ink/docs/${r.path}`,
+                  })),
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      },
+    },
+
+    get_changelog: {
+      name: "get_changelog",
+      description: "Get recent changelog entries for NeuroLink releases.",
+      paramsSchema: {
+        limit: z
+          .number()
+          .int()
+          .min(1)
+          .max(50)
+          .optional()
+          .describe("Max entries to return (default: 5)"),
+      },
+      handler: (args) => {
+        const changelogDocs = search.getBySection("community");
+        const changelog = changelogDocs
+          .filter(
+            (d) =>
+              d.path.includes("changelog") ||
+              d.title.toLowerCase().includes("changelog") ||
+              d.title.toLowerCase().includes("release notes"),
+          )
+          .sort((a, b) => {
+            const toEpoch = (p) => {
+              const m = p.match(/(\d{4})[-/](\d{1,2})[-/](\d{1,2})/);
+              if (!m) return Number.NEGATIVE_INFINITY;
+              const [, y, mo, d] = m;
+              return Date.UTC(Number(y), Number(mo) - 1, Number(d));
+            };
+            return (
+              toEpoch(b.path) - toEpoch(a.path) || b.path.localeCompare(a.path)
+            );
+          });
+        const limit = Math.max(1, Math.min(args.limit || 5, 50));
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  entries: changelog.slice(0, limit).map((d) => ({
+                    title: d.title,
+                    description: d.description,
+                    path: d.path,
+                    url: `https://docs.neurolink.ink/docs/${d.path}`,
+                    content: d.content.slice(0, 2000),
+                  })),
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      },
+    },
+  };
+}
+//# sourceMappingURL=tools.js.map