LocalEye

Loqari

Loqari ist ein selbst gehosteter Telegram-Assistent mit KI-Anbindung. Er liest deine Termine und E-Mails aus verbundenen Konten (Google, Microsoft 365, CalDAV, IMAP, ICS-Abos) und schickt sie als kompaktes Briefing per Telegram.

Jetzt kaufen

Loqari – Installationsanleitung

Self-hosted Docker-Container, der Kalender + Mails mit einem Telegram-Bot und KI verbindet.

Diese Anleitung beschreibt die Installation und Erstkonfiguration auf allen gängigen Plattformen: Linux, macOS, Windows (Docker Desktop / WSL2), Synology DSM, UGREEN NAS, QNAP, Unraid, TrueNAS Scale sowie Kubernetes.

---

Inhaltsverzeichnis

  1. Voraussetzungen
  2. Schnellstart (alle Plattformen)
  3. Linux
  4. macOS
  5. Windows (Docker Desktop + WSL2)
  6. Synology DSM (Container Manager)
  7. UGREEN NAS (DXP-Serie / UGOS Pro)
  8. QNAP (Container Station)
  9. Unraid
  10. TrueNAS Scale
  11. Kubernetes
  12. Reverse Proxy einrichten
  13. Erste Schritte nach der Installation
  14. Update / Upgrade
  15. Backup & Restore
  16. Deinstallation
  17. Troubleshooting

---

1. Voraussetzungen

| Komponente | Mindestversion | Hinweis | | ---------- | -------------- | ------- | | Docker Engine | 24.x | mit Compose-Plugin (docker compose, nicht docker-compose) | | RAM | 256 MB frei | App-Container selbst ist sehr leicht | | Disk | ~300 MB | Image + Daten | | CPU | beliebig (x86_64 oder ARM64) | | | Netzwerk | ausgehend zu Telegram, Google, Microsoft, OpenAI, Anthropic, Gemini | je nachdem, welche Provider genutzt werden | | Optional | Ollama auf Host oder im Netz | nur bei Nutzung lokaler KI | | Port | 47840 (Standard) | frei wählbar in .env |

Hinweis zu lokaler KI (Ollama): Loqari kommuniziert per HTTP mit einer existierenden Ollama-Instanz. Ollama wird nicht im Container mitgeliefert – Standard ist host.docker.internal:11434 (Host-Ollama).

---

2. Schnellstart (alle Plattformen)

# 1. Beliebiges Verzeichnis wählen, z.B. /opt/loqari oder ~/docker/loqari
mkdir -p ~/docker/loqari && cd ~/docker/loqari

# 2. ZIP entpacken (oder Repo clonen)
unzip /pfad/zu/loqari_release.zip

# 3. Starten
chmod +x manage.sh
./manage.sh up

Beim ersten Start erzeugt manage.sh automatisch eine .env mit erkannten Werten (UID, GID, Zeitzone) und baut das Image.

Web-UI: http://<host>:47840/ Login: admin / admin → sofort in der UI ändern.

---

3. Linux (Debian / Ubuntu / Fedora / Arch / RHEL)

3.1. Docker installieren (falls noch nicht vorhanden)

Debian / Ubuntu:

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

Fedora / RHEL / CentOS Stream:

sudo dnf install -y dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

Arch / Manjaro:

sudo pacman -S docker docker-compose
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

Test:

docker version
docker compose version
3.2. Loqari installieren
sudo mkdir -p /opt/loqari
sudo chown $USER:$USER /opt/loqari
cd /opt/loqari
unzip /pfad/zu/loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

manage.sh erkennt automatisch:

  • PUID aus id -u
  • PGID aus id -g
  • TZ aus /etc/timezone oder /etc/localtime

und legt sie in .env ab.

3.3. Als systemd-Dienst (optional, Auto-Start beim Boot)

docker compose mit restart: unless-stopped startet bereits automatisch nach Reboot. Ein zusätzlicher systemd-Service wird nicht benötigt. Falls explizit gewünscht:

sudo tee /etc/systemd/system/loqari.service > /dev/null << 'EOF'
[Unit]
Description=Loqari Docker Compose
Requires=docker.service
After=docker.service network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/opt/loqari
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now loqari

---

4. macOS

4.1. Docker Desktop installieren
  1. Docker Desktop für Mac herunterladen (Apple Silicon oder Intel).
  2. Installieren und starten.
  3. In den Einstellungen → Resources mindestens 1 GB RAM zuweisen (Default reicht meist).
4.2. Loqari installieren

Im Terminal:

mkdir -p ~/docker/loqari && cd ~/docker/loqari
unzip ~/Downloads/loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

Bekannte macOS-Spezifika:

  • host.docker.internal funktioniert nativ (für Ollama-Anbindung an Host).
  • Volumes liegen im Mac-Filesystem – Performance ist auf Apple Silicon sehr gut.
  • Bei Problemen mit Datei-Permissions: manage.sh setzt automatisch korrekte UID/GID in .env.

---

5. Windows (Docker Desktop + WSL2)

5.1. WSL2 + Docker Desktop installieren
  1. WSL2 aktivieren (PowerShell als Admin):
wsl --install

Reboot, danach Ubuntu (oder eine andere Distro) aus dem Microsoft Store installieren.

  1. Docker Desktop für Windows installieren.
  2. In den Docker-Desktop-Settings → General → „Use the WSL2 based engine" aktivieren.
  3. Resources → WSL Integration → die installierte Distro (Ubuntu) aktivieren.
5.2. Loqari installieren (innerhalb WSL2)

Wir empfehlen, Loqari innerhalb der WSL2-Distro zu installieren, nicht direkt unter Windows. Das erspart Probleme mit Dateirechten und Line-Endings.

In Ubuntu (WSL):

mkdir -p ~/docker/loqari && cd ~/docker/loqari
# ZIP nach WSL kopieren, z.B. via Explorer-Pfad \\wsl$\Ubuntu\home\<user>\docker\loqari\
unzip loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

