# Autoprotocol

Autoprotocol ist ein lokaler Streamlit-Prototyp zur Erstellung strukturierter Sitzungsprotokolle aus Audio- oder Videoaufzeichnungen.

## Funktionsumfang

- Mobile-freundliche Web-App über Streamlit, erreichbar im Tailnet
- Upload von Audio-/Videodateien inklusive iPhone Voice Memos (`.m4a`) und iPhone/iPad Videos (`.mov`, `.mp4`)
- Kontext-Uploads für Teams-/Zoom-Transkripte, Traktandenlisten und Vorprotokolle
- Transkription und Speaker-Diarization via WhisperX
- Separate STT-Profile: Hermes/Telegram bleibt schnell (`medium`), AutoProtocol nutzt lokal `large-v3` auf CUDA
- Protokollgenerierung via ChatGPT/CodexCLI (`CODEX_MODEL`, Standard: `gpt-5.5`)
- Export als Word-Dokument (`.docx`)
- Prompt-Profile für verschiedene Sitzungsarten in `config/prompts.yaml`

## Voraussetzungen

- Python 3.11+ empfohlen
- `ffmpeg` im Systempfad
- CUDA-fähige GPU für WhisperX/Torch empfohlen
- CodexCLI im `PATH` und mit ChatGPT/OpenAI-Auth eingerichtet (`codex doctor`)
- HuggingFace Token für diarization-fähige WhisperX-Modelle

## Setup

```bash
cd /home/agent/projects/Autoprotocol
uv venv .venv --python 3.11
uv pip install --python .venv/bin/python -r requirements.txt
cp .env.example .env
```

Danach in `.env` mindestens den HuggingFace Token setzen:

```bash
HF_TOKEN=<your-huggingface-token>
CODEX_MODEL=gpt-5.5
CODEX_TIMEOUT_SECONDS=1800

# STT für Sitzungs-Aufzeichnungen. Bewusst getrennt von Hermes Telegram-STT.
AUTOPROTOCOL_WHISPER_MODEL=large-v3
AUTOPROTOCOL_WHISPER_DEVICE=cuda
AUTOPROTOCOL_WHISPER_COMPUTE_TYPE=float16
AUTOPROTOCOL_WHISPER_FALLBACK_COMPUTE_TYPE=int8_float16
AUTOPROTOCOL_WHISPER_BATCH_SIZE=2
AUTOPROTOCOL_WHISPER_LANGUAGE=de
```

### STT-/GPU-Betrieb

AutoProtocol lädt WhisperX standardmässig mit `large-v3` auf CUDA. Chatterbox TTS wird dabei **nicht** automatisch gestoppt; wir testen bewusst den Parallelbetrieb. Falls der VRAM beim ersten Modell-Load nicht reicht, versucht AutoProtocol automatisch denselben `large-v3`-Lauf mit `int8_float16`, bevor der Job abbricht.

Für maximale Qualität/Reserve kann Chatterbox vor langen Batch-Transkriptionen manuell gestoppt werden; für den normalen Testbetrieb bleibt es parallel aktiv.

## Start

```bash
cd /home/agent/projects/Autoprotocol
.venv/bin/streamlit run app.py
```

## Web-App unterwegs nutzen

Die Web-App ist für Tailnet-Zugriff vorbereitet. Auf diesem Host läuft sie als User-Systemd-Service:

```bash
systemctl --user status autoprotocol-webapp.service
systemctl --user restart autoprotocol-webapp.service
```

Repo-nahe Start/Status/Stop-Helfer:

```bash
cd /home/agent/projects/Autoprotocol
scripts/start-webapp.sh
scripts/status-webapp.sh
scripts/stop-webapp.sh
```

Standard-Port: `8501`, Bind-Adresse: `0.0.0.0`, Upload-Limit: `4096 MB`.
Die aktuelle Tailnet-URL steht in der Ausgabe von `scripts/status-webapp.sh`, z. B.:

```text
http://100.101.173.25:8501/
```

Auf iPhone/iPad unterstützt der Upload insbesondere:

- Voice Memos / Sprachmemos als `.m4a`
- Videos aus Fotos/Dateien als `.mov` oder `.mp4`
- klassische Audioformate wie `.wav`, `.mp3`, `.aac`, `.ogg`, `.flac`

Die App speichert temporäre Eingaben unter `input/` und erzeugte Dokumente unter `output/`.

## Lokale Daten und Secrets

Folgende Pfade werden bewusst nicht versioniert:

- `.env`
- `input/`
- `output/`
- `venv/` / `.venv/`
- `__pycache__/`

Keine Rohdaten, generierten Protokolle oder Tokens ins Git committen.

## Projektstruktur

```text
app.py                 Streamlit UI
autoprotocol.py        WhisperX-Transkription und Word-Export
llm_processor.py       ChatGPT/CodexCLI-Protokollgenerierung
config/prompts.yaml    Sitzungsarten und Prompt-Konfiguration
.streamlit/config.toml Streamlit-Konfiguration
```

## Verifikation

Minimaler Syntaxcheck:

```bash
.venv/bin/python -m py_compile app.py autoprotocol.py llm_processor.py
```

LLM-/DOCX-Smoke ohne externen Modellaufruf:

```bash
AUTOPROTOCOL_LLM_MOCK=1 .venv/bin/python - <<'PY'
from llm_processor import generate_protocol_with_llm, save_llm_to_word
text = generate_protocol_with_llm([{'speaker':'SPEAKER_00','text':'Wir beschliessen den Test.'}], 'jour_fixe', 'SPEAKER_00 = Testperson')
print(save_llm_to_word(text, 'smoke.wav'))
PY
```

Ein vollständiger End-to-End-Test benötigt GPU, gültigen HuggingFace Token, `ffmpeg`, CodexCLI-Auth und lokale Testmedien.