Das Heimstudio

# In der TrueNAS-Shell ausfuehren (System Settings > Shell)
{
echo "=== Geraet ==="
sudo dmidecode -s system-product-name 2>/dev/null || echo "  (dmidecode nicht verfuegbar)"
sudo dmidecode -s baseboard-product-name 2>/dev/null
echo
echo "=== Prozessor ==="
lscpu | grep -E "Model name|^CPU\(s\)|Thread|Core"
echo
echo "=== Speicher (das entscheidende Mass) ==="
free -h | head -2
sudo dmidecode -t memory 2>/dev/null | grep -E "Size:|Speed:|Locator:" | grep -v "No Module"
echo
echo "=== Netz ==="
ip -br link | grep -v lo
lspci -nn | grep -i ethernet
echo
echo "=== Platten ==="
lsblk -o NAME,SIZE,MODEL,TRAN 2>/dev/null | grep -v loop
echo
echo "=== Grafik (fuer den Entscheidungspunkt in Take 04) ==="
lspci -k | grep -A3 -Ei 'vga|display' || echo "  keine dedizierte Grafik"
ls -l /dev/dri/ 2>/dev/null || echo "  /dev/dri fehlt"
echo
echo "=== TrueNAS ==="
cat /etc/version 2>/dev/null
uname -r
echo
echo "=== ZFS ==="
zpool list
cat /sys/module/zfs/parameters/zfs_arc_max 2>/dev/null | awk '{printf "ARC-Deckel: %.1f GB\n", $1/1073741824}'
} | tee ~/soundcheck-$(date +%F).txt

# Aktuellen Zustand pruefen
ethtool enp1s0 | grep -E "Speed|Duplex"

# Energiesparmodus abschalten - das ist die Massnahme, die wirkt.
sudo ethtool --set-eee enp1s0 eee off

# Feste Geschwindigkeit erzwingen funktioniert bei diesem Chip NICHT:
# der igc-Treiber unterstuetzt kein Force-Speed, und 2,5GBASE-T verlangt
# ohnehin Autonegotiation. Der Befehl quittiert mit "Invalid argument".
#   sudo ethtool -s enp1s0 autoneg off speed 2500 duplex full   # <- geht nicht

# Ueberlebt keinen Neustart. Dauerhaft machen:
#   System Settings > Advanced > Init/Shutdown Scripts
#   Type: Command  |  When: Post Init
#   Command: /usr/sbin/ethtool --set-eee enp1s0 eee off
# Bleibt das Problem, hilft manchmal noch:
#   sudo ethtool -K enp1s0 tso off gso off

# In der TrueNAS-Shell. Pool heisst hier "tank" - passe das an.

# --- Das Rack: Ollama. Grosse Dateien, sequenziell gelesen. ---
sudo zfs create -o recordsize=128K -o compression=lz4    -o atime=off tank/studio
sudo zfs create -o recordsize=1M   -o compression=lz4    -o atime=off tank/studio/rack
sudo zfs create -o recordsize=1M   -o compression=off    -o atime=off tank/studio/rack/models
sudo zfs create -o recordsize=128K -o compression=zstd-3 -o atime=off tank/studio/rack/presets

# --- Die Library: Qdrant. Wahlfreier Zugriff, wie eine Datenbank. ---
sudo zfs create -o recordsize=16K  -o compression=lz4    -o atime=off tank/studio/library
sudo zfs create -o recordsize=16K  -o compression=lz4    -o atime=off tank/studio/library/storage
sudo zfs create -o recordsize=1M   -o compression=lz4    -o atime=off tank/studio/library/snapshots

# --- Das Mischpult und der Rest ---
sudo zfs create -o recordsize=128K -o compression=lz4    -o atime=off tank/studio/desk
sudo zfs create -o recordsize=128K -o compression=lz4    -o atime=off tank/studio/backstage
sudo zfs create -o recordsize=128K -o compression=lz4    -o atime=off tank/studio/stagebox
sudo zfs create -o recordsize=128K -o compression=zstd-3 -o atime=off tank/studio/logs

# --- Das Songbook: viele kleine Textdateien, hoch komprimierbar ---
sudo zfs create -o recordsize=128K -o compression=zstd-3 -o atime=off tank/songbook
sudo zfs create -o recordsize=128K -o compression=zstd-3 -o atime=off tank/songbook/vault
sudo zfs create -o recordsize=128K -o compression=zstd-3 -o atime=off tank/songbook/inbox
sudo zfs create -o recordsize=1M   -o compression=off    -o atime=off tank/songbook/attachments

# --- Das Bandtagebuch ---
sudo zfs create -o recordsize=128K -o compression=zstd-3 -o atime=off tank/tapes

# --- Kontrolle ---
zfs list -o name,used,avail,recordsize,compression,atime -r tank/studio tank/songbook tank/tapes

