Vorratsdatenspeicher läuft auf deinem eigenen Gerät — deine Belege und Zahlen bleiben bei dir, nicht in irgendeiner Cloud. Diese Seite führt dich Schritt für Schritt, egal was du hast: einen Windows-Laptop, einen Mac, einen alten Rechner in der Ecke oder einen günstig gemieteten Server.

Grundidee Welcher Weg? 💻 Windows 🍎 Mac 🐧 Alter PC ☁️ Von überall 🧠 Welche KI? 🤖 KI-Hilfe Danach FAQ

🧩Die Grundidee (in 30 Sekunden)

Vorratsdatenspeicher steckt in einem Docker-Container — das ist eine Art sauber verpackte App, die überall gleich läuft. Du musst also nur zwei Dinge tun:

1. Docker installieren (einmalig, per Klick oder ein Befehl).
2. Einen einzigen Befehl ausführen, der Vorratsdatenspeicher herunterlädt und startet.

Das war's im Kern. Du brauchst dafür ein Gerät, das möglichst immer läuft (ein Laptop, ein alter PC, ein Mini-Rechner oder ein gemieteter Server) — denn solange das Gerät aus ist, ist auch die App offline.

🧭Welcher Weg passt zu dir?

Tipp auf das, was du gerade hast. Alle Wege führen zum selben Ziel.

💻Windows — in 3 Schritten

Windows 10 oder 11. Du brauchst keine Admin-Kenntnisse — nur klicken und einfügen.

1. Docker Desktop installieren. Lade es hier: docker.com/products/docker-desktop → „Download for Windows". Installer starten, „Weiter / OK / Fertig", Rechner neu starten. Danach Docker Desktop öffnen und warten, bis unten links „Engine running" (grün) steht.
2. PowerShell öffnen. Start-Menü → tippe PowerShell → öffnen.
3. Diesen Block einfügen und Enter drücken. Er legt einen Ordner an, würfelt zwei sichere Passwörter, lädt Vorratsdatenspeicher und startet es — und öffnet den Browser für dich.

$dir = "$HOME\Vorratsdatenspeicher"; New-Item -ItemType Directory -Force $dir | Out-Null; Set-Location $dir
$jwt = -join ((1..64) | ForEach-Object { '{0:x}' -f (Get-Random -Maximum 16) })
$int = -join ((1..64) | ForEach-Object { '{0:x}' -f (Get-Random -Maximum 16) })
@"
services:
  vds:
    image: ghcr.io/martinkadauke/vorratsdatenspeicher:stable
    ports: ["8766:80"]
    environment:
      DATABASE_URL: postgres://vds:vds@db:5432/vds
      JWT_SECRET: $jwt
      INTERNAL_SECRET: $int
    volumes: ["vds-receipts:/receipts"]
    depends_on:
      db: { condition: service_healthy }
    restart: unless-stopped
  db:
    image: postgres:16
    environment: { POSTGRES_USER: vds, POSTGRES_PASSWORD: vds, POSTGRES_DB: vds }
    volumes: ["vds-db:/var/lib/postgresql/data"]
    healthcheck: { test: ["CMD-SHELL", "pg_isready -U vds -d vds"], interval: 5s, timeout: 3s, retries: 20 }
    restart: unless-stopped
volumes:
  vds-receipts: {}
  vds-db: {}
"@ | Set-Content -Encoding ascii docker-compose.yml
docker compose up -d
Start-Process http://localhost:8766

Fertig! Es öffnet sich http://localhost:8766. Erster Login: admin / vorrat-start-2026 — das Passwort änderst du gleich im Einrichtungs-Assistenten.

Ich installiere „Docker Desktop" auf Windows 11 und bekomme diese Meldung: [Meldung hier einfügen]. Ich bin Anfänger. Erklär mir bitte in einfachen Worten, Schritt für Schritt, wie ich das behebe.

🍎Mac — in 3 Schritten

