Exclude .tex and .pdf from Docker build context

Split second example into focused model listing only, remove repeated
prompt code. Replace TUI with 'interaktive Terminal-Oberfläche'.

.dockerignore

@@ -42,6 +42,8 @@ docker-compose.yml
 
 # Docs
 *.md
+*.tex
+*.pdf
 
 # Dev & build scripts
 run_dev.py

.gitignore

@@ -27,3 +27,7 @@ frontend/dist/
 
 # Misc
 config.json
+
+# Generated documents
+KURZANLEITUNG.tex
+KURZANLEITUNG.pdf

DOCKERHUB.en.md

@@ -2,13 +2,12 @@
 
 A lightweight reverse proxy for [Ollama](https://ollama.com) that manages API keys with configurable token and request quotas. Incoming requests in OpenAI-compatible format are authenticated, checked against the quota, and forwarded to the configured Ollama server.
 
-Ollama does not need to run on the same host — `OLLAMA_URL` can point to any reachable server: the Docker host itself, another machine on the network, or a remote server.
-
 ## Features
 
 - OpenAI-compatible endpoint (`/v1/chat/completions`, `/v1/models`)
 - API key management with daily and monthly token/request limits
 - Web-based admin interface (port 8001)
+- Model lock: enforces a specific model for all requests (useful for courses and lab sessions)
 - Streaming support (Server-Sent Events)
 - Tool use / function calling passthrough
 - Rotating usage logs
@@ -21,12 +20,7 @@ Ollama does not need to run on the same host — `OLLAMA_URL` can point to any r
 | `8000` | Proxy endpoint (OpenAI API) |
 | `8001` | Admin API + web interface |
 
-Port 8001 must be exposed because the container serves the admin interface directly on this port. To restrict access to the local machine, bind it to `127.0.0.1` — this makes the port reachable only from the host, not from the network:
-
-```
-ports:
-  - "127.0.0.1:8001:8001"
-```
+All API endpoints require the `ADMIN_PASSWORD` — without a valid token, only the public frontend files (HTML/JS/CSS of the login page) are accessible. The password is therefore the primary protection.
 
 ## Environment Variables
 
@@ -34,88 +28,43 @@ ports:
 |----------|---------|-------------|
 | `ADMIN_PASSWORD` | – | **Required.** Password for the admin interface |
 | `OLLAMA_URL` | `http://localhost:11434` | URL of the Ollama server (without `/v1` suffix) |
-| `DEFAULT_MODEL` | `llama3` | Model used when the client does not specify one |
 | `DATABASE_URL` | `sqlite:///./test.db` | Database connection string (SQLite or PostgreSQL) |
 | `PROXY_HOST` | `0.0.0.0` | Proxy bind address |
 | `PROXY_PORT` | `8000` | Proxy port |
+| `ADMIN_HOST` | `0.0.0.0` | Admin API bind address (`127.0.0.1` to restrict to local access) |
 | `ADMIN_PORT` | `8001` | Admin API port |
 | `APP_TZ` | `Europe/Berlin` | Timezone for daily/monthly quota resets |
 | `LOG_FILE` | `logs/usage.log` | Path of the rotating usage log file |
 
-## Docker Compose – External Ollama, SQLite
+## Docker Compose – Ollama on the Host (Linux, recommended)
 
-Use this when Ollama runs outside of Docker — on the Docker host or any other reachable server. Adjust `OLLAMA_URL` accordingly.
+`network_mode: host` gives the container direct access to the host network stack. Ollama runs on the host and is reachable at `localhost:11434` — not visible from outside. The proxy and admin interface are available directly on host ports 8000 and 8001.
 
 ```yaml
 services:
   llmproxy:
     image: mediaeng/llmproxy:latest
+    container_name: llmproxy
     restart: unless-stopped
-    ports:
-      - "8000:8000"
-      - "127.0.0.1:8001:8001"
-    environment:
-      ADMIN_PASSWORD: changeme
-      OLLAMA_URL: http://host.docker.internal:11434  # or http://<ip>:11434
-      DEFAULT_MODEL: llama3
-      APP_TZ: Europe/Berlin
+    network_mode: host
+    env_file: .env
     volumes:
       - llmproxy-data:/app/backend
-    # On Linux, add extra_hosts since host.docker.internal is not
-    # available automatically:
-    # extra_hosts:
-    #   - "host.docker.internal:host-gateway"
 
 volumes:
   llmproxy-data:
 ```
 
-## Docker Compose – External Ollama, PostgreSQL
-
-```yaml
-services:
-  llmproxy:
-    image: mediaeng/llmproxy:latest
-    restart: unless-stopped
-    ports:
-      - "8000:8000"
-      - "127.0.0.1:8001:8001"
-    environment:
-      ADMIN_PASSWORD: changeme
-      OLLAMA_URL: http://host.docker.internal:11434  # or http://<ip>:11434
-      DEFAULT_MODEL: llama3
-      APP_TZ: Europe/Berlin
-      DATABASE_URL: postgresql://llmproxy:secret@db:5432/llmproxy
-    volumes:
-      - llmproxy-data:/app/backend
-    depends_on:
-      db:
-        condition: service_healthy
-    # extra_hosts:
-    #   - "host.docker.internal:host-gateway"
-
-  db:
-    image: postgres:16-alpine
-    restart: unless-stopped
-    environment:
-      POSTGRES_DB: llmproxy
-      POSTGRES_USER: llmproxy
-      POSTGRES_PASSWORD: secret
-    volumes:
-      - pg-data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U llmproxy"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-
-volumes:
-  pg-data:
+`.env`:
+```env
+ADMIN_PASSWORD=changeme
+OLLAMA_URL=http://localhost:11434
+APP_TZ=Europe/Berlin
 ```
 
 ## Docker Compose – Ollama as Container, SQLite
 
-Ollama and llmproxy run together in Docker, data persisted in a volume.
+Ollama and llmproxy run together in Docker. Ollama is not exposed externally.
 
 ```yaml
 services:
@@ -124,11 +73,11 @@ services:
     restart: unless-stopped
     ports:
       - "8000:8000"
-      - "127.0.0.1:8001:8001"
+      - "8001:8001"
     environment:
       ADMIN_PASSWORD: changeme
       OLLAMA_URL: http://ollama:11434
-      DEFAULT_MODEL: llama3
+
       APP_TZ: Europe/Berlin
     volumes:
       - llmproxy-data:/app/backend
@@ -157,11 +106,11 @@ services:
     restart: unless-stopped
     ports:
       - "8000:8000"
-      - "127.0.0.1:8001:8001"
+      - "8001:8001"
     environment:
       ADMIN_PASSWORD: changeme
       OLLAMA_URL: http://ollama:11434
-      DEFAULT_MODEL: llama3
+
       APP_TZ: Europe/Berlin
       DATABASE_URL: postgresql://llmproxy:secret@db:5432/llmproxy
     depends_on:
@@ -196,17 +145,6 @@ volumes:
   ollama-data:
 ```
 
-## Quick Start
-
-```bash
-docker run -d \
-  -p 8000:8000 \
-  -e ADMIN_PASSWORD=changeme \
-  -e OLLAMA_URL=http://host.docker.internal:11434 \
-  -v llmproxy-data:/app/backend \
-  mediaeng/llmproxy:latest
-```
-
 ## Client Configuration
 
 Configure the proxy as an OpenAI-compatible endpoint:

DOCKERHUB.md

@@ -2,13 +2,12 @@
 
 Ein schlanker Reverse-Proxy für [Ollama](https://ollama.com), der API-Keys mit konfigurierbaren Token- und Request-Quoten verwaltet. Eingehende Anfragen im OpenAI-kompatiblen Format werden authentifiziert, auf Quota geprüft und an den konfigurierten Ollama-Server weitergeleitet.
 
-Ollama muss dabei nicht auf demselben Host laufen — `OLLAMA_URL` kann auf jeden erreichbaren Server zeigen, also auf den Docker-Host selbst, einen anderen Rechner im Netzwerk oder einen Remote-Server.
-
 ## Funktionen
 
 - OpenAI-kompatibler Endpunkt (`/v1/chat/completions`, `/v1/models`)
 - API-Key-Verwaltung mit tages- und monatlichen Token-/Request-Limits
 - Web-basierte Admin-Oberfläche (Port 8001)
+- Modell-Lock: erzwingt ein bestimmtes Modell für alle Requests (nützlich für Praktika/Kurse)
 - Streaming-Support (Server-Sent Events)
 - Tool-Use / Function Calling wird durchgereicht
 - Rotierende Nutzungs-Logs
@@ -21,12 +20,7 @@ Ollama muss dabei nicht auf demselben Host laufen — `OLLAMA_URL` kann auf jede
 | `8000` | Proxy-Endpunkt (OpenAI-API) |
 | `8001` | Admin-API + Web-Oberfläche |
 
-Port 8001 muss exposed werden, da der Container die Admin-Oberfläche selbst auf diesem Port ausliefert. Um den Zugriff auf den lokalen Rechner zu beschränken, die Portbindung auf `127.0.0.1` setzen — so ist der Port nur vom Host erreichbar, nicht aus dem Netzwerk:
-
-```
-ports:
-  - "127.0.0.1:8001:8001"
-```
+Alle API-Endpunkte erfordern das `ADMIN_PASSWORD` — ein Zugriff ohne gültiges Token liefert nur die öffentlichen Frontend-Dateien (HTML/JS/CSS der Login-Seite). Das Passwort ist damit die primäre Schutzmaßnahme.
 
 ## Umgebungsvariablen
 
@@ -34,88 +28,43 @@ ports:
 |----------|----------|--------------|
 | `ADMIN_PASSWORD` | – | **Pflicht.** Passwort für die Admin-Oberfläche |
 | `OLLAMA_URL` | `http://localhost:11434` | URL des Ollama-Servers (ohne `/v1`-Suffix) |
-| `DEFAULT_MODEL` | `llama3` | Modell, das verwendet wird wenn der Client keines angibt |
 | `DATABASE_URL` | `sqlite:///./test.db` | Datenbank-Verbindungsstring (SQLite oder PostgreSQL) |
 | `PROXY_HOST` | `0.0.0.0` | Bind-Adresse des Proxy |
 | `PROXY_PORT` | `8000` | Port des Proxy |
+| `ADMIN_HOST` | `0.0.0.0` | Bind-Adresse der Admin-API (`127.0.0.1` für lokalen Zugriff) |
 | `ADMIN_PORT` | `8001` | Port der Admin-API |
 | `APP_TZ` | `Europe/Berlin` | Zeitzone für Tages-/Monats-Reset der Quoten |
 | `LOG_FILE` | `logs/usage.log` | Pfad der rotierenden Nutzungs-Logdatei |
 
-## Docker Compose – Ollama extern, SQLite
+## Docker Compose – Ollama auf dem Host (Linux, empfohlen)
 
-Wenn Ollama außerhalb von Docker läuft — auf dem Docker-Host oder einem anderen erreichbaren Server. `OLLAMA_URL` entsprechend anpassen.
+`network_mode: host` gibt dem Container direkten Zugriff auf das Host-Netzwerk. Ollama läuft auf dem Host und ist über `localhost:11434` erreichbar — nach außen nicht sichtbar. Proxy und Admin-Oberfläche sind direkt auf den Host-Ports 8000 und 8001 verfügbar.
 
 ```yaml
 services:
   llmproxy:
     image: mediaeng/llmproxy:latest
+    container_name: llmproxy
     restart: unless-stopped
-    ports:
-      - "8000:8000"
-      - "127.0.0.1:8001:8001"
-    environment:
-      ADMIN_PASSWORD: changeme
-      OLLAMA_URL: http://host.docker.internal:11434  # oder http://<ip>:11434
-      DEFAULT_MODEL: llama3
-      APP_TZ: Europe/Berlin
+    network_mode: host
+    env_file: .env
     volumes:
       - llmproxy-data:/app/backend
-    # Auf Linux extra_hosts ergänzen, da host.docker.internal dort
-    # nicht automatisch verfügbar ist:
-    # extra_hosts:
-    #   - "host.docker.internal:host-gateway"
 
 volumes:
   llmproxy-data:
 ```
 
-## Docker Compose – Ollama extern, PostgreSQL
-
-```yaml
-services:
-  llmproxy:
-    image: mediaeng/llmproxy:latest
-    restart: unless-stopped
-    ports:
-      - "8000:8000"
-      - "127.0.0.1:8001:8001"
-    environment:
-      ADMIN_PASSWORD: changeme
-      OLLAMA_URL: http://host.docker.internal:11434  # oder http://<ip>:11434
-      DEFAULT_MODEL: llama3
-      APP_TZ: Europe/Berlin
-      DATABASE_URL: postgresql://llmproxy:secret@db:5432/llmproxy
-    volumes:
-      - llmproxy-data:/app/backend
-    depends_on:
-      db:
-        condition: service_healthy
-    # extra_hosts:
-    #   - "host.docker.internal:host-gateway"
-
-  db:
-    image: postgres:16-alpine
-    restart: unless-stopped
-    environment:
-      POSTGRES_DB: llmproxy
-      POSTGRES_USER: llmproxy
-      POSTGRES_PASSWORD: secret
-    volumes:
-      - pg-data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U llmproxy"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-
-volumes:
-  pg-data:
+`.env`:
+```env
+ADMIN_PASSWORD=changeme
+OLLAMA_URL=http://localhost:11434
+APP_TZ=Europe/Berlin
 ```
 
 ## Docker Compose – Ollama als Container, SQLite
 
-Ollama und llmproxy laufen gemeinsam in Docker, Daten in einem Volume.
+Ollama und llmproxy laufen gemeinsam in Docker. Ollama ist nicht nach außen exposed.
 
 ```yaml
 services:
@@ -124,11 +73,11 @@ services:
     restart: unless-stopped
     ports:
       - "8000:8000"
-      - "127.0.0.1:8001:8001"
+      - "8001:8001"
     environment:
       ADMIN_PASSWORD: changeme
       OLLAMA_URL: http://ollama:11434
-      DEFAULT_MODEL: llama3
+
       APP_TZ: Europe/Berlin
     volumes:
       - llmproxy-data:/app/backend
@@ -157,11 +106,11 @@ services:
     restart: unless-stopped
     ports:
       - "8000:8000"
-      - "127.0.0.1:8001:8001"
+      - "8001:8001"
     environment:
       ADMIN_PASSWORD: changeme
       OLLAMA_URL: http://ollama:11434
-      DEFAULT_MODEL: llama3
+
       APP_TZ: Europe/Berlin
       DATABASE_URL: postgresql://llmproxy:secret@db:5432/llmproxy
     depends_on:
@@ -196,17 +145,6 @@ volumes:
   ollama-data:
 ```
 
-## Schnellstart
-
-```bash
-docker run -d \
-  -p 8000:8000 \
-  -e ADMIN_PASSWORD=changeme \
-  -e OLLAMA_URL=http://host.docker.internal:11434 \
-  -v llmproxy-data:/app/backend \
-  mediaeng/llmproxy:latest
-```
-
 ## Client-Konfiguration
 
 Den Proxy als OpenAI-kompatibler Endpunkt konfigurieren:

KURZANLEITUNG.md

@@ -0,0 +1,165 @@
+# LLM-Dienst – Kurzanleitung
+
+## Worum geht es?
+
+Der Dienst stellt **große Sprachmodelle (LLMs)** über eine einfache HTTP-API bereit, die direkt aus Python-Skripten, Jupyter-Notebooks oder eigenen Anwendungen angesprochen werden kann. Die Modelle laufen lokal auf einem GPU-Server im Intranet – ohne Datenübertragung nach außen und ohne Cloud-Kosten.
+
+Typische Anwendungsfälle:
+
+- Texte zusammenfassen, übersetzen oder umformulieren
+- KI-gestütztes Coding (z.B. mit **[opencode](https://opencode.ai)**) 
+- Experimente mit Prompt-Engineering und LLM-Integration in eigene Projekte
+
+---
+
+## Zugang
+
+Der Dienst ist **nur im Intranet** erreichbar.
+
+| | |
+|---|---|
+| **API-Endpunkt** | `http://141.75.33.244:8000` |
+| **Authentifizierung** | API-Key erforderlich (per E-Mail beim Admin anfragen) |
+
+---
+
+## Verfügbare Modelle
+
+| Modell | Größe | Hinweis |
+|---|---|---|
+| `gemma4:31b` | 19 GB | kompakt, schnell |
+| `gpt-oss:20b` | 13 GB | kompakt, schnell |
+| `gpt-oss:120b` | 65 GB | sehr leistungsfähig |
+| `qwen3.5:122b` | 81 GB | sehr leistungsfähig |
+| `qwen3-coder-next:q8_0` | 84 GB | speziell für Code |
+
+> **Wichtig:** Es kann immer nur **ein Modell gleichzeitig** im GPU-Speicher geladen sein.
+> Wechselt jemand das Modell, muss das vorherige entladen und das neue geladen werden –
+> das kann **mehrere Minuten** dauern. Der erste Prompt nach einem Modellwechsel ist
+> deshalb deutlich langsamer. Danach bleibt das Modell einige Zeit geladen.
+
+---
+
+## Python-Beispiel – Einfacher Prompt
+
+Das API folgt dem **OpenAI-Standard**, d.h. die `openai`-Bibliothek kann direkt verwendet werden.
+
+```bash
+pip install openai
+```
+
+```python
+from openai import OpenAI
+
+API_KEY = "sk-..."            # euren API-Key eintragen
+BASE_URL = "http://141.75.33.244:8000/v1"
+MODEL = "gemma4:31b"          # Modell nach Bedarf wählen
+
+client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
+
+response = client.chat.completions.create(
+    model=MODEL,
+    messages=[
+        {"role": "user", "content": "Erkläre den Unterschied zwischen L1- und L2-Regularisierung."}
+    ]
+)
+
+print(response.choices[0].message.content)
+```
+
+---
+
+## Python-Beispiel – Verfügbare Modelle abfragen
+
+```python
+from openai import OpenAI
+
+API_KEY = "sk-..."
+BASE_URL = "http://141.75.33.244:8000/v1"
+
+client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
+
+models = client.models.list()
+for m in models.data:
+    print(m.id)
+```
+
+---
+
+## Empfehlungen zur Nutzung
+
+- **Kleines Modell zuerst** (`gemma4:31b` oder `gpt-oss:20b`) – viel schneller, für viele Aufgaben ausreichend.
+- **Großes Modell** nur bei komplexen Aufgaben (`qwen3.5:122b`, `gpt-oss:120b`).
+- **Code-Aufgaben**: `qwen3-coder-next:q8_0` ist speziell dafür optimiert.
+- Wenn möglich, **dasselbe Modell wie andere Nutzer** verwenden, um häufige Modellwechsel zu vermeiden.
+
+---
+
+## Quotas
+
+Je nach API-Key können folgende Limits konfiguriert sein:
+
+- Maximale **Anfragen pro Tag / Monat**
+- Maximale **Tokens pro Tag / Monat**
+
+Bei Überschreitung gibt die API den Statuscode `429 Too Many Requests` zurück.
+
+---
+
+## Coding-Assistent: opencode
+
+[opencode](https://opencode.ai) ist ein terminal-basierter KI-Coding-Agent (ähnlich Claude Code), der OpenAI-kompatible APIs unterstützt und damit direkt auf den Intranet-Dienst zeigen kann.
+
+### Installation
+
+```bash
+npm install -g opencode-ai
+# oder
+curl -fsSL https://opencode.ai/install | bash
+```
+
+### Konfiguration
+
+Konfigurationsdatei anlegen unter `~/.config/opencode/config.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "providers": {
+    "openai": {
+      "apiKey": "sk-...",
+      "baseURL": "http://141.75.33.244:8000/v1"
+    }
+  },
+  "model": "openai/qwen3-coder-next:q8_0"
+}
+```
+
+Für Code-Aufgaben empfiehlt sich `qwen3-coder-next:q8_0`, für allgemeine Aufgaben `gemma4:31b` oder `gpt-oss:20b`.
+
+### Starten
+
+```bash
+opencode
+```
+
+opencode öffnet eine interaktive Terminal-Oberfläche und kann dann im Projektverzeichnis eingesetzt werden – Dateien lesen, Code generieren, Refactoring vorschlagen usw.
+
+---
+
+## Administration (nur für Admins)
+
+Das Web-Interface zur Verwaltung von API-Keys und Quotas ist erreichbar unter:
+
+**`http://141.75.33.244:8001`**
+
+Dort können API-Keys angelegt, deaktiviert und mit Quotas versehen werden.
+
+### Modell-Lock für Praktika
+
+Unter **Einstellungen → Aktives Modell (Lock)** kann ein Modell fest vorgegeben werden. Ist ein Lock gesetzt, wird das `model`-Feld in jedem Request durch dieses Modell ersetzt – unabhängig davon, was der Client schickt. Das verhindert unkoordinierte Modellwechsel während einer Veranstaltung, die alle Teilnehmenden durch lange Ladezeiten ausbremsen würden.
+
+Typischer Ablauf für ein Praktikum:
+1. Vor der Veranstaltung: passendes Modell in Ollama laden
+2. Lock in der Admin-Oberfläche aktivieren
+3. Nach der Veranstaltung: Lock wieder deaktivieren (Feld leeren)

README.md

@@ -1,6 +1,6 @@
 # Ollama Proxy mit API-Keys und Quotas
 
-Ein Reverse-Proxy für Ollama mit API-Key-Authentifizierung, Quota-Management und Web-Admin-Oberfläche.
+Ollama bietet von sich aus keine Authentifizierung — wer die API erreicht, kann sie nutzen. Dieses Projekt löst das Problem: Ollama bleibt an `localhost` gebunden und ist von außen nicht erreichbar. Vorgeschaltet läuft ein Proxy (Port 8000), der jeden Request auf einen gültigen API-Key prüft und optional Token- sowie Request-Quoten pro Key durchsetzt. Eine Web-Admin-Oberfläche (Port 8001) erlaubt das Verwalten von Keys, Quoten und Ollama-Einstellungen.
 
 ## Features
 
@@ -8,30 +8,33 @@ Ein Reverse-Proxy für Ollama mit API-Key-Authentifizierung, Quota-Management un
 - Optionales Ablaufdatum pro API-Key
 - Quota-Management mit getrennten Tages- und Monatslimits (Tokens & Requests)
 - Token-Zählung via tiktoken, Reset-Grenzen in der Zeitzone Europe/Berlin
-- Web-Admin-Oberfläche (API-Keys verwalten, Ollama-Einstellungen, Proxy-Info)
-- OpenAI-kompatibler `/v1/chat/completions`-Endpunkt
+- Web-Admin-Oberfläche (API-Keys verwalten, Ollama-Einstellungen, Verbrauchsanzeige)
+- OpenAI-kompatibler `/v1/chat/completions`-Endpunkt mit Streaming und Tool-Use
+- Rotierende Nutzungs-Logs
+- SQLite (Standard) oder PostgreSQL
+- Docker-Image auf DockerHub: `mediaeng/llmproxy`
 
 ## Sicherheit
 
-- Admin-Oberfläche passwortgeschützt (`ADMIN_PASSWORD`)
-- Admin-API bindet lokal auf `127.0.0.1` (nicht von außen erreichbar)
+- Admin-Oberfläche passwortgeschützt (`ADMIN_PASSWORD`) — alle API-Endpunkte erfordern den Token
 - API-Keys als SHA-256-Hash in der DB — Plaintext nur einmalig bei Erstellung
 - Quota-Check atomar mit `SELECT FOR UPDATE` (kein TOCTOU-Race)
-- CORS-Origins konfigurierbar via `ALLOWED_ORIGINS`
+- Admin-Port 8001 über `ADMIN_HOST=127.0.0.1` auf lokalen Zugriff beschränkbar
 
 ## Konfiguration
 
-`.env`-Datei im Projektverzeichnis anlegen (Vorlage: `.env.example`):
+`.env`-Datei im Projektverzeichnis anlegen:
 
 ```env
 ADMIN_PASSWORD=change-me
 PROXY_HOST=0.0.0.0
 PROXY_PORT=8000
+ADMIN_HOST=0.0.0.0
 ADMIN_PORT=8001
 DATABASE_URL=sqlite:///./test.db
 OLLAMA_URL=http://localhost:11434
-DEFAULT_MODEL=llama3
 APP_TZ=Europe/Berlin
+LOG_FILE=logs/usage.log
 ```
 
 | Variable | Standard | Beschreibung |
@@ -39,26 +42,16 @@ APP_TZ=Europe/Berlin
 | `ADMIN_PASSWORD` | — | Passwort für die Admin-Oberfläche (**Pflicht**) |
 | `PROXY_HOST` | `0.0.0.0` | Bind-Adresse des Proxys |
 | `PROXY_PORT` | `8000` | Port des Proxys |
+| `ADMIN_HOST` | `0.0.0.0` | Bind-Adresse der Admin-API (z. B. `127.0.0.1` für lokalen Zugriff) |
 | `ADMIN_PORT` | `8001` | Port der Admin-API |
-| `DATABASE_URL` | `sqlite:///./test.db` | DB-Verbindungsstring |
+| `DATABASE_URL` | `sqlite:///./test.db` | DB-Verbindungsstring (SQLite oder PostgreSQL) |
 | `OLLAMA_URL` | `http://localhost:11434` | Adresse der Ollama-Instanz (auch in der UI änderbar) |
-| `DEFAULT_MODEL` | `llama3` | Standard-Modell für `/v1/chat/completions` (auch in der UI änderbar) |
 | `APP_TZ` | `Europe/Berlin` | Zeitzone für tägliche/monatliche Quota-Resets |
-| `ALLOWED_ORIGINS` | `http://localhost:5173` | Kommagetrennte CORS-Origins |
+| `LOG_FILE` | `logs/usage.log` | Pfad der rotierenden Nutzungs-Logdatei |
+| `ALLOWED_ORIGINS` | `http://localhost:5173` | CORS-Origins (nur für Entwicklung relevant) |
 
 ## Entwicklung (lokal)
 
-```bash
-cp .env.example .env
-# ADMIN_PASSWORD in .env setzen
-
-./start.sh
-```
-
-Das Script prüft alle Ports auf Belegung, aktiviert automatisch eine vorhandene `.venv`, initialisiert die Datenbank und startet Proxy, Admin-API und Vite-Dev-Server.
-
-Admin-Oberfläche: `http://localhost:5173`
-
 ### Voraussetzungen
 
 - Python 3.12+ mit virtualenv
@@ -68,71 +61,117 @@ Admin-Oberfläche: `http://localhost:5173`
 python -m venv .venv
 source .venv/bin/activate
 pip install -r backend/requirements-dev.txt
-
 cd frontend && npm install
 ```
 
+### Starten
+
+**Per Script:**
+```bash
+cp .env.example .env   # ADMIN_PASSWORD setzen
+./start.sh
+```
+
+**Per PyCharm:** Run-Config „Dev" starten (startet Proxy, Admin-API und Vite-Dev-Server gemeinsam).
+
+Das Script prüft alle Ports auf Belegung, initialisiert die Datenbank und startet alle drei Dienste.
+
+Admin-Oberfläche: `http://localhost:5173`
+
 ## Produktion (Docker)
 
-### Image bauen
+### Docker Compose (empfohlen)
 
 ```bash
-docker build -t llm-quota .
+docker compose up -d
 ```
 
-### Container starten
+Zieht das Image von DockerHub und lädt Variablen aus `.env`.
+
+Das Setup verwendet `network_mode: host`: Der Container teilt den Netzwerkstack des Hosts, statt ein eigenes virtuelles Netzwerk zu bekommen. Das ist hier aus zwei Gründen die richtige Wahl:
+
+1. **Ollama soll nicht von außen erreichbar sein.** Ollama läuft auf dem Host und ist an `127.0.0.1:11434` gebunden — nur lokal erreichbar. Mit einem eigenen Container-Netzwerk (Bridge-Mode) wäre `localhost` aus Sicht des Containers der Container selbst, nicht der Host. Die übliche Alternative (`host.docker.internal` + `extra_hosts`) ist auf Linux unzuverlässig.
+
+2. **Kein doppeltes Port-Mapping nötig.** Mit `network_mode: host` sind Port 8000 und 8001 direkt auf dem Host verfügbar, ohne `ports:`-Einträge in der Compose-Datei.
+
+### Image selbst bauen und pushen
 
 ```bash
-docker run -d \
-  -p 8000:8000 \
-  -p 127.0.0.1:8001:8001 \
-  -e ADMIN_PASSWORD=geheim \
-  -e OLLAMA_URL=http://host.docker.internal:11434 \
-  -e DATABASE_URL=sqlite:///./data/quota.db \
-  -v $(pwd)/data:/app/backend/data \
-  --name llm-quota \
-  llm-quota
+./build_push.sh
 ```
 
-| Port | Bindung | Dienst |
-|------|---------|--------|
-| `8000` | `0.0.0.0` — öffentlich | Proxy (für LLM-Clients) |
-| `8001` | `127.0.0.1` — nur lokal am Server | Admin-API + Admin-Oberfläche |
+Das Script zeigt den aktuellen Git-Tag, bietet an einen neuen zu setzen, baut das Image für `linux/arm64` und pusht zu `mediaeng/llmproxy`.
 
-Docker unterscheidet beim Port-Mapping zwischen `0.0.0.0` (alle Interfaces, öffentlich erreichbar) und `127.0.0.1` (nur der Server selbst kann zugreifen). Mit `-p 127.0.0.1:8001:8001` ist Port 8001 am Server verfügbar, aber von außen nicht direkt ansprechbar.
+### Port 8001 (Admin)
 
-### Admin-Oberfläche per SSH-Tunnel erreichbar machen
+Alle Admin-Endpunkte erfordern das `ADMIN_PASSWORD` — der Token ist der primäre Schutz. Für zusätzliche Härtung lässt sich die Admin-API auf lokalen Zugriff beschränken:
 
-Der SSH-Tunnel leitet einen lokalen Port auf den Server weiter und nutzt dabei, dass Port 8001 dort auf `127.0.0.1` erreichbar ist:
-
-```
-Admin-Laptop:8001  ──SSH──►  Server:127.0.0.1:8001  ──►  Container:8001
+```env
+ADMIN_HOST=127.0.0.1
 ```
 
-```bash
-ssh -L 8001:localhost:8001 user@server
+Bei `network_mode: host` (Produktions-Standard) ist das die einzig wirksame Methode — Docker-Port-Mapping greift dort nicht.
+
+### HTTPS via Reverse-Proxy (ungetestet)
+
+Wer Proxy und Admin-Oberfläche per HTTPS bereitstellen will, kann einen weiteren Reverse-Proxy (z. B. Nginx oder Caddy) vorschalten. Bei `network_mode: host` lauschen beide Dienste direkt auf dem Host, Nginx/Caddy proxyen auf `localhost`.
+
+**Caddy** (empfohlen — automatisches TLS via Let's Encrypt):
+
+```
+llm.example.com {
+    reverse_proxy localhost:8000 {
+        flush_interval -1
+    }
+}
+
+llm-admin.example.com {
+    reverse_proxy localhost:8001
+}
 ```
 
-Danach ist die Admin-Oberfläche auf dem Laptop unter `http://localhost:8001` erreichbar — ohne dass Port 8001 öffentlich exponiert wird.
+**Nginx** (mit Certbot-Zertifikaten):
 
-### Mit PostgreSQL
+```nginx
+server {
+    listen 443 ssl;
+    server_name llm.example.com;
 
-```bash
-docker run -d \
-  -p 8000:8000 \
-  -p 127.0.0.1:8001:8001 \
-  -e ADMIN_PASSWORD=geheim \
-  -e DATABASE_URL=postgresql://user:pass@db-host:5432/llm_quota \
-  -e OLLAMA_URL=http://ollama:11434 \
-  llm-quota
+    ssl_certificate     /etc/letsencrypt/live/llm.example.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/llm.example.com/privkey.pem;
+
+    location / {
+        proxy_pass         http://127.0.0.1:8000;
+        proxy_set_header   Host $host;
+        proxy_set_header   X-Real-IP $remote_addr;
+        proxy_buffering    off;   # nötig für Streaming
+        proxy_cache        off;
+    }
+}
+
+server {
+    listen 443 ssl;
+    server_name llm-admin.example.com;
+
+    ssl_certificate     /etc/letsencrypt/live/llm-admin.example.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/llm-admin.example.com/privkey.pem;
+
+    location / {
+        proxy_pass       http://127.0.0.1:8001;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
 ```
 
+Clients konfigurieren dann `https://llm.example.com/v1` als Base URL.
+
 ## Proxy-Endpunkte (Port 8000)
 
 Alle Endpunkte erfordern einen gültigen API-Key im `Authorization`-Header.
 
 ```bash
-curl -X POST http://localhost:8000/api/chat \
+curl -X POST http://localhost:8000/v1/chat/completions \
   -H "Authorization: Bearer sk-xxxxxx" \
   -H "Content-Type: application/json" \
   -d '{"model":"llama3","messages":[{"role":"user","content":"Hallo"}]}'
@@ -140,12 +179,12 @@ curl -X POST http://localhost:8000/api/chat \
 
 | Endpunkt | Methode | Beschreibung |
 |----------|---------|--------------|
-| `/api/generate` | POST | Ollama generate |
-| `/api/chat` | POST | Ollama chat |
+| `/v1/chat/completions` | POST | Chat (OpenAI-Format, Streaming + Tool-Use) |
+| `/v1/models` | GET | Modelle (OpenAI-Format) |
+| `/api/generate` | POST | Ollama generate (nativ) |
+| `/api/chat` | POST | Ollama chat (nativ) |
 | `/api/tags` | GET | Verfügbare Modelle |
 | `/api/versions` | GET | Ollama-Version |
-| `/v1/models` | GET | Modelle (OpenAI-Format) |
-| `/v1/chat/completions` | POST | Chat (OpenAI-Format) |
 
 ## Admin-API (Port 8001)
 
@@ -153,10 +192,12 @@ Alle Endpunkte erfordern `Authorization: Bearer <ADMIN_PASSWORD>`.
 
 | Endpunkt | Methode | Beschreibung |
 |----------|---------|--------------|
-| `/api/api-keys` | GET | Alle API-Keys auflisten |
+| `/api/api-keys` | GET | Alle API-Keys mit Verbrauchsdaten |
 | `/api/api-keys` | POST | Neuen API-Key erstellen |
+| `/api/api-keys/{id}/quota` | PATCH | Limits eines Keys aktualisieren |
+| `/api/api-keys/{id}/activate` | PUT | API-Key aktivieren |
 | `/api/api-keys/{id}/deactivate` | PUT | API-Key deaktivieren |
-| `/api/api-keys/{id}/quota` | PATCH | Quota eines Keys aktualisieren |
+| `/api/api-keys/{id}` | DELETE | API-Key löschen |
 | `/api/settings` | GET/PUT | Ollama-URL und Standard-Modell |
 | `/api/ollama-models` | GET | Verfügbare Modelle von Ollama |
 | `/api/proxy-info` | GET | Lokaler Proxy-Endpunkt |
@@ -180,22 +221,27 @@ llm_quota/
 │   ├── schemas.py           # Pydantic-Schemas
 │   ├── crud.py              # DB-Operationen, Token-Zählung, Quota-Logik
 │   ├── init_db.py           # Tabellen anlegen & Settings seeden
-│   ├── setup_admin.py       # Standard-API-Key erstellen
 │   ├── requirements.txt     # Produktiv-Dependencies
 │   ├── requirements-dev.txt # Test-Dependencies
 │   └── tests/
-│       ├── conftest.py      # Fixtures
-│       ├── test_auth.py     # Authentifizierungs-Tests
-│       └── test_quota.py    # Quota-, Token- und Ablauf-Tests
+│       ├── conftest.py
+│       ├── test_auth.py
+│       └── test_quota.py
 ├── frontend/
 │   └── src/
 │       ├── main.jsx         # React-Admin-UI
 │       └── styles.css
+├── .idea/runConfigurations/
+│   └── Dev.xml              # PyCharm Run-Config
 ├── Dockerfile
+├── docker-compose.yml       # Produktiv-Start mit DockerHub-Image
 ├── docker-entrypoint.sh
 ├── .dockerignore
-├── .env.example
 ├── start.sh                 # Entwicklungs-Startscript
+├── run_dev.py               # Entwicklungs-Runner für PyCharm
+├── build_push.sh            # Docker-Build & Push zu DockerHub
+├── DOCKERHUB.md             # DockerHub-Beschreibung (deutsch)
+├── DOCKERHUB.en.md          # DockerHub-Beschreibung (englisch)
 └── .gitignore
 ```
 

backend/admin.py

@@ -137,7 +137,7 @@ async def get_proxy_info(_ = Depends(require_admin_auth)):
 async def read_settings(db: Session = Depends(get_db), _ = Depends(require_admin_auth)):
     return schemas.Settings(
         ollama_url=crud.get_setting(db, "ollama_url", "http://localhost:11434"),
-        default_model=crud.get_setting(db, "default_model", "llama3"),
+        force_model=crud.get_setting(db, "force_model") or None,
     )
 
 @app.put("/api/settings", response_model=schemas.Settings)
@@ -148,8 +148,8 @@ async def update_settings(
 ):
     ollama_url = settings.ollama_url.rstrip('/').removesuffix('/v1')
     crud.set_setting(db, "ollama_url", ollama_url)
-    crud.set_setting(db, "default_model", settings.default_model)
-    return schemas.Settings(ollama_url=ollama_url, default_model=settings.default_model)
+    crud.set_setting(db, "force_model", settings.force_model or "")
+    return schemas.Settings(ollama_url=ollama_url, force_model=settings.force_model or None)
 
 @app.get("/api/ollama-models")
 async def get_ollama_models(
@@ -162,9 +162,9 @@ async def get_ollama_models(
         async with httpx.AsyncClient(timeout=5.0) as client:
             response = await client.get(f"{ollama_url}/api/tags")
         models = [m["name"] for m in response.json().get("models", [])]
+        return {"models": models, "reachable": True}
     except Exception:
-        models = []
-    return {"models": models}
+        return {"models": [], "reachable": False}
 
 # Statisches Frontend ausliefern (nur im Produktivbetrieb, wenn dist/ existiert)
 _dist = Path(__file__).parent.parent / "frontend" / "dist"

backend/init_db.py

@@ -13,8 +13,6 @@ def init_db():
     db = SessionLocal()
     if not get_setting(db, "ollama_url"):
         set_setting(db, "ollama_url", os.getenv("OLLAMA_URL", "http://localhost:11434"))
-    if not get_setting(db, "default_model"):
-        set_setting(db, "default_model", os.getenv("DEFAULT_MODEL", "llama3"))
     db.close()
 
     print("Database initialized.")

backend/main.py

@@ -10,20 +10,40 @@ from database import get_db
 import crud
 import httpx
 
+_log_dir = Path(os.getenv("LOG_FILE", "logs/usage.log")).parent
+_log_dir.mkdir(parents=True, exist_ok=True)
+_fmt = logging.Formatter("%(asctime)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+
 # Rotating usage log (8 KB per file, 3 backups)
-_log_path = Path(os.getenv("LOG_FILE", "logs/usage.log"))
-_log_path.parent.mkdir(parents=True, exist_ok=True)
-_handler = RotatingFileHandler(str(_log_path), maxBytes=8192, backupCount=3, encoding="utf-8")
-_handler.setFormatter(logging.Formatter("%(asctime)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S"))
+_usage_handler = RotatingFileHandler(str(_log_dir / "usage.log"), maxBytes=8192, backupCount=3, encoding="utf-8")
+_usage_handler.setFormatter(_fmt)
 usage_log = logging.getLogger("proxy.usage")
 usage_log.setLevel(logging.INFO)
-usage_log.addHandler(_handler)
+usage_log.addHandler(_usage_handler)
 usage_log.propagate = False
 
+# Rotating error log (64 KB per file, 5 backups)
+_error_handler = RotatingFileHandler(str(_log_dir / "error.log"), maxBytes=65536, backupCount=5, encoding="utf-8")
+_error_handler.setFormatter(_fmt)
+error_log = logging.getLogger("proxy.error")
+error_log.setLevel(logging.ERROR)
+error_log.addHandler(_error_handler)
+error_log.propagate = False
+
+def _content_to_str(content) -> str:
+    """Normalize OpenAI content: string or array of content parts → plain string."""
+    if isinstance(content, list):
+        return " ".join(
+            part.get("text", "") if isinstance(part, dict) else str(part)
+            for part in content
+        )
+    return content or ""
+
+
 def _last_user_msg(messages: list, max_len: int = 120) -> str:
     for msg in reversed(messages):
         if msg.get("role") == "user":
-            text = (msg.get("content") or "").replace("\n", " ").strip()
+            text = _content_to_str(msg.get("content")).replace("\n", " ").strip()
             return text[:max_len] + ("…" if len(text) > max_len else "")
     return ""
 
@@ -43,6 +63,23 @@ async def require_api_key(request: Request, db: Session = Depends(get_db)):
 
 app = FastAPI(title="Ollama Proxy", dependencies=[Depends(require_api_key)])
 
+@app.on_event("startup")
+def apply_env_settings():
+    """Write env-configured values into DB so they take effect until next restart."""
+    db = next(get_db())
+    try:
+        if url := os.getenv("OLLAMA_URL"):
+            crud.set_setting(db, "ollama_url", url)
+        db.commit()
+    finally:
+        db.close()
+
+@app.exception_handler(Exception)
+async def unhandled_exception_handler(request: Request, exc: Exception):
+    error_log.error("Unhandled exception | %s %s | %s: %s",
+                    request.method, request.url.path, type(exc).__name__, exc, exc_info=exc)
+    return JSONResponse(status_code=500, content={"error": {"message": "Internal server error", "type": "server_error"}})
+
 async def proxy_request(url: str, method: str = "GET", json_data: dict = None):
     async with httpx.AsyncClient(timeout=300.0) as client:
         response = await client.request(method=method, url=url, json=json_data)
@@ -52,6 +89,11 @@ async def proxy_request(url: str, method: str = "GET", json_data: dict = None):
 async def generate(request: Request, db: Session = Depends(get_db)):
     ollama_url = crud.get_setting(db, "ollama_url", os.getenv("OLLAMA_URL", "http://localhost:11434"))
     body = await request.json()
+    force_model = crud.get_setting(db, "force_model") or None
+    if force_model:
+        body = {**body, "model": force_model}
+    if not body.get("model"):
+        raise HTTPException(status_code=422, detail="Field 'model' is required")
     prompt_tokens = crud.count_tokens(body.get("prompt", ""))
 
     if not crud.check_and_increment_quota(db, request.state.api_key_id, tokens=prompt_tokens, requests=1):
@@ -60,23 +102,46 @@ async def generate(request: Request, db: Session = Depends(get_db)):
     prompt_preview = (body.get("prompt", "").replace("\n", " ").strip())[:120]
     usage_log.info('%s | /api/generate | %s | ~%d tokens | "%s"',
                    request.state.api_key_name, body.get("model", "?"), prompt_tokens, prompt_preview)
+    try:
         response = await proxy_request(f"{ollama_url}/api/generate", method="POST", json_data=body)
-    return JSONResponse(content=response.json(), status_code=response.status_code)
+        resp_json = response.json()
+        usage_log.info('%s | /api/generate | %s | actual ↑%d ↓%d tokens',
+                       request.state.api_key_name, body.get("model", "?"),
+                       resp_json.get("prompt_eval_count", 0), resp_json.get("eval_count", 0))
+        return JSONResponse(content=resp_json, status_code=response.status_code)
+    except Exception as exc:
+        error_log.error("Proxy error | %s | /api/generate | %s | %s: %s",
+                        request.state.api_key_name, body.get("model", "?"), type(exc).__name__, exc, exc_info=exc)
+        raise
 
 @app.post("/api/chat")
 async def chat(request: Request, db: Session = Depends(get_db)):
     ollama_url = crud.get_setting(db, "ollama_url", os.getenv("OLLAMA_URL", "http://localhost:11434"))
     body = await request.json()
+    force_model = crud.get_setting(db, "force_model") or None
+    if force_model:
+        body = {**body, "model": force_model}
+    if not body.get("model"):
+        raise HTTPException(status_code=422, detail="Field 'model' is required")
     messages = body.get("messages", [])
-    prompt_tokens = sum(crud.count_tokens(msg.get("content") or "") for msg in messages)
+    prompt_tokens = sum(crud.count_tokens(_content_to_str(msg.get("content"))) for msg in messages)
 
     if not crud.check_and_increment_quota(db, request.state.api_key_id, tokens=prompt_tokens, requests=1):
         raise HTTPException(status_code=429, detail="Quota exceeded")
 
     usage_log.info('%s | /api/chat | %s | ~%d tokens | "%s"',
                    request.state.api_key_name, body.get("model", "?"), prompt_tokens, _last_user_msg(messages))
+    try:
         response = await proxy_request(f"{ollama_url}/api/chat", method="POST", json_data=body)
-    return JSONResponse(content=response.json(), status_code=response.status_code)
+        resp_json = response.json()
+        usage_log.info('%s | /api/chat | %s | actual ↑%d ↓%d tokens',
+                       request.state.api_key_name, body.get("model", "?"),
+                       resp_json.get("prompt_eval_count", 0), resp_json.get("eval_count", 0))
+        return JSONResponse(content=resp_json, status_code=response.status_code)
+    except Exception as exc:
+        error_log.error("Proxy error | %s | /api/chat | %s | %s: %s",
+                        request.state.api_key_name, body.get("model", "?"), type(exc).__name__, exc, exc_info=exc)
+        raise
 
 @app.get("/api/tags")
 async def list_models(db: Session = Depends(get_db)):
@@ -99,19 +164,21 @@ async def list_openai_models(db: Session = Depends(get_db)):
 @app.post("/v1/chat/completions")
 async def openai_chat_completions(request: Request, db: Session = Depends(get_db)):
     ollama_url = crud.get_setting(db, "ollama_url", os.getenv("OLLAMA_URL", "http://localhost:11434"))
-    default_model = crud.get_setting(db, "default_model", os.getenv("DEFAULT_MODEL", "llama3"))
 
     body = await request.json()
+    force_model = crud.get_setting(db, "force_model") or None
+    if force_model:
+        body = {**body, "model": force_model}
+    if not body.get("model"):
+        raise HTTPException(status_code=422, detail="Field 'model' is required")
     messages = body.get("messages", [])
-    prompt_tokens = sum(crud.count_tokens(msg.get("content") or "") for msg in messages)
+    prompt_tokens = sum(crud.count_tokens(_content_to_str(msg.get("content"))) for msg in messages)
 
     if not crud.check_and_increment_quota(db, request.state.api_key_id, tokens=prompt_tokens, requests=1):
         raise HTTPException(status_code=429, detail="Quota exceeded")
 
-    if "model" not in body:
-        body = {**body, "model": default_model}
-
     model_name = body["model"]
+
     usage_log.info('%s | /v1/chat/completions | %s | ~%d tokens | "%s"',
                    request.state.api_key_name, model_name, prompt_tokens, _last_user_msg(messages))
 
@@ -119,15 +186,30 @@ async def openai_chat_completions(request: Request, db: Session = Depends(get_db
 
     if body.get("stream"):
         async def generate():
+            try:
                 async with httpx.AsyncClient(timeout=300.0) as client:
                     async with client.stream("POST", target, json=body) as resp:
                         async for chunk in resp.aiter_bytes():
                             yield chunk
+            except Exception as exc:
+                error_log.error("Stream error | %s | /v1/chat/completions | %s | %s: %s",
+                                request.state.api_key_name, model_name, type(exc).__name__, exc, exc_info=exc)
+                raise
         return StreamingResponse(
             generate(),
             media_type="text/event-stream",
             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
         )
 
+    try:
         response = await proxy_request(target, method="POST", json_data=body)
-    return JSONResponse(content=response.json(), status_code=response.status_code)
+        resp_json = response.json()
+        usage = resp_json.get("usage", {})
+        usage_log.info('%s | /v1/chat/completions | %s | actual ↑%d ↓%d tokens',
+                       request.state.api_key_name, model_name,
+                       usage.get("prompt_tokens", 0), usage.get("completion_tokens", 0))
+        return JSONResponse(content=resp_json, status_code=response.status_code)
+    except Exception as exc:
+        error_log.error("Proxy error | %s | /v1/chat/completions | %s | %s: %s",
+                        request.state.api_key_name, model_name, type(exc).__name__, exc, exc_info=exc)
+        raise

backend/schemas.py

@@ -40,7 +40,7 @@ class QuotaUpdate(BaseModel):
 
 class Settings(BaseModel):
     ollama_url: str
-    default_model: str
+    force_model: Optional[str] = None
 
 class UsageStats(BaseModel):
     tokens_used_today: int = 0

build_push.sh

@@ -5,17 +5,24 @@ cd "$(dirname "$0")"
 IMAGE=mediaeng/llmproxy
 PLATFORM=linux/arm64
 
-CURRENT=$(git describe --tags --always)
-if [ -z "$CURRENT" ]; then
-    echo "Fehler: git describe liefert kein Ergebnis"
+LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || true)
+HEAD_TAG=$(git tag --points-at HEAD | head -1)
+
+if [ -n "$HEAD_TAG" ]; then
+    echo "HEAD bereits getaggt: $HEAD_TAG"
+    read -rp "Neuer Tag [${HEAD_TAG}]: " INPUT
+    VERSION="${INPUT:-$HEAD_TAG}"
+else
+    echo "Letzter Tag: ${LAST_TAG:-kein Tag}"
+    read -rp "Neuer Tag: " INPUT
+    if [ -z "$INPUT" ]; then
+        echo "Kein Tag angegeben, breche ab."
         exit 1
+    fi
+    VERSION="$INPUT"
 fi
 
-echo "Aktueller Tag: $CURRENT"
-read -rp "Neuer Tag [${CURRENT}]: " INPUT
-VERSION="${INPUT:-$CURRENT}"
-
-if [ "$VERSION" != "$CURRENT" ]; then
+if [ "$VERSION" != "$HEAD_TAG" ]; then
     git tag "$VERSION"
     git push origin "$VERSION"
     echo "Tag '$VERSION' gesetzt und gepusht."

docker-compose.yml

@@ -1,11 +1,11 @@
 services:
   llmproxy:
     image: mediaeng/llmproxy:latest
+    container_name: llmproxy
     restart: unless-stopped
+    network_mode: host
     env_file: .env
-    ports:
-      - "${PROXY_PORT:-8000}:${PROXY_PORT:-8000}"
-      - "127.0.0.1:8001:8001"
     volumes:
       - ./backend/test.db:/app/backend/test.db
       - ./backend/logs:/app/backend/logs
+

docker-entrypoint.sh

@@ -10,7 +10,7 @@ uvicorn main:app \
 PROXY_PID=$!
 
 uvicorn admin:app \
-    --host "0.0.0.0" \
+    --host "${ADMIN_HOST:-0.0.0.0}" \
     --port "${ADMIN_PORT:-8001}" &
 ADMIN_PID=$!
 

frontend/src/main.jsx

@@ -80,6 +80,7 @@ function SettingsSection({ password }) {
   const [settings, setSettings] = useState(null);
   const [availableModels, setAvailableModels] = useState([]);
   const [modelsLoading, setModelsLoading] = useState(false);
+  const [ollamaReachable, setOllamaReachable] = useState(true);
   const [proxyEndpoint, setProxyEndpoint] = useState(null);
   const [saved, setSaved] = useState(false);
   const [error, setError] = useState(null);
@@ -91,12 +92,14 @@ function SettingsSection({ password }) {
         headers: authHeaders(password),
         params: url ? { url } : {},
       });
-      const models = res.data.models;
+      const { models, reachable } = res.data;
+      setOllamaReachable(reachable);
       setAvailableModels(models);
-      if (models.length > 0 && !models.includes(currentModel)) {
-        setSettings(s => ({ ...s, default_model: models[0] }));
+      if (models.length > 0 && currentModel && !models.includes(currentModel)) {
+        setSettings(s => ({ ...s, force_model: models[0] }));
       }
     } catch {
+      setOllamaReachable(false);
       setAvailableModels([]);
     } finally {
       setModelsLoading(false);
@@ -112,7 +115,7 @@ function SettingsSection({ password }) {
       const s = settingsRes.data;
       setSettings(s);
       setProxyEndpoint(proxyRes.data.endpoint);
-      fetchModels(s.ollama_url, s.default_model);
+      fetchModels(s.ollama_url, s.force_model);
     }).catch(() => setError('Einstellungen konnten nicht geladen werden.'));
   }, []);
 
@@ -144,33 +147,38 @@ function SettingsSection({ password }) {
         </div>
         <div className="settings-row">
           <label>Ollama-Endpunkt</label>
+          <div className="settings-input-wrap">
             <input
               type="url"
               value={settings.ollama_url}
               onChange={(e) => setSettings({ ...settings, ollama_url: e.target.value })}
-            onBlur={(e) => fetchModels(e.target.value, settings.default_model)}
+              onBlur={(e) => fetchModels(e.target.value, settings.force_model)}
               placeholder="http://localhost:11434"
               required
             />
+            {!ollamaReachable && !modelsLoading && (
+              <div className="warning">⚠ Ollama nicht erreichbar unter {settings.ollama_url}</div>
+            )}
+          </div>
         </div>
         <div className="settings-row">
-          <label>Standard-Modell</label>
+          <label>Aktives Modell (Lock)</label>
           {modelsLoading ? (
             <span className="settings-value">Lade Modelle…</span>
           ) : availableModels.length > 0 ? (
             <select
-              value={settings.default_model}
-              onChange={(e) => setSettings({ ...settings, default_model: e.target.value })}
+              value={settings.force_model || ""}
+              onChange={(e) => setSettings({ ...settings, force_model: e.target.value || null })}
             >
+              <option value="">— kein Lock —</option>
               {availableModels.map(m => <option key={m} value={m}>{m}</option>)}
             </select>
           ) : (
             <input
               type="text"
-              value={settings.default_model}
-              onChange={(e) => setSettings({ ...settings, default_model: e.target.value })}
-              placeholder="llama3"
-              required
+              value={settings.force_model || ""}
+              onChange={(e) => setSettings({ ...settings, force_model: e.target.value || null })}
+              placeholder="leer = kein Lock"
             />
           )}
         </div>

frontend/src/styles.css

@@ -194,6 +194,31 @@ tr:hover {
   font-size: 14px;
 }
 
+.settings-input-wrap {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.settings-input-wrap input {
+  width: 100%;
+  padding: 8px 10px;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  font-size: 14px;
+  box-sizing: border-box;
+}
+
+.warning {
+  color: #b8520a;
+  background: #fff3e0;
+  border: 1px solid #e67e22;
+  border-radius: 4px;
+  padding: 6px 10px;
+  font-size: 13px;
+}
+
 .settings-form button {
   align-self: flex-start;
   padding: 8px 20px;

frontend/vite.config.js

@@ -5,6 +5,7 @@ export default defineConfig({
   plugins: [react()],
   clearScreen: false,
   server: {
+    open: true,
     proxy: {
       '/api/api-keys': 'http://localhost:8001',
       '/api/settings': 'http://localhost:8001',

run_dev.py

@@ -40,13 +40,14 @@ def main():
 
     proxy_host = os.environ.get('PROXY_HOST', '0.0.0.0')
     proxy_port = os.environ.get('PROXY_PORT', '8000')
+    admin_host = os.environ.get('ADMIN_HOST', '127.0.0.1')
     admin_port = os.environ.get('ADMIN_PORT', '8001')
 
     print('Initialisiere Datenbank...')
     subprocess.run([str(python), 'init_db.py'], cwd=backend, check=True)
 
     print(f'Starte Proxy      → http://{proxy_host}:{proxy_port}')
-    print(f'Starte Admin-API  → http://127.0.0.1:{admin_port}')
+    print(f'Starte Admin-API  → http://{admin_host}:{admin_port}')
     print('Starte Frontend   → http://localhost:5173')
 
     env = {**os.environ, 'PYTHONUNBUFFERED': '1'}
@@ -59,7 +60,7 @@ def main():
         ), 'Proxy   ', '34'),  # blau
         (subprocess.Popen(
             [str(python), '-m', 'uvicorn', 'admin:app', '--reload',
-             '--host', '127.0.0.1', '--port', admin_port],
+             '--host', admin_host, '--port', admin_port],
             cwd=backend, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env,
         ), 'Admin   ', '33'),  # gelb
         (subprocess.Popen(

start.sh

@@ -21,6 +21,7 @@ fi
 
 PROXY_HOST=${PROXY_HOST:-0.0.0.0}
 PROXY_PORT=${PROXY_PORT:-8000}
+ADMIN_HOST=${ADMIN_HOST:-127.0.0.1}
 ADMIN_PORT=${ADMIN_PORT:-8001}
 FRONTEND_PORT=5173
 
@@ -60,9 +61,8 @@ cd backend
 python3 -m uvicorn main:app --reload --host "$PROXY_HOST" --port "$PROXY_PORT" &
 PIDS+=($!)
 
-# Admin-API immer nur lokal erreichbar (Host nicht konfigurierbar)
-echo "Starte Admin-API auf 127.0.0.1:${ADMIN_PORT}..."
-python3 -m uvicorn admin:app --reload --host 127.0.0.1 --port "$ADMIN_PORT" &
+echo "Starte Admin-API auf ${ADMIN_HOST}:${ADMIN_PORT}..."
+python3 -m uvicorn admin:app --reload --host "$ADMIN_HOST" --port "$ADMIN_PORT" &
 PIDS+=($!)
 cd ..
 
@@ -75,7 +75,7 @@ PIDS+=($!)
 cd ..
 
 echo "Backend läuft (Port $PROXY_PORT)"
-echo "Admin-API läuft (Port $ADMIN_PORT, nur lokal)"
+echo "Admin-API läuft (${ADMIN_HOST}:${ADMIN_PORT})"
 echo "Admin-Oberfläche: http://localhost:$FRONTEND_PORT"
 
 wait