# Erst schauen, was passieren wuerde - schreibt nichts
./studio-bootstrap.sh --root /mnt/tank --mode zfs --dry-run

# Wenn die Ausgabe passt: scharf schalten
sudo ./studio-bootstrap.sh --root /mnt/tank --mode zfs --pool tank

# Kontrolle
zfs list -o name,recordsize,compression,atime -r tank/studio tank/songbook tank/tapes
cat /mnt/tank/studio/studio-map.json | jq '.paths | length'

# Der Regelfall: alles, was Apps beschreiben duerfen
sudo chown -R 568:568 /mnt/tank/studio /mnt/tank/songbook /mnt/tank/tapes

# Verzeichnisse 775, Dateien 664 - ein pauschales "chmod -R 775" wuerde
# jede Textdatei ausfuehrbar machen und die feineren Rechte darunter
# gleich wieder ueberschreiben.
sudo find /mnt/tank/studio /mnt/tank/songbook -type d -exec chmod 775 {} +
sudo find /mnt/tank/studio /mnt/tank/songbook -type f -exec chmod 664 {} +

# Die Ausnahmen - hier wird die Regel bewusst gebrochen:
sudo chmod 700 /mnt/tank/studio/stagebox    # Secrets: nur du
sudo chmod 755 /mnt/tank/songbook/vault     # Vault: Indexer liest nur
sudo chmod 775 /mnt/tank/songbook/inbox     # Inbox: Agenten duerfen schreiben

# Kontrolle - das -n ist wichtig, es zeigt die Zahlen statt der Namen
ls -ln /mnt/tank/studio/
ls -ld /mnt/tank/studio/stagebox /mnt/tank/songbook/vault /mnt/tank/songbook/inbox

# Merkpunkt setzen, rekursiv ueber alles was zaehlt
sudo zfs snapshot -r tank/studio@vor-$(date +%Y%m%d-%H%M)

# Nachsehen, was da ist
zfs list -t snapshot -r tank/studio | tail -5

# In einen Merkpunkt hineinsehen, ohne irgendetwas zurueckzudrehen:
ls /mnt/tank/songbook/vault/.zfs/snapshot/
cp /mnt/tank/songbook/vault/.zfs/snapshot/<name>/Projekte/notiz.md ~/

# Wenn alles gut lief, wieder aufraeumen.
# IMMER erst mit -n trocken laufen lassen und die Ausgabe lesen:
# ein vergessenes "@..." macht daraus "zfs destroy -r tank/studio"
# und loescht das gesamte Studio mit allen Kindern.
sudo zfs destroy -rn tank/studio@vor-20260729-2100   # nur anzeigen
sudo zfs destroy -r  tank/studio@vor-20260729-2100   # wirklich loeschen

sudo mkdir -p /mnt/tank/studio/stagebox
sudo tee /mnt/tank/studio/stagebox/.env >/dev/null <<EOF
QDRANT_API_KEY=$(openssl rand -hex 24)
QDRANT_RO_KEY=$(openssl rand -hex 24)     # fuer nur-lesende Zugriffe
WEBUI_SECRET=$(openssl rand -hex 32)      # wird zu WEBUI_SECRET_KEY im Pult
EOF
sudo chmod 600 /mnt/tank/studio/stagebox/.env
sudo chown 568:568 /mnt/tank/studio/stagebox/.env

# Zum Einsetzen ins YAML anzeigen (Install via YAML liest keine .env-Datei):
sudo cat /mnt/tank/studio/stagebox/.env

