Liteparse

LiteParse (lit CLI)

Parse unstructured documents (PDF, DOCX, PPTX, XLSX, images) locally with LiteParse: fast, no cloud dependencies, no LLM. Output text, Markdown, or structured JSON with per-item bounding boxes and OCR confidence.

All commands and outputs below were verified Aug 2026 against @llamaindex/liteparse 2.13.1 on macOS arm64.

Defaults — OCR and LibreOffice are opt-in

Both cost the user something (network download, 800 MB install), so neither runs or installs silently:

1. OCR is off by default. The CLI enables OCR unless told otherwise — so always pass --no-ocr explicitly. Turn OCR on only when the gate below says so (lit is-complex → needsOcr: true with textLength: 0, or a parse came back empty) and the user approved. First run per language downloads ~15 MB over the network.
2. LibreOffice is never auto-installed. Offer it — stating the 800 MB size — only when the user actually needs an Office format parsed locally. Install only after explicit approval. If the user declines, route Office files to mineru (cloud converts them with zero local install) or a lighter skill.
3. Try lighter skills first for text-layer PDFs (pdf-to-markdown, pymupdf-pdf). Escalate to this skill's OCR only when those fail or return empty — that failure is the "needed" signal.

Setup

Run the pre-flight first, then install only what is missing for the formats at hand — asking before every install beyond the CLI. Images and PDFs need nothing beyond the CLI; Office formats additionally need LibreOffice (opt-in, see Defaults).

Pre-flight (run before parsing)

node --version                                 # must be v18+
command -v lit >/dev/null 2>&1 && echo "lit: ok" || echo "lit: MISSING"
command -v soffice >/dev/null 2>&1 && echo "libreoffice: ok" || echo "libreoffice: MISSING (only needed for Office formats)"

Install

1. CLI — always required:

npm i -g @llamaindex/liteparse
lit parse --help >/dev/null && echo "install ok"

lit parse --help is the right verification: it loads the native platform binary at startup and fails loudly if the install is broken. Don't use lit --version — it prints a hardcoded 2.0.0 regardless of the installed package.

2. LibreOffice — opt-in, user approval required (only for Office formats: DOCX/PPTX/XLSX/ODT/RTF/CSV): ~800 MB. Offer it with the size stated; never install unprompted. If it's missing, Office files fail immediately with a clear exit-1 error listing these same commands; PDFs and images are unaffected.

brew install --cask libreoffice     # macOS
sudo apt-get install libreoffice    # Ubuntu/Debian
choco install libreoffice-fresh     # Windows

Verify with command -v soffice.

