Log actual tokens and elapsed time for all endpoints incl. streaming

For streaming /v1/chat/completions: inject stream_options.include_usage, parse usage from SSE chunks, log actual ↑↓ tokens and wall time in the generator's finally block. Add elapsed time to all second log entries.
Show app version in admin UI and /version endpoint
2026-05-08 09:47:32 +02:00 · 2026-05-08 09:30:23 +02:00 · 2026-05-08 09:25:44 +02:00 · 2026-05-08 09:22:17 +02:00 · 2026-05-08 09:17:08 +02:00 · 2026-05-08 08:41:49 +02:00
13 changed files with 295 additions and 39 deletions
@@ -42,6 +42,8 @@ docker-compose.yml

 # Docs
 *.md
+*.tex
+*.pdf

 # Dev & build scripts
 run_dev.py
@@ -26,4 +26,8 @@ frontend/node_modules/
 frontend/dist/

 # Misc
-config.json
+config.json
+
+# Generated documents
+KURZANLEITUNG.tex
+KURZANLEITUNG.pdf
@@ -7,6 +7,7 @@ A lightweight reverse proxy for [Ollama](https://ollama.com) that manages API ke
 - 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
@@ -27,7 +28,6 @@ All API endpoints require the `ADMIN_PASSWORD` — without a valid token, only t
 |----------|---------|-------------|
 | `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 |
@@ -59,7 +59,6 @@ volumes:
 ```env
 ADMIN_PASSWORD=changeme
 OLLAMA_URL=http://localhost:11434
-DEFAULT_MODEL=llama3
 APP_TZ=Europe/Berlin
 ```

@@ -78,7 +77,7 @@ services:
    environment:
      ADMIN_PASSWORD: changeme
      OLLAMA_URL: http://ollama:11434
-      DEFAULT_MODEL: llama3
+
      APP_TZ: Europe/Berlin
    volumes:
      - llmproxy-data:/app/backend
@@ -111,7 +110,7 @@ services:
    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:
@@ -7,6 +7,7 @@ Ein schlanker Reverse-Proxy für [Ollama](https://ollama.com), der API-Keys mit
 - 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
@@ -27,7 +28,6 @@ Alle API-Endpunkte erfordern das `ADMIN_PASSWORD` — ein Zugriff ohne gültiges
 |----------|----------|--------------|
 | `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 |
@@ -59,7 +59,6 @@ volumes:
 ```env
 ADMIN_PASSWORD=changeme
 OLLAMA_URL=http://localhost:11434
-DEFAULT_MODEL=llama3
 APP_TZ=Europe/Berlin
 ```

@@ -78,7 +77,7 @@ services:
    environment:
      ADMIN_PASSWORD: changeme
      OLLAMA_URL: http://ollama:11434
-      DEFAULT_MODEL: llama3
+
      APP_TZ: Europe/Berlin
    volumes:
      - llmproxy-data:/app/backend
@@ -111,7 +110,7 @@ services:
    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:
@@ -6,6 +6,8 @@ COPY frontend/ frontend/
 RUN npm run build --prefix frontend

 FROM python:3.12-slim
+ARG APP_VERSION=dev
+ENV APP_VERSION=$APP_VERSION
 WORKDIR /app

 COPY backend/requirements.txt .
@@ -0,0 +1,183 @@
+# 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 (VPN)** 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)
+```
+
+---
+
+## Aktuell geladenes Modell abfragen
+
+Da immer nur ein Modell gleichzeitig im Speicher sein kann, lässt sich mit folgendem Aufruf prüfen, welches Modell gerade aktiv ist:
+
+```python
+import httpx
+
+r = httpx.get(
+    "http://141.75.33.244:8000/api/ps",
+    headers={"Authorization": "Bearer sk-..."}
+)
+print(r.json())
+```
+
+Die Antwort enthält Modellname, Größe und wie lange das Modell noch im Speicher bleibt.
+
+---
+
+## 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)
@@ -33,7 +33,6 @@ 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
 ```
@@ -47,7 +46,6 @@ LOG_FILE=logs/usage.log
 | `ADMIN_PORT` | `8001` | Port der Admin-API |
 | `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 |
 | `LOG_FILE` | `logs/usage.log` | Pfad der rotierenden Nutzungs-Logdatei |
 | `ALLOWED_ORIGINS` | `http://localhost:5173` | CORS-Origins (nur für Entwicklung relevant) |
@@ -131,13 +131,16 @@ async def get_proxy_info(_ = Depends(require_admin_auth)):
    host = os.getenv("PROXY_HOST", "0.0.0.0")
    port = os.getenv("PROXY_PORT", "8000")
    display_host = "localhost" if host in ("0.0.0.0", "::") else host
-    return {"endpoint": f"http://{display_host}:{port}"}
+    return {
+        "endpoint": f"http://{display_host}:{port}",
+        "version": os.getenv("APP_VERSION", "dev"),
+    }

@app.get("/api/settings", response_model=schemas.Settings)
 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 +151,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(
@@ -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.")
@@ -1,5 +1,7 @@
+import json
 import logging
 import os
+import time
 from logging.handlers import RotatingFileHandler
 from pathlib import Path

@@ -70,8 +72,6 @@ def apply_env_settings():
    try:
        if url := os.getenv("OLLAMA_URL"):
            crud.set_setting(db, "ollama_url", url)
-        if model := os.getenv("DEFAULT_MODEL"):
-            crud.set_setting(db, "default_model", model)
        db.commit()
    finally:
        db.close()
@@ -91,6 +91,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):
@@ -99,9 +104,15 @@ 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)
+    start = time.monotonic()
    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 | %.1fs',
