feat: add intelligent routing functionality with natural language processing for knowledge management

server.js

@@ -9,6 +9,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { vectorTools, handleVectorTool } from "./tools/vectorTool.js";
 import { curateTools, handleCurateTool } from "./tools/curateTool.js";
+import { routerTools, handleRouterTool } from "./tools/routerTool.js";
 
 const PORT = Number(process.env.PORT || 3000);
 const HOST = process.env.HOST || "0.0.0.0";
@@ -45,12 +46,15 @@ function createMcpServer() {
   );
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [...curateTools, ...vectorTools],
+    tools: [...routerTools, ...curateTools, ...vectorTools],
   }));
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args = {} } = request.params;
 
+    const routerResult = await handleRouterTool(name, args, config);
+    if (routerResult) return routerResult;
+
     const curateResult = await handleCurateTool(name, args, config);
     if (curateResult) return curateResult;
 

services/curation.js

@@ -2,6 +2,7 @@ import fs from "fs-extra";
 import path from "path";
 import matter from "gray-matter";
 import { askOpenAI } from "./llm.js";
+import { addDocuments } from "./vector.js";
 
 export async function curateText(rawText, config) {
   const OUTPUT_DIR = config.OUTPUT_DIR || "/data/context-tree";
@@ -36,6 +37,26 @@ RETURN THIS JSON (no markdown, no explanation):
     OUTPUT_DIR,
   );
 
+  try {
+    await addDocuments({
+      documents: [
+        {
+          id,
+          text: `${parsed.title}\n\n${parsed.content}`,
+          metadata: {
+            title: parsed.title,
+            topic: parsed.topic,
+            type: parsed.type,
+            filePath,
+            summary: parsed.summary,
+          },
+        },
+      ],
+    });
+  } catch (err) {
+    console.error("Warning: Failed to add to ChromaDB:", err.message);
+  }
+
   return {
     id,
     title: parsed.title,

services/router.js

@@ -0,0 +1,154 @@
+import { askOpenAI } from "./llm.js";
+import { curateText } from "./curation.js";
+import { queryCollectionDataEnhanced, queryCollectionData } from "./vector.js";
+import { loadContextTreeDocuments } from "../utils.js";
+
+export async function routeUserInput(input, config) {
+  try {
+    const intent = await classifyIntent(input, config);
+
+    switch (intent.type) {
+      case "search":
+        return await handleSearch(input, intent, config);
+
+      case "curate":
+        return await handleCurate(input, intent, config);
+
+      case "add":
+        return await handleAdd(input, intent, config);
+
+      case "list":
+        return await handleList(input, intent, config);
+
+      default:
+        return {
+          error: "Could not determine intent",
+          input,
+          intent: intent.type,
+        };
+    }
+  } catch (error) {
+    return {
+      error: `Routing failed: ${error.message}`,
+      input,
+    };
+  }
+}
+
+async function classifyIntent(input, config) {
+  const prompt = `Analyze this user input and classify the intent. Return ONLY valid JSON:
+
+Input: "${input}"
+
+Classify as one of these intents:
+- "search": User is asking questions to find knowledge
+- "curate": User is teaching/storing new knowledge
+- "add": User is adding documents to the knowledge base
+- "list": User wants to see all stored knowledge
+
+Response format (valid JSON only):
+{
+  "type": "search|curate|add|list",
+  "confidence": 0.0-1.0,
+  "reasoning": "brief explanation",
+  "hints": {
+    "enhanced": false,
+    "rerank": false,
+    "extractText": null
+  }
+}`;
+
+  try {
+    const response = await askOpenAI(input, prompt);
+    const parsed = JSON.parse(response);
+    return parsed;
+  } catch (error) {
+    console.error("Intent classification failed:", error.message);
+    return { type: "search", confidence: 0.5, reasoning: "Fallback to search" };
+  }
+}
+
+async function handleSearch(input, intent, config) {
+  try {
+    const searchParams = {
+      query: input,
+      nResults: 5,
+      enhanced: intent.hints?.enhanced || false,
+      rerank: intent.hints?.rerank || false,
+    };
+
+    const results = searchParams.enhanced
+      ? await queryCollectionDataEnhanced(searchParams)
+      : await queryCollectionData(searchParams);
+
+    return {
+      intent: "search",
+      query: input,
+      searchStrategy: {
+        enhanced: searchParams.enhanced,
+        rerank: searchParams.rerank,
+      },
+      results,
+    };
+  } catch (error) {
+    return {
+      intent: "search",
+      error: `Search failed: ${error.message}`,
+      query: input,
+    };
+  }
+}
+
+async function handleCurate(input, intent, config) {
+  try {
+    const textToCurate = intent.hints?.extractText || input;
+
+    const result = await curateText(textToCurate, config);
+
+    return {
+      intent: "curate",
+      action: "extracted_and_stored",
+      result,
+    };
+  } catch (error) {
+    return {
+      intent: "curate",
+      error: `Curation failed: ${error.message}`,
+      input,
+    };
+  }
+}
+
+async function handleAdd(input, intent, config) {
+  return {
+    intent: "add",
+    message:
+      "To add documents, use the add_documents tool with an array of {id, text, metadata}",
+    guidance: input,
+  };
+}
+
+async function handleList(input, intent, config) {
+  try {
+    const dataDir = process.env.DATA_DIR || "/data";
+    const docs = await loadContextTreeDocuments(dataDir);
+
+    return {
+      intent: "list",
+      count: docs.length,
+      documents: docs.map((d) => ({
+        id: d.id,
+        title: d.title,
+        topic: d.topic,
+        type: d.type,
+        importance: d.importance,
+        filePath: d.filePath,
+      })),
+    };
+  } catch (error) {
+    return {
+      intent: "list",
+      error: `List failed: ${error.message}`,
+    };
+  }
+}

tools/routerTool.js

@@ -0,0 +1,62 @@
+import { routeUserInput } from "../services/router.js";
+
+const intelligentRouterToolDefinition = {
+  name: "intelligent_router",
+  description:
+    "Natural language interface to the knowledge base. Ask questions, teach knowledge, or manage documents. LLM automatically understands intent and routes to the right operation (search, curate, add, or list).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      input: {
+        type: "string",
+        description:
+          "Your natural language question, statement, or command about the knowledge base.",
+      },
+    },
+    required: ["input"],
+    additionalProperties: false,
+  },
+};
+
+export const routerTools = [intelligentRouterToolDefinition];
+
+export async function handleRouterTool(name, args, config) {
+  if (name === "intelligent_router") {
+    try {
+      if (!args.input || typeof args.input !== "string") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Error: 'input' field is required and must be a string",
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const result = await routeUserInput(args.input, config);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Router error: ${err.message}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  return null;
+}