3. OCR data — automatic, needs network once per language: the first OCR run downloads Tesseract data (45 s; cached at `/Library/Application Support/tesseract-rs/tessdata/on macOS). For offline machines, pre-seed a tessdata directory and point the config file'stessdataPath` at it.

When to Use This vs. Other Parsers

Route to mineru when: OCR output comes back empty or garbled (see Limits), the document has LaTeX formulas or complex multi-column layout, or the user explicitly wants maximum accuracy and accepts a cloud round-trip.

See the parse-docs router skill for full decision logic.

Supported Input Formats

Office documents are converted to PDF via LibreOffice first, then parsed. Anything else fails fast: Error: conversion error: unsupported file format: .txt, exit 1.

Commands

Single File → Text (default: no OCR)

lit parse document.pdf --no-ocr

[liteparse] extract: 23.1ms (1 pages)
[liteparse] ocr: 0.0ms
...
LiteParse Audit Report

Section 1: Introduction

The CLI turns OCR on by default — always pass --no-ocr unless the OCR gate below passed and the user approved (see Defaults).

Add -q/--quiet to suppress the [liteparse] timing lines on stderr. Read from stdin with lit parse - (e.g. curl -sL url/file.pdf | lit parse -).

Markdown (headings, lists, tables, links)

lit parse document.pdf --format markdown

JSON with Bounding Boxes

lit parse document.pdf --format json -o output.json

Output structure (verified):

{
  "pages": [
    {
      "page": 1,
      "width": 384,
      "height": 144,
      "text": "Invoice 2026-08-19  Total due: 142.50 USD",
      "text_items": [
        {
          "text": "Invoice 2026-08-19",
          "x": 20.6, "y": 32.2, "width": 145.4, "height": 12.5,
          "font_name": "OCR",
          "font_size": 12.5,
          "confidence": 0.962
        }
      ]
    }
  ]
}

Optional JSON extras (each adds fields): --extract-images (+--image-output-dir <dir> to write bytes), --extract-annotations, --extract-form-fields, --extract-blocks, --extract-structure-tree, --extract-vector-graphics, --extract-text-metadata, --complexity.

The OCR Gate — run before ever dropping --no-ocr

is-complex is a cheap text-layer-only pass. It decides whether OCR is warranted at all; only a positive gate plus user approval turns OCR on:

lit is-complex scan.png

[
  {
    "pageNumber": 1,
    "textLength": 0,
    "needsOcr": true,
    "reasons": ["scanned"],
    "layout": { "columnCount": 1, "isComplex": false, "reasons": [] }
  }
]

Reading the verdict: needsOcr: true with textLength: 0 (reasons like scanned, no-text, garbled) → offer OCR to the user. Reasons: scanned, no-text, sparse-text, embedded-images, garbled, vector-text, annotation-text. Caveat (verified): it is conservative — a short text-layer memo flags sparse-text/needsOcr: true even when the text layer is fine. Check textLength before routing; don't blindly trust the flag.

Page Ranges, DPI, and OCR (gated)

lit parse document.pdf --no-ocr                # DEFAULT — always start here
lit parse document.pdf --target-pages "1-5,10,15-20"
lit parse document.pdf --max-pages 50          # hard limit (default: 1000)
lit parse document.pdf --password secret       # encrypted documents

# OCR variants — only after the gate passed AND the user approved:
lit parse document.pdf --ocr-language fra      # Tesseract code; default eng
lit parse document.pdf --dpi 300               # default 150

External OCR Server (higher accuracy than built-in Tesseract)

lit parse document.pdf --ocr-server-url http://localhost:8828/ocr \
  --ocr-server-header "Authorization: Bearer tkn"

The server implements POST /ocr taking file (multipart) + language, returning {"results": [{"text": "Hello", "bbox": [x1, y1, x2, y2], "confidence": 0.98}]}.

Screenshots (for vision-capable agents)

lit screenshot document.pdf -o ./screenshots          # writes page_1.png, page_2.png, ...
lit screenshot document.pdf --target-pages "1,3,5" -o ./screenshots

Batch Directory

lit batch-parse ./input ./output --recursive --no-ocr   # → "batch complete: 2 succeeded, 0 failed"
lit batch-parse ./input ./output --extension .pdf --format markdown --no-ocr

Writes one file per input named <stem>.<txt|json|md> directly in the output dir — files with the same stem overwrite each other (verified: a.docx and a.png both produce a.txt). Keep stems unique in batch inputs.

Config File

For repeated use, pass a JSON config with Node-API camelCase keys (verified in CLI source — snake_case does not work here):

lit parse document.pdf --config liteparse.config.json

{
  "ocrEnabled": false,
  "ocrLanguage": "eng",
  "maxPages": 1000,
  "dpi": 150,
  "outputFormat": "json",
  "numWorkers": 4,
  "preserveVerySmallText": false,
  "continueOnPageError": false
}

Keep ocrEnabled: false in configs too — flip it to true only after the OCR gate passed and the user approved (see Defaults).

CLI flags override config-file values. Valid keys include everything above plus ocrServerUrl, ocrServerHeaders, targetPages, password, quiet, skipDiagonalText (config-only; no CLI flag).

Limits (verified Aug 2026)