Overview

NetMind ParsePro MCP Server is an MCP (Model Context Protocol)–compatible backend designed to accelerate and standardize PDF parsing workflows. It exposes a simple HTTP API that accepts PDFs, applies OCR and layout-aware extraction, and returns structured outputs (JSON, plain text, tables) tailored for downstream AI models or automation pipelines. The implementation is optimized for predictable, reproducible extraction so LLMs receive clean, high-quality context windows.

The server is useful when you need reliable PDF-to-data conversion as part of an AI workflow — for example, feeding contract clauses or invoice line items into LLM chains, populating databases from research papers, or running compliance checks. It integrates with model-serving components via MCP and provides configurable extraction presets (pages, regions, schema mapping) so teams can move from raw PDF bytes to actionable structured data with fewer manual steps.

Features

MCP-compatible HTTP API for model-driven workflows
Fast, layout-aware PDF parsing with optional OCR
Multiple output formats: JSON (field extraction), plain text, CSV/TSV for tables
Extraction presets and custom schema mapping to target data structures
Upload endpoints, URL ingestion, and streaming support for large PDFs
Webhook and callback hooks for asynchronous processing
Docker-ready and suitable for Kubernetes deployments
Configurable resource limits and provider-agnostic model hooks
Logging, metrics, and basic authentication support

Installation / Configuration

Prerequisites: Docker (recommended) or Node.js 18+ (if building locally).

Clone and build:

git clone https://github.com/protagolabs/Netmind-Parse-PDF-MCP.git
cd Netmind-Parse-PDF-MCP

Run with Docker (recommended):

# Build image
docker build -t netmind-parsepro .

# Run container (example)
docker run -d \
  -p 8080:8080 \
  -e PORT=8080 \
  -e STORAGE_DIR=/data/storage \
  -e MODEL_PROVIDER=your-model-provider \
  -e MODEL_API_KEY=your-model-api-key \
  -v $(pwd)/data:/data/storage \
  --name netmind-parsepro \
  netmind-parsepro:latest

Docker Compose example:

version: "3.8"
services:
  parsepro:
    image: netmind-parsepro:latest
    ports:
      - "8080:8080"
    environment:
      - PORT=8080
      - STORAGE_DIR=/data/storage
      - MODEL_PROVIDER=your-model-provider
      - MODEL_API_KEY=your-model-api-key
    volumes:
      - ./data:/data/storage
    restart: unless-stopped

Environment configuration (recommended variables):

PORT=8080
STORAGE_DIR=/data/storage
MODEL_PROVIDER=openai|local|azure
MODEL_API_KEY=sk-...
OCR_ENABLED=true
MAX_FILE_SIZE_MB=200
ASYNC_WORKERS=4
LOG_LEVEL=info

If building/running locally with Node:

npm install
npm run build
npm start

Available Tools / Resources

The server exposes several logical tools (endpoints) intended to be consumed via MCP or direct HTTP:

/health: basic liveness and readiness checks
/upload: multipart upload endpoint for PDF files
/parse: synchronous parse endpoint (small files / fast ops)
/parse/async: enqueue PDF parsing and receive webhook/callback
/schema: list of built-in extraction schemas (invoice, contract, research-paper)
/presets: saved preset configurations for page ranges, OCR, table detection
/tools: MCP discovery endpoint listing capabilities and tool signatures

Example endpoints table:

Endpoint	Method	Purpose
/upload	POST	Upload PDF bytes
/parse	POST	Parse and return structured output
/parse/async	POST	Accept job, return job-id
/schema	GET	List or fetch extraction schemas

Use Cases

Invoice automation
- Scenario: Automatically extract invoice number, vendor, line items, totals.
- Flow: Upload invoice PDF to /parse with preset “invoice-v1” -> receive JSON with structured invoice fields -> insert into accounting system.
Contract clause extraction
- Scenario: Pull clause texts and metadata for legal review.
- Flow: Call /parse with pages and “contract” schema -> server returns clause-level segments and positions -> feed into LLM for summarization or compliance checks.
Academic literature ingestion
- Scenario: Import paper metadata, abstract, figures and tables for indexing.
- Flow: Use /parse with “research-paper” schema + OCR -> extract title, authors, abstract, and tables -> index into search engine.
Batch processing with callbacks
- Scenario: Large archive of PDFs requires asynchronous processing.
- Flow: POST to /parse/async with callback URL -> server enqueues jobs and posts results to callback when ready.

Example curl request (sync parse):

curl -X POST "http://localhost:8080/parse" \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@/path/to/document.pdf" \
  -F 'options={"output":"json","schema":"invoice-v1","pages":"1-2"}'

Example JavaScript (fetch) snippet:

const form = new FormData();
form.append('file', fileInput.files[0]);
form.append('options', JSON.stringify({output: 'json', schema: 'contract-v1'}));
const res = await fetch('http://localhost:8080/parse', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer ' + API_KEY },
  body: form
});
const result = await res.json();
console.log(result);

Operational Notes

Tune OCR and worker concurrency for CPU-bound workloads; large-volume deployments benefit from horizontal scaling.
Keep STORAGE_DIR backed by persistent volume when running in containers.
Use HTTPS and proper API key management in production; consider placing the server behind an API gateway for rate limiting.
For model integrations, configure MODEL_PROVIDER and API keys — the server acts as a bridge between parsed content and model-driven MCP workflows.

Repository and issues: https://github.com/protagolabs/Netmind-Parse-PDF-MCP

NetMind ParsePro MCP Server for PDF Parsing