+                       request.state.api_key_name, body.get("model", "?"),
+                       resp_json.get("prompt_eval_count", 0), resp_json.get("eval_count", 0),
+                       time.monotonic() - start)
+        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)
@@ -111,6 +122,11 @@ async def generate(request: Request, db: Session = Depends(get_db)):
 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(_content_to_str(msg.get("content"))) for msg in messages)

@@ -119,9 +135,15 @@ async def chat(request: Request, db: Session = Depends(get_db)):

    usage_log.info('%s | /api/chat | %s | ~%d tokens | "%s"',
                   request.state.api_key_name, body.get("model", "?"), prompt_tokens, _last_user_msg(messages))
+    start = time.monotonic()
    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 | %.1fs',
+                       request.state.api_key_name, body.get("model", "?"),
+                       resp_json.get("prompt_eval_count", 0), resp_json.get("eval_count", 0),
+                       time.monotonic() - start)
+        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)
@@ -133,6 +155,16 @@ async def list_models(db: Session = Depends(get_db)):
    response = await proxy_request(f"{ollama_url}/api/tags", method="GET")
    return JSONResponse(content=response.json(), status_code=response.status_code)

+@app.get("/version")
+async def version():
+    return {"version": os.getenv("APP_VERSION", "dev")}
+
+@app.get("/api/ps")
+async def running_models(db: Session = Depends(get_db)):
+    ollama_url = crud.get_setting(db, "ollama_url", os.getenv("OLLAMA_URL", "http://localhost:11434"))
+    response = await proxy_request(f"{ollama_url}/api/ps", method="GET")
+    return JSONResponse(content=response.json(), status_code=response.status_code)
+
@app.get("/api/versions")
 async def versions(db: Session = Depends(get_db)):
    ollama_url = crud.get_setting(db, "ollama_url", os.getenv("OLLAMA_URL", "http://localhost:11434"))
@@ -148,44 +180,73 @@ 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(_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))

    target = f"{ollama_url}/v1/chat/completions"

    if body.get("stream"):
+        existing_opts = body.get("stream_options") or {}
+        stream_body = {**body, "stream_options": {**existing_opts, "include_usage": True}}
+        start = time.monotonic()
+        usage_tokens = {"prompt": 0, "completion": 0}
+
        async def generate():
            try:
                async with httpx.AsyncClient(timeout=300.0) as client:
-                    async with client.stream("POST", target, json=body) as resp:
+                    async with client.stream("POST", target, json=stream_body) as resp:
                        async for chunk in resp.aiter_bytes():
+                            try:
+                                for line in chunk.decode("utf-8", errors="ignore").splitlines():
+                                    if line.startswith("data: ") and "[DONE]" not in line:
+                                        data = json.loads(line[6:])
+                                        if u := data.get("usage"):
+                                            usage_tokens["prompt"] = u.get("prompt_tokens", 0)
+                                            usage_tokens["completion"] = u.get("completion_tokens", 0)
+                            except Exception:
+                                pass
                            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
+            finally:
+                usage_log.info('%s | /v1/chat/completions | %s | actual ↑%d ↓%d tokens | %.1fs',
+                               request.state.api_key_name, model_name,
+                               usage_tokens["prompt"], usage_tokens["completion"],
+                               time.monotonic() - start)
+
        return StreamingResponse(
            generate(),
            media_type="text/event-stream",
            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
        )

+    start = time.monotonic()
    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 | %.1fs',
+                       request.state.api_key_name, model_name,
+                       usage.get("prompt_tokens", 0), usage.get("completion_tokens", 0),
+                       time.monotonic() - start)
+        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)
@@ -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
@@ -37,6 +37,7 @@ echo ""
 docker buildx build \
    --platform "$PLATFORM" \
    --push \
