Update app.py

app.py

@@ -1,889 +1,295 @@
+import torch
 import os
 import json
-import re
 import time
 import sys
-import traceback
 import threading
-from datetime import datetime
-
-import torch
-import gradio as gr
+import re
 from transformers import AutoTokenizer, AutoModelForCausalLM
-from huggingface_hub import hf_hub_download, upload_file
-
-# =========================================================
-# KONFIG
-# =========================================================
-MODEL_NAME = "Qwen/Qwen2.5-0.5B-Instruct"
-
-HF_DATASET = "RedJul2110/wissen-datenbank"
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-ADMIN_CODE = os.environ.get("CODE", "1234")
-
-DATA_DIR = "/data" if os.path.isdir("/data") else "."
-os.makedirs(DATA_DIR, exist_ok=True)
-
-WISSEN_FILE = os.path.join(DATA_DIR, "wissen.json")
-CHAT_FILE = os.path.join(DATA_DIR, "chat_history.json")
-LOG_FILE = os.path.join(DATA_DIR, "ai_log.txt")
-
-FALLBACK_NO_INFO = "Das weiß ich leider nicht. Bitte bringe es mir im Lern-Tab bei."
 
-USE_QWEN_POLISH = True
-
-# =========================================================
-# GLOBALE VARIABLEN
-# =========================================================
+# =========================
+# GLOBALS
+# =========================
 model = None
 tokenizer = None
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-knowledge_lock = threading.Lock()
-chat_lock = threading.Lock()
+device = torch.device("cpu")
 
-api_chat_historie = []  # list[dict]
-upload_in_progress = False
+WISSEN_FILE = "wissen.json"
+CHAT_FILE = "chat_history.json"
 
-letzter_hf_sync = None
-letzter_upload = None
-letzte_wissensänderung = None
-letzte_api_latenz = None
-letzter_fehler = None
+api_chat_historie = []
 
-# =========================================================
-# HILFSFUNKTIONEN
-# =========================================================
-def now_str():
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+FALLBACK_NO_INFO = "Dazu habe ich nichts in meiner Datenbank."
 
-def log_line(message):
-    try:
-        with open(LOG_FILE, "a", encoding="utf-8") as f:
-            f.write(f"[{now_str()}] {message}\n")
-    except:
-        pass
+# =========================
+# BASIS FUNKTIONEN
+# =========================
+def normalize_text(text):
+    return re.sub(r"[^a-z0-9 ]", "", text.lower())
 
-def log_error(where, exc):
-    global letzter_fehler
-    letzter_fehler = f"{where}: {exc}"
-    log_line(f"[ERROR] {where}: {exc}\n{traceback.format_exc()}")
+def now_str():
+    return time.strftime("%Y-%m-%d %H:%M:%S")
 
-def normalize_text(text):
-    text = (text or "").lower().strip()
-    text = (
-        text.replace("ä", "ae")
-            .replace("ö", "oe")
-            .replace("ü", "ue")
-            .replace("ß", "ss")
-    )
-    text = re.sub(r"[^a-z0-9]+", " ", text)
-    return re.sub(r"\s+", " ", text).strip()
-
-def text_tokens(text):
-    stopwords = {
-        "der", "die", "das", "ein", "eine", "einer", "eines", "und", "oder", "ist",
-        "sind", "war", "waren", "wie", "was", "wer", "wo", "wann", "warum", "wieso",
-        "woher", "wieviel", "wieviele", "im", "in", "am", "an", "zu", "mit", "von",
-        "für", "auf", "aus", "den", "dem", "des", "ich", "du", "er", "sie", "es",
-        "man", "nicht", "nur", "auch", "noch"
-    }
-    tokens = normalize_text(text).split()
-    return {t for t in tokens if t and t not in stopwords}
-
-def ensure_json_list_file(path):
-    if not os.path.exists(path):
-        save_json_list(path, [])
-
-def load_json_list(path):
-    if not os.path.exists(path):
+# =========================
+# WISSEN
+# =========================
+def wissen_laden():
+    if not os.path.exists(WISSEN_FILE):
         return []
     try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        return data if isinstance(data, list) else []
