@hiai-gg/docsmint 0.6.1 → 0.6.2

package/README.md

@@ -40,7 +40,19 @@ server.
 - **Own the full stack**: application data, vectors, graph, queue, and files run
   on infrastructure you control.
 
-## What's new in DocsMint 0.6.1?
+## What's new in DocsMint 0.6.2?
+
+- **Official MCP identity.** DocsMint now publishes the verified
+  `io.github.hiai-gg/docsmint` registry identity for both the npm stdio server
+  and the hosted Streamable HTTP endpoint.
+- **One capability implementation.** The public `@hiai-gg/docsmint/mcp`
+  contract lets hosts provide a scoped API client while reusing the same 17
+  tools, two prompts, three resources, and bundled document-manager Skill.
+- **Current protocol runtime.** The MCP server uses the stable v2 server
+  package and retains compatible stdio negotiation for existing clients.
+
+DocsMint 0.6.2 includes the reliable knowledge refresh and scoped automation
+foundation introduced in 0.6.1:
 
 - **Reliable knowledge refreshes.** Explicit full reindexing now supersedes
   failed or stuck generations, retries release stale extraction claims, and

package/dist/backend/index.js

@@ -234946,7 +234946,7 @@ var swaggerConfig = {
     },
     info: {
       title: "DocsMint API",
-      version: "0.6.1",
+      version: "0.6.2",
       description: "Self-hosted AI-first documentation platform. Full-text + semantic search, version history, sharing, and folder organization.",
       contact: { name: "HiAi-gg", url: "https://github.com/HiAi-gg/docsmint" },
       license: {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@hiai-gg/docsmint",
-  "version": "0.6.1",
+  "mcpName": "io.github.hiai-gg/docsmint",
+  "version": "0.6.2",
   "type": "module",
   "browser": {
     "./dist/backend-launcher.js": false,
@@ -57,6 +58,10 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
+    "./mcp": {
+      "import": "./packages/mcp-server/src/server.ts",
+      "types": "./packages/mcp-server/src/server.ts"
+    },
     "./lifecycle": {
       "browser": "./dist/server-only-browser-entry.js",
       "import": "./dist/lifecycle.js",
@@ -362,6 +367,7 @@
     "backend/src/lib/api-keys.ts",
     "backend/src/lib/api-key-encryption.ts",
     "backend/src/lib/lifecycle-service.ts",
+    "server.json",
     "README.md",
     "LICENSE"
   ],
@@ -380,7 +386,7 @@
     "prepublishOnly": "cd packages/sdk && bun run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@modelcontextprotocol/server": "2.0.0",
     "bullmq": "^5.80.2",
     "commander": "^13.1.0",
     "ioredis": "^5.11.1",

package/packages/cli/src/index.ts

@@ -24,7 +24,7 @@ import { registerSearch } from "./commands/search.js";
 import { registerSnapshot } from "./commands/snapshot.js";
 import { registerUpdate } from "./commands/update.js";
 
-const VERSION = "0.6.1";
+const VERSION = "0.6.2";
 
 const program = new Command();
 program

package/packages/mcp-server/src/capabilities.ts

@@ -1,165 +1,189 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
+import type { McpServer } from '@modelcontextprotocol/server';
+import { z } from 'zod';
 
-import { client } from "./client.js";
+import type { HiaiDocsClient } from './client.js';
 
 export const capabilityCatalog = {
-	tools: [
-		"search_documents",
-		"get_document",
-		"create_document",
-		"update_document",
-		"list_documents",
-		"list_folders",
-		"create_folder",
-		"create_snapshot",
-		"get_version_history",
-		"export_document",
-		"list_categories",
-		"create_category",
-		"list_tags",
-		"get_related_documents",
-		"search_knowledge_graph",
-		"get_document_index_status",
-		"refresh_document_index",
-	] as const,
-	prompts: ["organize_workspace", "research_workspace"] as const,
-	resources: [
-		"docsmint://guide/editor",
-		"docsmint://guide/search",
-		"docsmint://workspace/catalog",
-	] as const,
+  tools: [
+    'search_documents',
+    'get_document',
+    'create_document',
+    'update_document',
+    'list_documents',
+    'list_folders',
+    'create_folder',
+    'create_snapshot',
+    'get_version_history',
+    'export_document',
+    'list_categories',
+    'create_category',
+    'list_tags',
+    'get_related_documents',
+    'search_knowledge_graph',
+    'get_document_index_status',
+    'refresh_document_index',
+  ] as const,
+  prompts: ['organize_workspace', 'research_workspace'] as const,
+  resources: [
+    'docsmint://guide/editor',
+    'docsmint://guide/search',
+    'docsmint://workspace/catalog',
+  ] as const,
 };
 
-type TextResult = { content: Array<{ type: "text"; text: string }> };
+type TextResult = { content: Array<{ type: 'text'; text: string }> };
 
 function jsonResult(value: unknown): TextResult {
-	return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+  return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
 }
 
-export function registerExtendedCapabilities(server: McpServer): void {
-	server.tool(
-		"list_categories",
-		"List categories visible to the API key. Category keys receive only their bound category.",
-		{},
-		async () => jsonResult(await client.listCategories()),
-	);
-	server.tool(
-		"create_category",
-		"Create a category. Requires a workspace key with write access; category keys cannot mutate categories.",
-		{ name: z.string().min(1), description: z.string().optional() },
-		async (input) => jsonResult(await client.createCategory(input)),
-	);
-	server.tool(
-		"list_tags",
-		"List tags visible in the workspace or bound category.",
-		{},
-		async () => jsonResult(await client.listTags()),
-	);
-	server.tool(
-		"get_related_documents",
-		"Traverse the knowledge graph from one authorized document.",
-		{
-			documentId: z.string().min(1),
-			limit: z.number().int().min(1).max(50).optional(),
-		},
-		async ({ documentId, limit }) =>
-			jsonResult(await client.getRelatedDocuments(documentId, limit)),
-	);
-	server.tool(
-		"search_knowledge_graph",
-		"Search connected knowledge using authorized seed documents. Category keys may use only documents in their category.",
-		{
-			query: z.string().min(1).max(1000),
-			docIds: z.array(z.string().min(1)).min(1),
-			limit: z.number().int().min(1).max(50).optional(),
-		},
-		async (input) => jsonResult(await client.searchGraph(input)),
-	);
-	server.tool(
-		"get_document_index_status",
-		"Read the current indexing and knowledge-pipeline status of a document.",
-		{ documentId: z.string().min(1) },
-		async ({ documentId }) =>
-			jsonResult(await client.getDocumentIndexStatus(documentId)),
-	);
-	server.tool(
-		"refresh_document_index",
-		"Request reindexing after a document or metadata change. Requires write access.",
-		{ documentId: z.string().min(1) },
-		async ({ documentId }) =>
-			jsonResult(await client.refreshDocumentIndex(documentId)),
-	);
+export function registerExtendedCapabilities(server: McpServer, client: HiaiDocsClient): void {
+  server.registerTool(
+    'list_categories',
+    {
+      description:
+        'List categories visible to the API key. Category keys receive only their bound category.',
+      inputSchema: z.object({}),
+    },
+    async () => jsonResult(await client.listCategories())
+  );
+  server.registerTool(
+    'create_category',
+    {
+      description:
+        'Create a category. Requires a workspace key with write access; category keys cannot mutate categories.',
+      inputSchema: z.object({
+        name: z.string().min(1),
+        description: z.string().optional(),
+      }),
+    },
+    async (input) => jsonResult(await client.createCategory(input))
+  );
+  server.registerTool(
+    'list_tags',
+    {
+      description: 'List tags visible in the workspace or bound category.',
+      inputSchema: z.object({}),
+    },
+    async () => jsonResult(await client.listTags())
+  );
+  server.registerTool(
+    'get_related_documents',
+    {
+      description: 'Traverse the knowledge graph from one authorized document.',
+      inputSchema: z.object({
+        documentId: z.string().min(1),
+        limit: z.number().int().min(1).max(50).optional(),
+      }),
+    },
+    async ({ documentId, limit }) => jsonResult(await client.getRelatedDocuments(documentId, limit))
+  );
+  server.registerTool(
+    'search_knowledge_graph',
+    {
+      description:
+        'Search connected knowledge using authorized seed documents. Category keys may use only documents in their category.',
+      inputSchema: z.object({
+        query: z.string().min(1).max(1000),
+        docIds: z.array(z.string().min(1)).min(1),
+        limit: z.number().int().min(1).max(50).optional(),
+      }),
+    },
+    async (input) => jsonResult(await client.searchGraph(input))
+  );
+  server.registerTool(
+    'get_document_index_status',
+    {
+      description: 'Read the current indexing and knowledge-pipeline status of a document.',
+      inputSchema: z.object({ documentId: z.string().min(1) }),
+    },
+    async ({ documentId }) => jsonResult(await client.getDocumentIndexStatus(documentId))
+  );
+  server.registerTool(
+    'refresh_document_index',
+    {
+      description: 'Request reindexing after a document or metadata change. Requires write access.',
+      inputSchema: z.object({ documentId: z.string().min(1) }),
+    },
+    async ({ documentId }) => jsonResult(await client.refreshDocumentIndex(documentId))
+  );
 
-	server.prompt(
-		"organize_workspace",
-		"Plan safe document organization using DocsMint categories and folders.",
-		{ objective: z.string(), language: z.string().optional() },
-		({ objective, language }) => ({
-			messages: [
-				{
-					role: "user",
-					content: {
-						type: "text",
-						text: `Organize this DocsMint workspace for: ${objective}. Work in ${language ?? "the document language"}. Inspect categories, folders, tags, and documents before proposing or applying changes. Preserve document content and obey the API key scope.`,
-					},
-				},
-			],
-		}),
-	);
-	server.prompt(
-		"research_workspace",
-		"Research a question with hybrid search and GraphRAG while citing DocsMint document IDs.",
-		{ question: z.string(), language: z.string().optional() },
-		({ question, language }) => ({
-			messages: [
-				{
-					role: "user",
-					content: {
-						type: "text",
-						text: `Answer this question from DocsMint: ${question}. Respond in ${language ?? "the question language"}. Start with hybrid search, use graph traversal only from authorized result documents, and cite document IDs. Distinguish retrieved facts from inference.`,
-					},
-				},
-			],
-		}),
-	);
+  server.registerPrompt(
+    'organize_workspace',
+    {
+      description: 'Plan safe document organization using DocsMint categories and folders.',
+      argsSchema: z.object({
+        objective: z.string(),
+        language: z.string().optional(),
+      }),
+    },
+    ({ objective, language }) => ({
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Organize this DocsMint workspace for: ${objective}. Work in ${language ?? 'the document language'}. Inspect categories, folders, tags, and documents before proposing or applying changes. Preserve document content and obey the API key scope.`,
+          },
+        },
+      ],
+    })
+  );
+  server.registerPrompt(
+    'research_workspace',
+    {
+      description:
+        'Research a question with hybrid search and GraphRAG while citing DocsMint document IDs.',
+      argsSchema: z.object({
+        question: z.string(),
+        language: z.string().optional(),
+      }),
+    },
+    ({ question, language }) => ({
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Answer this question from DocsMint: ${question}. Respond in ${language ?? 'the question language'}. Start with hybrid search, use graph traversal only from authorized result documents, and cite document IDs. Distinguish retrieved facts from inference.`,
+          },
+        },
+      ],
+    })
+  );
 
-	server.resource("editor-guide", "docsmint://guide/editor", async (uri) => ({
-		contents: [
-			{
-				uri: uri.href,
-				mimeType: "text/markdown",
-				text: "# DocsMint editing rules\n\nRead a document before updating it. Preserve its language, title intent, TipTap/Markdown structure, category, folder, and tags unless the user explicitly requests a change. After content changes, verify index status and request refresh only when needed.",
-			},
-		],
-	}));
-	server.resource("search-guide", "docsmint://guide/search", async (uri) => ({
-		contents: [
-			{
-				uri: uri.href,
-				mimeType: "text/markdown",
-				text: "# DocsMint retrieval rules\n\nUse search_documents for normal retrieval. Use get_related_documents or search_knowledge_graph only with document IDs already authorized by the active API key. Keep multilingual queries in their original language and cite document IDs in answers.",
-			},
-		],
-	}));
-	server.resource(
-		"workspace-catalog",
-		"docsmint://workspace/catalog",
-		async (uri) => {
-			const [categories, folders, tags] = await Promise.all([
-				client.listCategories(),
-				client.listFolders({}),
-				client.listTags(),
-			]);
-			return {
-				contents: [
-					{
-						uri: uri.href,
-						mimeType: "application/json",
-						text: JSON.stringify({ categories, folders, tags }, null, 2),
-					},
-				],
-			};
-		},
-	);
+  server.registerResource('editor-guide', 'docsmint://guide/editor', {}, async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: 'text/markdown',
+        text: '# DocsMint editing rules\n\nRead a document before updating it. Preserve its language, title intent, TipTap/Markdown structure, category, folder, and tags unless the user explicitly requests a change. After content changes, verify index status and request refresh only when needed.',
+      },
+    ],
+  }));
+  server.registerResource('search-guide', 'docsmint://guide/search', {}, async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: 'text/markdown',
+        text: '# DocsMint retrieval rules\n\nUse search_documents for normal retrieval. Use get_related_documents or search_knowledge_graph only with document IDs already authorized by the active API key. Keep multilingual queries in their original language and cite document IDs in answers.',
+      },
+    ],
+  }));
+  server.registerResource('workspace-catalog', 'docsmint://workspace/catalog', {}, async (uri) => {
+    const [categories, folders, tags] = await Promise.all([
+      client.listCategories(),
+      client.listFolders({}),
+      client.listTags(),
+    ]);
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          mimeType: 'application/json',
+          text: JSON.stringify({ categories, folders, tags }, null, 2),
+        },
+      ],
+    };
+  });
 }

