Docpick

Docpick

한국어 문서 · llms.txt

Document in, Structured JSON out. Locally. With your schema.

docpick is a lightweight, schema-driven document extraction pipeline that combines local OCR engines with local LLMs to extract structured JSON from any document — invoices, receipts, bills of lading, tax forms, and more.

• Zero cloud dependency — runs entirely on your machine (CPU or GPU)
• Custom schemas — define your own Pydantic models or use 8 built-in document schemas
• Validation built-in — checkdigit verification, cross-field rules, cross-document consistency
• Apache 2.0 — no GPL/AGPL dependencies

Install

pip install docpick            # core (LLM extraction only)

pip install docpick[paddle] # + PaddleOCR (recommended) pip install docpick[easyocr] # + EasyOCR (Korean-optimized) pip install docpick[got] # + GOT-OCR2.0 (GPU, vision-language) pip install docpick[all] # all OCR backends

Requirements: Python 3.11+ / LLM endpoint (vLLM, Ollama, or OpenAI-compatible)

Quick Start

Python API

from docpick import DocpickPipeline

from docpick.schemas import InvoiceSchema

pipeline = DocpickPipeline() result = pipeline.extract("invoice.pdf", schema=InvoiceSchema)

print(result.data) # Structured dict matching schema print(result.validation) # Validation errors/warnings print(result.confidence) # Per-field confidence scores

CLI

# Extract structured data

docpick extract invoice.pdf --schema invoice --output result.json

OCR only (no LLM)

docpick ocr document.png --lang ko,en

Validate extracted JSON

docpick validate result.json --schema invoice

Batch process a directory

docpick batch ./documents/ --schema invoice --output ./results/ --concurrency 4

List available schemas

docpick schemas list

Show schema details

docpick schemas show invoice

Built-in Schemas

Custom Schemas

Define your own schema with Pydantic:

from pydantic import BaseModel

from docpick import DocpickPipeline from docpick.validation.rules import SumEqualsRule, RequiredFieldRule

class MyDocument(BaseModel): """Custom document schema.""" company_name: str | None = None total_amount: float | None = None tax_amount: float | None = None net_amount: float | None = None items: list[dict] | None = None

class ValidationRules: rules = [ RequiredFieldRule("company_name"), SumEqualsRule(["net_amount", "tax_amount"], "total_amount"), ]

pipeline = DocpickPipeline() result = pipeline.extract("my_document.pdf", schema=MyDocument)

Or use a JSON Schema file:

docpick extract document.pdf --schema my_schema.json

Validation

Check Digit Algorithms

Cross-Field Rules

Cross-Document Validation

Validate consistency across related documents (e.g., Invoice + B/L + Packing List):

from docpick.validation.cross_document import create_trade_document_validator

validator = create_trade_document_validator() result = validator.validate({ "invoice": invoice_data, "bl": bl_data, "packing_list": packing_list_data, "certificate": certificate_data, }) print(result.is_valid)

OCR Engines

2-Tier Auto Engine

The default auto engine uses confidence-based fallback:

1. Tier 1 (CPU): PaddleOCR → EasyOCR
2. Tier 2 (GPU): GOT-OCR2.0 → VLM

If Tier 1 average confidence falls below threshold (default 0.7), automatically escalates to Tier 2.

LLM Providers

Configure via CLI or YAML:

docpick config set llm.provider ollama

docpick config set llm.base_url http://localhost:11434 docpick config set llm.model qwen3.5:7b

Error Handling

The pipeline is designed to be resilient:

• OCR failure → automatic fallback to next available engine
• LLM JSON parse failure → automatic retry with correction prompt (up to 1 retry)
• Partial results → returns whatever was extracted, with errors logged in result.errors
• Document load failure → returns empty result with error message

result = pipeline.extract("damaged.pdf", schema=InvoiceSchema)

if result.errors: print("Pipeline warnings:", result.errors) if result.data: print("Partial extraction:", result.data)

Batch Processing

Process entire directories with parallel workers:

from docpick.batch import BatchProcessor

from docpick.schemas import InvoiceSchema

processor = BatchProcessor(concurrency=4) result = processor.process_directory( "./invoices/", schema=InvoiceSchema, recursive=True, )

print(f"Processed {result.succeeded}/{result.total} files") for path, extraction in result.results.items(): print(f"{path}: {extraction.data.get('total_amount')}")

Architecture

flowchart TD

A["📄 Document\n(PDF / Image)"] --> B["DocumentLoader\n(pypdfium2)"] B --> C["Tier 1: OCR\n(PaddleOCR / EasyOCR)\nCPU"] C --> D{"Confidence\n≥ threshold?"} D -->|"yes"| F["LLM Extractor\n(vLLM / Ollama)\nSchema prompt"] D -->|"no"| E["Tier 2: VLM\n(GOT / VLM)\nGPU"] E --> F F --> G["Pydantic Validation"] G --> H["✅ ExtractionResult"]

License

Apache 2.0 — all dependencies are Apache 2.0 or MIT licensed.

---

Part of the QuartzUnit ecosystem — composable Python libraries for data collection, extraction, search, and AI agent safety.