Web-UI: vom Windows-Host aus erreichbar unter http://localhost:47840/.

5.3. Direkt unter Windows ohne WSL (nicht empfohlen)

Falls erforderlich, geht es auch in PowerShell, aber mit Einschränkungen (Zeilenenden, fehlendes id, fehlendes chmod):

cd C:\loqari
# .env manuell anlegen mit:
#   TZ=Europe/Berlin
#   PUID=1000
#   PGID=1000
#   PORT=47840
docker compose up -d --build

---

6. Synology DSM (Container Manager)

Container Manager ist auf DSM 7.2+ verfügbar (vorher „Docker"-Paket). Funktional identisch.
6.1. Vorbereitung
  1. Paketzentrum → Container Manager installieren.
  2. Per File Station einen Ordner anlegen, z.B. /docker/loqari.
  3. ZIP per File Station hochladen und entpacken (Rechtsklick → Extrahieren).
  4. SSH aktivieren (DSM → Systemsteuerung → Terminal & SNMP → SSH-Dienst aktivieren).
6.2. Installation per SSH (empfohlen)
ssh admin@<nas-ip>
cd /volume1/docker/loqari   # oder dein gewählter Pfad
chmod +x manage.sh entrypoint.sh
sudo ./manage.sh up
6.3. Alternativ: Container Manager UI
  1. Projekt erstellen → Pfad auf /docker/loqari setzen.
  2. Quelle: „docker-compose.yml in diesem Ordner" wählen.
  3. .env manuell anlegen mit:
TZ=Europe/Berlin
PUID=1026
PGID=100
PORT=47840
Synology nutzt Standard-UID 1026 für Admin und GID 100 (Gruppe users). Mit id <user> per SSH genau ermitteln.
  1. Erstellen + Starten.
6.4. Reverse Proxy (DSM)

Systemsteuerung → Anmeldeportal → Erweitert → Reverse Proxy → Erstellen:

| Feld | Wert | | ---- | ---- | | Beschreibung | Loqari | | Quelle | HTTPS, loqari.deine-domain.tld, Port 443 | | Ziel | HTTP, localhost, Port 47840 | | Custom Header → WebSocket | „Erstellen" → WebSocket aktivieren |

Anschließend in der Loqari-UI „Allgemein → Public Base URL" auf https://loqari.deine-domain.tld setzen.

---

7. UGREEN NAS (DXP-Serie / UGOS Pro)

7.1. Vorbereitung
  1. App Center → Docker / Container Manager installieren.
  2. SSH aktivieren (UGOS → Systemeinstellungen → Terminal → SSH).
  3. Verzeichnis anlegen, z.B. /volume3/docker/loqari (Pfad je nach Volume-Layout).
7.2. Installation per SSH
ssh fabian@<nas-ip>
cd /volume3/docker/loqari
unzip loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

manage.sh erkennt deine UID/GID automatisch (auf UGREEN typisch uid=1000 (fabian), gid=10 (admin)).

7.3. Container Manager UI

Falls bevorzugt, kannst du das Projekt auch über die UI als Compose-Stack importieren:

  1. Container Manager → Projekt → Import → Compose-Datei wählen.
  2. .env daneben legen mit TZ, PUID, PGID, PORT.
  3. Bauen + Starten.
7.4. Hinweise
  • Zugriff: http://<nas-ip>:47840/
  • Für externe Erreichbarkeit: Reverse Proxy (z.B. Nginx Proxy Manager auf gleichem NAS, siehe Abschnitt 12).

---

8. QNAP (Container Station)

  1. App Center → Container Station installieren.
  2. SSH aktivieren (QTS → Systemsteuerung → Telnet/SSH).
  3. Verzeichnis: z.B. /share/Container/loqari.
ssh admin@<nas-ip>
cd /share/Container/loqari
unzip loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

QNAP-Hinweis: UID/GID des Container-Station-Users ist meist admin/administrators (UID 0 / GID 0). manage.sh setzt entsprechend PUID=0, was funktioniert, aber Daten gehören dann root. Für saubere Trennung einen eigenen User mit fester UID/GID anlegen.

Alternativ: in Container Station → Anwendungen → Erstellen → Compose-Datei einfügen.

---

9. Unraid

9.1. Compose Manager (empfohlen)
  1. Unraid Plugin Compose Manager installieren (Community Apps).
  2. Apps → Compose Manager → Add new stack → „loqari".
  3. Inhalt von docker-compose.yml einfügen.
  4. Im Stack-Verzeichnis (/boot/config/plugins/compose.manager/projects/loqari/) .env anlegen:
TZ=Europe/Berlin
PUID=99
PGID=100
PORT=47840
Unraid Standard-User: UID 99 (nobody), GID 100 (users).
  1. Stack starten.
9.2. Datenpfad

Der Volume-Mount ./data:/data zeigt standardmäßig auf /boot/config/plugins/compose.manager/projects/loqari/data. Empfehlung: stattdessen in der Compose-Datei explizit auf einen Array-Pfad mappen, z.B. /mnt/user/appdata/loqari:/data, damit das boot-Filesystem klein bleibt:

volumes:
  - /mnt/user/appdata/loqari:/data

---

10. TrueNAS Scale

TrueNAS Scale (≥ 24.10 „Electric Eel") nutzt nativ Docker. Einfachster Weg über die App-Verwaltung als „Custom App":

  1. Apps → Discover Apps → Custom App.
  2. Im YAML-Bereich docker-compose.yml-Inhalt einfügen.
  3. Volume data auf einen Dataset-Pfad mappen, z.B. /mnt/tank/apps/loqari/data.
  4. Environment-Variablen TZ, PUID, PGID, PORT direkt setzen.

Alternativ klassisch per SSH wie unter Linux.

---

11. Kubernetes

Für produktive K8s-Deployments wird kein offizielles Helm-Chart mitgeliefert. Loqari ist ein einzelner stateful Container, ein einfaches Manifest reicht:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loqari
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: loqari
  template:
    metadata:
      labels:
        app: loqari
    spec:
      containers:
      - name: loqari
        image: loqari:latest
        imagePullPolicy: IfNotPresent
        env:
        - name: TZ
          value: "Europe/Berlin"
        - name: PUID
          value: "1000"
        - name: PGID
          value: "1000"
        - name: DATA_DIR
          value: "/data"
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: data
          mountPath: /data
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 30
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: loqari-data
---
apiVersion: v1
kind: Service
metadata:
  name: loqari
spec:
  selector:
    app: loqari
  ports:
  - port: 80
    targetPort: 8000
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: loqari-data
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 1Gi

Wichtig:

  • Image vorher selbst bauen (docker build -t loqari:latest .) und in eine Registry pushen.
  • replicas: 1 erzwingen – Loqari ist nicht für horizontale Skalierung ausgelegt (lokaler State, einzelner Telegram-Bot pro User, einzelner Scheduler).
  • Ingress mit aktivierten WebSockets davorschalten.

---

12. Reverse Proxy einrichten

Loqari verlangt keinen internen TLS-Endpoint, läuft aber dennoch problemlos hinter einem Reverse Proxy (NPM, Traefik, Caddy, nginx, HAProxy). Für OAuth (Google/Microsoft) ist eine extern erreichbare HTTPS-URL erforderlich.

12.1. Nginx Proxy Manager (NPM)
  1. Proxy Hosts → Add Proxy Host:

| Feld | Wert | | ---- | ---- | | Domain Names | loqari.example.com | | Scheme | http | | Forward Hostname / IP | <docker-host-ip> oder Container-Name (wenn NPM im selben Docker-Netz) | | Forward Port | 47840 | | Cache Assets | aus | | Block Common Exploits | aus | | Websockets Support | an |

  1. SSL-Tab → Let's Encrypt → DNS oder HTTP-Challenge → Force SSL aktivieren.
  2. In Loqari-UI: Einstellungen → Allgemein → Public Base URL = https://loqari.example.com.
12.2. Traefik (Compose-Labels)

Falls Loqari im selben Compose-Stack mit Traefik läuft:

services:
  loqari:
    # ... bestehende Definition ...
    labels:
      - traefik.enable=true
      - traefik.http.routers.loqari.rule=Host(`loqari.example.com`)
      - traefik.http.routers.loqari.entrypoints=websecure
      - traefik.http.routers.loqari.tls.certresolver=letsencrypt
      - traefik.http.services.loqari.loadbalancer.server.port=8000
12.3. Caddy

Caddyfile:

loqari.example.com {
    reverse_proxy localhost:47840
}

Caddy unterstützt WebSockets automatisch und holt Let's-Encrypt-Zertifikate selbst.

12.4. Plain nginx
server {
    listen 443 ssl http2;
    server_name loqari.example.com;

    ssl_certificate     /etc/letsencrypt/live/loqari.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/loqari.example.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:47840;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host  $host;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    }
}
12.5. Public Base URL nach Reverse Proxy setzen

Loqari erkennt eingehende X-Forwarded-Proto / X-Forwarded-Host automatisch und setzt beim ersten Zugriff die public_base_url selbst, falls noch der Default http://localhost:47840 aktiv ist.

Wenn die UI bereits eine andere public_base_url hat oder du sie manuell überschreiben möchtest:

UI → Einstellungen → Allgemein → Public Base URL = z.B. https://loqari.example.com → Speichern.

Diese URL wird für die OAuth-Redirects (Google, Microsoft) verwendet – sie muss mit den dort eingetragenen Redirect-URIs übereinstimmen, sonst schlägt der OAuth-Flow fehl.

---

13. Erste Schritte nach der Installation

Reihenfolge, sobald die UI unter http://<host>:47840/ erreichbar ist.

13.1. Login ändern
  1. Login mit admin / admin.
  2. Banner ganz oben warnt vor Default-Login.
  3. Einstellungen → Login & Passwort → neuen Benutzernamen + Passwort setzen → Speichern.
13.2. Public Base URL prüfen

Einstellungen → Allgemein. Wenn du hinter einem Reverse Proxy bist und die externe URL korrekt ist, wird sie meist automatisch erkannt (X-Forwarded-* Header). Andernfalls manuell setzen.

13.3. Telegram-Bot anlegen
  1. In Telegram: @BotFather öffnen → /newbot → Name + Username vergeben → HTTP-API-Token kopieren.
  2. Loqari-UI → Einstellungen → Telegram & Briefing → Bot-Token einfügen → Speichern.
  3. Im Bot: /start schicken, dann /id → die zurückgegebene User-ID kopieren.
  4. UI → „Erlaubte User-IDs" mit der User-ID füllen (mehrere komma-separiert) → Speichern.
Bot startet automatisch neu, sobald der Token in der UI geändert wird.
13.4. KI-Provider wählen

Einstellungen → KI-Auswahl → Provider wählen:

  • Ollama (lokal, kostenlos): Modell vorher per UI pullen (z.B. llama3.1:8b).
  • OpenAI: erst unter „KI-API-Keys" (Admin) den Key setzen, dann hier Modell wählen.
  • Anthropic (Claude): erst Key setzen, dann Modell wählen.
  • Gemini (Google): erst Key setzen, dann Modell wählen.
13.5. Erstes Konto verbinden

Einstellungen → Hinzufügen. Optionen:

  • CalDAV (NextCloud, Posteo, Mailbox.org, iCloud-CalDAV …)
  • IMAP (jede Mailbox)
  • ICS (read-only abonnieren)
  • Google (Gmail + Kalender, OAuth – Admin muss vorher Client-ID + Secret hinterlegen)
  • Microsoft (Outlook + Kalender, OAuth – Admin muss vorher Client-ID + Secret hinterlegen)

Nach dem Anlegen unter „Test" überprüfen, ob die Verbindung funktioniert.

13.6. Briefing aktivieren (optional)
  1. UI → Telegram & Briefing → Briefing-Zeitplan: mindestens ein Zeitfenster anlegen (Wochentage, Von/Bis, Update-Intervall).
  2. „Zeitplan aktiviert" Checkbox setzen, Speichern.
  3. In Telegram im gewünschten Chat (privat oder Gruppe): /briefing_on senden.

---

14. Update / Upgrade

cd /pfad/zu/loqari

# 1. Backup machen
tar -czf ~/loqari-backup-$(date +%F).tgz data/

# 2. Container stoppen
./manage.sh down

# 3. Neue Version entpacken (überschreibt Code, NICHT data/)
unzip -o /pfad/zu/loqari_release_neu.zip

# 4. Image neu bauen + starten
./manage.sh rebuild

manage.sh rebuild führt ein docker compose down --rmi all && docker compose up -d --build aus. Dadurch wird das Image komplett neu gebaut.

Migrationen der config.json laufen automatisch beim Start (Single-User → Multi-User, Legacy-Briefing-Felder → Window-Schema).

---

15. Backup & Restore

Alle persistenten Daten liegen in ./data/:

| Datei | Inhalt | | ----- | ------ | | config.json | Globale Einstellungen, alle User, Telegram-Tokens, KI-API-Keys, OAuth-Apps, Secret Key | | accounts.json | Hinterlegte Kalender-/Mail-Accounts inkl. OAuth-Refresh-Tokens, IMAP-/CalDAV-Passwörtern | | briefing_chats.json | Pro User die Telegram-Chats mit aktiviertem Briefing | | state.json | Briefing-Sende-Status (welcher Chat hat heute schon ein Briefing erhalten) |

config.json und accounts.json enthalten alle Geheimnisse im Klartext. Backup entsprechend verschlüsselt ablegen.

15.1. Backup
tar -czf loqari-backup-$(date +%F).tgz -C /pfad/zu/loqari data/
15.2. Restore
cd /pfad/zu/loqari
./manage.sh down
rm -rf data/
tar -xzf loqari-backup-2025-12-01.tgz
./manage.sh up
15.3. Backup automatisieren (Beispiel-Cron)
crontab -e
# tägliches Backup um 03:00, 14 Tage Aufbewahrung
0 3 * * * tar -czf /backup/loqari-$(date +\%F).tgz -C /opt/loqari data/ && find /backup -name 'loqari-*.tgz' -mtime +14 -delete

---

16. Deinstallation

cd /pfad/zu/loqari
./manage.sh down
docker rmi loqari:latest
cd ..
rm -rf loqari/         # entfernt auch ./data ! Vorher Backup!

Oder nur Container weg, Daten behalten:

./manage.sh down
docker rmi loqari:latest

---

17. Troubleshooting

17.1. „Permission denied" beim Schreiben in /data

PUID/PGID in .env stimmen nicht mit dem Owner des data/-Verzeichnisses überein. Lösung:

sudo chown -R $(id -u):$(id -g) data/
./manage.sh restart

oder die Werte in .env anpassen.

17.2. Bot reagiert nicht
  1. Telegram-Bot-Token gespeichert? UI → Telegram & Briefing → Token sichtbar.
  2. Bot läuft? Logs prüfen: ./manage.sh logs → Zeile „Bot gestartet für User=…".
  3. Eigene User-ID in „Erlaubte User-IDs"? /id in Telegram aufrufen → mit Eintrag in der UI vergleichen.
  4. Token ungültig oder von einem anderen Bot? Logs zeigen Conflict: terminated by other getUpdates request oder Unauthorized.
17.3. Briefing kommt nicht
  • „Zeitplan aktiviert" Checkbox in der UI gesetzt?
  • Mindestens ein Zeitfenster konfiguriert?
  • Im Ziel-Chat /briefing_on ausgeführt?
  • Aktueller Zeitpunkt fällt in ein Fenster und triggert einen Slot? Slot-Logik: erster Slot = Window-Start = Tagesbriefing (1×/Tag); Folge-Slots im Intervall = Updates.
  • Tag passt? Wochentage im Fenster sind 0=Mo … 6=So.
  • Container-Zeitzone (TZ in .env) korrekt? Sonst sendet er gefühlt zu falscher Uhrzeit.
17.4. OAuth (Google/Microsoft) bricht ab
  • Public Base URL in der UI = exakt die externe HTTPS-URL?
  • Redirect-URI in Google Cloud Console / Azure App Registration = https://<deine-url>/oauth/google/callback bzw. /oauth/microsoft/callback?
  • Bei Google: kein refresh_token zurück → App-Berechtigung im Google-Konto manuell widerrufen (myaccount.google.com → Sicherheit → Drittanbieter-Apps) und erneut autorisieren. Loqari fordert beim Re-Consent automatisch einen neuen refresh_token an.
  • Bei Microsoft: Tenant in Loqari = common (private + Org-Konten), consumers (nur privat) oder konkrete Tenant-ID (nur eine Org)?
17.5. Ollama nicht erreichbar
  • UI → Einstellungen → KI-API-Keys → Ollama Base URL prüfen. Default: http://host.docker.internal:11434.
  • Bei Ollama auf einem anderen Host: dortige IP/URL eintragen.
  • Bei Ollama im selben Docker-Netz: Servicename eintragen, z.B. http://ollama:11434.
  • Test: curl http://host.docker.internal:11434/api/tags aus dem Loqari-Container heraus (docker exec -it loqari sh -c 'apt-get update && apt-get install -y curl && curl …').
17.6. „host.docker.internal" auflösen Linux-Hosts

Auf Linux ist host.docker.internal nicht out-of-the-box vorhanden. In docker-compose.yml ist deshalb gesetzt:

extra_hosts:
  - "host.docker.internal:host-gateway"

Das funktioniert mit Docker ≥ 20.10. Falls nicht: stattdessen die LAN-IP des Hosts eintragen (z.B. http://192.168.1.10:11434).

17.7. Container kommt nicht hoch (unhealthy / Restart-Loop)
  • Logs prüfen: ./manage.sh logs
  • Port 47840 schon belegt? ss -tlnp | grep 47840
  • Disk voll? df -h
  • data/ schreibbar? Permissions wie unter 17.1.
17.8. Default-Login-Banner verschwindet nicht

Banner zeigt sich nur, solange ein Admin-User die Kombi admin / admin hat. Sobald ein Admin geänderte Credentials hat, verschwindet der Banner. Bei mehreren Admins muss jeder Admin geändert sein.

17.9. Nach Image-Rebuild keine Verbesserung

Compose-Cache:

./manage.sh down
docker compose build --no-cache
docker compose up -d
17.10. Zeitzone falsch
  • .env: TZ=Europe/Berlin (oder passend) setzen.
  • manage.sh restart reicht. Bei Wechsel der TZ wird der Scheduler automatisch mit der neuen TZ instanziiert.

---

Anhang: Wichtige Dateien & Pfade

| Pfad (Host) | Inhalt | | ----------- | ------ | | ./.env | Plattform-Werte (TZ, PUID, PGID, PORT) | | ./docker-compose.yml | Compose-Definition | | ./Dockerfile | Image-Bauanweisungen | | ./entrypoint.sh | Container-Entrypoint, übernimmt UID/GID-Drop | | ./manage.sh | Helfer-Skript (up | down | rebuild | restart | logs | status) | | ./app/ | Python-Code | | ./data/ | persistente Daten (volume-gemountet auf /data im Container) |

| Pfad (Container) | Inhalt | | ---------------- | ------ | | /app/ | App-Code | | /data/ | Volume-Mount aus ./data | | /entrypoint.sh | Entrypoint |

---

Anhang: Standard-Ports

| Port | Funktion | | ---- | -------- | | 8000 (im Container) | Uvicorn / FastAPI Web-UI | | 47840 (Host, Default) | Mapping aus ${PORT} in .env | | 11434 (auf Host, optional) | Ollama API |

---

Fertig. Bei Problemen: erst ./manage.sh logs lesen, dann diese Anleitung nach Stichwort durchsuchen, dann ggf. Issue eröffnen.

Loqari – Installation Guide

Self-hosted Docker container that connects calendar + email with a Telegram bot and AI.

This guide describes installation and initial setup on all common platforms: Linux, macOS, Windows (Docker Desktop / WSL2), Synology DSM, UGREEN NAS, QNAP, Unraid, TrueNAS Scale, and Kubernetes.

---

Table of Contents

  1. Requirements
  2. Quick Start (all platforms)
  3. Linux
  4. macOS
  5. Windows (Docker Desktop + WSL2)
  6. Synology DSM (Container Manager)
  7. UGREEN NAS (DXP Series / UGOS Pro)
  8. QNAP (Container Station)
  9. Unraid
  10. TrueNAS Scale
  11. Kubernetes
  12. Set up Reverse Proxy
  13. First Steps After Installation
  14. Update / Upgrade
  15. Backup & Restore
  16. Uninstall
  17. Troubleshooting

---

1. Requirements

| Component | Minimum Version | Note | | --------- | --------------- | ---- | | Docker Engine | 24.x | with Compose plugin (docker compose, not docker-compose) | | RAM | 256 MB free | app container itself is very lightweight | | Disk | ~300 MB | image + data | | CPU | any (x86_64 or ARM64) | | | Network | outbound to Telegram, Google, Microsoft, OpenAI, Anthropic, Gemini | depending on which providers you use | | Optional | Ollama on host or in network | only when using local AI | | Port | 47840 (default) | freely selectable in .env |

Note on local AI (Ollama): Loqari communicates via HTTP with an existing Ollama instance. Ollama is not included in the container – default is host.docker.internal:11434 (host Ollama).

---

2. Quick Start (all platforms)

# 1. Choose any directory, e.g. /opt/loqari or ~/docker/loqari
mkdir -p ~/docker/loqari && cd ~/docker/loqari

# 2. Extract ZIP (or clone repo)
unzip /path/to/loqari_release.zip

# 3. Start
chmod +x manage.sh
./manage.sh up

On first start, manage.sh automatically creates a .env with detected values (UID, GID, timezone) and builds the image.

Web UI: http://<host>:47840/ Login: admin / admin → change immediately in the UI.

---

3. Linux (Debian / Ubuntu / Fedora / Arch / RHEL)

3.1. Install Docker (if not already installed)

Debian / Ubuntu:

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

Fedora / RHEL / CentOS Stream:

sudo dnf install -y dnf-plugins-core
sudo dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo
sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

Arch / Manjaro:

sudo pacman -S docker docker-compose
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

Test:

docker version
docker compose version
3.2. Install Loqari
sudo mkdir -p /opt/loqari
sudo chown $USER:$USER /opt/loqari
cd /opt/loqari
unzip /path/to/loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

manage.sh automatically detects:

  • PUID from id -u
  • PGID from id -g
  • TZ from /etc/timezone or /etc/localtime

and places them in .env.

3.3. As systemd service (optional, auto-start on boot)

docker compose with restart: unless-stopped already automatically restarts after reboot. An additional systemd service is not required. If explicitly desired:

sudo tee /etc/systemd/system/loqari.service > /dev/null << 'EOF'
[Unit]
Description=Loqari Docker Compose
Requires=docker.service
After=docker.service network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/opt/loqari
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now loqari

---

4. macOS

4.1. Install Docker Desktop
  1. Download Docker Desktop for Mac (Apple Silicon or Intel).
  2. Install and launch.
  3. In settings → Resources, assign at least 1 GB RAM (default is usually sufficient).
4.2. Install Loqari

In terminal:

mkdir -p ~/docker/loqari && cd ~/docker/loqari
unzip ~/Downloads/loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

Known macOS specifics:

  • host.docker.internal works natively (for Ollama binding to host).
  • Volumes reside in Mac filesystem – performance is excellent on Apple Silicon.
  • If issues with file permissions: manage.sh automatically sets correct UID/GID in .env.

---

5. Windows (Docker Desktop + WSL2)

5.1. Install WSL2 + Docker Desktop
  1. Enable WSL2 (PowerShell as Admin):
wsl --install

Reboot, then install Ubuntu (or another distro) from Microsoft Store.

  1. Install Docker Desktop for Windows.
  2. In Docker Desktop settings → General → "Use the WSL2 based engine" → enable.
  3. Resources → WSL Integration → enable the installed distro (Ubuntu).
5.2. Install Loqari (within WSL2)

We recommend installing Loqari within the WSL2 distro, not directly under Windows. This avoids file permission and line-ending issues.

In Ubuntu (WSL):

mkdir -p ~/docker/loqari && cd ~/docker/loqari
# Copy ZIP to WSL, e.g., via Explorer path \\wsl$\Ubuntu\home\<user>\docker\loqari\
unzip loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

Web UI: accessible from Windows host at http://localhost:47840/.

5.3. Directly under Windows without WSL (not recommended)

If required, it also works in PowerShell, but with limitations (line endings, missing id, missing chmod):

cd C:\loqari
# Create .env manually with:
#   TZ=Europe/Berlin
#   PUID=1000
#   PGID=1000
#   PORT=47840
docker compose up -d --build

---

6. Synology DSM (Container Manager)

Container Manager is available on DSM 7.2+ (previously "Docker" package). Functionally identical.
6.1. Preparation
  1. Package Center → install Container Manager.
  2. Via File Station, create a folder, e.g. /docker/loqari.
  3. Upload ZIP via File Station and extract (right-click → Extract).
  4. Enable SSH (DSM → Control Panel → Terminal & SNMP → enable SSH service).
6.2. Installation via SSH (recommended)
ssh admin@<nas-ip>
cd /volume1/docker/loqari   # or your chosen path
chmod +x manage.sh entrypoint.sh
sudo ./manage.sh up
6.3. Alternatively: Container Manager UI
  1. Create Project → set path to /docker/loqari.
  2. Source: select "docker-compose.yml in this folder".
  3. Create .env manually with:
TZ=Europe/Berlin
PUID=1026
PGID=100
PORT=47840
Synology uses standard UID 1026 for admin and GID 100 (group users). Determine exactly with id <user> via SSH.
  1. Create + Start.
6.4. Reverse Proxy (DSM)

Control Panel → Login Portal → Advanced → Reverse Proxy → Create:

| Field | Value | | ----- | ----- | | Description | Loqari | | Source | HTTPS, loqari.your-domain.tld, Port 443 | | Destination | HTTP, localhost, Port 47840 | | Custom Header → WebSocket | "Create" → enable WebSocket |

Then in Loqari UI, set "General → Public Base URL" to https://loqari.your-domain.tld.

---

7. UGREEN NAS (DXP Series / UGOS Pro)

7.1. Preparation
  1. App Center → install Docker / Container Manager.
  2. Enable SSH (UGOS → System Settings → Terminal → SSH).
  3. Create directory, e.g. /volume3/docker/loqari (path depends on volume layout).
7.2. Installation via SSH
ssh fabian@<nas-ip>
cd /volume3/docker/loqari
unzip loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

manage.sh automatically detects your UID/GID (on UGREEN typically uid=1000 (fabian), gid=10 (admin)).

7.3. Container Manager UI

If preferred, you can also import the project via UI as a Compose stack:

  1. Container Manager → Project → Import → select Compose file.
  2. Place .env alongside it with TZ, PUID, PGID, PORT.
  3. Build + Start.
7.4. Notes
  • Access: http://<nas-ip>:47840/
  • For external access: reverse proxy (e.g., Nginx Proxy Manager on same NAS, see section 12).

---

8. QNAP (Container Station)

  1. App Center → install Container Station.
  2. Enable SSH (QTS → Control Panel → Telnet/SSH).
  3. Directory: e.g. /share/Container/loqari.
ssh admin@<nas-ip>
cd /share/Container/loqari
unzip loqari_release.zip
chmod +x manage.sh entrypoint.sh
./manage.sh up

QNAP Note: UID/GID of Container Station user is usually admin/administrators (UID 0 / GID 0). manage.sh sets PUID=0 accordingly, which works, but then data is owned by root. For clean separation, create a separate user with fixed UID/GID.

Alternatively: in Container Station → Applications → Create → paste Compose file.

---

9. Unraid

9.1. Compose Manager (recommended)
  1. Install Unraid plugin Compose Manager (Community Apps).
  2. Apps → Compose Manager → Add new stack → "loqari".
  3. Paste content of docker-compose.yml.
  4. In stack directory (/boot/config/plugins/compose.manager/projects/loqari/) create .env:
TZ=Europe/Berlin
PUID=99
PGID=100
PORT=47840
Unraid standard user: UID 99 (nobody), GID 100 (users).
  1. Start stack.
9.2. Data path

The volume mount ./data:/data points by default to /boot/config/plugins/compose.manager/projects/loqari/data. Recommendation: instead, map explicitly to an array path in Compose, e.g. /mnt/user/appdata/loqari:/data, to keep the boot filesystem small:

volumes:
  - /mnt/user/appdata/loqari:/data

---

10. TrueNAS Scale

TrueNAS Scale (≥ 24.10 "Electric Eel") natively supports Docker. Easiest via app management as "Custom App":

  1. Apps → Discover Apps → Custom App.
  2. In YAML section, paste docker-compose.yml content.
  3. Map volume data to a dataset path, e.g. /mnt/tank/apps/loqari/data.
  4. Set environment variables TZ, PUID, PGID, PORT directly.

Alternatively, classically via SSH like under Linux.

---

11. Kubernetes

For productive K8s deployments, no official Helm chart is provided. Loqari is a single stateful container; a simple manifest suffices:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loqari
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: loqari
  template:
    metadata:
      labels:
        app: loqari
    spec:
      containers:
      - name: loqari
        image: loqari:latest
        imagePullPolicy: IfNotPresent
        env:
        - name: TZ
          value: "Europe/Berlin"
        - name: PUID
          value: "1000"
        - name: PGID
          value: "1000"
        - name: DATA_DIR
          value: "/data"
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: data
          mountPath: /data
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 30
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: loqari-data
---
apiVersion: v1
kind: Service
metadata:
  name: loqari
spec:
  selector:
    app: loqari
  ports:
  - port: 80
    targetPort: 8000
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: loqari-data
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 1Gi

Important:

  • Build image yourself first (docker build -t loqari:latest .) and push to a registry.
  • Force replicas: 1 – Loqari is not designed for horizontal scaling (local state, single Telegram bot per user, single scheduler).
  • Place an ingress with WebSockets enabled in front.

---

12. Set up Reverse Proxy

Loqari does not require an internal TLS endpoint, but works seamlessly behind a reverse proxy (NPM, Traefik, Caddy, nginx, HAProxy). For OAuth (Google/Microsoft), an externally reachable HTTPS URL is required.

12.1. Nginx Proxy Manager (NPM)
  1. Proxy Hosts → Add Proxy Host:

| Field | Value | | ----- | ----- | | Domain Names | loqari.example.com | | Scheme | http | | Forward Hostname / IP | <docker-host-ip> or container name (if NPM in same Docker network) | | Forward Port | 47840 | | Cache Assets | off | | Block Common Exploits | off | | Websockets Support | on |

  1. SSL tab → Let's Encrypt → DNS or HTTP challenge → enable Force SSL.
  2. In Loqari UI: Settings → General → Public Base URL = https://loqari.example.com.
12.2. Traefik (Compose labels)

If Loqari is in the same Compose stack with Traefik:

services:
  loqari:
    # ... existing definition ...
    labels:
      - traefik.enable=true
      - traefik.http.routers.loqari.rule=Host(`loqari.example.com`)
      - traefik.http.routers.loqari.entrypoints=websecure
      - traefik.http.routers.loqari.tls.certresolver=letsencrypt
      - traefik.http.services.loqari.loadbalancer.server.port=8000
12.3. Caddy

Caddyfile:

loqari.example.com {
    reverse_proxy localhost:47840
}

Caddy supports WebSockets automatically and obtains Let's Encrypt certificates itself.

12.4. Plain nginx
server {
    listen 443 ssl http2;
    server_name loqari.example.com;

    ssl_certificate     /etc/letsencrypt/live/loqari.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/loqari.example.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:47840;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host  $host;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    }
}
12.5. Set Public Base URL after reverse proxy

Loqari automatically recognizes incoming X-Forwarded-Proto / X-Forwarded-Host and on first access sets the public_base_url itself if the default http://localhost:47840 is still active.

If the UI already has a different public_base_url or you want to override it manually:

UI → Settings → General → Public Base URL = e.g. https://loqari.example.com → Save.

This URL is used for OAuth redirects (Google, Microsoft) – it must match the redirect URIs registered there, otherwise the OAuth flow fails.

---

13. First Steps After Installation

Sequence once the UI is accessible at http://<host>:47840/.

13.1. Change login
  1. Log in with admin / admin.
  2. Banner at top warns about default login.
  3. Settings → Login & Password → set new username + password → Save.
13.2. Check Public Base URL

Settings → General. If you are behind a reverse proxy and the external URL is correct, it is usually detected automatically (X-Forwarded-* headers). Otherwise, set manually.

13.3. Create Telegram bot
  1. In Telegram: open @BotFather → /newbot → enter name + username → copy HTTP API token.
  2. Loqari UI → Settings → Telegram & Briefing → paste bot token → Save.
  3. In the bot: send /start, then /id → copy the returned user ID.
  4. UI → "Allowed User IDs" → fill with the user ID (multiple comma-separated) → Save.
Bot automatically restarts once token is changed in UI.
13.4. Choose AI provider

Settings → AI Selection → choose provider:

  • Ollama (local, free): pull model first via UI (e.g. llama3.1:8b).
  • OpenAI: first set key under "AI API Keys" (admin), then choose model here.
  • Anthropic (Claude): first set key, then choose model.
  • Gemini (Google): first set key, then choose model.
13.5. Connect first account

Settings → Add. Options:

  • CalDAV (NextCloud, Posteo, Mailbox.org, iCloud CalDAV …)
  • IMAP (any mailbox)
  • ICS (read-only subscribe)
  • Google (Gmail + Calendar, OAuth – admin must first enter Client ID + secret)
  • Microsoft (Outlook + Calendar, OAuth – admin must first enter Client ID + secret)

After creating, check under "Test" whether connection works.

13.6. Enable Briefing (optional)
  1. UI → Telegram & Briefing → Briefing Schedule: create at least one time window (weekdays, from/to, update interval).
  2. Check "Schedule enabled", Save.
  3. In Telegram, in desired chat (private or group): send /briefing_on.

---

14. Update / Upgrade

cd /path/to/loqari

# 1. Make backup
tar -czf ~/loqari-backup-$(date +%F).tgz data/

# 2. Stop container
./manage.sh down

# 3. Extract new version (overwrites code, NOT data/)
unzip -o /path/to/loqari_release_new.zip

# 4. Rebuild image + start
./manage.sh rebuild

manage.sh rebuild runs docker compose down --rmi all && docker compose up -d --build. This completely rebuilds the image.

Migrations of config.json run automatically on start (single-user → multi-user, legacy briefing fields → window schema).

---

15. Backup & Restore

All persistent data resides in ./data/:

| File | Content | | ---- | ------- | | config.json | Global settings, all users, Telegram tokens, AI API keys, OAuth apps, secret key | | accounts.json | Stored calendar/email accounts incl. OAuth refresh tokens, IMAP/CalDAV passwords | | briefing_chats.json | Per user, Telegram chats with briefing enabled | | state.json | Briefing send status (which chat has already received briefing today) |

config.json and accounts.json contain all secrets in plaintext. Store backups encrypted accordingly.

15.1. Backup
tar -czf loqari-backup-$(date +%F).tgz -C /path/to/loqari data/
15.2. Restore
cd /path/to/loqari
./manage.sh down
rm -rf data/
tar -xzf loqari-backup-2025-12-01.tgz
./manage.sh up
15.3. Automate backups (example cron)
crontab -e
# daily backup at 03:00, keep 14 days
0 3 * * * tar -czf /backup/loqari-$(date +\%F).tgz -C /opt/loqari data/ && find /backup -name 'loqari-*.tgz' -mtime +14 -delete

---

16. Uninstall

cd /path/to/loqari
./manage.sh down
docker rmi loqari:latest
cd ..
rm -rf loqari/         # removes ./data too! Backup first!

Or container only, keep data:

./manage.sh down
docker rmi loqari:latest

---

17. Troubleshooting

17.1. "Permission denied" writing to /data

PUID/PGID in .env don't match the owner of the data/ directory. Solution:

sudo chown -R $(id -u):$(id -g) data/
./manage.sh restart

or adjust values in .env.

17.2. Bot doesn't respond
  1. Telegram bot token saved? UI → Telegram & Briefing → token visible.
  2. Bot running? Check logs: ./manage.sh logs → line "Bot started for User=…".
  3. Your user ID in "Allowed User IDs"? Send /id in Telegram → compare with UI entry.
  4. Token invalid or from another bot? Logs show Conflict: terminated by other getUpdates request or Unauthorized.
17.3. Briefing doesn't arrive
  • "Schedule enabled" checkbox set in UI?
  • At least one time window configured?
  • Sent /briefing_on in target chat?
  • Is current time in a window triggering a slot? Slot logic: first slot = window start = daily briefing (1×/day); subsequent slots at interval = updates.
  • Does day match? Weekdays in window are 0=Mo … 6=Su.
  • Container timezone (TZ in .env) correct? Otherwise sends at wrong time.
17.4. OAuth (Google/Microsoft) aborts
  • Public Base URL in UI = exactly the external HTTPS URL?
  • Redirect URI in Google Cloud Console / Azure App Registration = https://<your-url>/oauth/google/callback or /oauth/microsoft/callback?
  • Google: no refresh_token returned → manually revoke app permission in Google account (myaccount.google.com → Security → Third-party apps) and authorize again. Loqari automatically requests new refresh_token on re-consent.
  • Microsoft: tenant in Loqari = common (private + org accounts), consumers (private only) or specific tenant ID (one org only)?
17.5. Ollama not reachable
  • UI → Settings → AI API Keys → Ollama Base URL check. Default: http://host.docker.internal:11434.
  • If Ollama on different host: enter its IP/URL.
  • If Ollama in same Docker network: enter service name, e.g. http://ollama:11434.
  • Test: curl http://host.docker.internal:11434/api/tags from Loqari container (docker exec -it loqari sh -c 'apt-get update && apt-get install -y curl && curl …').
17.6. "host.docker.internal" resolution on Linux hosts

On Linux, host.docker.internal is not available out-of-the-box. Therefore in docker-compose.yml is set:

extra_hosts:
  - "host.docker.internal:host-gateway"

This works with Docker ≥ 20.10. If not: instead enter the LAN IP of the host (e.g. http://192.168.1.10:11434).

17.7. Container won't start (unhealthy / restart loop)
  • Check logs: ./manage.sh logs
  • Port 47840 already taken? ss -tlnp | grep 47840
  • Disk full? df -h
  • data/ writable? Permissions as under 17.1.
17.8. Default login banner doesn't disappear

Banner shows only while an admin user has combo admin / admin. Once any admin has changed credentials, banner disappears. If multiple admins, all must be changed.

17.9. After image rebuild, no improvement

Compose cache:

./manage.sh down
docker compose build --no-cache
docker compose up -d
17.10. Wrong timezone
  • .env: set TZ=Europe/Berlin (or as appropriate).
  • manage.sh restart is enough. Scheduler auto-instantiates with new TZ on switch.

---

Appendix: Important Files & Paths

| Path (Host) | Content | | ----------- | ------- | | ./.env | Platform values (TZ, PUID, PGID, PORT) | | ./docker-compose.yml | Compose definition | | ./Dockerfile | Image build instructions | | ./entrypoint.sh | Container entrypoint, performs UID/GID drop | | ./manage.sh | Helper script (up | down | rebuild | restart | logs | status) | | ./app/ | Python code | | ./data/ | Persistent data (volume-mounted to /data in container) |

| Path (Container) | Content | | ---------------- | ------- | | /app/ | App code | | /data/ | Volume mount from ./data | | /entrypoint.sh | Entrypoint |

---

Appendix: Standard Ports

| Port | Function | | ---- | -------- | | 8000 (in container) | Uvicorn / FastAPI web UI | | 47840 (host, default) | Mapping from ${PORT} in .env | | 11434 (on host, optional) | Ollama API |

---

Done. If problems: first read ./manage.sh logs, then search this guide by keyword, then if needed open an issue.

Preise

Einmal kaufen, dauerhaft nutzen

Loqari
Preis zzgl. 19% MwSt. von = 8,55€
45,00€ einmalig
  • ✓Tägliches Briefing per Telegram zur frei wählbaren Uhrzeit + optionale Intervall-Updates (z.B. alle 4 h) mit Tagesterminen und neuen Mails
  • ✓Multi-Account-Anbindung: CalDAV, IMAP, Google (OAuth2), Microsoft 365 (OAuth2) und ICS-URLs — Kalenderauswahl pro Account
  • ✓KI-Zusammenfassungen mit 4 Providern: Ollama (lokal, datenschutzfreundlich), OpenAI, Anthropic Claude, Google Gemini
  • ✓Telegram-Bot mit Befehlen (`/heute`, `/morgen`, `/woche`, `/mails`, `/briefing`) und Freitext-Erkennung („was steht heute an?")
  • ✓Multi-User mit Admin-Rechtemanagement: eigener Bot pro User, KI-Provider-Whitelist, self-hosted Docker auf Linux/macOS/Windows/NAS/Raspberry Pi
Kaufen
Weitere Produkte

Entdecken Sie auch unsere anderen Projekte

Lade Produkte…