@khoinguyen2002/doc-mcp 1.0.0

package/dist/tools/knowledgeTools.js

@@ -0,0 +1,39 @@
+import { upsertProjectDocument, searchProjectMemory } from "../db/vector.js";
+import { syncFolderState } from "./driveTools.js";
+export async function saveAgentNote(content) {
+    const folderId = process.env.DOC_MCP_DRIVE_FOLDER_ID;
+    if (!folderId) {
+        return { success: false, error: "DOC_MCP_DRIVE_FOLDER_ID is not configured." };
+    }
+    try {
+        // We use folderId as the "projectId" parameter for vector-db namespace
+        await upsertProjectDocument(folderId, content, {
+            source: "agent",
+        });
+        return { success: true, message: "Successfully stored note in vector memory." };
+    }
+    catch (err) {
+        return { success: false, error: `Failed to store note: ${err.message}` };
+    }
+}
+export async function searchKnowledge(query, topK = 3) {
+    const folderId = process.env.DOC_MCP_DRIVE_FOLDER_ID;
+    if (!folderId) {
+        return { success: false, error: "DOC_MCP_DRIVE_FOLDER_ID is not configured." };
+    }
+    try {
+        // Auto-sync folder state before searching
+        await syncFolderState(folderId);
+        const results = await searchProjectMemory(folderId, query, topK);
+        if (!results || results.length === 0) {
+            return { success: true, results: "NOT_FOUND" };
+        }
+        return {
+            success: true,
+            results: results.map((r) => r.text).join("\n\n---\n\n"),
+        };
+    }
+    catch (err) {
+        return { success: false, error: `Failed to search: ${err.message}` };
+    }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@khoinguyen2002/doc-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "doc-mcp": "./dist/mcp-server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/mcp-server.js"
+  },
+  "dependencies": {
+    "@langchain/textsplitters": "^1.0.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@qdrant/js-client-rest": "^1.18.0",
+    "googleapis": "^173.0.0",
+    "uuid": "^14.0.0",
+    "zod": "^4.4.3"
+  },
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "devDependencies": {
+    "@types/uuid": "^11.0.0"
+  }
+}

package/src/config.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+const schema = z.object({
+  DOC_MCP_DRIVE_FOLDER_ID: z.string().optional(),
+  DOC_MCP_GOOGLE_CLIENT_EMAIL: z.string().email().optional(),
+  DOC_MCP_GOOGLE_PRIVATE_KEY: z.string().optional(),
+  
+  // Vector DB / Embeddings
+  QDRANT_URL: z.string().url().describe("The URL of your Qdrant instance"),
+  QDRANT_API_KEY: z.string().optional().describe("API Key for Qdrant Cloud (optional for local)"),
+  OPENROUTER_API_KEY: z.string().min(1),
+  EMBEDDING_MODEL_ID: z.string().default("nvidia/llama-nemotron-embed-vl-1b-v2:free"),
+  CHUNK_SIZE: z.coerce.number().int().positive().default(4000),
+  CHUNK_OVERLAP: z.coerce.number().int().nonnegative().default(500),
+});
+
+function loadConfig() {
+  const result = schema.safeParse(process.env);
+  if (!result.success) {
+    const missing = result.error.issues
+      .map((i) => `  ${i.path.join(".")}: ${i.message}`)
+      .join("\n");
+    throw new Error(`Invalid environment configuration for doc-mcp:\n${missing}`);
+  }
+  return result.data;
+}
+
+export const config = loadConfig();
+export type Config = typeof config;

package/src/db/vector.ts