services:

  # ============ DAS RACK: Ollama ============
  ollama:
    image: ollama/ollama:0.32.5
    container_name: studio-rack
    restart: unless-stopped
    ports:
      - "127.0.0.1:11434:11434"     # nur Loopback - Ollama hat keine Anmeldung
    volumes:
      - type: bind
        source: /mnt/tank/studio/rack
        target: /root/.ollama
    environment:
      TZ: Europe/Berlin
      OLLAMA_VULKAN: "0"
      OLLAMA_IGPU_ENABLE: "0"
      OLLAMA_MAX_LOADED_MODELS: "3"
      OLLAMA_NUM_PARALLEL: "1"
      OLLAMA_MAX_QUEUE: "64"
      OLLAMA_CONTEXT_LENGTH: "4096"
      OLLAMA_KEEP_ALIVE: "30m"
      OLLAMA_LOAD_TIMEOUT: "20m"
      OLLAMA_FLASH_ATTENTION: "1"
      OLLAMA_KV_CACHE_TYPE: "q8_0"
      OLLAMA_NO_CLOUD: "1"
      OLLAMA_NOHISTORY: "1"
    deploy:
      resources:
        limits: { cpus: "3.5", memory: 9G }
    networks: [studio]

  # ============ DIE LIBRARY: Qdrant ============
  qdrant:
    image: qdrant/qdrant:v1.18.3-unprivileged
    container_name: studio-library
    restart: unless-stopped
    ports:
      - "127.0.0.1:6333:6333"       # nur Loopback, fuer curl und das Dashboard
    volumes:
      - type: bind
        source: /mnt/tank/studio/library/storage
        target: /qdrant/storage
      - type: bind
        source: /mnt/tank/studio/library/snapshots
        target: /qdrant/snapshots
    environment:
      TZ: Europe/Berlin
      QDRANT__SERVICE__API_KEY: "HIER-DEN-QDRANT_API_KEY-EINSETZEN"
      QDRANT__SERVICE__READ_ONLY_API_KEY: "HIER-DEN-QDRANT_RO_KEY-EINSETZEN"
      QDRANT__SERVICE__ENABLE_TLS: "false"
      QDRANT__STORAGE__ON_DISK_PAYLOAD: "true"
      QDRANT__STORAGE__PERFORMANCE__OPTIMIZER_CPU_BUDGET: "-2"
      QDRANT__STORAGE__OPTIMIZERS__MAX_OPTIMIZATION_THREADS: "1"
      QDRANT__STORAGE__HNSW_INDEX__MAX_INDEXING_THREADS: "2"
      QDRANT__TELEMETRY_DISABLED: "true"
    ulimits:
      nofile: { soft: 10000, hard: 10000 }
    deploy:
      resources:
        limits: { memory: 1G }
    networks: [studio]

  # ============ DAS MISCHPULT: Open WebUI ============
  webui:
    image: ghcr.io/open-webui/open-webui:0.11.0
    container_name: studio-desk
    restart: unless-stopped
    ports:
      - "31028:8080"                # das einzige, was ins LAN darf
    volumes:
      - type: bind
        source: /mnt/tank/studio/desk/webui
        target: /app/backend/data
      - type: bind
        source: /mnt/tank/songbook/vault
        target: /vault
        read_only: true             # das Songbook wird gelesen, nie beschrieben
    environment:
      TZ: Europe/Berlin
      OLLAMA_BASE_URL: "http://ollama:11434"
      WEBUI_SECRET_KEY: "HIER-DEN-WEBUI_SECRET-EINSETZEN"
      WEBUI_AUTH: "true"
      ENABLE_SIGNUP: "false"
      VECTOR_DB: "qdrant"
      QDRANT_URI: "http://qdrant:6333"
      QDRANT_API_KEY: "HIER-DEN-QDRANT_API_KEY-EINSETZEN"
      RAG_EMBEDDING_ENGINE: "ollama"
      RAG_EMBEDDING_MODEL: "qwen3-embedding:0.6b"
      RAG_OLLAMA_BASE_URL: "http://ollama:11434"
    depends_on: [ollama, qdrant]
    deploy:
      resources:
        limits: { memory: 1500M }
    networks: [studio]

  # ============ DAS BANDTAGEBUCH: Forgejo ============
  forgejo:
    image: codeberg.org/forgejo/forgejo:16.0.1
    container_name: studio-tapes
    restart: unless-stopped
    ports:
      - "3000:3000"
      - "222:22"
    volumes:
      - type: bind
        source: /mnt/tank/tapes/forgejo
        target: /data
    environment:
      USER_UID: "568"
      USER_GID: "568"
      FORGEJO__database__DB_TYPE: "sqlite3"
      FORGEJO__service__DISABLE_REGISTRATION: "true"
      FORGEJO__security__INSTALL_LOCK: "true"
      FORGEJO__actions__ENABLED: "false"
      FORGEJO__indexer__REPO_INDEXER_ENABLED: "true"
    deploy:
      resources:
        limits: { memory: 512M }
    networks: [studio]

  # ============ DER ROADIE: Syncthing ============
  syncthing:
    image: syncthing/syncthing:2.1.2
    container_name: studio-roadie
    hostname: studio-nas
    restart: unless-stopped
    ports:
      - "8384:8384"
      - "22000:22000/tcp"
      - "22000:22000/udp"
      - "21027:21027/udp"
    volumes:
      - type: bind
        source: /mnt/tank/studio/desk/syncthing
        target: /var/syncthing/config
      - type: bind
        source: /mnt/tank/songbook
        target: /var/syncthing/songbook
    environment:
      PUID: "568"
      PGID: "568"
      TZ: Europe/Berlin
    deploy:
      resources:
        limits: { memory: 256M }
    networks: [studio]

  # ============ DER AUFNAHMELEITER: Warmup ============
  warmup:
    image: curlimages/curl:8.11.1
    container_name: studio-warmup
    restart: on-failure
    depends_on: [ollama]
    entrypoint: ["/bin/sh", "-c"]
    command:
      - |
        until curl -sf http://ollama:11434/api/version >/dev/null; do sleep 3; done
        curl -s http://ollama:11434/api/generate -H 'Content-Type: application/json' \
             -d '{"model":"granite4.1:3b-q4_K_M","keep_alive":-1}' >/dev/null
        curl -s http://ollama:11434/api/embed -H 'Content-Type: application/json' \
             -d '{"model":"qwen3-embedding:0.6b","input":"warmup","keep_alive":-1}' >/dev/null
        echo "Generalist und Embedder stehen bereit."
    networks: [studio]

