vault backup: 2026-05-03 00:50:13

2026-05-03 00:50:13 +02:00
parent 6fb6404344
commit 68e8607abb
3 changed files with 129 additions and 4 deletions
--- a/Intelligenz/Entwicklerumgebung.md
+++ b/Intelligenz/Entwicklerumgebung.md
@@ -0,0 +1,125 @@
+# 1. Erstelle ein Volume für die Modelle (damit sie bei Updates nicht gelöscht werden)
+podman volume create mistral-models
+
+# 2. Starte das All-in-One Paket (GPU Support inklusive)
+podman run -d -p 3000:8080 \
+  --gpus all \
+  -v mistral-models:/app/backend/data \
+  --name mistral-station \
+  ghcr.io/open-webui/open-webui:main
+
+
+Anleitung:
+
+Diese Workstation ist ein absolutes Kraftpaket. Mit dem **9950X3D** (dem aktuell schnellsten Consumer-Prozessor für Multitasking und Gaming), der **RTX 5080** (Blackwell-Architektur mit massiver Tensor-Power) und **96 GB RAM** hast du eine Umgebung, die viele professionelle KI-Server in den Schatten stellt.
+
+Hier ist dein kompletter Masterplan für das "Mistral-Headquarter" auf Bazzite.
+
+---
+
+## Schritt 1: Das Fundament (Host-Ebene)
+
+Bazzite ist ein "Atomic Desktop". Wir installieren nichts direkt im System, sondern nutzen **Flatpaks** für GUI-Apps und **Podman/Distrobox** für die Entwicklung.
+
+1. **System-Update & Treiber-Check:** Stelle sicher, dass deine RTX 5080 voll erkannt wird:
+    
+    Bash
+    
+    ```
+    ujust setup-nvidia # Falls bei der Installation nicht automatisch konfiguriert
+    nvidia-smi
+    ```
+    
+2. **Basis-Tools installieren:**
+    
+    Bash
+    
+    ```
+    flatpak install flathub com.visualstudio.code io.podman_desktop.PodmanDesktop com.github.geigi.gearlever
+    ```
+    
+
+---
+
+## Schritt 2: KI-Infrastruktur (Lokal & Privat)
+
+Du nutzt Mistral als dein "Gehirn". Da du Apps für Linux und GrapheneOS bauen willst, brauchen wir ein Setup, das Code versteht.
+
+1. **Ollama als Backend (für VS Code Integration):**
+    
+    Bash
+    
+    ```
+    podman run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama docker.io/ollama/ollama
+    podman exec -it ollama ollama run mistral-nemo
+    ```
+    
+2. **Open WebUI (Dein lokales Gemini/Claude Interface):**
+    
+    Bash
+    
+    ```
+    podman run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
+    
+    ```
+    
+
+```
+    *   *Nutzen:* Unter `localhost:3000` kannst du Dokumente hochladen, Code-Architekturen planen und Bilder (via Pixtral) analysieren.
+
+---
+
+## Schritt 3: Die Dev-Umgebung für Apps & GrapheneOS
+
+Für Linux-Programme und GrapheneOS (Android-Basis) brauchst du spezifische Toolchains (Java, Rust, Android SDK). Wir kapseln diese in **Distrobox**, damit dein Bazzite sauber bleibt.
+
+1.  **Entwicklungs-Container erstellen:**
+    ```bash
+    distrobox create -n dev-station --image fedora:latest --nvidia
+    distrobox enter dev-station
+    # Innerhalb der Distrobox Tools installieren:
+    sudo dnf install git rust cargo nodejs java-latest-openjdk-devel
+    ```
+2.  **GrapheneOS / Android Entwicklung:**
+    Lade das Android Studio "Linux Bundle" herunter und installiere es innerhalb der Distrobox oder als Flatpak. Da GrapheneOS auf AOSP basiert, kannst du Apps ganz normal mit Kotlin/Compose entwickeln und über die Konsole (ADB) auf dein GrapheneOS-Gerät schieben.
+
+3.  **KI-Integration in VS Code:**
+    *   Öffne VS Code.
+    *   Installiere die Extension **Continue**.
+    *   Verbinde sie mit deinem lokalen Ollama (`localhost:11434`).
+    *   *Nutzen:* Die KI schreibt dir Boilerplate-Code für deine GrapheneOS-Apps oder Linux-Skripte.
+
+---
+
+## Schritt 4: Eigene KIs entwickeln (Fine-Tuning)
+
+Deine Hardware ist perfekt, um bestehende Modelle (wie Mistral) auf deine eigenen Daten zu trainieren (Fine-Tuning).
+
+1.  **Tooling:** Nutze **Unsloth** oder **Axolotl** (in einem Podman-Container).
+2.  **Daten:** Sammle deine Dokumente/Code in einem Ordner.
+3.  **Training:** Nutze deine RTX 5080. Dank 16 GB VRAM kannst du Mistral 7B oder NeMo 12B mittels **QLoRA** in wenigen Stunden auf deinem eigenen PC trainieren.
+
+---
+
+## Schritt 5: GitLab & Sicherungs-Konzept
+
+1.  **GitLab Projekt:** Erstelle ein Repo namens `Workstation-Config`.
+2.  **Automatisierung:** Erstelle ein Shell-Skript `install.sh`, das alle oben genannten `podman` und `flatpak` Befehle enthält.
+3.  **Versionierung:** Lade deine `.devcontainer` Dateien und deine KI-Prompts (System Prompts) in GitLab hoch.
+4.  **Hardware-Backups:** Da du 4 TB hast, nutze **Pika Backup** (Flatpak), um dein `/home` Verzeichnis täglich auf eine separate Partition oder eine externe Platte zu sichern.
+
+---
+
+## Warum deine Workstation "perfekt" ist:
+
+*   **Der 9950X3D:** Die 16 Kerne und der riesige L3-Cache sind ein Segen beim Kompilieren von Android/AOSP-Code (GrapheneOS). Es verkürzt die Wartezeit massiv.
+*   **RTX 5080:** Die Blackwell-Architektur bietet überlegene Geschwindigkeit bei der Token-Generierung. Du wirst kaum einen Unterschied zu Cloud-Diensten merken.
+*   **96 GB RAM:** Dies erlaubt dir das **"Model Switching"**. Du kannst Mistral Large im Hintergrund geladen lassen (für schwere Denkaufgaben) und gleichzeitig mit Mistral NeMo auf der GPU programmieren.
+
+### Der Nutzen für dich:
+1.  **Absolute Privatsphäre:** Dein Code für GrapheneOS oder deine eigenen KIs verlässt nie deine 4 TB Platte.
+2.  **Unabhängigkeit:** Keine Abokosten für Claude/Gemini.
+3.  **Speed:** Lokale KIs haben keine Latenz durch Internetverbindungen oder Server-Warteschlangen.
+
+**Welches Projekt möchtest du als erstes angehen: Eine Linux-App oder eine Android-App für dein GrapheneOS?**
+```