1. Docker Desktop installieren: docker.com/products/docker-desktop → „Download for Mac". (Docker erkennt selbst, ob du einen Apple-Silicon- oder Intel-Mac hast.) Öffnen, bis das Wal-Symbol oben in der Leiste ruhig steht.
2. Terminal öffnen: ⌘ + Leertaste → Terminal → Enter.
3. Diesen Block einfügen + Enter:

mkdir -p ~/vorratsdatenspeicher && cd ~/vorratsdatenspeicher
cat > docker-compose.yml <<EOF
services:
  vds:
    image: ghcr.io/martinkadauke/vorratsdatenspeicher:stable
    ports: ["8766:80"]
    environment:
      DATABASE_URL: postgres://vds:vds@db:5432/vds
      JWT_SECRET: $(openssl rand -hex 32)
      INTERNAL_SECRET: $(openssl rand -hex 32)
    volumes: ["vds-receipts:/receipts"]
    depends_on:
      db: { condition: service_healthy }
    restart: unless-stopped
  db:
    image: postgres:16
    environment: { POSTGRES_USER: vds, POSTGRES_PASSWORD: vds, POSTGRES_DB: vds }
    volumes: ["vds-db:/var/lib/postgresql/data"]
    healthcheck: { test: ["CMD-SHELL", "pg_isready -U vds -d vds"], interval: 5s, timeout: 3s, retries: 20 }
    restart: unless-stopped
volumes:
  vds-receipts: {}
  vds-db: {}
EOF
docker compose up -d
open http://localhost:8766

Fertig — der Browser öffnet http://localhost:8766. Login admin / vorrat-start-2026.

🐧Alten Laptop oder PC wiederbeleben

Ein ausrangierter Rechner wird zum leisen 24/7-Server — kostet nur ein bisschen Strom.

1. Linux drauf (falls noch Windows läuft): Am einfachsten ist Ubuntu. Du machst dir einen USB-Stick, steckst ihn rein und installierst — ein Assistent führt dich durch. Die KI erstellt dir die Anleitung passgenau für deinen Laptop (siehe Prompt unten). Wenn schon Linux/Ubuntu läuft, überspring das.
2. Docker installieren — im Terminal (Ubuntu: Strg + Alt + T):

curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

Nach dem zweiten Befehl einmal ab- und wieder anmelden (oder neu starten), damit du Docker ohne sudo nutzen kannst.

3. Vorratsdatenspeicher starten — genau der Mac-Befehl von oben funktioniert hier auch:

mkdir -p ~/vorratsdatenspeicher && cd ~/vorratsdatenspeicher
cat > docker-compose.yml <<EOF
services:
  vds:
    image: ghcr.io/martinkadauke/vorratsdatenspeicher:stable
    ports: ["8766:80"]
    environment:
      DATABASE_URL: postgres://vds:vds@db:5432/vds
      JWT_SECRET: $(openssl rand -hex 32)
      INTERNAL_SECRET: $(openssl rand -hex 32)
    volumes: ["vds-receipts:/receipts"]
    depends_on:
      db: { condition: service_healthy }
    restart: unless-stopped
  db:
    image: postgres:16
    environment: { POSTGRES_USER: vds, POSTGRES_PASSWORD: vds, POSTGRES_DB: vds }
    volumes: ["vds-db:/var/lib/postgresql/data"]
    healthcheck: { test: ["CMD-SHELL", "pg_isready -U vds -d vds"], interval: 5s, timeout: 3s, retries: 20 }
    restart: unless-stopped
volumes:
  vds-receipts: {}
  vds-db: {}
EOF
docker compose up -d

Aufrufen kannst du es dann von jedem Gerät im selben WLAN unter http://<IP-des-Rechners>:8766 (die IP zeigt dir ip a oder die KI).