+    --build-arg APP_VERSION="$VERSION" \
    -t "$IMAGE:$VERSION" \
    -t "$IMAGE:latest" \
    .
@@ -82,6 +82,7 @@ function SettingsSection({ password }) {
  const [modelsLoading, setModelsLoading] = useState(false);
  const [ollamaReachable, setOllamaReachable] = useState(true);
  const [proxyEndpoint, setProxyEndpoint] = useState(null);
+  const [appVersion, setAppVersion] = useState(null);
  const [saved, setSaved] = useState(false);
  const [error, setError] = useState(null);

@@ -95,8 +96,8 @@ function SettingsSection({ password }) {
      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);
@@ -115,7 +116,8 @@ function SettingsSection({ password }) {
      const s = settingsRes.data;
      setSettings(s);
      setProxyEndpoint(proxyRes.data.endpoint);
-      fetchModels(s.ollama_url, s.default_model);
+      setAppVersion(proxyRes.data.version);
+      fetchModels(s.ollama_url, s.force_model);
    }).catch(() => setError('Einstellungen konnten nicht geladen werden.'));
  }, []);

@@ -145,6 +147,10 @@ function SettingsSection({ password }) {
            <small> (Änderung erfordert Neustart)</small>
          </span>
        </div>
+        <div className="settings-row">
+          <label>Version</label>
+          <span className="settings-value">{appVersion ?? '…'}</span>
+        </div>
        <div className="settings-row">
          <label>Ollama-Endpunkt</label>
          <div className="settings-input-wrap">
@@ -152,7 +158,7 @@ function SettingsSection({ password }) {
              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
            />
@@ -162,23 +168,23 @@ function SettingsSection({ password }) {
          </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>
Author	SHA1	Message	Date
Oliver Hofmann	70fd61608b	Log actual tokens and elapsed time for all endpoints incl. streaming For streaming /v1/chat/completions: inject stream_options.include_usage, parse usage from SSE chunks, log actual ↑↓ tokens and wall time in the generator's finally block. Add elapsed time to all second log entries.	2026-05-08 09:47:32 +02:00
Oliver Hofmann	07f6fec4bf	Show app version in admin UI and /version endpoint Embed APP_VERSION build arg in Docker image (default: dev). build_push.sh passes the git tag as build arg. Proxy exposes GET /version, admin UI shows it as read-only field in settings.	2026-05-08 09:30:23 +02:00
Oliver Hofmann	6761a73364	Add /api/ps example to Kurzanleitung	2026-05-08 09:25:44 +02:00
Oliver Hofmann	0d1ce96c99	Expose /api/ps to show currently loaded model	2026-05-08 09:22:17 +02:00
Oliver Hofmann	b16b3af44d	Mention VPN as alias for Intranet in Kurzanleitung	2026-05-08 09:17:08 +02:00
Oliver Hofmann	fdbe0a74e8	Exclude .tex and .pdf from Docker build context	2026-05-08 08:41:49 +02:00
Oliver Hofmann	0154c89c6b	Improve Python examples and opencode description in Kurzanleitung Split second example into focused model listing only, remove repeated prompt code. Replace TUI with 'interaktive Terminal-Oberfläche'.	2026-05-08 08:40:25 +02:00
Oliver Hofmann	e3dbed9f5e	Ignore generated KURZANLEITUNG.tex and .pdf	2026-05-08 08:15:07 +02:00
Oliver Hofmann	5b37718120	Fix list indentation in KURZANLEITUNG.md	2026-05-08 08:07:02 +02:00
Oliver Hofmann	f823e7d314	Return 422 when model field is missing and no force_model is set Prevents an opaque Ollama error from reaching the client by failing fast with a clear message before the request is forwarded.	2026-05-08 08:04:52 +02:00
Oliver Hofmann	34b108f4df	Replace default_model with force_model (model lock) Removes DEFAULT_MODEL in favour of a force_model setting configurable via the admin UI. When set, every proxy request's model field is overridden, preventing uncoordinated model switches during lab sessions. Updates schemas, admin API, all three proxy endpoints, frontend, init_db, and docs (README, DOCKERHUB, KURZANLEITUNG).	2026-05-08 08:02:16 +02:00
Oliver Hofmann	cced65693c	Log actual Ollama token counts and add user guide Add a second usage log line after each proxy response with actual ↑prompt ↓completion token counts from Ollama (prompt_eval_count/eval_count for native endpoints, usage object for OpenAI endpoint). Also adds KURZANLEITUNG.md for students and colleagues covering API access, model selection, Python examples, opencode setup, and quota/admin information.	2026-05-08 07:21:36 +02:00