@@ -0,0 +1,185 @@
+import { QdrantClient } from '@qdrant/js-client-rest';
+import { v4 as uuidv4 } from 'uuid';
+import { config } from '../config.js';
+
+let client: QdrantClient | null = null;
+const COLLECTION_NAME = 'project_memory';
+
+export async function initVectorDB() {
+  if (!client) {
+    client = new QdrantClient({
+      url: config.QDRANT_URL,
+      apiKey: config.QDRANT_API_KEY,
+    });
+    console.error(`Connected to Qdrant at ${config.QDRANT_URL}`);
+
+    // Check if collection exists
+    const res = await client.getCollections();
+    const exists = res.collections.some(c => c.name === COLLECTION_NAME);
+    if (!exists) {
+      console.error(`Creating Qdrant collection: ${COLLECTION_NAME}`);
+      const dummyVector = await embedText("test");
+      const dimension = dummyVector.length;
+
+      await client.createCollection(COLLECTION_NAME, {
+        vectors: {
+          size: dimension,
+          distance: "Cosine",
+        },
+      });
+      await client.createPayloadIndex(COLLECTION_NAME, {
+        field_name: "projectId",
+        field_schema: "keyword",
+      });
+      await client.createPayloadIndex(COLLECTION_NAME, {
+        field_name: "file_id",
+        field_schema: "keyword",
+      });
+      await client.createPayloadIndex(COLLECTION_NAME, {
+        field_name: "source",
+        field_schema: "keyword",
+      });
+      console.error(`Collection ${COLLECTION_NAME} created with dimension ${dimension}.`);
+    }
+  }
+}
+
+export async function embedText(text: string): Promise<number[]> {
+  const response = await fetch("https://openrouter.ai/api/v1/embeddings", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${config.OPENROUTER_API_KEY}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: config.EMBEDDING_MODEL_ID,
+      input: text
+    })
+  });
+
+  if (!response.ok) {
+    const errText = await response.text();
+    throw new Error(`OpenRouter Embedding API failed: ${response.status} ${errText}`);
+  }
+
+  const json: any = await response.json();
+  if (!json.data || !json.data[0] || !json.data[0].embedding) {
+    throw new Error("Invalid response from OpenRouter Embedding API");
+  }
+
+  return json.data[0].embedding;
+}
+
+export async function upsertProjectDocument(projectId: string, text: string, metadata: Record<string, any> = {}): Promise<void> {
+  await initVectorDB();
+  if (!client) throw new Error("Qdrant not initialized");
+
+  const vector = await embedText(text);
+
+  await client.upsert(COLLECTION_NAME, {
+    wait: true,
+    points: [
+      {
+        id: uuidv4(),
+        vector: vector,
+        payload: {
+          projectId,
+          text,
+          source: metadata.source || "user",
+          file_id: metadata.file_id || null,
+          modified_time: metadata.modified_time || null,
+          metadata: JSON.stringify(metadata),
+          createdAt: new Date().toISOString()
+        }
+      }
+    ]
+  });
+
+  console.error(`Upserted document chunk for project ${projectId}`);
+}
+
+export async function searchProjectMemory(projectId: string, query: string, topK: number = 3): Promise<any[]> {
+  await initVectorDB();
+  if (!client) throw new Error("Qdrant not initialized");
+
+  const queryVector = await embedText(query);
+
+  const results = await client.search(COLLECTION_NAME, {
+    vector: queryVector,
+    limit: topK,
+    with_payload: true,
+    filter: {
+      must: [
+        {
+          key: "projectId",
+          match: {
+            value: projectId
+          }
+        }
+      ]
+    }
+  });
+
+  // Map to match LanceDB format expected by other tools
+  return results.map(r => ({
+    id: r.id,
+    vector: r.vector,
+    ...r.payload
+  }));
+}
+
+export async function deleteProjectDocument(projectId: string, fileId: string): Promise<void> {
+  await initVectorDB();
+  if (!client) return;
+
+  await client.delete(COLLECTION_NAME, {
+    filter: {
+      must: [
+        { key: "projectId", match: { value: projectId } },
+        { key: "file_id", match: { value: fileId } }
+      ]
+    }
+  });
+  console.error(`Deleted old chunks from Qdrant for ${projectId} / ${fileId}`);
+}
+
+export async function checkProjectDocumentExists(projectId: string, fileId: string): Promise<boolean> {
+  await initVectorDB();
+  if (!client) return false;
+
+  const res = await client.count(COLLECTION_NAME, {
+    filter: {
+      must: [
+        { key: "projectId", match: { value: projectId } },
+        { key: "file_id", match: { value: fileId } }
+      ]
+    }
+  });
+  return res.count > 0;
+}
+
+export async function getProjectDocumentMetadata(projectId: string): Promise<Record<string, string>> {
+  await initVectorDB();
+  if (!client) return {};
+
+  const res = await client.scroll(COLLECTION_NAME, {
+    filter: {
+      must: [
+        { key: "projectId", match: { value: projectId } },
+        { key: "source", match: { value: "google_drive" } }
+      ]
+    },
+    limit: 10000,
+    with_payload: ["file_id", "modified_time"],
+    with_vector: false
+  });
+
+  const fileMap: Record<string, string> = {};
+  for (const r of res.points) {
+    if (r.payload && r.payload.file_id && r.payload.modified_time) {
+      fileMap[r.payload.file_id as string] = r.payload.modified_time as string;
+    }
+  }
+
+  return fileMap;
+}