Ich habe einen alten Laptop [Modell, z. B. „Lenovo ThinkPad von 2014"] und möchte darauf Ubuntu Linux installieren, um ihn als kleinen Heim-Server zu nutzen. Ich bin absoluter Anfänger. Führe mich bitte Schritt für Schritt: welches Ubuntu, wie mache ich den USB-Stick, wie boote ich davon, und worauf muss ich achten, damit nichts Wichtiges verloren geht?

🌍Von überall erreichbar & aufs Handy

Zuhause im WLAN läuft VDS sofort. Damit du von unterwegs drauf kommst — und es als App aufs Handy holst — braucht es eine feste Adresse und HTTPS (das Schloss-Symbol). Such dir deinen Weg aus:

Zuerst: eine Domain kaufen

Eine Domain ist deine feste Internet-Adresse, z. B. mein-vorrat.de — damit du dir keine wechselnde Zahlen-IP merken musst und HTTPS bekommst. Kostet meist 5–15 € pro Jahr.

1. Domain registrieren bei z. B. Cloudflare, Namecheap, Netcup, Strato oder IONOS. Wunschnamen eingeben, kaufen.
2. Die Domain auf dein Gerät zeigen lassen (DNS). Im Verwaltungsbereich der Domain legst du einen „A-Record" an: Name @ (für die nackte Domain) oder z. B. vds (für vds.deine-domain.de), Wert = die öffentliche IPv4-Adresse deines Servers. (Beim Weg „Zuhause" übernimmt das später DynDNS automatisch.)

Der Reverse Proxy (Caddy) — dein HTTPS-Türsteher

Ein Reverse Proxy ist wie ein Türsteher vor deiner App: Anfragen aus dem Internet kommen bei ihm an, er kümmert sich um HTTPS und reicht sie an Vorratsdatenspeicher weiter. Wir nehmen Caddy — es holt sich das Sicherheitszertifikat vollautomatisch, du musst damit nichts tun.

Leg in deinem VDS-Ordner eine Datei namens Caddyfile an (deine Domain einsetzen):

deine-domain.de {
    reverse_proxy vds:80
}

… und ergänze deine docker-compose.yml um den Caddy-Dienst (unter services:, mit gleicher Einrückung wie vds:):

  caddy:
    image: caddy:2
    restart: unless-stopped
    ports: ["80:80", "443:443"]
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy-data:/data
    depends_on: [vds]

… und bei den volumes: ganz unten noch caddy-data: {} hinzufügen. Dann docker compose up -d. Sobald die Domain auf deine IP zeigt, ist VDS unter https://deine-domain.de mit gültigem Zertifikat erreichbar.

Ich hoste die Docker-App „Vorratsdatenspeicher" (Container-Port 80, Service-Name „vds") per docker compose. Meine Domain: [deine-domain.de]. Bitte gib mir die fertige Caddyfile und den Caddy-Service für meine docker-compose.yml, sodass die App unter https://[deine-domain.de] mit automatischem Zertifikat läuft — und erklär mir jeden Schritt. Ich bin Anfänger.

Weg A — auf einem gemieteten Server

Ein kleiner Server (VPS) hat eine feste öffentliche IP und läuft rund um die Uhr — der bequemste Weg.

1. Server mieten: Hetzner Cloud (ab ~4 €/Monat), Netcup, Hostinger … — als System Ubuntu wählen. Du bekommst eine IP-Adresse und ein Passwort.
2. Verbinden (SSH) — Windows: PowerShell, Mac/Linux: Terminal:
   SSH · mit dem Server verbindenKopieren

   ssh root@DEINE-SERVER-IP

   (IP einsetzen, Passwort eingeben — beim Tippen bleibt es unsichtbar, das ist normal.)
