---
title: "Installation"
description: "Ein einziges Docker-Image stellt API, MCP und Weboberfläche auf Port 3000 bereit; ein einziges /data-Volume hält den gesamten Zustand."
---

# Installation

Notarium wird als **ein einziges, in sich geschlossenes Image** ausgeliefert: Ein einzelner Node-Prozess bedient die REST-API, den MCP-Endpunkt für Agenten und die kompilierte Weboberfläche auf einem einzigen Port (standardmäßig `3000`). Externe Dienste braucht es nicht — keine Datenbank, keinen Message-Broker, keine separate Suchmaschine: Die Wissens-Engine läuft im selben Prozess. Der gesamte Zustand liegt in einem einzigen `/data`-Volume: die Metadaten-Datenbank, die abgeleiteten Indizes, deine Markdown-Dateien (die Quelle der Wahrheit) und die Export-Artefakte.

> [!note] Was du brauchst
> Nur **Docker** (oder Docker Desktop) und einen freien Port. Node, eine Datenbank oder einen Vektor-Index musst du nicht separat installieren — alles steckt im Image.

## Das Image starten

Am schnellsten geht es, einen Container aus dem fertigen Image hochzufahren:

```bash
docker run -d --name notarium \
  -p 3000:3000 \
  -v notarium-data:/data \
  docouno/notarium:latest
```

Ein einziges `/data`-Volume hält den gesamten Zustand: die Metadaten-Datenbank, die Indizes, deine Notizen und die Export-Artefakte. Mehr ist nicht einzustellen — Port `3000` und der Datenpfad `/data` stecken bereits im Image. Das Volume übersteht das Neuanlegen des Containers; den Port links von `:3000` kannst du auf jeden freien Port ändern.

Einen Befehl musst du an `docker run` nicht anhängen: Der Entrypoint des Images ist die eingebaute CLI `notarium`, und standardmäßig führt sie `start` aus. Dieselbe CLI bringt die Betreiberbefehle mit — `backup`, `restore`, `admin`, `healthcheck`, `version`. Siehe [Image-CLI](/docs/self-hosting/cli/).

## Mit Docker Compose

Für eine Instanz, die dauerhaft bleiben soll, ist eine Compose-Datei die bequemere Wahl: leichter zu bearbeiten und leichter unter Versionskontrolle zu halten — und `restart` holt den Container nach einem Neustart des Hosts zurück.

```yaml
services:
  notarium:
    image: docouno/notarium:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - notarium-data:/data

volumes:
  notarium-data:
```

Speichere das Ganze als `compose.yaml` und fahre es mit `docker compose up -d` hoch. Das benannte Volume `notarium-data` existiert unabhängig vom Container: `docker compose down` lässt es unangetastet, gelöscht wird es nur durch ein ausdrückliches `docker volume rm`.

> [!note] Einstellungen gehören ebenfalls hierher
> Umgebungsvariablen setzt du im `environment:`-Block des Service. Hältst du sie lieber in einer eigenen Datei, ergänze dort zusätzlich die Zeile `env_file: .env` — eine `.env`-Datei neben der Compose-Datei erreicht den Container von allein **nicht**: Docker Compose setzt sie nur in den Text der Compose-Datei selbst ein. Die vollständige Liste — [Umgebungsvariablen](/docs/reference/environment-variables/).

## Erster Start

Öffne `http://localhost:3000` — es begrüßt dich der **Setup-Bildschirm beim ersten Start**. Standardmäßig läuft die Instanz im Modus `password`, und der erste Besucher legt den **Eigentümer** an — das einzige Konto mit Administratorrechten und Eigentümerschaft an den von ihm erstellten Spaces. Ein voreingestelltes Passwort gibt es nicht; sobald sich der Eigentümer registriert hat, schließt sich das Setup endgültig. Mehr zu den Modi auf der Seite [Authentifizierung](/docs/self-hosting/authentication/).

## Daten-Volumes

| Volume | Was es enthält | Art |
|---|---|---|
| `/data` | Deine Markdown-Dateien (`/data/spaces`, ein Ordner pro Space), die Metadaten-Datenbank (`/data/meta.db` — Identifikatoren, Versionsverlauf, Benutzer, Zugriffe), die abgeleiteten Indizes der Engine (`/data/engine`) und die Export-Artefakte. | Dateien sind die Quelle der Wahrheit (das File-first-Prinzip); die Metadaten-Datenbank lässt sich nicht aus den Dateien ableiten; die Indizes sind abgeleitet und werden durch einen Neuaufbau wiederhergestellt. |

Schütze das Volume selbst: Geht es verloren, gehen deine Daten mit. Sind die Indizes in `/data/engine` verloren, werden sie aus den Dateien neu aufgebaut — die Metadaten-Datenbank (`/data/meta.db` — Verlauf, Benutzer, Zugriffe) und die Notizen selbst (`/data/spaces`) lassen sich dagegen nirgendwoher wiederherstellen; ihr Backup ist Pflicht. Wie du ein verifiziertes Backup ziehst, ohne den Dienst anzuhalten, steht unter [Backup und Wiederherstellung](/docs/self-hosting/backup/).

## Aus dem Quellcode bauen

Wenn du mit dem Notarium-Repository arbeitest, ist `make` der einheitliche Einstiegspunkt für Docker:

```bash
cp .env.example .env   # die Defaults funktionieren — nichts auszufüllen
make up                # Prod-Image lokal → http://localhost:3000
make dev               # Dev-Stack mit Hot-Reload (HMR)
```

Praktische Befehle: `make logs` (Logs), `make ps` (Status), `make down` (stoppen und entfernen), `make sh` (Shell im Container).

## Installation ohne Registry (air-gapped)

Für die Bereitstellung in einer isolierten Umgebung lässt sich das Image als Datei übertragen, ohne Zugriff auf eine Registry:

```bash
make image                              # Image bauen
make save                               # Export nach notarium-<version>.tar.gz
# das Archiv auf den Zielhost übertragen, dann:
docker load < notarium-<version>.tar.gz # Image laden
```

Starte es dort mit deinem eigenen `compose`/`.env` — die Registry-Koordinate steckt nicht fest im Image.

Der nächste Schritt ist, die Instanz an deine Bedürfnisse anzupassen: siehe [Konfiguration](/docs/self-hosting/configuration/).