+        with open(WISSEN_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
     except:
         return []
 
-def save_json_list(path, data):
-    tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        json.dump(data, f, ensure_ascii=False, indent=2)
-    os.replace(tmp, path)
-
-def format_entry(item, idx=None):
-    titel = item.get("frage", "").strip()
-    text = item.get("antwort", "").strip()
-    kategorie = item.get("kategorie", "").strip()
-    created = item.get("created_at", "").strip()
-
-    out = []
-    if idx is None:
-        out.append(f"{titel}")
-    else:
-        out.append(f"{idx}. {titel}")
-    if kategorie:
-        out.append(f"[Kategorie: {kategorie}]")
-    if created:
-        out.append(f"[Zeit: {created}]")
-    out.append(text)
-    return "\n".join(out)
-
-def history_to_context(history, max_turns=3):
-    """
-    history kann sein:
-    - list[tuple(user, assistant)]  -> UI-Chat
-    - list[dict(role/content)]      -> API-Chat
-    """
-    if not history:
-        return ""
-
-    lines = []
-
-    # UI-Chat: tuples
-    if isinstance(history[0], tuple):
-        for user, assistant in history[-max_turns:]:
-            lines.append(f"User: {user}")
-            lines.append(f"Assistant: {assistant}")
-        return "\n".join(lines)
-
-    # API-Chat: dicts
-    recent = history[-max_turns * 2:]
-    for msg in recent:
-        role = msg.get("role", "")
-        content = msg.get("content", "")
-        lines.append(f"{role}: {content}")
-
-    return "\n".join(lines)
-
-def api_history_to_pairs(messages):
-    pairs = []
-    pending_user = None
-
-    for msg in messages:
-        role = msg.get("role", "")
-        content = msg.get("content", "")
-        if role == "user":
-            pending_user = content
-        elif role == "assistant" and pending_user is not None:
-            pairs.append((pending_user, content))
-            pending_user = None
-
-    return pairs
-
-def trim_api_history(max_messages=20):
-    global api_chat_historie
-    if len(api_chat_historie) > max_messages:
-        api_chat_historie = api_chat_historie[-max_messages:]
-
-# =========================================================
-# KNOWLEDGE / DATENBANK
-# =========================================================
-def load_wissen():
-    ensure_json_list_file(WISSEN_FILE)
-    return load_json_list(WISSEN_FILE)
-
-def sync_wissen_from_hf():
-    """
-    Holt die aktuelle wissen.json aus dem HF Dataset und schreibt sie lokal.
-    Wenn keine Datei existiert oder der Sync fehlschlägt, bleibt lokal eine leere Liste.
-    """
-    global letzter_hf_sync
-
-    ensure_json_list_file(WISSEN_FILE)
-
-    if not HF_TOKEN:
-        log_line("[WARN] HF_TOKEN fehlt. Lokale Datei wird genutzt.")
-        return False, "HF_TOKEN fehlt. Lokale Datei wird genutzt."
-
-    try:
-        remote_path = hf_hub_download(
-            repo_id=HF_DATASET,
-            filename="wissen.json",
-            repo_type="dataset",
-            token=HF_TOKEN,
-            force_download=True
-        )
-        remote_data = load_json_list(remote_path)
-        save_json_list(WISSEN_FILE, remote_data)
-        letzter_hf_sync = now_str()
-        return True, f"✅ Wissen aus HF geladen ({len(remote_data)} Einträge)."
-    except Exception as e:
-        log_error("sync_wissen_from_hf", e)
-        return False, f"⚠️ HF-Sync fehlgeschlagen, lokale Datei bleibt aktiv: {e}"
-
-def upload_wissen_background():
-    """
-    Lädt die lokale wissen.json im Hintergrund ins HF Dataset hoch.
-    So blockiert der Space nicht.
-    """
-    global upload_in_progress, letzter_upload
-
-    if not HF_TOKEN:
-        log_line("[WARN] Upload übersprungen, weil HF_TOKEN fehlt.")
-        return
-
-    upload_in_progress = True
-    try:
-        upload_file(
-            path_or_fileobj=WISSEN_FILE,
-            path_in_repo="wissen.json",
-            repo_id=HF_DATASET,
-            repo_type="dataset",
-            token=HF_TOKEN,
-            commit_message=f"Update wissen.json ({now_str()})"
-        )
-        letzter_upload = now_str()
-        log_line("[OK] wissen.json erfolgreich hochgeladen.")
-    except Exception as e:
-        log_error("upload_wissen_background", e)
-    finally:
-        upload_in_progress = False
+def wissen_speichern(frage, antwort):
+    data = wissen_laden()
+    data.append({
+        "frage": frage.strip(),
+        "antwort": antwort.strip()
+    })
+    with open(WISSEN_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=4)
 
 def exact_db_answer(user_message):
-    q = normalize_text(user_message)
-    if not q:
-        return None
-
-    data = load_wissen()
+    data = wissen_laden()
+    msg = normalize_text(user_message)
     for item in data:
-        frage = normalize_text(item.get("frage", ""))
-        antwort = item.get("antwort", "").strip()
-
-        if q == frage:
-            return antwort
-
+        if normalize_text(item["frage"]) == msg:
+            return item["antwort"]
     return None
 
-def score_entry(item, query_tokens, query_norm):
-    frage = item.get("frage", "")
-    antwort = item.get("antwort", "")
-    kategorie = item.get("kategorie", "")
-
-    blob = f"{frage} {antwort} {kategorie}"
-    blob_norm = normalize_text(blob)
-    blob_tokens = text_tokens(blob)
-
-    score = len(query_tokens & blob_tokens)
-
-    if query_norm and query_norm in blob_norm:
-        score += 3
-
-    if normalize_text(frage) == query_norm:
-        score += 10
-
-    if normalize_text(kategorie) == query_norm and query_norm:
-        score += 4
-
-    return score
-
-def find_relevant_facts(query, max_items=6):
-    data = load_wissen()
-    if not data:
-        return []
-
-    query_norm = normalize_text(query)
-    query_tokens = text_tokens(query)
-
-    if not query_tokens and not query_norm:
-        return data[:max_items]
-
+def find_relevant_facts(query, max_items=5):
+    data = wissen_laden()
+    query_words = set(normalize_text(query).split())
     scored = []
-    for item in data:
-        score = score_entry(item, query_tokens, query_norm)
-        if score > 0:
-            scored.append((score, item))
-
-    scored.sort(key=lambda x: x[0], reverse=True)
-    return [item for _, item in scored[:max_items]]
 
-def get_knowledge_stats():
-    data = load_wissen()
-    categories = []
     for item in data:
-        cat = item.get("kategorie", "").strip()
-        if cat and cat not in categories:
-            categories.append(cat)
-    return {
-        "count": len(data),
-        "categories": categories[:10],
-    }
-
-def search_knowledge(query, max_results=8):
-    query = (query or "").strip()
-    if not query:
-        return "❌ Bitte gib einen Suchbegriff ein."
-
-    data = load_wissen()
-    if not data:
-        return "Keine Einträge vorhanden."
-
-    query_tokens = text_tokens(query)
-    query_norm = normalize_text(query)
-
-    scored = []
-    for item in data:
-        score = score_entry(item, query_tokens, query_norm)
+        words = set(normalize_text(item["frage"]).split())
+        score = len(query_words & words)
         if score > 0:
             scored.append((score, item))
 
-    scored.sort(key=lambda x: x[0], reverse=True)
-    matches = [item for _, item in scored[:max_results]]
-
-    if not matches:
-        return "❌ Keine passenden Einträge gefunden."
-
-    out = [f"✅ {len(matches)} Treffer:\n"]
-    for i, item in enumerate(matches, 1):
-        out.append(format_entry(item, i))
-        out.append("\n" + "-" * 40 + "\n")
-    return "\n".join(out).strip()
-
-def delete_knowledge(query):
-    global letzte_wissensänderung
-
-    query = (query or "").strip()
-    if not query:
-        return False, "❌ Bitte einen Suchbegriff zum Löschen eingeben."
-
-    with knowledge_lock:
-        sync_wissen_from_hf()
-        data = load_wissen()
-        if not data:
-            return False, "Keine Einträge vorhanden."
-
-        query_norm = normalize_text(query)
-        query_tokens = text_tokens(query)
-
-        new_data = []
-        removed = []
-
-        for item in data:
-            item_score = score_entry(item, query_tokens, query_norm)
-            if item_score > 0:
-                removed.append(item)
-            else:
-                new_data.append(item)
-
-        if not removed:
-            return False, "❌ Nichts gefunden, was gelöscht werden kann."
-
-        save_json_list(WISSEN_FILE, new_data)
-        letzte_wissensänderung = now_str()
-
-        threading.Thread(target=upload_wissen_background, daemon=True).start()
-        return True, f"✅ {len(removed)} Eintrag/Einträge gelöscht."
-
-def delete_all_knowledge(admin_code):
-    global letzte_wissensänderung
-
-    if admin_code != ADMIN_CODE:
-        return False, "❌ Falscher Admin-Code."
-
-    with knowledge_lock:
-        save_json_list(WISSEN_FILE, [])
-        letzte_wissensänderung = now_str()
-
-        threading.Thread(target=upload_wissen_background, daemon=True).start()
-        return True, "✅ Alle Wissenseinträge wurden gelöscht."
-
-def save_knowledge_entry(frage, antwort, kategorie=""):
-    global letzte_wissensänderung
-
-    frage = (frage or "").strip()
-    antwort = (antwort or "").strip()
-    kategorie = (kategorie or "").strip()
-
-    if not frage or not antwort:
-        return False, "❌ Thema/Stichwort und Text dürfen nicht leer sein."
-
-    with knowledge_lock:
-        sync_wissen_from_hf()
-
-        data = load_wissen()
-        q_norm = normalize_text(frage)
+    scored.sort(reverse=True, key=lambda x: x[0])
+    return [x[1] for x in scored[:max_items]]
 
-        for item in data:
-            if normalize_text(item.get("frage", "")) == q_norm:
-                return False, "ℹ️ Dieser Eintrag ist schon vorhanden."
-
-        entry = {
-            "frage": frage,
-            "antwort": antwort,
-            "kategorie": kategorie,
-            "created_at": now_str()
-        }
-        data.append(entry)
-        save_json_list(WISSEN_FILE, data)
-        letzte_wissensänderung = now_str()
-
-        threading.Thread(target=upload_wissen_background, daemon=True).start()
-        return True, f"✅ Lokal gespeichert. Upload läuft im Hintergrund.\n\nThema: {frage}"
-
-# =========================================================
-# CHAT / SPEICHER
-# =========================================================
-def load_chat_history():
-    ensure_json_list_file(CHAT_FILE)
-    return load_json_list(CHAT_FILE)
-
-def save_chat_history(history):
-    save_json_list(CHAT_FILE, history)
-
-def reset_chat_history():
-    global api_chat_historie
-    with chat_lock:
-        api_chat_historie = []
-        save_chat_history(api_chat_historie)
-    log_line("[CHAT] Chat-Historie zurückgesetzt.")
-    return True, "✅ Chat-Historie gelöscht."
-
-def chat_history_status():
-    history = load_chat_history()
-    if not history:
-        return "Chat-Historie ist leer."
-
-    out = [f"📜 Gespeicherte Nachrichten: {len(history)}\n"]
-    for i, msg in enumerate(history[-12:], 1):
-        role = msg.get("role", "?")
-        content = msg.get("content", "")
-        out.append(f"{i}. {role}: {content[:250]}")
-        out.append("\n")
-    return "\n".join(out).strip()
-
-def load_visible_chat_history_for_ui():
-    pairs = api_history_to_pairs(load_chat_history())
-    return pairs, pairs
+def compose_draft_from_facts(facts):
+    texts = [f["antwort"] for f in facts if f.get("antwort")]
+    return " ".join(texts).strip()
 
-# =========================================================
-# MODEL / QWEN
-# =========================================================
+# =========================
+# KI
+# =========================
 def init_model_if_needed():
-    global model, tokenizer, device
-    if model is not None and tokenizer is not None:
+    global model, tokenizer
+    if model:
         return
 
-    print("=" * 60)
-    print("🤖 Initialisiere Modell")
-    print("=" * 60)
+    print("🤖 Lade Modell...")
+    model_name = "Qwen/Qwen2.5-0.5B-Instruct"
 
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
     if tokenizer.pad_token is None:
         tokenizer.pad_token = tokenizer.eos_token
 
-    dtype = torch.float16 if device.type == "cuda" else torch.float32
-    model = AutoModelForCausalLM.from_pretrained(
-        MODEL_NAME,
-        torch_dtype=dtype,
-        low_cpu_mem_usage=True
-    )
+    model = AutoModelForCausalLM.from_pretrained(model_name)
     model.to(device)
-    model.eval()
+    print("✅ Modell bereit")
 
-    print(f"✅ Modell geladen auf: {device}")
+def model_generate(messages, max_new_tokens=120):
+    text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
 
-def format_messages_for_model(messages_history):
-    try:
-        return tokenizer.apply_chat_template(
-            messages_history,
-            tokenize=False,
-            add_generation_prompt=True
-        )
-    except Exception:
-        lines = []
-        for m in messages_history:
-            role = m.get("role", "user").capitalize()
-            content = m.get("content", "")
-            lines.append(f"{role}: {content}")
-        lines.append("Assistant:")
-        return "\n".join(lines)
-
-def model_generate(messages_history, max_new_tokens=120):
-    prompt_text = format_messages_for_model(messages_history)
-    inputs = tokenizer(
-        [prompt_text],
-        return_tensors="pt",
-        truncation=True,
-        max_length=4096
-    ).to(device)
+    inputs = tokenizer([text], return_tensors="pt").to(device)
 
     with torch.no_grad():
         output = model.generate(
             inputs.input_ids,
             max_new_tokens=max_new_tokens,
-            do_sample=False,
-            repetition_penalty=1.05,
+            temperature=0.6,
+            top_p=0.9,
+            do_sample=True,
             pad_token_id=tokenizer.eos_token_id
         )
 
-    new_tokens = output[0][inputs.input_ids.shape[-1]:]
-    text = tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
-    return text
-
-def build_system_prompt(user_message=""):
-    facts = find_relevant_facts(user_message, max_items=6)
-    if not facts:
-        facts = load_wissen()[:6]
-
-    fact_lines = []
-    for idx, item in enumerate(facts, 1):
-        fact_lines.append(
-            f"Fakt {idx}:\n"
-            f"Thema: {item.get('frage', '')}\n"
-            f"Text: {item.get('antwort', '')}"
-        )
-
-    fact_block = "\n\n".join(fact_lines) if fact_lines else "Keine gespeicherten Fakten vorhanden."
-
-    return f"""Du bist kein Wissensmodell.
-Du bist nur ein Sprach- und Grammatik-Assistent.
-Du darfst KEINE neuen Fakten hinzufügen.
-Du darfst nur die unten stehenden Fakten sprachlich sauber formulieren.
-
-Wenn die Fakten nicht reichen, antworte exakt:
-"{FALLBACK_NO_INFO}"
-
---- SPEICHER ---
-{fact_block}
----------------"""
-
-def get_system_prompt():
-    return build_system_prompt("")
-
-def compose_draft_from_facts(facts):
-    if not facts:
-        return ""
-
-    answers = []
-    for item in facts:
-        ans = item.get("antwort", "").strip()
-        if ans and ans not in answers:
-            answers.append(ans)
-
-    if not answers:
-        return ""
+    generated = output[0][len(inputs.input_ids[0]):]
+    return tokenizer.decode(generated, skip_special_tokens=True)
 
-    if len(answers) == 1:
-        return answers[0]
+# =========================
+# CHAT INTELLIGENZ
+# =========================
+def looks_like_factual_question(text):
+    t = normalize_text(text)
+    return "?" in text or t.startswith(("was", "wer", "wie", "wann", "wo", "warum"))
 
-    return " ".join(answers[:3])
+def general_chat_reply(user_message, history_context=""):
+    messages = [
+        {"role": "system", "content": "Du bist ein freundlicher Chat-Assistent."},
+        {"role": "user", "content": user_message}
+    ]
+    try:
+        return model_generate(messages, 80)
+    except:
+        return FALLBACK_NO_INFO
 
 def polish_with_model(user_message, draft, facts, history_context=""):
-    if not USE_QWEN_POLISH:
-        return draft
-
-    if model is None or tokenizer is None:
+    if not draft:
         return draft
 
-    fact_lines = []
-    for idx, item in enumerate(facts, 1):
-        fact_lines.append(
-            f"{idx}. Thema: {item.get('frage', '')}\n"
-            f"   Text: {item.get('antwort', '')}"
-        )
-    fact_block = "\n".join(fact_lines)
+    fact_text = "\n".join([f["antwort"] for f in facts])
 
     messages = [
         {
             "role": "system",
-            "content": (
-                "Du bist nur ein Grammatik- und Formulierungsassistent. "
-                "Du darfst KEINE neuen Fakten erfinden. "
-                "Wenn der Rohentwurf leer oder unpassend ist, antworte exakt: "
-                f'"{FALLBACK_NO_INFO}"'
-            )
+            "content": "Formuliere den Text schöner, füge aber keine neuen Infos hinzu."
         },
         {
             "role": "user",
-            "content": (
-                f"Frage: {user_message}\n\n"
-                f"Kontext: {history_context}\n\n"
-                f"Gespeicherte Fakten:\n{fact_block}\n\n"
-                f"Rohentwurf:\n{draft}\n\n"
-                "Aufgabe: Formuliere den Rohentwurf natürlich, kurz und fehlerfrei auf Deutsch um. "
-                "Füge keine neuen Fakten hinzu."
-            )
+            "content": f"{draft}\n\nFakten:\n{fact_text}"
         }
     ]
 
     try:
-        out = model_generate(messages, max_new_tokens=120)
-        if not out:
-            return draft
-        return out.strip()
-    except Exception as e:
-        log_error("polish_with_model", e)
+        return model_generate(messages, 120)
+    except:
         return draft
 
 def generate_reply(user_message, history_context=""):
-    """
-    1) exakte DB-Antwort direkt zurück
-    2) sonst relevante Fakten suchen
-    3) Draft aus Fakten bauen
-    4) Qwen nur als Sprach-Polierer verwenden
-    """
-    query = f"{user_message} {history_context}".strip()
-
     exact = exact_db_answer(user_message)
     if exact:
         return exact
 
-    facts = find_relevant_facts(query, max_items=6)
-    if not facts:
-        return FALLBACK_NO_INFO
+    facts = find_relevant_facts(user_message)
 
-    draft = compose_draft_from_facts(facts)
-    if not draft:
+    if facts:
+        draft = compose_draft_from_facts(facts)
+        return polish_with_model(user_message, draft, facts)
+
+    if looks_like_factual_question(user_message):
         return FALLBACK_NO_INFO
 
-    reply = polish_with_model(user_message, draft, facts, history_context)
-    return reply if reply else draft
+    return general_chat_reply(user_message)
+
+# =========================
+# CHAT HISTORY
+# =========================
+def load_chat_history():
+    if not os.path.exists(CHAT_FILE):
+        return []
+    try:
+        with open(CHAT_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return []
+
+def save_chat_history(history):
+    with open(CHAT_FILE, "w", encoding="utf-8") as f:
+        json.dump(history, f, ensure_ascii=False, indent=2)
+
+def api_history_to_pairs(history):
+    pairs = []
+    for i in range(0, len(history)-1, 2):
+        if history[i]["role"] == "user":
+            pairs.append((history[i]["content"], history[i+1]["content"]))
+    return pairs
+
+def load_visible_chat_history_for_ui():
+    pairs = api_history_to_pairs(load_chat_history())
+    return pairs, pairs
 
-# =========================================================
+# =========================
 # API
-# =========================================================
+# =========================
 def gradio_simple_api(user_message):
-    global api_chat_historie, letzte_api_latenz
+    history = load_chat_history()
+    history.append({"role": "user", "content": user_message})
 
-    start = time.perf_counter()
+    reply = generate_reply(user_message)
 
-    with chat_lock:
-        history_context = history_to_context(api_chat_historie)
-        reply = generate_reply(user_message, history_context=history_context)
+    history.append({"role": "assistant", "content": reply})
+    save_chat_history(history)
 
-        api_chat_historie.append({"role": "user", "content": user_message})
-        api_chat_historie.append({"role": "assistant", "content": reply})
-        trim_api_history(20)
-        save_chat_history(api_chat_historie)
+    return reply
 
-        log_line(f"[USER] {user_message}")
-        log_line(f"[ASSISTANT] {reply}")
+# =========================
+# UI
+# =========================
+def ui_chat_send(message, history):
+    reply = generate_reply(message)
+    history.append((message, reply))
 
-    letzte_api_latenz = f"{(time.perf_counter() - start) * 1000:.2f} ms"
-    return reply
+    hist = load_chat_history()
+    hist.append({"role": "user", "content": message})
+    hist.append({"role": "assistant", "content": reply})
+    save_chat_history(hist)
 
-# =========================================================
-# UI FUNKTIONEN
-# =========================================================
-def ui_zeige_status():
-    facts = load_wissen()
-    stats = get_knowledge_stats()
-    chat_entries = len(load_chat_history())
-
-    return f"""🟢 SYSTEM ONLINE
-
-🤖 Modell: {MODEL_NAME}
-🖥️ Device: {device}
-🏠 Space: RedJul2110/MyfirstAI
-📦 Datenbank: {HF_DATASET}
-💾 Gespeicherte Fakten: {len(facts)}
-🗂️ Kategorien: {", ".join(stats["categories"]) if stats["categories"] else "keine"}
-💬 Gespeicherte Chat-Nachrichten: {chat_entries}
-⏱️ Letzte API-Antwortzeit: {letzte_api_latenz if letzte_api_latenz else "noch keine"}
-🔁 Letzter HF-Sync: {letzter_hf_sync if letzter_hf_sync else "noch keiner"}
-⬆️ Letzter Upload: {letzter_upload if letzter_upload else "noch keiner"}
-🧠 Letzte Wissensänderung: {letzte_wissensänderung if letzte_wissensänderung else "noch keine"}
-🔄 Upload läuft: {"ja" if upload_in_progress else "nein"}
-⚠️ Letzter Fehler: {letzter_fehler if letzter_fehler else "keiner"}
-
-Lokale Wissensdatei: {WISSEN_FILE}
-Chat-Datei: {CHAT_FILE}
-Log-Datei: {LOG_FILE}
-"""
-
-def ui_sync_wissen():
-    ok, msg = sync_wissen_from_hf()
-    return msg
-
-def ui_web_lernen(passwort, frage, antwort, kategorie):
-    if passwort != ADMIN_CODE:
-        return "❌ Zugriff verweigert! Falscher Admin-Code."
-
-    ok, msg = save_knowledge_entry(frage, antwort, kategorie)
-    return msg
-
-def ui_wissen_suchen(suchbegriff):
-    return search_knowledge(suchbegriff)
-
-def ui_wissen_loeschen(passwort, suchbegriff):
-    if passwort != ADMIN_CODE:
-        return "❌ Zugriff verweigert! Falscher Admin-Code."
-    ok, msg = delete_knowledge(suchbegriff)
-    return msg
-
-def ui_wissen_alle_loeschen(passwort):
-    if passwort != ADMIN_CODE:
-        return "❌ Zugriff verweigert! Falscher Admin-Code."
-    ok, msg = delete_all_knowledge(passwort)
-    return msg
-
-def ui_chat_send(user_message, visible_history):
-    """
-    Echter Chat-Tab:
-    - zeigt Verlauf
-    - nutzt dieselbe Antwortlogik
-    - speichert den Verlauf auch für die API
-    """
-    global api_chat_historie, letzte_api_latenz
-
-    user_message = (user_message or "").strip()
-    if not user_message:
-        return visible_history, "", visible_history
-
-    start = time.perf_counter()
-
-    if visible_history is None:
-        visible_history = []
-
-    history_context = history_to_context(visible_history)
-    reply = generate_reply(user_message, history_context=history_context)
-
-    visible_history = visible_history + [(user_message, reply)]
-
-    with chat_lock:
-        api_chat_historie.append({"role": "user", "content": user_message})
-        api_chat_historie.append({"role": "assistant", "content": reply})
-        trim_api_history(20)
-        save_chat_history(api_chat_historie)
-
-        log_line(f"[CHAT USER] {user_message}")
-        log_line(f"[CHAT BOT] {reply}")
-
-    letzte_api_latenz = f"{(time.perf_counter() - start) * 1000:.2f} ms"
-    return visible_history, "", visible_history
+    return "", history
 
 def ui_chat_reset():
-    ok, msg = reset_chat_history()
-    return [], [], msg
+    save_chat_history([])
+    return [], []
 
-def ui_chat_status():
-    return chat_history_status()
+def ui_status():
+    data = wissen_laden()
+    return f"Fakten: {len(data)}"
 
-def load_visible_chat_history_for_ui():
-    pairs = api_history_to_pairs(load_chat_history())
-    return pairs, pairs
+def ui_learn(code, frage, antwort):
+    if code != os.environ.get("CODE", "1234"):
+        return "❌ Falscher Code"
+    wissen_speichern(frage, antwort)
+    return "✅ Gespeichert"
 
-# =========================================================
-# APP
-# =========================================================
 def erzeuge_gradio_app():
-    with gr.Blocks(title="Privates KI Kontrollzentrum", theme="soft") as demo:
-        gr.Markdown("# 🤖 Privates KI Kontrollzentrum")
-        gr.Markdown("Die KI nutzt zuerst die Datenbank. Qwen darf nur bei der Formulierung helfen.")
-
-        with gr.Tab("📊 Status"):
-            status_text = gr.Textbox(label="Systembericht", lines=16, interactive=False)
-            with gr.Row():
-                refresh_btn = gr.Button("Status aktualisieren")
-                sync_btn = gr.Button("Wissen von HF neu laden")
-            refresh_btn.click(ui_zeige_status, outputs=status_text)
-            sync_btn.click(ui_sync_wissen, outputs=status_text)
-            demo.load(ui_zeige_status, outputs=status_text)
-
-        with gr.Tab("🧠 Lernen (Admin)"):
-            gr.Markdown("Hier speicherst du neue Fakten in die Datenbank.")
-            pw_input = gr.Textbox(label="Geheimer Code", type="password")
-            k_input = gr.Textbox(label="Kategorie / Bereich (optional)", placeholder="z. B. Geschichte, Geo, Technik")
-            q_input = gr.Textbox(label="Thema / Stichwort", placeholder="z. B. Frankreich, Mars, Bundeskanzler")
-            a_input = gr.Textbox(label="Text", placeholder="Langer Infotext", lines=6)
-            lern_btn = gr.Button("Wissen speichern", variant="primary")
-            lern_out = gr.Textbox(label="Ergebnis", interactive=False)
-            lern_btn.click(ui_web_lernen, inputs=[pw_input, q_input, a_input, k_input], outputs=lern_out)
-
-        with gr.Tab("🔍 Suchen / Löschen"):
-            gr.Markdown("Suche in der Datenbank oder l��sche Einträge wieder.")
-            search_box = gr.Textbox(label="Suchbegriff", placeholder="z. B. Frankreich")
-            search_btn = gr.Button("Suchen")
-            search_out = gr.Textbox(label="Treffer", lines=12, interactive=False)
-
-            del_pw = gr.Textbox(label="Admin-Code", type="password")
-            del_box = gr.Textbox(label="Löschen nach Begriff", placeholder="z. B. Frankreich")
-            del_btn = gr.Button("Löschen", variant="secondary")
-            del_out = gr.Textbox(label="Lösch-Ergebnis", interactive=False)
-
-            all_del_btn = gr.Button("ALLES löschen", variant="stop")
-            all_del_out = gr.Textbox(label="Alles löschen", interactive=False)
-
-            search_btn.click(ui_wissen_suchen, inputs=[search_box], outputs=search_out)
-            del_btn.click(ui_wissen_loeschen, inputs=[del_pw, del_box], outputs=del_out)
-            all_del_btn.click(ui_wissen_alle_loeschen, inputs=[del_pw], outputs=all_del_out)
+    import gradio as gr
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🤖 KI")
 
         with gr.Tab("Chat"):
-            gr.Markdown("Echter Chat mit Verlauf. API und Chat nutzen dieselbe Wissenslogik.")
-            chatbot = gr.Chatbot(label="Chat", height=420)
-            chat_state = gr.State([])
-
-            with gr.Row():
-                chat_input = gr.Textbox(label="Nachricht", placeholder="Schreib etwas ...", scale=5)
-                chat_send = gr.Button("Senden", scale=1)
-
-            with gr.Row():
-                chat_clear = gr.Button("Chat leeren")
-                chat_history_btn = gr.Button("Gespeicherte Chat-Historie anzeigen")
-
-            chat_history_text = gr.Textbox(label="Gespeicherte Chat-Historie", lines=12, interactive=False)
-
-            demo.load(load_visible_chat_history_for_ui, outputs=[chatbot, chat_state])
-
-            chat_send.click(
-                ui_chat_send,
-                inputs=[chat_input, chat_state],
-                outputs=[chatbot, chat_input, chat_state]
-            )
-
-            chat_clear.click(
-                ui_chat_reset,
-                outputs=[chatbot, chat_state, chat_history_text]
-            )
-
-            chat_history_btn.click(
-                ui_chat_status,
-                outputs=chat_history_text
-            )
-            demo.load(ui_chat_status, outputs=chat_history_text)
-
-        # Unsichtbare API bleibt erhalten
-        api_eingabe = gr.Textbox(visible=False)
-        api_ausgabe = gr.Textbox(visible=False)
-        api_btn = gr.Button(visible=False)
-        api_btn.click(gradio_simple_api, inputs=api_eingabe, outputs=api_ausgabe, api_name="predict")
-
-        demo.queue(default_concurrency_limit=8)
-    return demo
+            chatbot = gr.Chatbot(height=400, type="tuples")
+            msg = gr.Textbox()
+            send = gr.Button("Senden")
+            reset = gr.Button("Reset")
+
+            send.click(ui_chat_send, [msg, chatbot], [msg, chatbot])
+            reset.click(ui_chat_reset, None, [chatbot, chatbot])
 
-# =========================================================
-# LOKALER CHAT (FALLBACK)
-# =========================================================
-def local_terminal_chat():
-    print("Lokaler Chat gestartet. Tippe 'exit' zum Beenden.")
-    while True:
-        user = input("Du: ").strip()
-        if user.lower() in {"exit", "quit", "ende"}:
-            break
-        if not user:
-            continue
-        reply = gradio_simple_api(user)
-        print("Bot:", reply)
-
-# =========================================================
-# BOOTSTRAP
-# =========================================================
-def bootstrap():
-    global api_chat_historie
-
-    ensure_json_list_file(WISSEN_FILE)
-    ensure_json_list_file(CHAT_FILE)
-
-    sync_wissen_from_hf()
-    api_chat_historie = load_chat_history()
+            demo.load(load_visible_chat_history_for_ui, None, [chatbot, chatbot])
 
+        with gr.Tab("Lernen"):
+            code = gr.Textbox(label="Code", type="password")
+            frage = gr.Textbox(label="Frage")
+            antwort = gr.Textbox(label="Antwort")
+            btn = gr.Button("Speichern")
+            out = gr.Textbox()
+
+            btn.click(ui_learn, [code, frage, antwort], out)
+
+        with gr.Tab("Status"):
+            txt = gr.Textbox()
+            demo.load(ui_status, None, txt)
+
+        # API
+        inp = gr.Textbox(visible=False)
+        out = gr.Textbox(visible=False)
+        btn = gr.Button(visible=False)
+        btn.click(gradio_simple_api, inp, out, api_name="predict")
+
+    return demo
+
+# =========================
+# START
+# =========================
+if __name__ == "__main__":
     init_model_if_needed()
 
     if os.environ.get("SPACE_ID"):
         app = erzeuge_gradio_app()
         app.launch()
     else:
-        local_terminal_chat()
-
-if __name__ == "__main__":
-    bootstrap()
+        while True:
+            msg = input("Du: ")
+            print("KI:", generate_reply(msg))