865 lines
27 KiB
Markdown
865 lines
27 KiB
Markdown
# Eugen – Intelligenter Gaming & 3D-Druck Twitch-Bot
|
||
## Komplettes Setup & Implementierungs-Guide für Windows
|
||
|
||
---
|
||
|
||
## 📋 Inhaltsverzeichnis
|
||
|
||
1. [Überblick](#überblick)
|
||
2. [Systemanforderungen](#systemanforderungen)
|
||
3. [Installation & Setup](#installation--setup)
|
||
4. [Konfigurationsassistent](#konfigurationsassistent)
|
||
5. [GUI Dashboard](#gui-dashboard)
|
||
6. [Architektur & Implementierung](#architektur--implementierung)
|
||
7. [API-Integration & Debugging](#api-integration--debugging)
|
||
8. [Fehlerbehandlung](#fehlerbehandlung)
|
||
9. [Projektstruktur](#projektstruktur)
|
||
|
||
---
|
||
|
||
## Überblick
|
||
|
||
**Eugen** ist ein intelligenter Twitch-Chat-Agent für:
|
||
- **Gaming**: World of Warcraft, Elden Ring, Gamedev
|
||
- **3D-Druck**: Prusa i3, Bambu, Creality
|
||
- **Tech**: Python, Linux, Home Automation
|
||
|
||
### Kernfeatures
|
||
|
||
| Feature | Beschreibung |
|
||
|---------|-------------|
|
||
| **Name Recognition** | Erkennt automatisch wenn angesprochen (@Eugen, Eugen:, etc.) |
|
||
| **Persistent Memory** | Speichert Chat-History pro User (max 25 Nachrichten) |
|
||
| **Context-Aware** | Antwortet basierend auf vorherigem Gesprächsverlauf |
|
||
| **Perplexity Integration** | Nutzt Perplexity Sonar für Echtzeit-Web-Suche |
|
||
| **Live Monitoring** | GUI zeigt alle API-Calls, Responses, Fehler in Echtzeit |
|
||
| **Windows-Native** | Vollständige Windows-Unterstützung, keine Linux-Tools nötig |
|
||
|
||
---
|
||
|
||
## Systemanforderungen
|
||
|
||
### Minimal
|
||
- Windows 10/11
|
||
- Python 3.9+
|
||
- 100 MB Festplatte
|
||
- Internetverbindung
|
||
|
||
### Empfohlen
|
||
- Python 3.11+
|
||
- 500 MB Festplatte (für Chat-History & Logs)
|
||
- Stabiles Netzwerk (für IRC & API)
|
||
|
||
---
|
||
|
||
## Installation & Setup
|
||
|
||
### Schritt 1: Python installieren
|
||
|
||
1. Gehe zu [python.org](https://www.python.org/downloads/)
|
||
2. Lade **Python 3.11+** herunter
|
||
3. **WICHTIG**: Häkchen setzen bei "Add Python to PATH"
|
||
4. Installieren
|
||
|
||
**Verifizieren:**
|
||
```powershell
|
||
python --version
|
||
pip --version
|
||
```
|
||
|
||
### Schritt 2: Projekt initialisieren
|
||
|
||
```powershell
|
||
# Neuer Ordner für Eugen
|
||
mkdir C:\Users\YourUsername\eugen
|
||
cd C:\Users\YourUsername\eugen
|
||
|
||
# Virtual Environment erstellen
|
||
python -m venv venv
|
||
|
||
# Aktivieren (Windows PowerShell)
|
||
.\venv\Scripts\Activate.ps1
|
||
|
||
# Falls Fehler bei Ausführungsrichtlinie:
|
||
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
|
||
# Dann nochmal: .\venv\Scripts\Activate.ps1
|
||
```
|
||
|
||
### Schritt 3: Dependencies installieren
|
||
|
||
```powershell
|
||
pip install -r requirements.txt
|
||
```
|
||
|
||
**requirements.txt:**
|
||
```
|
||
perplexity-python-client==1.0.0
|
||
irc==20.1.0
|
||
python-dotenv==1.0.0
|
||
PySimpleGUI==4.60.0
|
||
requests==2.31.0
|
||
```
|
||
|
||
---
|
||
|
||
## Konfigurationsassistent
|
||
|
||
### Setup-Flow (Automatisch beim ersten Start)
|
||
|
||
Beim ersten Start wird ein **interaktives Setup-Fenster** angezeigt:
|
||
|
||
```
|
||
╔════════════════════════════════════════════════════════════════╗
|
||
║ EUGEN KONFIGURATIONSASSISTENT ║
|
||
╠════════════════════════════════════════════════════════════════╣
|
||
║ ║
|
||
║ 1️⃣ TWITCH KONFIGURATION ║
|
||
║ ─────────────────────────────────────────────────────────── ║
|
||
║ Bot-Name: [___________________________] ║
|
||
║ OAuth Token: [***hidden***] [🔑 Anleitung] ║
|
||
║ Channel: [___________________________] ║
|
||
║ ║
|
||
║ 2️⃣ PERPLEXITY KONFIGURATION ║
|
||
║ ─────────────────────────────────────────────────────────── ║
|
||
║ API Key: [***hidden***] [🔑 Anleitung] ║
|
||
║ Model: [sonar-pro ▼] ║
|
||
║ Max Tokens: [450] ║
|
||
║ ║
|
||
║ 3️⃣ BOT-VERHALTEN ║
|
||
║ ─────────────────────────────────────────────────────────── ║
|
||
║ ☑ Context Memory aktivieren ║
|
||
║ ☑ Name Recognition aktivieren ║
|
||
║ ☑ Debug-Mode (zeigt API-Calls) ║
|
||
║ ║
|
||
║ [Speichern & Starten] [Abbrechen] ║
|
||
║ ║
|
||
╚════════════════════════════════════════════════════════════════╝
|
||
```
|
||
|
||
### API-Keys beschaffen
|
||
|
||
#### Twitch OAuth Token
|
||
|
||
1. Gehe zu [twitchtokengenerator.com](https://twitchtokengenerator.com/) **ODER** manuell:
|
||
- [Twitch Developer Console](https://dev.twitch.tv/console/apps)
|
||
- Neue Anwendung erstellen
|
||
- OAuth-Authentifizierung
|
||
- Scopes: `chat:read`, `chat:edit`
|
||
- Token generieren
|
||
|
||
2. **Token Format:** `oauth:abcd1234efgh5678...`
|
||
3. **Speichern in Setup-Fenster**
|
||
|
||
**⚠️ WICHTIG:** Token niemals ins Repository committen!
|
||
|
||
#### Perplexity API Key
|
||
|
||
1. Gehe zu [perplexity.ai/api](https://www.perplexity.ai/api)
|
||
2. Registrieren / Anmelden
|
||
3. API Keys → Neuen Key generieren
|
||
4. **Format:** `pplx-abcd1234efgh5678...`
|
||
5. **Speichern in Setup-Fenster**
|
||
|
||
---
|
||
|
||
## GUI Dashboard
|
||
|
||
### Live Monitoring Interface
|
||
|
||
Während der Bot läuft, zeigt das Dashboard in Echtzeit:
|
||
|
||
```
|
||
╔════════════════════════════════════════════════════════════════════╗
|
||
║ EUGEN BOT - LIVE DASHBOARD ║
|
||
╠════════════════════════════════════════════════════════════════════╣
|
||
║ ║
|
||
║ STATUS: 🟢 VERBUNDEN (Kanal: #dein_kanal) ║
|
||
║ Uptime: 00:45:23 | Messages: 12 | Errors: 0 ║
|
||
║ ║
|
||
║ ┌────────────────────────────────────────────────────────────┐ ║
|
||
║ │ LIVE CHAT AKTIVITÄT │ ║
|
||
║ ├────────────────────────────────────────────────────────────┤ ║
|
||
║ │ 12:02:15 | User123: Eugen, was ist dein Lieblings-Game? │ ║
|
||
║ │ 12:02:16 | [API] → Perplexity (sonar-pro) │ ║
|
||
║ │ 12:02:18 | [RESPONSE] Mein Lieblings-Game ist WoW... │ ║
|
||
║ │ 12:02:19 | Eugen: @User123 Mein Lieblings-Game ist WoW... │ ║
|
||
║ │ │ ║
|
||
║ │ 12:03:05 | User456: Eugen, wie levelt man schnell? │ ║
|
||
║ │ 12:03:06 | [CONTEXT] Gefundener History (3 msgs) │ ║
|
||
║ │ 12:03:06 | [API] → Perplexity (sonar-pro) │ ║
|
||
║ │ 12:03:08 | [RESPONSE] Die besten Leveling-Spots sind... │ ║
|
||
║ │ 12:03:09 | Eugen: @User456 Die besten Leveling-Spots... │ ║
|
||
║ └────────────────────────────────────────────────────────────┘ ║
|
||
║ ║
|
||
║ ┌─────────────────────┬─────────────────────────────────────┐ ║
|
||
║ │ API STATISTIKEN │ FEHLER LOG │ ║
|
||
║ ├─────────────────────┼─────────────────────────────────────┤ ║
|
||
║ │ Requests: 12 │ (Leer - alles OK!) │ ║
|
||
║ │ Avg Response: 620ms │ │ ║
|
||
║ │ Costs: $0.0036 │ │ ║
|
||
║ │ Erfolgsrate: 100% │ │ ║
|
||
║ └─────────────────────┴─────────────────────────────────────┘ ║
|
||
║ ║
|
||
║ [Settings] [Clear Logs] [Export Data] [Stop Bot] ║
|
||
║ ║
|
||
╚════════════════════════════════════════════════════════════════════╝
|
||
```
|
||
|
||
### Dashboard-Tabs
|
||
|
||
#### 1. **Live Feed**
|
||
Zeigt Echtzeit-Aktivität:
|
||
- Chat-Messages
|
||
- API-Calls (Prompt → Perplexity)
|
||
- Responses von der KI
|
||
- Fehler & Warnungen
|
||
|
||
#### 2. **API Debug**
|
||
Detaillierte API-Logs mit:
|
||
```
|
||
[12:02:16] REQUEST SENT
|
||
├─ Endpoint: chat.completions
|
||
├─ Model: sonar-pro
|
||
├─ Messages: 4
|
||
├─ Prompt: "was ist dein Lieblings-Game?"
|
||
├─ Max Tokens: 450
|
||
├─ Temperature: 0.7
|
||
└─ Timestamp: 2026-01-02 12:02:16
|
||
|
||
[12:02:18] RESPONSE RECEIVED
|
||
├─ Status: 200 OK
|
||
├─ Tokens Used: 127
|
||
├─ Response: "Mein Lieblings-Game ist WoW wegen..."
|
||
├─ Processing Time: 1.834s
|
||
└─ Cost: $0.0003
|
||
```
|
||
|
||
#### 3. **User Statistics**
|
||
- Nutzer mit den meisten Interaktionen
|
||
- Top-Topics (Gaming, 3D-Druck, Tech)
|
||
- Chat-History pro User anschauen
|
||
- Context-Memory Status
|
||
|
||
#### 4. **Settings**
|
||
- API-Keys ändern
|
||
- Model auswählen
|
||
- Max Tokens anpassen
|
||
- Debug-Mode togglen
|
||
- Auto-Reconnect konfigurieren
|
||
|
||
---
|
||
|
||
## Architektur & Implementierung
|
||
|
||
### Dateisystem
|
||
|
||
```
|
||
C:\Users\YourUsername\eugen\
|
||
├── chatbot.py # Hauptprogramm
|
||
├── config.py # Config-Management
|
||
├── gui.py # Dashboard GUI
|
||
├── ai_provider.py # Perplexity Integration
|
||
├── memory.py # Conversation Memory
|
||
├── utils.py # Hilfsfunktionen
|
||
├── requirements.txt # Dependencies
|
||
├── .env # Secrets (NICHT committen!)
|
||
│
|
||
├── data/
|
||
│ ├── conversations/ # User Chat-Histories
|
||
│ │ ├── user1.json
|
||
│ │ ├── user2.json
|
||
│ │ └── ...
|
||
│ └── config.json # Gespeicherte Konfiguration
|
||
│
|
||
└── logs/
|
||
├── eugen.log # Hauptlogfile
|
||
└── api_debug.log # API Debug-Logs
|
||
```
|
||
|
||
### Kernklassen
|
||
|
||
#### `MentionDetector`
|
||
```python
|
||
class MentionDetector:
|
||
"""Erkennt ob Bot angesprochen wurde"""
|
||
|
||
def is_mentioned(self, message: str) -> bool:
|
||
"""True wenn @Eugen, Eugen:, eugen, etc. erwähnt"""
|
||
|
||
def extract_content(self, message: str) -> str:
|
||
"""Extrahiert Nachricht ohne Mention"""
|
||
```
|
||
|
||
#### `ConversationMemory`
|
||
```python
|
||
class ConversationMemory:
|
||
"""Speichert & lädt Chat-History pro User"""
|
||
|
||
def get_user_history(self, username: str) -> list:
|
||
"""Letzte 5 Messages für Context"""
|
||
|
||
def add_message(self, username: str, role: str, content: str):
|
||
"""Speichert Message (user/assistant)"""
|
||
|
||
def format_for_prompt(self, history: list) -> str:
|
||
"""Konvertiert zu Prompt-Format"""
|
||
```
|
||
|
||
#### `PerplexityProvider`
|
||
```python
|
||
class PerplexityProvider:
|
||
"""Kommunikiert mit Perplexity API"""
|
||
|
||
async def get_response(self, prompt: str, history: list) -> str:
|
||
"""Sendet Prompt + History, empfängt Response"""
|
||
|
||
def validate_api_key(self, key: str) -> bool:
|
||
"""Prüft ob API-Key gültig ist"""
|
||
```
|
||
|
||
#### `EugenBot` (Main)
|
||
```python
|
||
class EugenBot:
|
||
"""Orchestriert alles: IRC, Memory, AI, GUI"""
|
||
|
||
async def on_chat_message(self, username: str, message: str):
|
||
"""Wird aufgerufen wenn Chat-Message ankommt"""
|
||
|
||
def send_response(self, channel: str, username: str, response: str):
|
||
"""Sendet Antwort im Chat"""
|
||
|
||
def log_event(self, event_type: str, data: dict):
|
||
"""Loggt alles für Debug-Dashboard"""
|
||
```
|
||
|
||
---
|
||
|
||
## API-Integration & Debugging
|
||
|
||
### Was passiert beim Chat?
|
||
|
||
```
|
||
1. Chat-Message empfangen
|
||
↓
|
||
2. [MentionDetector] → Wurde Bot angesprochen?
|
||
↓ Ja
|
||
3. [ConversationMemory] → Lade letzte 5 Messages dieses Users
|
||
↓
|
||
4. [Prompt Builder]
|
||
├─ System Prompt: "Du bist Eugen, Gamer & 3D-Druck Experte"
|
||
├─ Context History: Letzte Konversation
|
||
└─ Current Message: Die neue Frage
|
||
↓
|
||
5. [API Call] → Perplexity Sonar
|
||
├─ Method: POST /chat/completions
|
||
├─ Model: sonar-pro
|
||
├─ Messages: 4 (system, history, history, user)
|
||
└─ Max Tokens: 450
|
||
↓
|
||
6. [Perplexity Processing] ~600-1000ms
|
||
↓
|
||
7. [Response] → KI-Antwort (z.B. "Mein Lieblings-Game ist WoW...")
|
||
↓
|
||
8. [ConversationMemory] → Speichere in user.json
|
||
↓
|
||
9. [IRC Send] → Sende im Chat: "@Username KI-Antwort"
|
||
↓
|
||
10. [Dashboard Update] → Zeige alles in Live-Feed
|
||
```
|
||
|
||
### Debug-Mode aktivieren
|
||
|
||
In der GUI oder `.env`:
|
||
```
|
||
DEBUG_MODE=true
|
||
```
|
||
|
||
Dann wird in der CLI ausgegeben:
|
||
```
|
||
[DEBUG] 12:02:16 - Message received from User123
|
||
[DEBUG] 12:02:16 - Mention detected: @Eugen
|
||
[DEBUG] 12:02:16 - Content extracted: "was ist dein Lieblings-Game?"
|
||
[DEBUG] 12:02:16 - History loaded: 3 messages
|
||
[DEBUG] 12:02:16 - Building prompt...
|
||
[DEBUG] 12:02:16 - SYSTEM: "Du bist Eugen..."
|
||
[DEBUG] 12:02:16 - HISTORY[0]: User: "Wie geht es dir?"
|
||
[DEBUG] 12:02:16 - HISTORY[1]: Assistant: "Mir geht's gut!"
|
||
[DEBUG] 12:02:16 - HISTORY[2]: User: "Spielst du WoW?"
|
||
[DEBUG] 12:02:16 - CURRENT: "was ist dein Lieblings-Game?"
|
||
[DEBUG] 12:02:16 - Sending to Perplexity API...
|
||
[DEBUG] 12:02:16 - REQUEST: {"model": "sonar-pro", "messages": [...], ...}
|
||
[DEBUG] 12:02:18 - RESPONSE: 200 OK
|
||
[DEBUG] 12:02:18 - Content: "Mein Lieblings-Game ist WoW..."
|
||
[DEBUG] 12:02:18 - Tokens used: 127 (cost: $0.0003)
|
||
[DEBUG] 12:02:18 - Saving to memory...
|
||
[DEBUG] 12:02:18 - Sending IRC: "@User123 Mein Lieblings-Game ist WoW..."
|
||
[DEBUG] 12:02:19 - Message sent successfully
|
||
```
|
||
|
||
### API-Keys validieren
|
||
|
||
Setup-Fenster prüft automatisch:
|
||
|
||
```python
|
||
# Twitch Token
|
||
def validate_twitch_token(token: str) -> bool:
|
||
"""Test mit Twitch IRC Connection"""
|
||
try:
|
||
irc.client.IRC().connect(
|
||
"irc.chat.twitch.tv", 6667,
|
||
nickname, token=token
|
||
)
|
||
return True
|
||
except:
|
||
return False
|
||
|
||
# Perplexity API Key
|
||
def validate_perplexity_key(key: str) -> bool:
|
||
"""Test mit einfachem API Call"""
|
||
try:
|
||
response = requests.post(
|
||
"https://api.perplexity.ai/chat/completions",
|
||
headers={"Authorization": f"Bearer {key}"},
|
||
json={
|
||
"model": "sonar-pro",
|
||
"messages": [{"role": "user", "content": "test"}],
|
||
"max_tokens": 10
|
||
},
|
||
timeout=5
|
||
)
|
||
return response.status_code == 200
|
||
except:
|
||
return False
|
||
```
|
||
|
||
---
|
||
|
||
## Fehlerbehandlung
|
||
|
||
### Häufige Fehler & Lösungen
|
||
|
||
#### 1. **"Invalid Twitch Token"**
|
||
```
|
||
Fehler: Setup schlägt fehl
|
||
Grund: Token abgelaufen oder falsch
|
||
|
||
Lösung:
|
||
1. Gehe zu twitchtokengenerator.com
|
||
2. Generiere neuen Token
|
||
3. Kopiere: oauth:... (mit oauth: Prefix!)
|
||
4. Paste in Setup-Fenster
|
||
5. Validierung sollte grün werden
|
||
```
|
||
|
||
#### 2. **"Perplexity API Error 401"**
|
||
```
|
||
Fehler: Bot startet, aber keine Responses
|
||
Grund: Ungültiger API-Key oder Account-Issue
|
||
|
||
Lösung:
|
||
1. Prüfe API-Key auf perplexity.ai
|
||
2. Stelle sicher Account hat Credits (kostenlos gibt es $5/Monat)
|
||
3. Copy-paste genau (ohne Spaces)
|
||
4. Teste mit Setup-Validierung
|
||
```
|
||
|
||
#### 3. **"Cannot connect to Twitch IRC"**
|
||
```
|
||
Fehler: Bot startet nicht
|
||
Grund: Netzwerk oder Twitch offline
|
||
|
||
Lösung:
|
||
1. Prüfe Internet-Verbindung
|
||
2. Teste: ping irc.chat.twitch.tv
|
||
3. Firewall-Regel für Python hinzufügen
|
||
4. Auto-Reconnect wartet 10 Sekunden, versucht erneut
|
||
5. Dashboard zeigt Reconnect-Versuche
|
||
```
|
||
|
||
#### 4. **"Memory File Corrupted"**
|
||
```
|
||
Fehler: Chat-History wird nicht geladen
|
||
Grund: JSON-Datei beschädigt
|
||
|
||
Lösung:
|
||
1. Dashboard → Settings → "Reset Memory"
|
||
2. Oder manuell: Lösche data/conversations/username.json
|
||
3. Nächster Chat-Start erstellt neue Datei
|
||
```
|
||
|
||
#### 5. **"Response Rate Limited"**
|
||
```
|
||
Fehler: Lange Wartezeiten, Timeout
|
||
Grund: Zu viele API-Calls zu schnell
|
||
|
||
Lösung:
|
||
1. Perplexity hat Rate-Limit pro Account
|
||
2. Warte 1-2 Sekunden zwischen Messages
|
||
3. Dashboard zeigt "Rate Limit - Waiting..."
|
||
4. Nach 60 Sekunden Auto-Retry
|
||
```
|
||
|
||
### Error Dashboard
|
||
|
||
Alle Fehler werden im Dashboard gesammelt:
|
||
|
||
```
|
||
┌─────────────────────────────────────────┐
|
||
│ FEHLER (LETZTE 24H) │
|
||
├─────────────────────────────────────────┤
|
||
│ │
|
||
│ ❌ 12:05:22 | Perplexity Timeout │
|
||
│ Message von User123 │
|
||
│ → Auto-Retry in 10 Sekunden │
|
||
│ │
|
||
│ ❌ 11:45:15 | API Rate Limited │
|
||
│ 10 Requests in 5 Sekunden │
|
||
│ → Auto-Wait aktiviert │
|
||
│ │
|
||
│ [Clear Errors] [Export Report] │
|
||
│ │
|
||
└─────────────────────────────────────────┘
|
||
```
|
||
|
||
---
|
||
|
||
## Projektstruktur
|
||
|
||
### Wichtigste Dateien für Programmiere r
|
||
|
||
#### `chatbot.py` (Hauptprogramm)
|
||
```python
|
||
import asyncio
|
||
from config import Config
|
||
from memory import ConversationMemory
|
||
from ai_provider import PerplexityProvider
|
||
from gui import Dashboard
|
||
from utils import MentionDetector, Logger
|
||
|
||
class EugenBot:
|
||
def __init__(self):
|
||
self.config = Config()
|
||
self.memory = ConversationMemory()
|
||
self.ai = PerplexityProvider(self.config.perplexity_key)
|
||
self.detector = MentionDetector()
|
||
self.logger = Logger()
|
||
self.dashboard = Dashboard(self)
|
||
|
||
async def run(self):
|
||
# IRC Connection
|
||
# Listen for messages
|
||
# Process & respond
|
||
# Update dashboard
|
||
```
|
||
|
||
#### `config.py` (Konfiguration)
|
||
```python
|
||
import os
|
||
import json
|
||
from pathlib import Path
|
||
from dotenv import load_dotenv
|
||
|
||
class Config:
|
||
def __init__(self):
|
||
load_dotenv()
|
||
|
||
self.twitch_token = os.getenv("TWITCH_OAUTH_TOKEN")
|
||
self.twitch_channel = os.getenv("TWITCH_CHANNEL")
|
||
self.bot_name = os.getenv("TWITCH_BOT_NICKNAME", "Eugen")
|
||
|
||
self.perplexity_key = os.getenv("PERPLEXITY_API_KEY")
|
||
self.model = os.getenv("PERPLEXITY_MODEL", "sonar-pro")
|
||
self.max_tokens = int(os.getenv("MAX_TOKENS", "450"))
|
||
|
||
self.debug_mode = os.getenv("DEBUG_MODE", "false").lower() == "true"
|
||
```
|
||
|
||
#### `ai_provider.py` (Perplexity API)
|
||
```python
|
||
import httpx
|
||
import json
|
||
from typing import List, Dict
|
||
|
||
class PerplexityProvider:
|
||
def __init__(self, api_key: str):
|
||
self.api_key = api_key
|
||
self.base_url = "https://api.perplexity.ai"
|
||
self.model = "sonar-pro"
|
||
|
||
async def get_response(self, messages: List[Dict]) -> str:
|
||
"""
|
||
Sendet Messages zu Perplexity, erhält Response
|
||
|
||
Args:
|
||
messages: [
|
||
{"role": "system", "content": "..."},
|
||
{"role": "user", "content": "..."},
|
||
...
|
||
]
|
||
|
||
Returns:
|
||
Response-Text von der KI
|
||
"""
|
||
headers = {
|
||
"Authorization": f"Bearer {self.api_key}",
|
||
"Content-Type": "application/json"
|
||
}
|
||
|
||
payload = {
|
||
"model": self.model,
|
||
"messages": messages,
|
||
"max_tokens": 450,
|
||
"temperature": 0.7
|
||
}
|
||
|
||
async with httpx.AsyncClient() as client:
|
||
response = await client.post(
|
||
f"{self.base_url}/chat/completions",
|
||
json=payload,
|
||
headers=headers,
|
||
timeout=30
|
||
)
|
||
|
||
if response.status_code == 200:
|
||
data = response.json()
|
||
return data['choices'][0]['message']['content']
|
||
else:
|
||
raise Exception(f"API Error {response.status_code}: {response.text}")
|
||
```
|
||
|
||
#### `memory.py` (Chat-Speicher)
|
||
```python
|
||
import json
|
||
from pathlib import Path
|
||
from datetime import datetime, timedelta
|
||
from typing import List, Dict
|
||
|
||
class ConversationMemory:
|
||
def __init__(self, max_messages=25, data_dir="data/conversations"):
|
||
self.data_dir = Path(data_dir)
|
||
self.data_dir.mkdir(parents=True, exist_ok=True)
|
||
self.max_messages = max_messages
|
||
|
||
def get_user_history(self, username: str, limit: int = 5) -> List[Dict]:
|
||
"""Lädt letzte Chat-Messages für User"""
|
||
file_path = self.data_dir / f"{username.lower()}.json"
|
||
|
||
if not file_path.exists():
|
||
return []
|
||
|
||
with open(file_path, 'r', encoding='utf-8') as f:
|
||
history = json.load(f)
|
||
|
||
# Nur Messages der letzten 1 Stunde
|
||
cutoff_time = datetime.now() - timedelta(hours=1)
|
||
recent = [
|
||
msg for msg in history[-limit:]
|
||
if datetime.fromisoformat(msg['timestamp']) > cutoff_time
|
||
]
|
||
|
||
return recent
|
||
|
||
def add_message(self, username: str, role: str, content: str):
|
||
"""Speichert eine Message (role: 'user' oder 'assistant')"""
|
||
file_path = self.data_dir / f"{username.lower()}.json"
|
||
|
||
history = []
|
||
if file_path.exists():
|
||
with open(file_path, 'r', encoding='utf-8') as f:
|
||
history = json.load(f)
|
||
|
||
history.append({
|
||
"role": role,
|
||
"content": content,
|
||
"timestamp": datetime.now().isoformat()
|
||
})
|
||
|
||
# Max Nachrichten-Limit einhalten
|
||
history = history[-self.max_messages:]
|
||
|
||
with open(file_path, 'w', encoding='utf-8') as f:
|
||
json.dump(history, f, ensure_ascii=False, indent=2)
|
||
|
||
def format_for_prompt(self, history: List[Dict]) -> List[Dict]:
|
||
"""Konvertiert History zu Message-Format für AI-API"""
|
||
return [
|
||
{
|
||
"role": msg['role'],
|
||
"content": msg['content']
|
||
}
|
||
for msg in history
|
||
]
|
||
```
|
||
|
||
#### `gui.py` (Dashboard)
|
||
```python
|
||
import PySimpleGUI as sg
|
||
import threading
|
||
from datetime import datetime
|
||
|
||
class Dashboard:
|
||
def __init__(self, bot):
|
||
self.bot = bot
|
||
sg.theme('DarkBlue3')
|
||
|
||
# Event-Queue für Thread-Safe Updates
|
||
self.event_queue = []
|
||
|
||
def log_event(self, event_type: str, data: Dict):
|
||
"""Protokolliert Event für Dashboard"""
|
||
timestamp = datetime.now().strftime("%H:%M:%S")
|
||
|
||
if event_type == "chat_message":
|
||
msg = f"{timestamp} | {data['username']}: {data['content']}"
|
||
elif event_type == "api_call":
|
||
msg = f"{timestamp} | [API] → {data['model']}"
|
||
elif event_type == "api_response":
|
||
msg = f"{timestamp} | [RESPONSE] {data['content'][:50]}..."
|
||
elif event_type == "error":
|
||
msg = f"{timestamp} | ❌ {data['error']}"
|
||
|
||
self.event_queue.append(msg)
|
||
|
||
def render(self):
|
||
"""Rendet GUI-Fenster"""
|
||
layout = [
|
||
[sg.Text("EUGEN BOT - LIVE DASHBOARD", font=("Arial", 16, "bold"))],
|
||
[sg.Text(f"Status: 🟢 VERBUNDEN", key="-STATUS-")],
|
||
[sg.Multiline(
|
||
size=(120, 30),
|
||
key="-LOG-",
|
||
disabled=True,
|
||
autoscroll=True
|
||
)],
|
||
[sg.Button("Settings"), sg.Button("Clear"), sg.Button("Stop")]
|
||
]
|
||
|
||
window = sg.Window("Eugen Bot", layout)
|
||
|
||
while True:
|
||
event, values = window.read(timeout=100)
|
||
|
||
# Update Log
|
||
if self.event_queue:
|
||
for msg in self.event_queue:
|
||
window["-LOG-"].print(msg)
|
||
self.event_queue = []
|
||
|
||
if event == sg.WINDOW_CLOSED or event == "Stop":
|
||
break
|
||
|
||
window.close()
|
||
```
|
||
|
||
#### `.env` (Secrets)
|
||
```
|
||
# Twitch Configuration
|
||
TWITCH_OAUTH_TOKEN=oauth:xxxxxxxxxxxxx
|
||
TWITCH_BOT_NICKNAME=Eugen
|
||
TWITCH_CHANNEL=#dein_kanal
|
||
|
||
# Perplexity Configuration
|
||
PERPLEXITY_API_KEY=pplx-xxxxxxxxxxxxx
|
||
PERPLEXITY_MODEL=sonar-pro
|
||
MAX_TOKENS=450
|
||
|
||
# Bot Configuration
|
||
DEBUG_MODE=true
|
||
AUTO_RECONNECT=true
|
||
RECONNECT_DELAY=10
|
||
|
||
# Data Configuration
|
||
DATA_DIR=data/conversations
|
||
LOG_DIR=logs
|
||
CONTEXT_RETENTION_HOURS=1
|
||
```
|
||
|
||
---
|
||
|
||
## Quick Start für Windows
|
||
|
||
### Installation (5 Minuten)
|
||
|
||
```powershell
|
||
# 1. Python installiert? Wenn nicht: python.org
|
||
python --version
|
||
|
||
# 2. Projekt clonen/downlaoden
|
||
cd C:\Users\YourUsername\eugen
|
||
|
||
# 3. Virtual Environment
|
||
python -m venv venv
|
||
.\venv\Scripts\Activate.ps1
|
||
|
||
# 4. Dependencies
|
||
pip install -r requirements.txt
|
||
|
||
# 5. Konfigurieren
|
||
python chatbot.py
|
||
# → Setup-Fenster öffnet sich
|
||
# → API-Keys eingeben
|
||
# → Validierung läuft
|
||
# → Speichern & Starten
|
||
|
||
# 6. Dashboard öffnet sich mit Live-Feed
|
||
```
|
||
|
||
### Fehlersuche
|
||
|
||
**Problem: Module nicht gefunden?**
|
||
```powershell
|
||
# Sicherstellen dass venv aktiviert ist:
|
||
.\venv\Scripts\Activate.ps1
|
||
|
||
# Dann reinstallieren:
|
||
pip install --upgrade pip
|
||
pip install -r requirements.txt
|
||
```
|
||
|
||
**Problem: Port 6667 blocked?**
|
||
```powershell
|
||
# Firewall-Exception für Python:
|
||
# Windows Defender → "Firewall & Netzwerkschutz"
|
||
# → "App durch Firewall zulassen"
|
||
# → Python hinzufügen
|
||
```
|
||
|
||
---
|
||
|
||
## Verbesserungen & Erweiterungen
|
||
|
||
### Einfache Adds (für später)
|
||
|
||
- [ ] Multi-Channel Support (mehrere Kanäle gleichzeitig)
|
||
- [ ] Custom Commands (!gaming, !3dprint)
|
||
- [ ] User-Blacklist (bestimmte User ignorieren)
|
||
- [ ] Response-Timeout (wenn API zu langsam)
|
||
- [ ] Discord Webhook (errori an Discord schicken)
|
||
- [ ] Analytics Export (CSV mit Stats)
|
||
|
||
### Für Programmiere r: Custom Features
|
||
|
||
Neue Commands hinzufügen:
|
||
```python
|
||
class CommandHandler:
|
||
def handle_command(self, cmd: str, args: str) -> str:
|
||
if cmd == "gaming":
|
||
return "Tipps für WoW, Elden Ring..."
|
||
elif cmd == "3dprint":
|
||
return "3D-Druck Hilfe..."
|
||
```
|
||
|
||
---
|
||
|
||
## Support & Debugging
|
||
|
||
Bei Fehlern:
|
||
|
||
1. **Prüfe Dashboard** → "Fehler" Tab
|
||
2. **Debug-Mode aktivieren** → `.env` → `DEBUG_MODE=true`
|
||
3. **Logs anschauen** → `logs/eugen.log`
|
||
4. **API Key validieren** → Setup-Fenster erneut öffnen
|
||
5. **Internet prüfen** → ping google.com
|
||
|
||
---
|
||
|