networks:
  studio:
    name: studio
    driver: bridge

docker ps --filter name=studio-rack
docker logs studio-rack 2>&1 | tail -20

# Antwortet es?
docker exec studio-rack ollama --version
curl -s http://localhost:11434/api/version   # nur vom NAS aus, kein Port nach aussen

# Die Diagnosezeilen, die wirklich etwas verraten:
docker logs studio-rack 2>&1 | grep -Ei "vram-based default|disabling mmap|dropping integrated|max runners"

# Hausmeister: Generalist, Deutsch, Werkzeuge, JSON        2,1 GB
docker exec studio-rack ollama pull granite4.1:3b-q4_K_M

# Zweitmeinung: 256K Kontext, Bilder, Nachdenken           1,9 GB
docker exec studio-rack ollama pull qwen3.5:2b-q4_K_M

# Notenschreiber: Einbettungen fuer die Suche              639 MB
docker exec studio-rack ollama pull qwen3-embedding:0.6b

# Setzer: Code                                             1,9 GB
docker exec studio-rack ollama pull qwen2.5-coder:3b

# Notenleser: OCR, nur bei Bedarf                          1,6 GB
docker exec studio-rack ollama pull glm-ocr:q8_0

# Wer ist da?
docker exec studio-rack ollama list

# /mnt/tank/studio/rack/presets/Modelfile.archivar
FROM granite4.1:3b-q4_K_M
PARAMETER temperature 0
PARAMETER top_p 1.0
PARAMETER top_k 1
PARAMETER num_ctx 8192
PARAMETER num_predict 512
PARAMETER num_thread 3
PARAMETER repeat_penalty 1.0
SYSTEM """Du bist ein Extraktionsdienst. Du gibst AUSSCHLIESSLICH gueltiges JSON
zurueck, das exakt dem vom Aufrufer gelieferten Schema entspricht. Kein Fliesstext,
keine Codefences, keine Erklaerung. Fehlende Werte sind null - niemals erfunden."""
MESSAGE user Schema: {"titel":"string","tags":["string"],"jahr":"number"} -- Text: Notiz ueber TrueNAS-Setup von 2026.
MESSAGE assistant {"titel":"TrueNAS-Setup","tags":["truenas","homeserver"],"jahr":2026}

# /mnt/tank/studio/rack/presets/Modelfile.kurator
FROM granite4.1:3b-q4_K_M
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 16384
PARAMETER num_predict 900
PARAMETER num_batch 256
PARAMETER use_mmap true
SYSTEM """Du fasst deutsche Fachtexte zusammen. Antworte auf Deutsch, hoechstens
fuenf Stichpunkte, sachlich, ohne Einleitungsfloskel. Was du nicht im Text findest,
erfindest du nicht - du schreibst 'steht nicht im Text'."""

# Die Presets liegen auf dem Host unter /mnt/tank/studio/rack/presets.
# Im Container sind sie damit unter /root/.ollama/presets sichtbar -
# denn genau dorthin ist /mnt/tank/studio/rack gemountet.
docker exec studio-rack ollama create archivar -f /root/.ollama/presets/Modelfile.archivar
docker exec studio-rack ollama create kurator  -f /root/.ollama/presets/Modelfile.kurator
docker exec studio-rack ollama list

# Der Archivar bei der Arbeit - mit erzwungenem Schema
curl -s http://localhost:11434/api/chat -H 'Content-Type: application/json' -d '{
  "model": "archivar",
  "messages": [{"role":"user","content":"Notiz: TrueNAS auf dem Beelink eingerichtet, Juli 2026, laeuft mit Tailscale."}],
  "stream": false, "think": false,
  "options": { "temperature": 0 },
  "format": {
    "type": "object",
    "properties": {
      "titel": {"type":"string"},
      "tags":  {"type":"array","items":{"type":"string"}},
      "jahr":  {"type":"integer"}
    },
    "required": ["titel","tags","jahr"]
  }
}' | jq -r '.message.content' | jq .

# Zwei Musiker dauerhaft pinnen (-1 = bleibt, bis du ihn gehen laesst)
curl -s http://localhost:11434/api/generate -H 'Content-Type: application/json' \
     -d '{"model":"granite4.1:3b-q4_K_M","keep_alive":-1}'
