mineru-mcp 1.0.2 → 1.0.3

package/README.md

@@ -1,27 +1,55 @@
 # mineru-mcp
 
-MCP server for [MinerU](https://mineru.net) document parsing API - optimized for Claude Code.
+MCP server for [MinerU](https://mineru.net) document parsing API — extract text, tables, and formulas from PDFs, DOCs, and images.
 
 ## Features
 
-- **4 optimized tools** with concise descriptions (~73% token reduction vs alternatives)
-- **VLM model support** (90%+ accuracy) and pipeline mode (faster)
-- **Page range selection** - parse specific pages only
-- **Batch processing** - up to 200 documents at once
-- **Pagination** - efficient handling of large batch results
+- **VLM model** — 90%+ accuracy for complex documents
+- **Pipeline model** — Fast processing for simple documents
+- **Local file upload** — Upload files from disk for batch parsing
+- **Batch processing** — Parse up to 200 documents at once
+- **Download & rename** — Extract markdown with original filenames
+- **Page ranges** — Extract specific pages only
 - **109 language OCR** support
+- **Optimized for Claude Code** — 73% token reduction vs alternatives
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `mineru_parse` | Parse a document URL |
+| `mineru_status` | Check task progress, get download URL |
+| `mineru_batch` | Parse multiple URLs (max 200) |
+| `mineru_batch_status` | Get batch results with pagination |
+| `mineru_upload_batch` | Upload local files for batch parsing |
+| `mineru_download_results` | Download results as named markdown files |
 
 ## Installation
 
-### Claude Code
+Requires [Node.js](https://nodejs.org/) 18+ and a [MinerU API key](https://mineru.net).
+
+### CLI Install (one-liner)
 
 ```bash
-claude mcp add mineru-mcp -e MINERU_API_KEY=your-api-key -- npx mineru-mcp
+# Claude Code
+claude mcp add mineru-mcp -e MINERU_API_KEY=your-api-key -- npx -y mineru-mcp
+
+# Codex CLI (OpenAI)
+codex mcp add mineru --env MINERU_API_KEY=your-api-key -- npx -y mineru-mcp
+
+# Gemini CLI (Google)
+gemini mcp add -e MINERU_API_KEY=your-api-key mineru npx -y mineru-mcp
 ```
 
 ### Claude Desktop
 
-Add to your Claude Desktop config:
+Add to your `claude_desktop_config.json`:
+
+| OS | Config path |
+|----|-------------|
+| macOS | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Windows | `%APPDATA%\Claude\claude_desktop_config.json` |
+| Linux | `~/.config/Claude/claude_desktop_config.json` |
 
 ```json
 {
@@ -37,6 +65,158 @@ Add to your Claude Desktop config:
 }
 ```
 
+### VS Code
+
+Add to `.vscode/mcp.json` (workspace) or open Command Palette > `MCP: Open User Configuration` (global):
+
+```json
+{
+  "servers": {
+    "mineru": {
+      "command": "npx",
+      "args": ["-y", "mineru-mcp"],
+      "env": {
+        "MINERU_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+> **Note**: VS Code uses `"servers"` as the top-level key, not `"mcpServers"`. Other VS Code forks (Trae, Void, PearAI, etc.) typically use this same format.
+
+### Cursor
+
+Add to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):
+
+```json
+{
+  "mcpServers": {
+    "mineru": {
+      "command": "npx",
+      "args": ["-y", "mineru-mcp"],
+      "env": {
+        "MINERU_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json` (Windows: `%USERPROFILE%\.codeium\windsurf\mcp_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "mineru": {
+      "command": "npx",
+      "args": ["-y", "mineru-mcp"],
+      "env": {
+        "MINERU_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### Cline
+
+Open MCP Servers icon in Cline panel > Configure > Advanced MCP Settings, then add:
+
+```json
+{
+  "mcpServers": {
+    "mineru": {
+      "command": "npx",
+      "args": ["-y", "mineru-mcp"],
+      "env": {
+        "MINERU_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### Cherry Studio
+
+In Settings > MCP Servers > Add Server, set Type to `STDIO`, Command to `npx`, Args to `-y mineru-mcp`, and add environment variable `MINERU_API_KEY`. Or paste in JSON/Code mode:
+
+```json
+{
+  "mineru": {
+    "name": "MinerU",
+    "command": "npx",
+    "args": ["-y", "mineru-mcp"],
+    "env": {
+      "MINERU_API_KEY": "your-api-key"
+    },
+    "isActive": true
+  }
+}
+```
+
+### Witsy
+
+In Settings > MCP Servers, add a new server with Type: `stdio`, Command: `npx`, Args: `-y mineru-mcp`, and set environment variable `MINERU_API_KEY` to your API key.
+
+### Codex CLI (TOML config)
+
+Alternatively, edit `~/.codex/config.toml` directly:
+
+```toml
+[mcp_servers.mineru]
+command = "npx"
+args = ["-y", "mineru-mcp"]
+
+[mcp_servers.mineru.env]
+MINERU_API_KEY = "your-api-key"
+```
+
+### Gemini CLI (JSON config)
+
+Alternatively, edit `~/.gemini/settings.json` directly:
+
+```json
+{
+  "mcpServers": {
+    "mineru": {
+      "command": "npx",
+      "args": ["-y", "mineru-mcp"],
+      "env": {
+        "MINERU_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+### Windows
+
+On Windows, `npx` requires a shell wrapper. Replace `"command": "npx"` with:
+
+```json
+{
+  "command": "cmd",
+  "args": ["/c", "npx", "-y", "mineru-mcp"],
+  "env": {
+    "MINERU_API_KEY": "your-api-key"
+  }
+}
+```
+
+For CLI tools on Windows:
+
+```bash
+claude mcp add mineru-mcp -e MINERU_API_KEY=your-api-key -- cmd /c npx -y mineru-mcp
+codex mcp add mineru --env MINERU_API_KEY=your-api-key -- cmd /c npx -y mineru-mcp
+```
+
+### ChatGPT
+
+ChatGPT only supports remote MCP servers over HTTPS — local stdio servers like this one are not directly supported. You would need to deploy behind a public URL with HTTP transport.
+
 ## Configuration
 
 | Environment Variable | Default | Description |
@@ -47,11 +227,9 @@ Add to your Claude Desktop config:
 
 Get your API key at [mineru.net](https://mineru.net)
 
-## Tools
-
-### `mineru_parse`
+## Usage
 
-Parse a single document URL.
+### Parse a single URL
 
 ```typescript
 mineru_parse({
@@ -66,9 +244,7 @@ mineru_parse({
 })
 ```
 
-### `mineru_status`
-
-Check task progress and get download URL.
+### Check task progress
 
 ```typescript
 mineru_status({
@@ -79,9 +255,7 @@ mineru_status({
 
 **Concise output**: `done | abc-123 | https://cdn-mineru.../result.zip`
 
-### `mineru_batch`
-
-Parse multiple documents in one batch (max 200).
+### Batch parse URLs
 
 ```typescript
 mineru_batch({
@@ -90,9 +264,7 @@ mineru_batch({
 })
 ```
 
-### `mineru_batch_status`
-
-Get batch results with pagination.
+### Check batch progress
 
 ```typescript
 mineru_batch_status({
@@ -103,6 +275,41 @@ mineru_batch_status({
 })
 ```
 
+### Upload local files
+
+```typescript
+mineru_upload_batch({
+  directory: "/path/to/pdfs",  // scan directory for supported files
+  // OR
+  files: ["/path/to/doc1.pdf", "/path/to/doc2.pdf"],  // explicit file list
+  model: "vlm",        // optional
+  formula: true,       // optional
+  table: true,         // optional
+  language: "en",      // optional
+  formats: ["html"]    // optional
+})
+```
+
+Returns `batch_id` for tracking. Each file's original name is preserved via `data_id` (spaces become underscores).
+
+### Download results as markdown
+
+```typescript
+mineru_download_results({
+  batch_id: "batch-123",       // from mineru_upload_batch or mineru_batch
+  output_dir: "/path/to/output",
+  overwrite: false             // optional: overwrite existing files
+})
+```
+
+Output filenames are derived from `data_id` (e.g., `my_paper_title.md`). Spaces in original filenames become underscores.
+
+### Typical local file workflow
+
+```
+mineru_upload_batch → mineru_batch_status (poll) → mineru_download_results
+```
+
 ## Supported Formats
 
 - PDF, DOC, DOCX, PPT, PPTX
@@ -112,7 +319,7 @@ mineru_batch_status({
 
 - Single file: 200MB max, 600 pages max
 - Daily quota: 2000 pages at high priority
-- Batch: max 200 URLs per request
+- Batch: max 200 files per request
 
 ## License
 
@@ -120,6 +327,6 @@ MIT
 
 ## Links
 
-- [MinerU](https://mineru.net) - Document parsing service
-- [MinerU GitHub](https://github.com/opendatalab/MinerU) - Open source version
-- [MCP Specification](https://modelcontextprotocol.io) - Model Context Protocol
+- [MinerU](https://mineru.net) — Document parsing service
+- [MinerU GitHub](https://github.com/opendatalab/MinerU) — Open source version
+- [MCP Specification](https://modelcontextprotocol.io) — Model Context Protocol

package/dist/index.d.ts

@@ -56,4 +56,44 @@ export default function createServer({ config }: {
         } | undefined;
     } | undefined;
 }>;
+export declare function createSandboxServer(): import("@modelcontextprotocol/sdk/server").Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        task?: {
+            [x: string]: unknown;
+            ttl?: number | null | undefined;
+            pollInterval?: number | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/related-task"?: {
+                [x: string]: unknown;
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        "io.modelcontextprotocol/related-task"?: {
+            [x: string]: unknown;
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>;
 export {};

package/dist/index.js

@@ -3,6 +3,12 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import axios, { AxiosError } from "axios";
+import { readFileSync, createWriteStream, readdirSync, statSync, mkdirSync, writeFileSync, existsSync, unlinkSync, rmSync, realpathSync } from "node:fs";
+import { join, basename, extname } from "node:path";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+import { pipeline } from "node:stream/promises";
 // Configuration schema for Smithery
 export const configSchema = z.object({
     mineruApiKey: z.string().describe("MinerU API key from mineru.net"),
@@ -110,7 +116,7 @@ export default function createServer({ config }) {
     // Create MCP server
     const server = new McpServer({
         name: "mineru",
-        version: "1.0.1",
+        version: "1.0.2",
     });
     // Tool 1: mineru_parse
     server.tool("mineru_parse", "Parse a document URL. Returns task_id to check status.", {
@@ -234,9 +240,262 @@ export default function createServer({ config }) {
             content: [{ type: "text", text }],
         };
     });
+    // Tool 5: mineru_upload_batch
+    server.tool("mineru_upload_batch", "Upload local files from a directory for batch parsing. Handles file upload to MinerU servers. Returns batch_id to track with mineru_batch_status. Use mineru_download_results to get named markdown files.", {
+        directory: z.string().optional().describe("Directory path containing PDF/DOC/PPT files"),
+        files: z.array(z.string()).optional().describe("Array of absolute file paths (alternative to directory)"),
+        model: z
+            .enum(["pipeline", "vlm"])
+            .optional()
+            .describe("pipeline=fast, vlm=90% accuracy"),
+        formula: z.boolean().optional().describe("Formula recognition"),
+        table: z.boolean().optional().describe("Table recognition"),
+        language: z.string().optional().describe("Language code: ch, en, etc"),
+        formats: z
+            .array(z.enum(["docx", "html", "latex"]))
+            .optional()
+            .describe("Extra export formats"),
+    }, async (params) => {
+        const supportedExts = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".png", ".jpg", ".jpeg"]);
+        // Collect files
+        let filePaths = [];
+        if (params.files?.length) {
+            filePaths = params.files;
+        }
+        else if (params.directory) {
+            const dir = params.directory;
+            if (!existsSync(dir)) {
+                throw new Error(`Directory not found: ${dir}`);
+            }
+            const entries = readdirSync(dir);
+            filePaths = entries
+                .filter((f) => supportedExts.has(extname(f).toLowerCase()))
+                .map((f) => join(dir, f));
+        }
+        else {
+            throw new Error("Provide either 'directory' or 'files' parameter.");
+        }
+        if (filePaths.length === 0) {
+            throw new Error("No supported files found.");
+        }
+        if (filePaths.length > 200) {
+            throw new Error(`Found ${filePaths.length} files. Max 200 per batch. Filter or split.`);
+        }
+        // Validate files exist and build request with collision-safe data_ids
+        const fileEntries = [];
+        const usedDataIds = new Set();
+        for (const fp of filePaths) {
+            if (!existsSync(fp)) {
+                throw new Error(`File not found: ${fp}`);
+            }
+            const stats = statSync(fp);
+            if (stats.size > 200 * 1024 * 1024) {
+                throw new Error(`File too large (${(stats.size / 1024 / 1024).toFixed(0)}MB): ${basename(fp)}. Max 200MB.`);
+            }
+            const name = basename(fp);
+            let stem = name.replace(extname(name), "").replace(/[^a-zA-Z0-9_\-\.]/g, "_").slice(0, 128);
+            // Handle data_id collisions
+            let candidate = stem;
+            let counter = 1;
+            while (usedDataIds.has(candidate)) {
+                candidate = `${stem}_${counter++}`;
+            }
+            usedDataIds.add(candidate);
+            fileEntries.push({ name, data_id: candidate });
+        }
+        // Request upload URLs
+        const requestData = {
+            files: fileEntries,
+            model_version: params.model || defaultModel,
+        };
+        if (params.formula !== undefined)
+            requestData.enable_formula = params.formula;
+        if (params.table !== undefined)
+            requestData.enable_table = params.table;
+        if (params.language)
+            requestData.language = params.language;
+        if (params.formats?.length)
+            requestData.extra_formats = params.formats;
+        const result = await mineruRequest("/file-urls/batch", "POST", requestData);
+        if (result.file_urls.length !== filePaths.length) {
+            throw new Error(`Expected ${filePaths.length} upload URLs, got ${result.file_urls.length}`);
+        }
+        // Upload each file to presigned OSS URLs using native fetch
+        // Presigned URLs are signed WITHOUT Content-Type — axios force-adds it, so use fetch
+        const uploadResults = [];
+        for (let i = 0; i < filePaths.length; i++) {
+            const fp = filePaths[i];
+            const uploadUrl = result.file_urls[i];
+            const fileName = basename(fp);
+            try {
+                const fileData = readFileSync(fp);
+                const resp = await fetch(uploadUrl, {
+                    method: "PUT",
+                    body: fileData,
+                    signal: AbortSignal.timeout(300_000),
+                });
+                if (!resp.ok) {
+                    const body = await resp.text();
+                    uploadResults.push(`FAIL: ${fileName} - HTTP ${resp.status}: ${body.slice(0, 200)}`);
+                }
+                else {
+                    uploadResults.push(`OK: ${fileName}`);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                uploadResults.push(`FAIL: ${fileName} - ${msg}`);
+            }
+        }
+        const successCount = uploadResults.filter((r) => r.startsWith("OK")).length;
+        const failCount = uploadResults.filter((r) => r.startsWith("FAIL")).length;
+        let text = `Batch ${result.batch_id}: ${successCount} uploaded, ${failCount} failed.\n`;
+        text += `Parsing starts automatically. Use mineru_batch_status to track.\n`;
+        text += `Use mineru_download_results with this batch_id to get named .md files.\n`;
+        if (failCount > 0) {
+            text += `\nFailed uploads:\n${uploadResults.filter((r) => r.startsWith("FAIL")).join("\n")}`;
+        }
+        return {
+            content: [{ type: "text", text }],
+        };
+    });
+    // Tool 6: mineru_download_results
+    server.tool("mineru_download_results", "Download batch results and extract markdown files with original filenames. Downloads zips, extracts .md content, and saves as {original_name}.md in output directory.", {
+        batch_id: z.string().describe("Batch ID from mineru_upload_batch or mineru_batch"),
+        output_dir: z.string().describe("Directory to save markdown files"),
+        overwrite: z.boolean().optional().default(false).describe("Overwrite existing files"),
+    }, async (params) => {
+        // Check batch status
+        const batch = await mineruRequest(`/extract-results/batch/${params.batch_id}`);
+        const results = batch.extract_result;
+        const doneResults = results.filter((r) => r.state === "done" && r.full_zip_url);
+        const pendingResults = results.filter((r) => ["pending", "running", "converting"].includes(r.state));
+        const failedResults = results.filter((r) => r.state === "failed");
+        if (doneResults.length === 0 && pendingResults.length > 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Batch ${params.batch_id}: ${pendingResults.length} still processing, 0 done. Try again later.`,
+                    }],
+            };
+        }
+        // Create output directory
+        mkdirSync(params.output_dir, { recursive: true });
+        const tmpBase = join(tmpdir(), `mineru-dl-${Date.now()}-${randomBytes(4).toString("hex")}`);
+        mkdirSync(tmpBase, { recursive: true });
+        const downloaded = [];
+        const errors = [];
+        // Depth-limited, symlink-safe .md file finder
+        const findMd = (dir, baseDir, depth = 0, maxDepth = 5) => {
+            if (depth > maxDepth)
+                return null;
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isSymbolicLink())
+                    continue; // skip symlinks (zip slip protection)
+                const fullPath = join(dir, entry.name);
+                if (entry.isFile() && entry.name.endsWith(".md")) {
+                    // Verify resolved path stays within extraction dir
+                    const realPath = realpathSync(fullPath);
+                    if (!realPath.startsWith(realpathSync(baseDir)))
+                        continue;
+                    return fullPath;
+                }
+                if (entry.isDirectory()) {
+                    const found = findMd(fullPath, baseDir, depth + 1, maxDepth);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        };
+        for (const r of doneResults) {
+            // Prefer data_id (set by us from original filename) over file_name (API-returned, can be stale)
+            const rawName = r.data_id || r.file_name || "unknown";
+            const safeName = basename(rawName).replace(/[^a-zA-Z0-9_\-\.\s]/g, "_");
+            const stem = safeName.replace(extname(safeName), "") || "unnamed";
+            const mdOutputPath = join(params.output_dir, `${stem}.md`);
+            if (!params.overwrite && existsSync(mdOutputPath)) {
+                downloaded.push(`SKIP: ${stem}.md (exists)`);
+                continue;
+            }
+            try {
+                // Download zip via streaming to avoid memory pressure
+                const zipPath = join(tmpBase, `${stem}.zip`);
+                const response = await axios.get(r.full_zip_url, {
+                    responseType: "stream",
+                    timeout: 120_000,
+                });
+                await pipeline(response.data, createWriteStream(zipPath));
+                // Extract zip using execFileSync (no shell injection)
+                const extractDir = join(tmpBase, stem);
+                mkdirSync(extractDir, { recursive: true });
+                try {
+                    execFileSync("unzip", ["-o", "-q", zipPath, "-d", extractDir], {
+                        timeout: 60_000,
+                    });
+                }
+                catch (unzipErr) {
+                    const msg = unzipErr instanceof Error ? unzipErr.message : String(unzipErr);
+                    errors.push(`UNZIP_FAIL: ${safeName} - ${msg}`);
+                    continue;
+                }
+                const mdFile = findMd(extractDir, extractDir);
+                if (mdFile) {
+                    const mdContent = readFileSync(mdFile, "utf-8");
+                    writeFileSync(mdOutputPath, mdContent, "utf-8");
+                    downloaded.push(`OK: ${stem}.md`);
+                }
+                else {
+                    errors.push(`NO_MD: ${safeName} - no .md file found in zip`);
+                }
+                // Cleanup zip
+                unlinkSync(zipPath);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push(`FAIL: ${safeName} - ${msg}`);
+            }
+        }
+        // Cleanup temp directory
+        try {
+            rmSync(tmpBase, { recursive: true, force: true });
+        }
+        catch { /* ignore cleanup errors */ }
+        let text = `Downloaded to: ${params.output_dir}\n`;
+        text += `Done: ${downloaded.filter((d) => d.startsWith("OK")).length}`;
+        text += ` | Skipped: ${downloaded.filter((d) => d.startsWith("SKIP")).length}`;
+        text += ` | Failed: ${errors.length}`;
+        if (pendingResults.length > 0) {
+            text += ` | Still processing: ${pendingResults.length}`;
+        }
+        if (failedResults.length > 0) {
+            text += ` | Parse failed: ${failedResults.length}`;
+        }
+        text += `\n\nFiles:\n${downloaded.join("\n")}`;
+        if (errors.length > 0) {
+            text += `\n\nErrors:\n${errors.join("\n")}`;
+        }
+        if (pendingResults.length > 0) {
+            text += `\n\nRe-run this tool to download remaining files once processing completes.`;
+        }
+        return {
+            content: [{ type: "text", text }],
+        };
+    });
     return server.server;
 }
-// STDIO mode for backward compatibility (npx, local dev)
+// Sandbox server for Smithery scanning (no real credentials needed)
+export function createSandboxServer() {
+    return createServer({
+        config: {
+            mineruApiKey: "sandbox-key",
+            mineruBaseUrl: "https://mineru.net/api/v4",
+            mineruDefaultModel: "pipeline",
+        },
+    });
+}
+// STDIO mode (npx, local dev, Claude Code)
 async function main() {
     const config = {
         mineruApiKey: process.env.MINERU_API_KEY || "",
@@ -248,7 +507,12 @@ async function main() {
     await server.connect(transport);
     console.error("MinerU MCP server running (stdio mode)");
 }
-main().catch((error) => {
-    console.error("Fatal error:", error);
-    process.exit(1);
-});
+// Only run stdio when executed directly (not when imported by Smithery CLI)
+const isDirectRun = process.argv[1] && (process.argv[1].endsWith('index.js') ||
+    process.argv[1].endsWith('index.ts'));
+if (isDirectRun) {
+    main().catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+    });
+}

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
  * HTTP Server for MinerU MCP
- * Run with: npm run start:http or node dist/server.js
+ * Run with: bun run start:http or node dist/server.js
  */
 export {};

package/dist/server.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
  * HTTP Server for MinerU MCP
- * Run with: npm run start:http or node dist/server.js
+ * Run with: bun run start:http or node dist/server.js
  */
 import express from "express";
 import { randomUUID } from "node:crypto";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mineru-mcp",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "MCP server for MinerU document parsing API - optimized for Claude Code with 73% token reduction",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,7 @@
     "start:http": "node dist/server.js",
     "dev": "tsx src/index.ts",
     "dev:http": "tsx src/server.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "bun run build"
   },
   "keywords": [
     "mcp",
@@ -35,6 +35,7 @@
   ],
   "author": "Xule Lin",
   "license": "MIT",
+  "mcpName": "io.github.linxule/mineru",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/linxule/mineru-mcp.git"