package/packages/mcp-server/src/index.ts

@@ -1,9 +1,8 @@
 #!/usr/bin/env bun
 /** DocsMint MCP stdio entry point. */
 
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
 
-import { createDocsmintMcpServer } from "./server.js";
+import { createDocsmintMcpServer } from './server.js';
 
-const server = createDocsmintMcpServer();
-await server.connect(new StdioServerTransport());
+serveStdio(() => createDocsmintMcpServer());

package/packages/mcp-server/src/server.ts

@@ -1,82 +1,87 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ZodRawShape } from "zod";
+import { McpServer } from '@modelcontextprotocol/server';
+import { z, type ZodRawShape } from 'zod';
 
-import { registerExtendedCapabilities } from "./capabilities.js";
-import { HiaiDocsError } from "./client.js";
-import * as createDocument from "./tools/create-document.js";
-import * as createFolder from "./tools/create-folder.js";
-import * as createSnapshot from "./tools/create-snapshot.js";
-import * as exportDocument from "./tools/export-document.js";
-import * as getDocument from "./tools/get-document.js";
-import * as listDocuments from "./tools/list-documents.js";
-import * as listFolders from "./tools/list-folders.js";
-import * as search from "./tools/search.js";
-import * as updateDocument from "./tools/update-document.js";
-import * as versionHistory from "./tools/version-history.js";
+import { registerExtendedCapabilities } from './capabilities.js';
+import { client as defaultClient, HiaiDocsError, type HiaiDocsClient } from './client.js';
+import * as createDocument from './tools/create-document.js';
+import * as createFolder from './tools/create-folder.js';
+import * as createSnapshot from './tools/create-snapshot.js';
+import * as exportDocument from './tools/export-document.js';
+import * as getDocument from './tools/get-document.js';
+import * as listDocuments from './tools/list-documents.js';
+import * as listFolders from './tools/list-folders.js';
+import * as search from './tools/search.js';
+import * as updateDocument from './tools/update-document.js';
+import * as versionHistory from './tools/version-history.js';
 
 type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
 interface McpToolResult {
-	content: Array<{ type: "text"; text: string }>;
-	isError?: boolean;
+  content: Array<{ type: 'text'; text: string }>;
+  isError?: boolean;
 }
 
 function wrapHandler(
-	name: string,
-	handler: ToolHandler,
+  name: string,
+  handler: ToolHandler
 ): (args: Record<string, unknown>) => Promise<McpToolResult> {
-	return async (args) => {
-		try {
-			return {
-				content: [
-					{ type: "text", text: JSON.stringify(await handler(args), null, 2) },
-				],
-			};
-		} catch (error) {
-			const message =
-				error instanceof HiaiDocsError
-					? `DocsMint API error (${error.status}): ${error.message}`
-					: `Tool '${name}' failed: ${error instanceof Error ? error.message : String(error)}`;
-			return { isError: true, content: [{ type: "text", text: message }] };
-		}
-	};
+  return async (args) => {
+    try {
+      return {
+        content: [{ type: 'text', text: JSON.stringify(await handler(args), null, 2) }],
+      };
+    } catch (error) {
+      const message =
+        error instanceof HiaiDocsError
+          ? `DocsMint API error (${error.status}): ${error.message}`
+          : `Tool '${name}' failed: ${error instanceof Error ? error.message : String(error)}`;
+      return { isError: true, content: [{ type: 'text', text: message }] };
+    }
+  };
 }
 