3. Docker + VDS installieren — die beiden Linux-Blöcke von oben.
4. Domain & HTTPS: A-Record auf die Server-IP, in der Firewall deines Anbieters Port 80 + 443 erlauben (bei Hetzner: „Firewalls"), dann Caddy wie oben ergänzen. Fertig: https://deine-domain.de.

Weg B — zuhause hinter deinem Router

Dein Rechner steht daheim hinter dem Router. Zwei Dinge fehlen: der Weg von außen zu deinem Rechner (Port-Weiterleitung) und eine Adresse, die deiner wechselnden Heim-IP folgt (DynDNS).

1. Port-Weiterleitung im Router. Öffne die Router-Oberfläche (meist http://192.168.0.1, http://192.168.1.1 oder fritz.box). Unter „Portfreigaben / Port-Weiterleitung" leitest du Port 80 und 443 auf die lokale IP deines Server-Rechners weiter (die zeigt dir die Geräteliste im Router, oder auf dem Rechner ip a / bei Windows ipconfig).
2. DynDNS einrichten — weil deine Heim-IP sich regelmäßig ändert, sorgt DynDNS dafür, dass deine Adresse immer auf die aktuelle IP zeigt:
   • Viele Router können das selbst (Fritz!Box: „Internet → Freigaben → DynDNS") — kostenlos z. B. mit DuckDNS oder MyFRITZ!.
   • DuckDNS gibt dir eine fertige Adresse wie meinname.duckdns.org — die kannst du direkt als Domain in der Caddyfile eintragen (dann brauchst du nicht mal eine gekaufte Domain).
3. Caddy wie oben — als Domain deine echte (per DynDNS aktuell gehaltene) Adresse oder direkt meinname.duckdns.org.

Ich möchte zuhause einen kleinen Server aus dem Internet erreichbar machen. Mein Router: [Modell, z. B. „AVM Fritz!Box 7590"], Internetanbieter: [z. B. Telekom]. Führe mich Schritt für Schritt: 1) Port 80 und 443 auf meinen Server-Rechner (lokale IP [z. B. 192.168.1.50]) weiterleiten, 2) DynDNS einrichten (am liebsten kostenlos, z. B. DuckDNS), 3) prüfen, ob ich überhaupt eine öffentliche IPv4 habe (CGNAT). Ich bin Anfänger, erklär jeden Schritt.

🪄 Der faule Weg: Tailscale (ohne Domain, Ports, DynDNS)

Willst du dir Domain, Port-Weiterleitung und DynDNS komplett sparen? Tailscale spannt ein privates, verschlüsseltes Netz zwischen deinen Geräten. Du installierst es auf dem Server und dem Handy — und erreichst VDS von überall, als wärst du zuhause. Kostenlos für Privatgebrauch, kein Router-Gefummel.

1. Auf dem Server: curl -fsSL https://tailscale.com/install.sh | sh, dann sudo tailscale up (einmal im Browser einloggen).
2. Tailscale-App aufs Handy laden, mit demselben Konto anmelden.
3. VDS am Handy öffnen unter http://<Tailscale-IP-des-Servers>:8766 (die IP zeigt die Tailscale-App).

Und dann: aufs Handy holen

Egal welcher Weg — sobald VDS unter deiner https://…-Adresse läuft, öffnest du sie am Handy und installierst die App:

• iPhone: in Safari öffnen → Teilen-Symbol → „Zum Home-Bildschirm".
• Android: in Chrome öffnen → Menü (⋮) → „App installieren".

Fertig — Vorratsdatenspeicher liegt als eigenes Icon auf dem Startbildschirm und fühlt sich an wie eine native App. Im Heim-WLAN kannst du übrigens auch einfach die lokale Adresse http://<IP>:8766 nutzen; die Domain brauchst du nur für unterwegs.

🧠Welche KI braucht VDS?

VDS liest deine Kassenbons mit KI, sortiert Artikel in Kategorien und beantwortet deine Fragen zur Statistik. Dafür brauchst du einen Zugang — entweder einen Schlüssel bei einem Anbieter (kostet ein paar Cent) oder ein Modell, das komplett auf deinem eigenen Rechner läuft (kostenlos).

Claude (Anthropic) — beste Beleg-Erkennung

Liest Fotos von Kassenbons am zuverlässigsten und kann auch alles andere. Rechne mit etwa 1–2 Cent pro Beleg.

• Schlüssel holen bei console.anthropic.com und ein kleines Guthaben aufladen.
• In VDS beim Einrichtungs-Assistenten auf Claude tippen und den Schlüssel einfügen — fertig, VDS wählt das passende Modell selbst.

ChatGPT (OpenAI) — der bekannte Name

Funktioniert genauso für Belege, Kategorien und Statistik-Fragen. Preislich ähnlich, oft etwas günstiger.

• Schlüssel holen bei platform.openai.com, Guthaben aufladen.
• In VDS auf ChatGPT tippen, Schlüssel einfügen — auch hier sucht VDS das Modell selbst aus.

Ollama — komplett lokal, kostenlos, privat

Läuft auf deiner eigenen Hardware. Kein Schlüssel, keine Cloud, kein Bild verlässt dein Gerät. Dafür braucht es etwas Leistung (gut: 16 GB RAM aufwärts, mit Grafikkarte deutlich schneller).

• Ollama installieren.
• Zwei Modelle laden: ollama pull mistral-small3.2 (liest Belege) und ollama pull qwen2.5:14b (alles andere).
• In VDS auf Ollama tippen und die Adresse eintragen, meist http://host.docker.internal:11434.

Fürs Belege-Lesen braucht Ollama ein Vision-Modell. mistral-small3.2 erreicht in unseren Tests rund 98 % der Genauigkeit eines großen Cloud-Modells — komplett offline. Sparsamer: llava oder minicpm-v.

🤖Lass dich von der KI durchlotsen

Das Wichtigste zuerst: Du musst nichts davon auswendig können. ChatGPT und Gemini sind unendlich geduldige Lehrer, die jeden einzelnen Schritt mit dir durchgehen, jeden Begriff erklären und bei jeder Fehlermeldung genau sagen, was zu tun ist. Nutze sie ohne Scham — genau dafür sind sie da.

So startest du das Gespräch

Ich möchte die Open-Source-App „Vorratsdatenspeicher" selbst hosten. Sie läuft in Docker und startet mit „docker compose up -d". Mein Gerät: [Windows-Laptop / Mac / alter PC mit Ubuntu / Hetzner-VPS mit Ubuntu]. Ich bin absoluter Anfänger und hatte noch nie mit Servern zu tun, aber ich will es lernen. Führe mich bitte GANZ langsam Schritt für Schritt, erkläre jeden Begriff, warte nach jedem Schritt auf meine Rückmeldung und frag nach, wenn du eine Information von mir brauchst. Fangen wir bei Null an.

Bei jeder Fehlermeldung

Egal was rot wird: kopiere die komplette Meldung in den Chat und schreib dazu: „Was bedeutet das und wie behebe ich es?" — In 9 von 10 Fällen bist du damit in einer Minute weiter.

✅Und danach?

• Passwort ändern und den Einrichtungs-Assistenten durchklicken (Haushalt, KI-Anbieter, Kategorien). Der Assistent erklärt alles direkt in der App.
• KI zum Belege-Lesen wählen: Anthropic (Claude) oder OpenAI (ein paar Cent pro Beleg) — oder komplett lokal & kostenlos mit Ollama, dann verlässt kein Bild deinen Rechner.
• Aufs Handy holen & Push: Der Onboarding-Coach in der App zeigt dir das genau, wenn es so weit ist.
• Updates: Ein Klick im „Update verfügbar"-Banner (mit dem optionalen Updater-Zusatz) oder der Befehl docker compose pull && docker compose up -d im selben Ordner.

💬Häufige Fragen

Muss der Rechner wirklich immer an sein?

Ja — solange er aus ist, ist die App offline (deine Daten bleiben aber gespeichert). Ein alter Laptop oder ein Mini-PC ist ideal: leise, sparsam, immer erreichbar. Ein gemieteter Server läuft ohnehin rund um die Uhr.

Ist das sicher?

Deine Daten liegen ausschließlich bei dir. Für den Zugriff von außen gilt: eine Domain mit HTTPS und ein starkes Passwort — beides deckt diese Anleitung ab. Zuhause im WLAN brauchst du nicht mal das.

Was kostet mich das?

Zuhause: nur Strom (ein paar Euro im Jahr). Ein VPS: ab etwa 4 €/Monat. Die App selbst ist kostenlos und quelloffen (AGPL-3.0).

Ich stecke fest und die KI hilft nicht weiter.

Schreib eine Mail an webmaster@vorratsdatenspeicher.com — am besten mit der genauen Fehlermeldung und deinem Weg (Windows / Mac / Linux / VPS).