document-processorv1.0.0AGPL-3.0-only + Commercial

Document Processor

Parse PDF, DOCX, TXT — on your machine, not theirs.

View on GitHub →Build from sourceReleases

Overview

A desktop application — Rust backend, Tauri 2 shell, Svelte 5 frontend — that parses documents locally and extracts text plus images with their surrounding context preserved. SQLite database with hybrid search (FTS5, optionally fused with local embeddings), a remembered scan folder for batch re-processing, packaged for Linux.

The point is not parsing. The point is locality. Cloud OCR and document AI services exist; this exists for teams whose documents legally cannot leave the host.

Who it's for

Targets are organisations where document confidentiality is a regulatory or contractual requirement, not a preference:

  • Law firms — contract review, pleadings analysis, opinion drafts. Attorney-client privilege precludes cloud AI.
  • Medical research and clinical labs — patient records, study protocols and trial data that the team chooses to process on its own host.
  • Patent attorneys — pre-filing applications. Even an embedding leaked to a model's training set is enough to lose novelty.
  • Engineering and R&D teams — unpatented IP, pre-publication research, internal designs.
  • Public-sector operators — classified, restricted, or sovereignty-controlled material.
  • Corporations with M&A pipelines or strategic IP — board reports, due diligence materials, financial models.

Features

  • Multi-format parsing — PDF, DOCX, TXT..doc files are accepted but routed through the DOCX parser (no guarantee for legacy binary .doc); RTF is not supported.
  • Image extraction with surrounding context — every image carries 200 chars of preceding and following text plus a position marker. Charts and diagrams stay anchored to the prose that explains them. (The schema reserves fields for future OCR text and AI descriptions — neither is implemented yet.)
  • Document type classification — automatic detection of types (configurable; ships with examples for legal documentsumowa, pozew, ustawa).
  • Watch folder — remembers a target directory; new files are picked up when you trigger a re-scan ("Scan again"), not automatically in the background.
  • SQLite database — fast cross-document search without a server. Single file, easy backup, no extra service.
  • Hybrid search — SQLite FTS5 lexical search, optionally fused with embeddings from a local Ollama instance (nomic-embed-text). If Ollama isn't running, search degrades cleanly to lexical-only. No cloud calls either way.
  • Modern UI — dark theme, drag-and-drop, responsive. Built with Svelte 5; reactive, small bundle.
  • Linux packages — built and distributed for Linux (.deb / AppImage). The Tauri toolchain compiles on Windows and macOS, but no installers are shipped for them — build from source. Tauri keeps the package small (~10–20 MB) and the runtime fast.

Output structure

Each processed document creates a self-contained directory:

przetworzone/<id>/
<app-data-dir>/przetworzone/<document-id>/
├── document.md          # Human-readable markdown
├── document.json        # Structured data for AI ingestion
│                        #   (incl. per-image context metadata)
├── images/
│   ├── img_001.png      # Extracted images
│   └── thumb_img_001.png  # Thumbnail
└── original.pdf         # Original file copy (audit trail)

Two parallel formats: document.md for humans anddocument.json for AI ingestion. Images live alongside; their metadata (surrounding context, position marker, dimensions) is recorded in document.json and in the SQLite index. The original file is preserved for audit.

Ecosystem fit

Document Processor writes its parsed output to local storage. It does not ship a direct integration with Consciousness Server or Key Server.

  • Use document.md and document.json as local inputs to a workflow you configure.
  • Keep access controls, retention rules and any downstream upload decisions in that workflow.

Install (build from source)

Linux installers (.deb / AppImage) are the distributed form. On any platform you can also build from source:

terminal
# Linux (Ubuntu/Debian) — system deps
sudo apt install -y libwebkit2gtk-4.1-dev libappindicator3-dev \
                    librsvg2-dev patchelf libssl-dev

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Clone and build
git clone https://github.com/build-on-ai/document-processor.git
cd document-processor
npm install
npm run tauri build

Windows note: build-from-source only — the bundle config defines Linux targets, so no .msi/.exeinstaller is produced. Install WebView2 and Visual Studio Build Tools first. Tauri uses the system WebView; nothing bundled.

Status

v1.0.0 — the current package version.

  • Supported input formats: PDF, DOCX and TXT.
  • Scanned documents: a scan without a text layer does not yield extracted text; OCR is not part of the app.
  • Distribution: Linux targets are configured for.AppImage and .deb; other platforms use the source build path.
  • Safe to use on real documents — output goes to a local directory, the original file is preserved as-is, no destructive operations on input.

Validate the output against the needs and controls of your own workflow before using it for a broader document set.

Next steps