package/src/hooks/driveSync.ts

@@ -0,0 +1,108 @@
+import {
+  getProjectDocumentMetadata,
+  deleteProjectDocument,
+  upsertProjectDocument,
+} from "../db/vector.js";
+import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
+// Remove childLogger dependency to fully decouple from core
+// import { childLogger } from "@workspace/core";
+import { config } from "../config.js";
+
+const log = {
+  info: (obj: any, msg: string) => console.log(`[driveSync] ${msg}`, obj),
+  error: (obj: any, msg: string) => console.error(`[driveSync] ${msg}`, obj)
+};
+
+export async function syncProjectDriveFiles(
+  projectId: string,
+  onSyncMessage?: (msg: string) => void,
+): Promise<void> {
+  const dbMeta = await getProjectDocumentMetadata(projectId);
+  const fileIds = Object.keys(dbMeta);
+
+  if (fileIds.length === 0) return;
+
+  log.info({ projectId, fileCount: fileIds.length }, "Checking Drive files for updates...");
+
+  const { google } = await import("googleapis");
+
+  const clientEmail = config.DOC_MCP_GOOGLE_CLIENT_EMAIL;
+  let privateKey = config.DOC_MCP_GOOGLE_PRIVATE_KEY;
+  if (!clientEmail || !privateKey) return;
+  if (privateKey.startsWith('"') && privateKey.endsWith('"')) {
+    privateKey = privateKey.slice(1, -1);
+  }
+  privateKey = privateKey.replace(/\\n/g, "\n");
+
+  const auth = new google.auth.JWT({
+    email: clientEmail,
+    key: privateKey,
+    scopes: ["https://www.googleapis.com/auth/drive.readonly"],
+  });
+
+  const drive = google.drive({ version: "v3", auth });
+
+  let updatedCount = 0;
+  for (const fileId of fileIds) {
+    try {
+      const fileInfo = await drive.files.get({
+        fileId: fileId,
+        fields: "id, name, modifiedTime, trashed",
+        supportsAllDrives: true,
+      });
+
+      if (fileInfo.data.trashed) {
+        log.info({ fileId, projectId }, "File trashed on Drive, deleting from VectorDB...");
+        await deleteProjectDocument(projectId, fileId);
+        continue;
+      }
+
+      const driveModifiedTime = fileInfo.data.modifiedTime || "";
+      const dbModifiedTime = dbMeta[fileId];
+
+      if (driveModifiedTime !== dbModifiedTime) {
+        if (onSyncMessage) {
+          onSyncMessage(`🔄 Syncing updated file: ${fileInfo.data.name}...`);
+        }
+        
+        log.info({ fileId, projectId }, "File updated on Drive, syncing...");
+        await deleteProjectDocument(projectId, fileId);
+        
+        const res = await drive.files.export({
+          fileId: fileId,
+          mimeType: "text/plain",
+        });
+        
+        const content = res.data;
+        if (typeof content === "string" && content.trim() !== "") {
+          const splitter = new RecursiveCharacterTextSplitter({
+            chunkSize: config.CHUNK_SIZE,
+            chunkOverlap: config.CHUNK_OVERLAP,
+          });
+          const chunks = await splitter.splitText(content);
+          
+          for (const chunk of chunks) {
+            await upsertProjectDocument(projectId, chunk, {
+              title: fileInfo.data.name,
+              file_id: fileId,
+              source: "google_drive",
+              modified_time: driveModifiedTime,
+            });
+          }
+          updatedCount++;
+        }
+      }
+    } catch (err: any) {
+      if (err.code === 404) {
+        log.info({ fileId, projectId }, "File not found on Drive, deleting from VectorDB...");
+        await deleteProjectDocument(projectId, fileId);
+      } else {
+        log.error({ fileId, err: err.message }, "Error syncing drive file");
+      }
+    }
+  }
+
+  if (updatedCount > 0 && onSyncMessage) {
+    onSyncMessage(`✅ Synced ${updatedCount} files from Google Drive.`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+// The doc-agent is now an MCP Server.
+// Use `npx doc-agent` or `node dist/mcp-server.js` to run it.
+// We no longer export tools directly as JS functions.

package/src/mcp-server.ts

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import {
+  listDriveFiles,
+  readDriveDocument,
+} from "./tools/driveTools.js";
+import { saveAgentNote, searchKnowledge } from "./tools/knowledgeTools.js";
+import { config } from "./config.js";
+
+const DRIVE_FOLDER_ID = config.DOC_MCP_DRIVE_FOLDER_ID;
+
+if (!DRIVE_FOLDER_ID) {
+  console.error(
+    "Missing DOC_MCP_DRIVE_FOLDER_ID environment variable. The doc-agent requires a target folder ID.",
+  );
+  process.exit(1);
+}
+
+const server = new McpServer({
+  name: "doc-agent",
+  version: "1.0.0",
+});
+
+// Register tools
+server.registerTool(
+  "list_drive_files",
+  {
+    description: "List and search for Google Drive documents in the configured folder.",
+    inputSchema: {
+      keyword: z
+        .string()
+        .optional()
+        .describe("Optional keyword to search for in document titles"),
+    },
+  },
+  async ({ keyword }) => {
+    const res = await listDriveFiles(keyword);
+    if (!res.success) {
+      return {
+        content: [{ type: "text", text: `Error: ${res.error}` }],
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(res.results, null, 2) }],
+    };
+  },
+);
+
+server.registerTool(
+  "read_drive_document",
+  {
+    description:
+      "Read the content of a specific Google Drive document. The document will also be automatically ingested into vector memory for future semantic search.",
+    inputSchema: {
+      fileId: z.string().describe("The Google Drive file ID to read"),
+    },
+  },
+  async ({ fileId }) => {
+    const res = await readDriveDocument(fileId);
+    if (!res.success) {
+      return {
+        content: [{ type: "text", text: `Error: ${res.error}` }],
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: res.content || "No content found." }],
+    };
+  },
+);
+
+server.registerTool(
+  "save_agent_note",
+  {
+    description: "Save an agent note, thought, or summary directly into the vector memory.",
+    inputSchema: {
+      content: z.string().describe("The note or knowledge content to store"),
+    },
+  },
+  async ({ content }) => {
+    const res = await saveAgentNote(content);
+    if (!res.success) {
+      return {
+        content: [{ type: "text", text: `Error: ${res.error}` }],
+        isError: true,
+      };
+    }
+    return {
+      content: [{ type: "text", text: res.message || "Saved successfully" }],
+    };
+  },
+);
+
+server.registerTool(
+  "search_knowledge",
+  {
+    description:
+      "Search the folder's vector memory for relevant context or knowledge.",
+    inputSchema: {
+      query: z.string().describe("The search query"),
+      topK: z
+        .number()
+        .optional()
+        .describe("Number of results to return (default: 3)"),
+    },
+  },
+  async ({ query, topK }) => {
+    const res = await searchKnowledge(query, topK);
+    if (!res.success) {
+      return {
+        content: [{ type: "text", text: `Error: ${res.error}` }],
+        isError: true,
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text:
+            typeof res.results === "string"
+              ? res.results
+              : JSON.stringify(res.results),
+        },
+      ],
+    };
+  },
+);
+
+// Start the server
+async function run() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("doc-agent MCP server running on stdio");
+}
+
+run().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});