"""OpenAmer-Server: OpenAI-kompatible Schnittstelle fuer die grossen Stufen. Lehren aus dem ersten Versuch: 1. Ein eigener uvicorn-Start kollidiert mit Gradios eigenem Server (Port belegt). Richtig ist, die Routen an Gradios eingebaute FastAPI zu haengen (demo.app) und Gradio starten zu lassen. 2. Ohne ausdrueckliche Hardware-Anforderung laeuft der Space auf cpu-basic. 32B auf der CPU ist nicht darstellbar - deshalb zero-a10g (ZeroGPU). Stufen: Desktop (14,7B), Pro (24B), Ultra (32B) als Basis + eigener LoRA-Adapter. Watch/Phone/Tab fehlen bewusst: fuer Phone und Tab gibt es keinen Adapter, und Watch laeuft auf einem eigenen CPU-Space ohne Wartezeit. """ import time import gradio as gr import torch from fastapi import Body from fastapi.responses import JSONResponse try: import spaces except ImportError: # ausserhalb von ZeroGPU class spaces: @staticmethod def GPU(*a, **k): def huelle(f): return f return huelle STUFEN = { "desktop": {"anzeige": "Desktop (14,7B)", "basis": "Qwen/Qwen2.5-14B-Instruct", "adapter": "openamer-max/openamer-max-desktop-adapter", "pruefstand": "44/45 (97,8 %)", "ollama": "amersacirovic/openamer-max-desktop"}, "pro": {"anzeige": "Pro (24B)", "basis": "mistralai/Mistral-Small-24B-Instruct-2501", "adapter": "openamer-max/openamer-max-pro-adapter", "pruefstand": "43/45 (95,6 %)", "ollama": "amersacirovic/openamer-max-pro"}, "ultra": {"anzeige": "Ultra (32B)", "basis": "Qwen/Qwen2.5-32B-Instruct", "adapter": "openamer-max/openamer-max-ultra-adapter", "pruefstand": "41/45 (91,1 %)", "ollama": "amersacirovic/openamer-max-ultra"}, } SYSTEM = ("Du bist OpenAmer, ein lokaler KI-Assistent. Du antwortest knapp, sachlich und " "auf Deutsch, wenn der Nutzer Deutsch schreibt. Du erfindest keine Zahlen, " "Versionen oder Namen. Wenn du etwas nicht weisst, sagst du das.") _geladen = {} def _lade(schluessel): if schluessel in _geladen: return _geladen[schluessel] from peft import PeftModel from transformers import AutoModelForCausalLM, AutoTokenizer info = STUFEN[schluessel] tok = AutoTokenizer.from_pretrained(info["basis"]) kw = {"device_map": "auto", "torch_dtype": torch.float16} if torch.cuda.is_available(): from transformers import BitsAndBytesConfig kw["quantization_config"] = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16, bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True) else: kw["torch_dtype"] = torch.float32 kw["device_map"] = None modell = AutoModelForCausalLM.from_pretrained(info["basis"], **kw) modell = PeftModel.from_pretrained(modell, info["adapter"]) modell.eval() _geladen[schluessel] = (modell, tok) return _geladen[schluessel] @spaces.GPU(duration=60) def erzeuge(schluessel, nachrichten, max_tokens): modell, tok = _lade(schluessel) text = tok.apply_chat_template(nachrichten, tokenize=False, add_generation_prompt=True) eingabe = tok(text, return_tensors="pt").to(modell.device) with torch.no_grad(): aus = modell.generate(**eingabe, max_new_tokens=int(max_tokens), do_sample=False, temperature=None, top_p=None, top_k=None, pad_token_id=tok.eos_token_id) return tok.decode(aus[0][eingabe["input_ids"].shape[1]:], skip_special_tokens=True).strip() def antworte_ui(stufe_name, frage_text, tokens_anzahl): schluessel = next((k for k, v in STUFEN.items() if v['anzeige'] == stufe_name), 'desktop') if not frage_text or not frage_text.strip(): return 'Bitte eine Frage eingeben.' t0 = time.time() try: text = erzeuge(schluessel, [{'role': 'system', 'content': SYSTEM}, {'role': 'user', 'content': frage_text}], tokens_anzahl) except Exception as e: return 'Fehler: ' + str(e)[:200] nl = chr(10) kopf = STUFEN[schluessel]['anzeige'] + ' | ' + STUFEN[schluessel]['pruefstand'] return text + nl + nl + kopf + ' | ' + format(time.time() - t0, '.1f') + 's' beschreibung = """ # OpenAmer-Server — kostenlos, ohne Schlüssel Dieselbe Schnittstelle, die die Web-App nutzt: `POST /v1/chat/completions`. | Modell | Parameter | Prüfstand (45 Fälle) | |---|---|---| | `desktop` | 14,70B | 44/45 (97,8 %) | | `pro` | 24,00B | 43/45 (95,6 %) | | `ultra` | 32,00B | 41/45 (91,1 %) | **Ehrlich:** Der erste Aufruf einer Stufe lädt das Modell — etwa eine Minute. Ein Wechsel der Stufe lädt neu. Die kleinste Stufe (`watch`, 0,6B) läuft auf einem eigenen CPU-Server und antwortet in Sekunden. """ with gr.Blocks(title="OpenAmer-Server") as demo: gr.Markdown(beschreibung) with gr.Row(): stufe = gr.Dropdown(choices=[v["anzeige"] for v in STUFEN.values()], value="Desktop (14,7B)", label="Stufe") tokens = gr.Slider(32, 256, value=96, step=32, label="Maximale Länge") frage = gr.Textbox(label="Frage", placeholder="Was ist OpenAmer?", lines=2) knopf = gr.Button("Antworten", variant="primary") ausgabe = gr.Textbox(label="Antwort", lines=8) # Die Verdrahtung gehoert INNERHALB des Blocks - ausserhalb wirft Gradio # "Cannot call click outside of a gradio.Blocks context". knopf.click(antworte_ui, [stufe, frage, tokens], ausgabe) frage.submit(antworte_ui, [stufe, frage, tokens], ausgabe) # ------------------------------------------------------------------ OpenAI-Routen # Gradio bringt eine FastAPI mit (demo.app). Routen dort einhaengen ist der # offizielle Weg - ein eigener uvicorn-Start kollidiert mit Gradios Port. @demo.app.get("/v1/models") def modelle(): return {"object": "list", "data": [{"id": k, "object": "model", "owned_by": "openamer", "name": v["anzeige"], "pruefstand": v["pruefstand"]} for k, v in STUFEN.items()]} @demo.app.post("/v1/chat/completions") def chat(anfrage: dict = Body(...)): roh = (anfrage.get("model") or "desktop").split("/")[-1].lower() schluessel = {"watch": "desktop", "phone": "desktop", "tab": "desktop"}.get(roh, roh) if schluessel not in STUFEN: return JSONResponse(status_code=400, content={ "error": {"message": f"Unbekanntes Modell '{roh}'. Verfuegbar: " f"{', '.join(STUFEN)}", "type": "invalid_request_error"}}) nachrichten = anfrage.get("messages") or [] if not nachrichten: return JSONResponse(status_code=400, content={ "error": {"message": "messages fehlt", "type": "invalid_request_error"}}) if not any(m.get("role") == "system" for m in nachrichten): nachrichten = [{"role": "system", "content": SYSTEM}] + nachrichten t0 = time.time() try: text = erzeuge(schluessel, nachrichten, anfrage.get("max_tokens") or 256) except Exception as e: return JSONResponse(status_code=503, content={ "error": {"message": f"Stufe '{schluessel}' nicht ladbar: {str(e)[:180]}", "type": "server_error"}}) zeichen = sum(len(m.get("content") or "") for m in nachrichten) return {"id": "chatcmpl-" + str(int(t0 * 1000)), "object": "chat.completion", "created": int(t0), "model": schluessel, "choices": [{"index": 0, "finish_reason": "stop", "message": {"role": "assistant", "content": text}}], "usage": {"prompt_tokens": zeichen // 4, "completion_tokens": max(1, len(text) // 4), "total_tokens": (zeichen + len(text)) // 4}, "openamer": {"stufe": STUFEN[schluessel]["anzeige"], "pruefstand": STUFEN[schluessel]["pruefstand"], "dauer_s": round(time.time() - t0, 1)}} @demo.app.get("/health") def health(): return {"status": "ok", "stufen": list(STUFEN), "geladen": list(_geladen), "gpu": torch.cuda.is_available()} demo.launch()