EU E-InvoicingPeppol & ViDA

Automated E-Invoicing XML Validation with Local AI: Peppol & ViDA Readiness

Validate UBL and CII e-invoices against EN 16931 and Peppol rules, with a local LLM that explains failures to AP teams. Built for ViDA readiness.

Published

Architecture

Recommended model

OpenAI gpt-oss-20b (Q4_K_M)

Parser / tooling

KoSIT Validator (EN 16931 Schematron)

VRAM required

13 GB

Q4_K_M, 8k tokens

Compliance standard

Peppol & ViDA

Validation stays deterministic: every UBL or CII invoice is checked against the EN 16931 and Peppol BIS Billing 3.0 Schematron rules by a self-hosted validator. The local LLM is used only where judgment helps (explaining rule failures in plain language, suggesting field mappings from ERP exports and triaging rejected invoices), so a model can never mark an invalid invoice as valid. Validation reports are retained for every invoice processed.

  1. 01

    Receive

    Invoices arrive from the ERP or a Peppol access point as UBL or CII XML.

  2. 02

    Validate

    The validator applies EN 16931 and Peppol BIS Billing 3.0 Schematron rules and stores the report.

  3. 03

    Explain

    gpt-oss-20b turns failed rule IDs into plain-language fixes for accounts-payable teams.

  4. 04

    Route

    Valid invoices continue to posting; failures go to a review queue with the explanation attached.

Performance & privacy profile

Pre-lab estimates for OpenAI gpt-oss-20b (20B), Q4_K_M (4-bit Recommended), 8k tokens. Not measured results.
MetricValueBasis
VRAM required13 GBWeights + FP16 KV cache + 1 GB runtime overhead
Decode speed~106–162 tok/sMemory-bandwidth estimate on RTX 5080 16GB, single user
Table extraction accuracyN/A (structured XML input)Not applicable to this workload
Privacy score7/10Editorial rubric, see breakdown below
  • On-prem inference, no third-party AI processor(implemented)+3
  • No outbound network route from AI hosts(implemented)+2
  • Encryption at rest for documents and indexes(not included)+1
  • Per-request audit logging(implemented)+2
  • Role- or matter-based access control(not included)+1
  • Data minimization before storage (redaction or hashing)(not included)+1

Deployment config

Starting point only. Pin image versions and review network policy before production.

# docker-compose.yml: deterministic validation + local LLM explanations.
# Download the KoSIT validator standalone jar and the XRechnung/Peppol
# scenario configuration into ./validator before starting.
services:
  validator:
    image: eclipse-temurin:21-jre
    working_dir: /validator
    volumes:
      - ./validator:/validator:ro
    # -D runs the validator as an HTTP daemon; POST invoice XML to port 8080
    command: >
      java -jar validator-standalone.jar
      -s scenarios.xml -r repository -D -H 0.0.0.0 -P 8080
    networks: [einvoice-internal]

  ollama:
    image: ollama/ollama:latest  # pin a specific tag in production
    volumes:
      - ollama:/root/.ollama  # pre-pulled: gpt-oss:20b
    networks: [einvoice-internal]
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

networks:
  einvoice-internal:
    internal: true

volumes:
  ollama:

Size it for your hardware

Local LLM VRAM Calculator

2026 models

Total VRAM required

13.0GB

Weights
11.8 GB
KV cache
0.2 GB
Overhead
1.0 GB

Recommended local hardware

  • RTX 5080 16GB~106–162 tok/s
  • Mac mini M4 Pro 64GB~30–46 tok/s

Estimated single-user decode speed from memory bandwidth. Real throughput depends on runtime, drivers and prompt length.

Runs locally on RTX 5080 16GB — no cloud requiredCompare with a RunPod GPU pod →

Frequently asked questions

What does ViDA change for e-invoicing?

The EU's VAT in the Digital Age (ViDA) package makes structured e-invoicing based on the EN 16931 standard the default for intra-EU B2B transactions, with mandatory digital reporting phased in from 2030. Several member states, including Belgium, Germany and France, are introducing domestic B2B e-invoicing mandates earlier, so validation capacity is needed well before the EU-wide deadline.

Why not let the AI validate the invoice?

Validation must be reproducible and auditable, so it is done by Schematron rules that give the same result every time. The LLM works on the validator's output, not instead of it: it explains failures and suggests fixes. This keeps a model error from ever approving a non-compliant invoice, and the stored validation report remains the evidence of record.

Is an 8k context enough for large invoices?

Usually. The model receives the failed rules and the relevant XML fragments, not the whole document, and invoices with hundreds of lines can be split by line group. At 8k context, gpt-oss-20b needs roughly 13 GB of VRAM, so it runs on a single 16 GB GPU such as the RTX 5080.

More blueprints