curl -s http://localhost:11434/api/embed -H 'Content-Type: application/json' \
     -d '{"model":"qwen3-embedding:0.6b","input":"warmup","keep_alive":-1}'

# Den Notenleser nach Gebrauch sofort wieder wegschicken
docker exec studio-rack ollama stop glm-ocr:q8_0

# Der Blick aufs Pult
docker exec studio-rack ollama ps
# NAME                     ID            SIZE     PROCESSOR   CONTEXT   UNTIL
# granite4.1:3b-q4_K_M     a1b2c3d4e5f6  2.6 GB   100% CPU    4096      Forever

# Nach dem ersten Start ZUERST das hier pruefen:
docker logs studio-library 2>&1 | grep -i "filesystem"
# Keine Ausgabe = alles gut.
# Steht dort etwas, hat Qdrant den Start verweigert - dann NICHT mit
# irgendwelchen Schaltern erzwingen, sondern die Ablage aendern.

# Antwortet sie?
K=$(sudo grep QDRANT_API_KEY /mnt/tank/studio/stagebox/.env | cut -d= -f2)
curl -s -H "api-key: $K" http://localhost:6333/healthz
curl -s -H "api-key: $K" http://localhost:6333/ | jq

# Ohne Schluessel muss 401 kommen - sonst steht die Tuer offen:
curl -s -o /dev/null -w "ohne Schluessel: HTTP %{http_code}\n" http://localhost:6333/collections

K=$(sudo grep QDRANT_API_KEY /mnt/tank/studio/stagebox/.env | cut -d= -f2)

curl -X PUT http://localhost:6333/collections/songbook \
  -H "api-key: $K" -H 'Content-Type: application/json' -d '{
  "vectors": {
    "size": 1024,
    "distance": "Cosine",
    "on_disk": true
  },
  "quantization_config": {
    "scalar": { "type": "int8", "quantile": 0.99, "always_ram": true }
  },
  "on_disk_payload":   true,
  "hnsw_config":       { "m": 16, "ef_construct": 100 },
  "optimizers_config": { "indexing_threshold": 20000 }
}'

# Filterfelder indizieren - sonst wird jede gefilterte Suche zur Schleppnetzfahrt
for f in path:keyword tags:keyword mtime:integer; do
  curl -s -X PUT http://localhost:6333/collections/songbook/index \
    -H "api-key: $K" -H 'Content-Type: application/json' \
    -d "{\"field_name\":\"${f%%:*}\",\"field_schema\":\"${f##*:}\"}"
done

K=$(sudo grep QDRANT_API_KEY /mnt/tank/studio/stagebox/.env | cut -d= -f2)

# 1. Text einbetten lassen
V=$(curl -s http://localhost:11434/api/embed -H 'Content-Type: application/json' -d '{
  "model": "qwen3-embedding:0.6b",
  "input": "Tailscale macht den Server von unterwegs erreichbar, ohne einen Port zu oeffnen.",
  "truncate": false, "keep_alive": "24h"
}' | jq -c '.embeddings[0]')

# 2. Ablegen
curl -s -X PUT "http://localhost:6333/collections/songbook/points?wait=true" \
  -H "api-key: $K" -H 'Content-Type: application/json' -d "{
  \"points\": [{ \"id\": 1, \"vector\": $V,
    \"payload\": {\"path\":\"Projekte/homeserver.md\",\"tags\":[\"netzwerk\"],\"text\":\"Tailscale ...\"} }]}"

# 3. Mit ANDEREN Worten suchen
Q=$(curl -s http://localhost:11434/api/embed -H 'Content-Type: application/json' \
    -d '{"model":"qwen3-embedding:0.6b","input":"wie komme ich von aussen auf mein NAS"}' | jq -c '.embeddings[0]')

curl -s -X POST http://localhost:6333/collections/songbook/points/query \
  -H "api-key: $K" -H 'Content-Type: application/json' \
  -d "{\"query\": $Q, \"limit\": 3, \"with_payload\": [\"path\",\"tags\"]}" | jq '.result.points'

#!/usr/bin/env bash
# TrueNAS: System Settings > Advanced > Cron Jobs, taeglich 03:10
set -euo pipefail
K=$(grep QDRANT_API_KEY /mnt/tank/studio/stagebox/.env | cut -d= -f2)

curl -sf -X POST "http://localhost:6333/collections/songbook/snapshots" -H "api-key: $K" \
  | tee -a /mnt/tank/studio/logs/qdrant-snapshots.log

# Aelter als 14 Tage wegraeumen - Snapshots sind Vollkopien
find /mnt/tank/studio/library/snapshots -name '*.snapshot' -mtime +14 -delete