-export function createDocsmintMcpServer(): McpServer {
-	const server = new McpServer({ name: "docsmint", version: "0.6.1" });
-	const register = <Args>(
-		name: string,
-		description: string,
-		inputSchema: ZodRawShape,
-		handler: (args: Args) => Promise<unknown>,
-	): void => {
-		server.tool(
-			name,
-			description,
-			inputSchema as never,
-			wrapHandler(name, handler as ToolHandler) as never,
-		);
-	};
+export function registerDocsmintMcpCapabilities(server: McpServer, client: HiaiDocsClient): void {
+  const register = <Args>(
+    name: string,
+    description: string,
+    inputSchema: ZodRawShape,
+    handler: (args: Args) => Promise<unknown>
+  ): void => {
+    server.registerTool(
+      name,
+      { description, inputSchema: z.object(inputSchema) },
+      wrapHandler(name, handler as ToolHandler) as never
+    );
+  };
 
-	const tools = [
-		search,
-		getDocument,
-		createDocument,
-		updateDocument,
-		listDocuments,
-		listFolders,
-		createFolder,
-		createSnapshot,
-		versionHistory,
-		exportDocument,
-	] as const;
-	for (const tool of tools) {
-		register(
-			tool.definition.name,
-			tool.definition.description,
-			tool.definition.inputSchema as ZodRawShape,
-			tool.handler as ToolHandler,
-		);
-	}
-	registerExtendedCapabilities(server);
-	return server;
+  const tools = [
+    search,
+    getDocument,
+    createDocument,
+    updateDocument,
+    listDocuments,
+    listFolders,
+    createFolder,
+    createSnapshot,
+    versionHistory,
+    exportDocument,
+  ] as const;
+  for (const tool of tools) {
+    register(
+      tool.definition.name,
+      tool.definition.description,
+      tool.definition.inputSchema as ZodRawShape,
+      tool.createHandler(client) as ToolHandler
+    );
+  }
+  registerExtendedCapabilities(server, client);
+}
+
+export interface CreateDocsmintMcpServerOptions {
+  client?: HiaiDocsClient;
+}
+
+export function createDocsmintMcpServer(options: CreateDocsmintMcpServerOptions = {}): McpServer {
+  const server = new McpServer({ name: 'docsmint', version: '0.6.2' });
+  registerDocsmintMcpCapabilities(server, options.client ?? defaultClient);
+  return server;
 }

package/packages/mcp-server/src/tools/create-document.ts

@@ -1,39 +1,34 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { DocumentDetail } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { DocumentDetail } from '../types.js';
 
 export const definition = {
-	name: "create_document",
-	description:
-		"Create a new document. Optionally provide initial markdown content and a folder ID.",
-	inputSchema: {
-		title: z.string().describe("Document title."),
-		content: z
-			.string()
-			.optional()
-			.describe("Initial markdown content for the document."),
-		folderId: z
-			.string()
-			.optional()
-			.describe("Optional folder ID to place the document in."),
-		categoryId: z
-			.string()
-			.optional()
-			.describe(
-				"Optional category ID. Category keys are always rebound to their configured category.",
-			),
-	},
+  name: 'create_document',
+  description:
+    'Create a new document. Optionally provide initial markdown content and a folder ID.',
+  inputSchema: {
+    title: z.string().describe('Document title.'),
+    content: z.string().optional().describe('Initial markdown content for the document.'),
+    folderId: z.string().optional().describe('Optional folder ID to place the document in.'),
+    categoryId: z
+      .string()
+      .optional()
+      .describe(
+        'Optional category ID. Category keys are always rebound to their configured category.'
+      ),
+  },
 } as const;
 
 export interface CreateDocumentArgs {
-	title: string;
-	content?: string;
-	folderId?: string;
-	categoryId?: string;
+  title: string;
+  content?: string;
+  folderId?: string;
+  categoryId?: string;
 }
 
-export async function handler(
-	args: CreateDocumentArgs,
-): Promise<DocumentDetail> {
-	return (await client.createDocument(args)) as DocumentDetail;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function createDocument(args: CreateDocumentArgs): Promise<DocumentDetail> {
+    return (await api.createDocument(args)) as DocumentDetail;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/create-folder.ts

@@ -1,31 +1,31 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { Folder } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { Folder } from '../types.js';
 
 export const definition = {
-	name: "create_folder",
-	description: "Create a new folder, optionally nested under a parent folder.",
-	inputSchema: {
-		name: z.string().describe("Folder name."),
-		parentId: z
-			.string()
-			.optional()
-			.describe("Optional parent folder ID for nesting."),
-		categoryId: z
-			.string()
-			.optional()
-			.describe(
-				"Optional category ID. Category keys are always rebound to their configured category.",
-			),
-	},
+  name: 'create_folder',
+  description: 'Create a new folder, optionally nested under a parent folder.',
+  inputSchema: {
+    name: z.string().describe('Folder name.'),
+    parentId: z.string().optional().describe('Optional parent folder ID for nesting.'),
+    categoryId: z
+      .string()
+      .optional()
+      .describe(
+        'Optional category ID. Category keys are always rebound to their configured category.'
+      ),
+  },
 } as const;
 
 export interface CreateFolderArgs {
-	name: string;
-	parentId?: string;
-	categoryId?: string;
+  name: string;
+  parentId?: string;
+  categoryId?: string;
 }
 
-export async function handler(args: CreateFolderArgs): Promise<Folder> {
-	return (await client.createFolder(args)) as Folder;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function createFolder(args: CreateFolderArgs): Promise<Folder> {
+    return (await api.createFolder(args)) as Folder;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/create-snapshot.ts

@@ -1,20 +1,14 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { Version } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { Version } from '../types.js';
 
 export const definition = {
-  name: "create_snapshot",
-  description:
-    "Create a named snapshot (labelled version) of a document from its current content.",
+  name: 'create_snapshot',
+  description: 'Create a named snapshot (labelled version) of a document from its current content.',
   inputSchema: {
-    documentId: z.string().describe("Document ID to snapshot."),
-    label: z
-      .string()
-      .describe("Short label for the snapshot (e.g. 'v1.0-release')."),
-    description: z
-      .string()
-      .optional()
-      .describe("Optional longer description of the snapshot."),
+    documentId: z.string().describe('Document ID to snapshot.'),
+    label: z.string().describe("Short label for the snapshot (e.g. 'v1.0-release')."),
+    description: z.string().optional().describe('Optional longer description of the snapshot.'),
   },
 } as const;
 
@@ -24,7 +18,10 @@ export interface CreateSnapshotArgs {
   description?: string;
 }
 
-export async function handler(args: CreateSnapshotArgs): Promise<Version> {
-  const { documentId, ...input } = args;
-  return (await client.createSnapshot(documentId, input)) as Version;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function createSnapshot(args: CreateSnapshotArgs): Promise<Version> {
+    const { documentId, ...input } = args;
+    return (await api.createSnapshot(documentId, input)) as Version;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/export-document.ts

@@ -1,13 +1,12 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { ExportResponse } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { ExportResponse } from '../types.js';
 
 export const definition = {
-  name: "export_document",
-  description:
-    "Export a document as markdown. Returns the rendered markdown content.",
+  name: 'export_document',
+  description: 'Export a document as markdown. Returns the rendered markdown content.',
   inputSchema: {
-    id: z.string().describe("Document ID to export."),
+    id: z.string().describe('Document ID to export.'),
   },
 } as const;
 
@@ -15,8 +14,9 @@ export interface ExportDocumentArgs {
   id: string;
 }
 
-export async function handler(
-  args: ExportDocumentArgs,
-): Promise<ExportResponse> {
-  return (await client.exportDocument(args.id)) as ExportResponse;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function exportDocument(args: ExportDocumentArgs): Promise<ExportResponse> {
+    return (await api.exportDocument(args.id)) as ExportResponse;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/get-document.ts

@@ -1,13 +1,12 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { DocumentDetail } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { DocumentDetail } from '../types.js';
 
 export const definition = {
-  name: "get_document",
-  description:
-    "Fetch a single document by ID. Returns full content, metadata, and tags.",
+  name: 'get_document',
+  description: 'Fetch a single document by ID. Returns full content, metadata, and tags.',
   inputSchema: {
-    id: z.string().describe("Document ID."),
+    id: z.string().describe('Document ID.'),
   },
 } as const;
 
@@ -15,6 +14,9 @@ export interface GetDocumentArgs {
   id: string;
 }
 
-export async function handler(args: GetDocumentArgs): Promise<DocumentDetail> {
-  return (await client.getDocument(args.id)) as DocumentDetail;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function getDocument(args: GetDocumentArgs): Promise<DocumentDetail> {
+    return (await api.getDocument(args.id)) as DocumentDetail;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/list-documents.ts

@@ -1,30 +1,21 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { ListDocumentsResponse } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { ListDocumentsResponse } from '../types.js';
 
 export const definition = {
-  name: "list_documents",
-  description:
-    "List documents with pagination, optionally filtered by folder or tag.",
+  name: 'list_documents',
+  description: 'List documents with pagination, optionally filtered by folder or tag.',
   inputSchema: {
-    folderId: z
-      .string()
-      .optional()
-      .describe("Optional folder ID to filter by."),
-    tag: z.string().optional().describe("Optional tag ID to filter by."),
-    page: z
-      .number()
-      .int()
-      .positive()
-      .optional()
-      .describe("Page number (1-indexed, default 1)."),
+    folderId: z.string().optional().describe('Optional folder ID to filter by.'),
+    tag: z.string().optional().describe('Optional tag ID to filter by.'),
+    page: z.number().int().positive().optional().describe('Page number (1-indexed, default 1).'),
     limit: z
       .number()
       .int()
       .positive()
       .max(100)
       .optional()
-      .describe("Items per page (default 20, max 100)."),
+      .describe('Items per page (default 20, max 100).'),
   },
 } as const;
 
@@ -35,8 +26,9 @@ export interface ListDocumentsArgs {
   limit?: number;
 }
 
-export async function handler(
-  args: ListDocumentsArgs,
-): Promise<ListDocumentsResponse> {
-  return (await client.listDocuments(args)) as ListDocumentsResponse;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function listDocuments(args: ListDocumentsArgs): Promise<ListDocumentsResponse> {
+    return (await api.listDocuments(args)) as ListDocumentsResponse;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/list-folders.ts

@@ -1,18 +1,16 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { Folder } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { Folder } from '../types.js';
 
 export const definition = {
-  name: "list_folders",
+  name: 'list_folders',
   description:
-    "List folders, optionally scoped to a parent folder. Returns a flat list of immediate children.",
+    'List folders, optionally scoped to a parent folder. Returns a flat list of immediate children.',
   inputSchema: {
     parentId: z
       .string()
       .optional()
-      .describe(
-        "Optional parent folder ID. Omit to list top-level (root) folders.",
-      ),
+      .describe('Optional parent folder ID. Omit to list top-level (root) folders.'),
   },
 } as const;
 
@@ -20,6 +18,9 @@ export interface ListFoldersArgs {
   parentId?: string;
 }
 
-export async function handler(args: ListFoldersArgs): Promise<Folder[]> {
-  return (await client.listFolders(args)) as Folder[];
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function listFolders(args: ListFoldersArgs): Promise<Folder[]> {
+    return (await api.listFolders(args)) as Folder[];
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/search.ts

@@ -1,27 +1,21 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { SearchResponse } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { SearchResponse } from '../types.js';
 
 export const definition = {
-  name: "search_documents",
+  name: 'search_documents',
   description:
-    "Hybrid search across documents (full-text + semantic). Supports filtering by folder and tags.",
+    'Hybrid search across documents (full-text + semantic). Supports filtering by folder and tags.',
   inputSchema: {
-    query: z.string().describe("Search query string."),
-    folder: z
-      .string()
-      .optional()
-      .describe("Optional folder ID to scope the search to."),
-    tags: z
-      .array(z.string())
-      .optional()
-      .describe("Optional tag IDs to filter by."),
+    query: z.string().describe('Search query string.'),
+    folder: z.string().optional().describe('Optional folder ID to scope the search to.'),
+    tags: z.array(z.string()).optional().describe('Optional tag IDs to filter by.'),
     limit: z
       .number()
       .int()
       .positive()
       .optional()
-      .describe("Maximum number of results to return (default 20)."),
+      .describe('Maximum number of results to return (default 20).'),
   },
 } as const;
 
@@ -32,11 +26,14 @@ export type SearchArgs = {
   limit?: number;
 };
 
-export async function handler(args: SearchArgs): Promise<SearchResponse> {
-  return (await client.search({
-    query: args.query,
-    folder: args.folder,
-    tags: args.tags,
-    limit: args.limit,
-  })) as SearchResponse;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function searchDocuments(args: SearchArgs): Promise<SearchResponse> {
+    return (await api.search({
+      query: args.query,
+      folder: args.folder,
+      tags: args.tags,
+      limit: args.limit,
+    })) as SearchResponse;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/update-document.ts

@@ -1,44 +1,38 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { DocumentDetail } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { DocumentDetail } from '../types.js';
 
 export const definition = {
-	name: "update_document",
-	description:
-		"Update an existing document's title and/or content. The server creates a new version on each update.",
-	inputSchema: {
-		id: z.string().describe("Document ID to update."),
-		title: z.string().optional().describe("New title for the document."),
-		content: z
-			.string()
-			.optional()
-			.describe("New markdown content for the document."),
-		folderId: z
-			.string()
-			.nullable()
-			.optional()
-			.describe("Move the document to a folder."),
-		categoryId: z
-			.string()
-			.nullable()
-			.optional()
-			.describe(
-				"Move the document to a category. Category keys cannot escape their configured category.",
-			),
-	},
+  name: 'update_document',
+  description:
+    "Update an existing document's title and/or content. The server creates a new version on each update.",
+  inputSchema: {
+    id: z.string().describe('Document ID to update.'),
+    title: z.string().optional().describe('New title for the document.'),
+    content: z.string().optional().describe('New markdown content for the document.'),
+    folderId: z.string().nullable().optional().describe('Move the document to a folder.'),
+    categoryId: z
+      .string()
+      .nullable()
+      .optional()
+      .describe(
+        'Move the document to a category. Category keys cannot escape their configured category.'
+      ),
+  },
 } as const;
 
 export interface UpdateDocumentArgs {
-	id: string;
-	title?: string;
-	content?: string;
-	folderId?: string | null;
-	categoryId?: string | null;
+  id: string;
+  title?: string;
+  content?: string;
+  folderId?: string | null;
+  categoryId?: string | null;
 }
 
-export async function handler(
-	args: UpdateDocumentArgs,
-): Promise<DocumentDetail> {
-	const { id, ...patch } = args;
-	return (await client.updateDocument(id, patch)) as DocumentDetail;
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function updateDocument(args: UpdateDocumentArgs): Promise<DocumentDetail> {
+    const { id, ...patch } = args;
+    return (await api.updateDocument(id, patch)) as DocumentDetail;
+  };
+
+export const handler = createHandler(client);

package/packages/mcp-server/src/tools/version-history.ts

@@ -1,21 +1,16 @@
-import { z } from "zod";
-import { client } from "../client.js";
-import type { Version } from "../types.js";
+import { z } from 'zod';
+import { client, type HiaiDocsClient } from '../client.js';
+import type { Version } from '../types.js';
 
 export const definition = {
-  name: "get_version_history",
-  description:
-    "List the version history for a document. Optionally restrict to named snapshots.",
+  name: 'get_version_history',
+  description: 'List the version history for a document. Optionally restrict to named snapshots.',
   inputSchema: {
-    documentId: z
-      .string()
-      .describe("Document ID whose versions should be listed."),
+    documentId: z.string().describe('Document ID whose versions should be listed.'),
     onlySnapshots: z
       .boolean()
       .optional()
-      .describe(
-        "When true, only return named snapshots (skip auto-saved revisions).",
-      ),
+      .describe('When true, only return named snapshots (skip auto-saved revisions).'),
   },
 } as const;
 
@@ -24,9 +19,9 @@ export interface VersionHistoryArgs {
   onlySnapshots?: boolean;
 }
 
-export async function handler(args: VersionHistoryArgs): Promise<Version[]> {
-  return (await client.getVersionHistory(
-    args.documentId,
-    args.onlySnapshots,
-  )) as Version[];
-}
+export const createHandler = (api: HiaiDocsClient) =>
+  async function getVersionHistory(args: VersionHistoryArgs): Promise<Version[]> {
+    return (await api.getVersionHistory(args.documentId, args.onlySnapshots)) as Version[];
+  };
+
+export const handler = createHandler(client);

package/server.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.hiai-gg/docsmint",
+  "title": "DocsMint",
+  "description": "Manage scoped DocsMint documents, folders, categories, search, GraphRAG, and indexing through MCP.",
+  "repository": {
+    "url": "https://github.com/HiAi-gg/docsmint",
+    "source": "github",
+    "id": "1249550690"
+  },
+  "version": "0.6.2",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@hiai-gg/docsmint",
+      "version": "0.6.2",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "HIAI_DOCS_URL",
+          "description": "Base URL of the DocsMint API.",
+          "default": "http://localhost:50700"
+        },
+        {
+          "name": "HIAI_DOCS_API_KEY",
+          "description": "Workspace or category scoped DocsMint API key.",
+          "isRequired": true,
+          "isSecret": true
+        }
+      ]
+    }
+  ],
+  "remotes": [
+    {
+      "type": "streamable-http",
+      "url": "https://docsmint.com/mcp",
+      "headers": [
+        {
+          "name": "Authorization",
+          "description": "Bearer DocsMint API key.",
+          "isRequired": true,
+          "isSecret": true
+        },
+        {
+          "name": "X-Docsmint-Workspace",
+          "description": "Optional workspace override for a workspace scoped key.",
+          "isRequired": false,
+          "isSecret": false
+        }
+      ]
+    }
+  ]
+}