---
tags: [homeserver, truenas, ki]
datum: 2026-07-29
status: aktiv
---

# Homeserver-Aufbau

## Speicher

ZFS mit sechs Steckplaetzen. Die recordsize haengt vom Zweck ab.

## Netzwerk

Tailscale sorgt fuer den Zugang von unterwegs, ohne einen Port zu oeffnen.
Siehe auch [[Tailscale-Einrichtung]].

VAULT=/mnt/tank/songbook/vault
BARE=/mnt/tank/tapes/songbook.git

# Ein nacktes Repo als Ziel
sudo -u apps git init --bare -b main "$BARE"

# Die Arbeitskopie
cd "$VAULT"
sudo -u apps git init -b main
sudo -u apps git config user.name  "studio-bot"
sudo -u apps git config user.email "studio@localhost"
sudo -u apps git config gc.auto 256
sudo -u apps git remote add origin "$BARE"

# WICHTIG: Git verweigert den Dienst, wenn Repo und aufrufender Nutzer
# nicht zusammenpassen. Erst initialisieren, dann uebereignen - und
# sicherheitshalber ausdruecklich freigeben:
sudo git config --global --add safe.directory "$VAULT"

cat > /mnt/tank/songbook/vault/.gitignore <<'EOF'
# geraete-/sitzungsspezifisch - nie committen
.obsidian/workspace.json
.obsidian/workspace-mobile.json
.obsidian/cache/
# ACHTUNG: hier liegen API-Schluessel von LLM-Plugins im KLARTEXT.
# Der Kommentar MUSS in einer eigenen Zeile stehen - .gitignore kennt
# keine Kommentare am Zeilenende, sonst wird er Teil des Musters und
# die Datei landet trotzdem im Repo.
.obsidian/plugins/*/data.json

# Plugin-Caches, die gross werden
.smart-env/
.smart-connections/

# Sync-Artefakte
.stfolder/
.stversions/
*.sync-conflict-*

# Betriebssystem
.DS_Store
Thumbs.db
desktop.ini
.trash/

# Secrets
.env
*.key
EOF

#!/usr/bin/env bash
# TrueNAS: System Settings > Advanced > Cron Jobs, alle 30 Minuten
set -euo pipefail
VAULT="${1:-/mnt/tank/songbook/vault}"
LOG="/mnt/tank/studio/logs/vault-git.log"
G(){ git -c "safe.directory=$VAULT" -C "$VAULT" "$@"; }

# Nicht mitten in einen Syncthing-Schreibvorgang hineincommitten:
# warten, bis 20 Sekunden lang nichts mehr angefasst wurde.
for _ in 1 2 3 4 5; do
  RECENT=$(find "$VAULT" -newermt '-20 seconds' -type f -not -path '*/.git/*' | head -1)
  [ -z "$RECENT" ] && break
  sleep 10
done

G add -A
G diff --cached --quiet && exit 0        # nichts passiert, nichts zu tun

STAT=$(G diff --cached --shortstat)
COUNT=$(G diff --cached --name-only | wc -l)
FILES=$(G diff --cached --name-only | head -3 | xargs -I{} basename {} | paste -sd, - | sed 's/,/, /g')
[ "$COUNT" -gt 3 ] && FILES="$FILES (+$((COUNT-3)) weitere)"

G commit -q -m "songbook: $FILES" -m "$STAT"
G push -q --follow-tags origin HEAD 2>>"$LOG" || echo "$(date '+%F %T') push fehlgeschlagen" >> "$LOG"
echo "$(date '+%F %T') commit: $FILES | $STAT" >> "$LOG"

# Wochenmarke als Ankerpunkt in der Historie
WEEK="w$(date +%G-%V)"
G rev-parse "$WEEK" >/dev/null 2>&1 || G tag -a "$WEEK" -m "Wochenstand KW $(date +%V)"

cd /mnt/tank/songbook/vault
G(){ git -c safe.directory=$PWD "$@"; }

# Was hat sich diese Woche getan?
G log --since="1 week ago" --name-only --pretty=format:'%C(yellow)%h%C(reset) %ad %s' --date=short

# Welche Notizen aendern sich am haeufigsten? Das sind deine Baustellen.
G log --pretty=format: --name-only | grep -v '^$' | sort | uniq -c | sort -rn | head -20

# Der eigentliche Trumpf: Volltextsuche ueber die GESCHICHTE.
# Findet Inhalte, die es heute nicht mehr gibt.
G log -S "Tailscale" --oneline --name-only

# Eine einzelne Notiz ueber die Zeit
G log -p --follow -- "Projekte/homeserver.md"

# Was wurde jemals geloescht?
G log --diff-filter=D --name-only --pretty=format:'%ad %h' --date=short

# Wieviel ist in 30 Tagen dazugekommen?
G diff --stat "@{30 days ago}" HEAD | tail -1

  forgejo:
    image: codeberg.org/forgejo/forgejo:16.0.1
    container_name: studio-tapes
    restart: unless-stopped
    ports:
      - "3000:3000"
      - "222:22"
    volumes:
      - type: bind
        source: /mnt/tank/tapes/forgejo
        target: /data
    environment:
      USER_UID: "568"
      USER_GID: "568"
      FORGEJO__database__DB_TYPE: "sqlite3"
      FORGEJO__service__DISABLE_REGISTRATION: "true"
      FORGEJO__service__REQUIRE_SIGNIN_VIEW: "true"
      FORGEJO__security__INSTALL_LOCK: "true"
      FORGEJO__actions__ENABLED: "false"          # CI auf 4 Kernen waere Unfug
      FORGEJO__indexer__REPO_INDEXER_ENABLED: "true"   # Volltextsuche ueber den Vault
    deploy:
      resources:
        limits: { memory: 512M }

docker exec -u git studio-tapes forgejo admin user create \
  --admin --username kingp --email kingp@localhost \
  --password "EIN-LANGES-PASSWORT" \
  --config /data/gitea/conf/app.ini

# Danach anmelden unter http://<nas-ip>:3000
# Dort ein leeres Repository "songbook" anlegen und den Vault dorthin schieben:
cd /mnt/tank/songbook/vault
git -c safe.directory=$PWD remote set-url origin http://<nas-ip>:3000/kingp/songbook.git
git -c safe.directory=$PWD push -u origin main

# Nach dem Start: http://<nas-ip>:31028
# Der ERSTE angelegte Zugang wird automatisch Verwalter. Also gleich selbst anlegen,
# bevor jemand anderes im LAN schneller ist.

docker logs studio-desk 2>&1 | tail -20
curl -s -o /dev/null -w "WebUI: HTTP %{http_code}\n" http://localhost:31028

# Sieht das Pult das Rack?
docker exec studio-desk curl -s http://ollama:11434/api/tags | head -c 300

"""Open WebUI: Workspace > Tools > neues Tool.
Sucht in der Library und liefert dem Modell fertigen Kontext.
Ein Aufruf, keine Kaskade."""
import json, os, urllib.request

class Tools:
    def __init__(self):
        self.qdrant = "http://qdrant:6333"
        self.ollama = "http://ollama:11434"
        self.key    = os.environ.get("QDRANT_API_KEY", "")
        if not self.key:
            # Ohne Schluessel antwortet Qdrant mit 401 - lieber hier sauber melden
            # als spaeter mit einer nackten HTTPError im Chat landen.
            print("WARNUNG: QDRANT_API_KEY ist im Container nicht gesetzt.")
        self.model  = "qwen3-embedding:0.6b"

    def _post(self, url, body, hdr=None):
        h = {"Content-Type": "application/json"}
        h.update(hdr or {})
        req = urllib.request.Request(url, json.dumps(body).encode(), h, method="POST")
        with urllib.request.urlopen(req, timeout=120) as r:
            return json.load(r)

    def songbook_durchsuchen(self, frage: str, treffer: int = 5, tag: str = "") -> str:
        """Durchsucht das persoenliche Songbook nach Inhalten zu einer Frage.

        :param frage: Wonach gesucht wird, in eigenen Worten.
        :param treffer: Wieviele Fundstellen zurueckkommen sollen.
        :param tag: Optionaler Filter auf ein Schlagwort.
        """
        vec = self._post(f"{self.ollama}/api/embed",
                         {"model": self.model, "input": frage,
                          "truncate": False, "keep_alive": "24h"})["embeddings"][0]
        body = {"query": vec, "limit": treffer,
                "with_payload": ["path", "heading", "text"]}
        if tag:
            body["filter"] = {"must": [{"key": "tags", "match": {"value": tag}}]}
        pts = self._post(f"{self.qdrant}/collections/songbook/points/query",
                         body, {"api-key": self.key})["result"]["points"]
        if not pts:
            return "Im Songbook steht dazu nichts."
        out = []
        for p in pts:
            pl = p.get("payload") or {}
            kopf = pl.get("path", "(ohne Pfad)")
            if pl.get("heading"):
                kopf += " > " + pl["heading"]
            out.append(f"### {kopf}  (Naehe {p['score']:.2f})\n{pl.get('text','')[:900]}")
        return "\n\n".join(out)

http://truenas.<dein-tailnet>.ts.net:31028   # Mischpult
http://truenas.<dein-tailnet>.ts.net:3000    # Bandtagebuch
http://truenas.<dein-tailnet>.ts.net:8384    # Syncthing
https://truenas.<dein-tailnet>.ts.net        # TrueNAS selbst

# Von jedem Geraet im Tailnet. Kein Port im Router. Kein dynamisches DNS.
# Der Verkehr ist durch WireGuard verschluesselt - auch ohne HTTPS.

# 1. Im Tailscale-Admin: HTTPS-Zertifikate und MagicDNS aktivieren
# 2. Dataset fuer die Konfiguration
sudo mkdir -p /mnt/tank/studio/backstage/config
sudo tee /mnt/tank/studio/backstage/config/serve.json >/dev/null <<'EOF'
{
  "TCP": { "443": { "HTTPS": true } },
  "Web": {
    "truenas.DEIN-TAILNET.ts.net:443": {
      "Handlers": { "/": { "Proxy": "http://127.0.0.1:31028" } }
    }
  }
}
EOF
sudo chown -R 568:568 /mnt/tank/studio/backstage/config

# 3. In der Tailscale-App:
#    Host Path /mnt/tank/studio/backstage/config -> /config
#    Umgebungsvariable TS_SERVE_CONFIG=/config/serve.json
# 4. App neu starten. Danach:
#    https://truenas.DEIN-TAILNET.ts.net   (ohne Portnummer, gueltiges Zertifikat)

# Zum Testen ohne Dauerhaftigkeit:
sudo docker exec -it $(docker ps --format '{{.Names}}' | grep -i tailscale) \
  tailscale serve --bg --https=443 http://127.0.0.1:31028

{
  "tagOwners": { "tag:studio": ["autogroup:admin"] },
  "acls": [
    {
      "action": "accept",
      "src":    ["autogroup:member"],
      "dst":    ["tag:studio:443", "tag:studio:31028", "tag:studio:3000"]
    },
    {
      "action": "accept",
      "src":    ["autogroup:admin"],
      "dst":    ["tag:studio:*"]
    }
  ]
}

#!/usr/bin/env bash
set -uo pipefail          # nicht -e: ein toter Dienst soll den Bericht nicht abbrechen
echo "===== STUDIO-CHECK  $(date '+%F %T') ====="

echo; echo "--- Container ---"
docker ps --filter name=studio- --format 'table {{.Names}}	{{.Status}}	{{.Image}}'

echo; echo "--- Speicher ---"
docker stats --no-stream --format 'table {{.Name}}	{{.MemUsage}}	{{.CPUPerc}}' \
  | grep -E 'NAME|studio-'
free -h | head -2

echo; echo "--- Wer steht auf der Buehne ---"
docker exec studio-rack ollama ps 2>/dev/null || echo "  Rack antwortet nicht"

echo; echo "--- Library ---"
K=$(grep QDRANT_API_KEY /mnt/tank/studio/stagebox/.env | cut -d= -f2)
curl -s -H "api-key: $K" http://localhost:6333/collections/songbook \
  | jq '{punkte:.result.points_count, indiziert:.result.indexed_vectors_count, status:.result.status}' \
  2>/dev/null || echo "  Library antwortet nicht"

echo; echo "--- Pool ---"
zpool list -o name,size,alloc,free,cap,health
zpool status -x

echo; echo "--- Bandtagebuch ---"
git -c safe.directory=/mnt/tank/songbook/vault -C /mnt/tank/songbook/vault \
    log --oneline -5 2>/dev/null || echo "  kein Repo"

echo; echo "--- Netz (die i226-Falle) ---"
for i in $(ls /sys/class/net | grep -v lo); do
  echo "  $i: $(ethtool $i 2>/dev/null | grep Speed | tr -d '\t')"
done

echo; echo "--- Was zuletzt schiefging ---"
tail -5 /mnt/tank/studio/logs/indexer.log 2>/dev/null
tail -3 /mnt/tank/studio/logs/vault-git.log 2>/dev/null

# Alle Datasets mit ihren Eigenschaften anlegen - direkt aus der Konfiguration
jq -r '.pfade.datasets[] | "zfs create -o recordsize=\(.recordsize) -o compression=\(.compression) -o atime=\(.atime) tank/\(.pfad)"' \
  /mnt/tank/studio/studio.config.json

# Alle Modelle holen
jq -r '.musiker[].tag' /mnt/tank/studio/studio.config.json \
  | xargs -I{} docker exec studio-rack ollama pull {}

# Die Umgebungsvariablen fuers Rack als .env ausgeben
jq -r '.rack.environment | to_entries[] | "\(.key)=\(.value)"' \
  /mnt/tank/studio/studio.config.json

# Was habe ich damals entschieden - und warum?
jq -r '.entscheidungen | to_entries[] | "\(.key): \(.value.gewaehlt)\n   \(.value.begruendung)\n"' \
  /mnt/tank/studio/studio.config.json

# Passt der Speicher noch? Summe aller Modellgroessen
jq '[.musiker[].groesse_gb] | add' /mnt/tank/studio/studio.config.json