import os
import re
import json
import datetime
import tempfile
import gradio as gr
from huggingface_hub import InferenceClient, HfApi, hf_hub_download
from huggingface_hub.utils import EntryNotFoundError
# ── Konfiguration ──────────────────────────────────────────────────────────────
HF_TOKEN = os.environ.get("HF_TOKEN", "")
DATASET_REPO = os.environ.get("DATASET_REPO", "")
DATASET_FILE = "data.jsonl"
MODEL_DEFAULT = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8"
MODEL_TUNING = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8"
LEADERBOARD_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "leaderboard.json")
# ── System Prompts ─────────────────────────────────────────────────────────────
PROMPT_TO_LINKEDIN = """Du bist der ultimative, satirische LinkedIn-Influencer-Generator. Deine Aufgabe: Verwandle die banalste, alltäglichste Eingabe in einen absurd überzogenen, klischeebeladenen LinkedIn-Post, der vor "Corporate Cringe" nur so trieft.
WICHTIGSTE REGELN:
- ZWINGEND die Originalsprache beibehalten! (Englisch -> Englisch, Deutsch -> Deutsch). Übersetze niemals.
- Antworte NUR mit dem fertigen Post in Markdown. Kein Vorwort, keine Erklärungen.
WÄHLE FÜR JEDEN POST ZUFÄLLIG EINE DIESER 4 PERSONAS (für maximale Abwechslung):
1. Der "Hustle Culture" CEO: Steht um 3:30 Uhr auf. Eisbaden. Macht aus der Eingabe eine harte Lektion über Grind, Disziplin, Outperforming und das 10X-Mindset.
2. Der "Vulnerable/Oversharing" Leader: Unglaublich emotional. Hat heute wegen der Eingabe geweint oder ist gescheitert. Zieht daraus tiefgründige Lektionen über Empathie, True Leadership, Mental Health und "Es ist okay, nicht okay zu sein".
3. Der "Triviality as a Masterclass" Guru: Die Eingabe ist eine unglaubliche Analogie für komplexe Business-Themen. "Was mir mein verpasster Bus/mein Toastbrot heute über B2B-Sales, AI-Strategien oder Agilität beigebracht hat..."
4. Der "Unconventional Hiring" Manager: Die Eingabe ist der absurde Grund, warum er heute jemanden eingestellt, gefeuert oder befördert hat. ("Der Bewerber tat [Eingabe]. Ich stellte ihn sofort als VP of Sales ein.")
FORMAT & STIL (Das "LinkedIn-Bingo"):
- Nutze "Broetry": Jeder Satz ist ein eigener Absatz. Dramatische. Zeilenumbrüche. Überall. Niemand liest lange Absätze.
- Beginne mit einem extrem provokanten oder hochdramatischen "Hook" (als ## Überschrift formatiert).
- Mache den Text viel länger als nötig. Blase die Mücke zum Elefanten auf.
- Erfinde passende Corporate-Buzzwords und Denglisch (z.B. Paradigm Shift, Disruptive, Alignment, Empowerment, Leverage, Resilienz). Hebe die **wichtigsten Buzzwords fett** hervor.
- Nutze 3-6 Emojis, aber absolut unpassend dramatisch verteilt (🚀, 💡, 🤯, 🤝, 🙏, 📉).
- Beende den Post IMMER mit einer pseudo-tiefgründigen, rhetorischen Frage an das Netzwerk. ("Agree?", "Thoughts?", "Wer hat heute auch schon die Komfortzone verlassen?")
- Füge 5-8 völlig übertriebene Hashtags am Ende hinzu.
"""
PROMPT_FROM_LINKEDIN = """Du bist ein gnadenloser semantischer Reduzierer. Du hasst Floskeln. Deine Aufgabe: LinkedIn-Texte auf das absolute, brutalste Minimum eindampfen.
Regeln:
- WICHTIG: Behalte ZWINGEND die Originalsprache des Eingabetextes bei! Übersetze niemals eigenmächtig.
- EIN Satz. Nicht zwei. Einer.
- Kürze bis es wehtut. Dann nochmal kürzen.
- Null Emotion, null Wertung, null Kontext der niemanden interessiert
- Streiche alles was keine neue Information trägt
- Wenn der gesamte Post nur bedeutet "Ich hab heute Kaffee getrunken" schreib genau das
- Maximal 15 Wörter
Antworte NUR mit diesem einen Satz. Kein Vorwort, keine Erklärung."""
PROMPT_BINGO = """You are a precise, fair but sarcastic LinkedIn post analyst. Your job is to measure actual corporate nonsense - not just LinkedIn formatting habits.
CRITICAL: You must distinguish between FORM and SUBSTANCE.
- A post with real technical depth, concrete tools, and actionable insights scores LOW on nonsense metrics, even if it uses hashtags.
- A post that sounds profound but says nothing scores HIGH.
- Hashtags are normal on LinkedIn. Only penalize if they are excessive (10+) or completely irrelevant to the content.
- Mentioning your own work/team is NOT self-praise if it is used to make a concrete point. Self-praise means: "I am amazing", "so proud", "humbled", "blessed", "excited to share" with no substance.
Rate on these 5 metrics (score 1-10, where 10 = maximum LinkedIn nonsense):
1. label="Buzzword-Dichte": Are the buzzwords empty filler, or do they refer to real, specific concepts? Real tools and methodologies (e.g. MLflow, LiteLLM, RAG, specific frameworks) are NOT buzzwords. Empty buzzwords: "synergy", "impact", "journey", "game-changer" used without context.
2. label="Länge vs. Inhalt": Is the length justified by actual information density? A long post with dense technical content scores LOW. A long post that repeats one obvious idea scores HIGH.
3. label="Selbstbeweihräuche": Is the post primarily about ego ("look how great we are") or about sharing knowledge? Score HIGH only if the author is the hero, not the content.
4. label="Hashtag-Overload": Score 1 for no hashtags, score 2 for 1 hashtag, LOW (3 to 5 score) for 1-6 relevant hashtags. Score HIGH for 10+ hashtags or hashtags irrelevant to the content. Medium (6-8 score) for in between usage, too much then nessacary.
5. label="Sinnlosigkeits-Index": Could someone learn something concrete from this post? A post with real takeaways, named tools, or specific problems solved scores LOW. Pure inspiration porn scores HIGH.
Reply ONLY with a single valid JSON object. No markdown fences, no backticks, no preamble. Raw JSON only.
Use exactly this structure:
{"metrics":[{"label":"Buzzword-Dichte","score":3,"comment":"kurz sarkastisch"},{"label":"Länge vs. Inhalt","score":4,"comment":"kurz sarkastisch"},{"label":"Selbstbeweihräuche","score":2,"comment":"kurz sarkastisch"},{"label":"Hashtag-Overload","score":5,"comment":"kurz sarkastisch"},{"label":"Sinnlosigkeits-Index","score":3,"comment":"kurz sarkastisch"}],"verdict":"Ein präzises Urteil auf Deutsch."}
Rules:
- score is an integer 1-10.
- comment is max 5 words in German, dry and precise.
- verdict is one precise sentence in German, max 12 words.
- CRITICAL JSON RULE: NEVER quote parts of the user's text (no hashtags, no phrases). Paraphrase instead.
- CRITICAL JSON RULE: NEVER use the double-quote character (") inside your string values! Use single quotes (') if you must.
- ALL string values must be valid JSON strings."""
PROMPT_AI_TUNING = """You are a top-tier Ghostwriter for Tech Executives and a master of LinkedIn algorithms. Your task is to rewrite the provided text into a high-performing LinkedIn post based STRICTLY on the tuning parameters.
CRITICAL LANGUAGE RULE:
- The output MUST be in the EXACT SAME LANGUAGE as the original text. Never translate!
- If the output is German: ALWAYS use the informal "Du", never "Sie".
TUNING PARAMETERS & HOW TO APPLY THEM:
- Tone: {ton}/100
(0-30: Highly corporate, academic, serious. 31-70: Conversational, confident expert. 71-100: Bold, contrarian, punchy, slightly provocative.)
- Substance: {substanz}/100
(0-30: Focus on emotions, storytelling, the "journey" and people. 31-70: Balanced case study or insights. 71-100: Brutally analytical, hard facts, frameworks, numbers, zero fluff.)
- Length: {laenge}/100
(0-30: Twitter/X-style, extremely concise, 2-4 lines max. 31-70: Standard post, 2-3 short paragraphs. 71-100: Deep-dive mini-essay, highly structured with bullet points.)
- Target Audience: {zielgruppe}
(Strictly adapt vocabulary, complexity, and inside jokes to this specific group)
- Call to Action: {cta}
(Integrate this organically at the very end)
RULES FOR "ELITE" QUALITY:
1. The Hook: Sentence 1 MUST be a scroll-stopper. Short, punchy, or a counter-intuitive statement. No boring introductions.
2. Formatting: Use line breaks strategically. Nobody reads text walls on mobile. Use bolding (**text**) sparingly for core concepts only.
3. Banned Words: NEVER use AI-typical fluff like "In today's fast-paced world", "Unlock the power of", "Delve", "Crucial", or "Game-changer". Keep emojis minimal unless Tone is > 50.
4. Authenticity: Sound like a real, battle-tested professional. If Substance is high, prove it with structure.
Output ONLY the final optimized post. No preamble, no meta-commentary, no markdown fences around the response
."""
# ── HF Dataset Persistenz ──────────────────────────────────────────────────────
def _fetch_dataset() -> list:
if not DATASET_REPO or not HF_TOKEN:
return []
try:
path = hf_hub_download(
repo_id=DATASET_REPO,
filename=DATASET_FILE,
repo_type="dataset",
token=HF_TOKEN,
)
entries = []
with open(path, "r", encoding="utf-8") as f:
for line in f:
line = line.strip()
if line:
entries.append(json.loads(line))
return entries
except EntryNotFoundError:
return []
except Exception:
return []
def _push_entry(entry: dict) -> str:
if not DATASET_REPO or not HF_TOKEN:
return ""
try:
existing = _fetch_dataset()
existing.append(entry)
jsonl_content = "\n".join(json.dumps(e, ensure_ascii=False) for e in existing) + "\n"
api = HfApi(token=HF_TOKEN)
with tempfile.NamedTemporaryFile(mode="w", suffix=".jsonl",
encoding="utf-8", delete=False) as tmp:
tmp.write(jsonl_content)
tmp_path = tmp.name
api.upload_file(
path_or_fileobj=tmp_path,
path_in_repo=DATASET_FILE,
repo_id=DATASET_REPO,
repo_type="dataset",
commit_message=f"Add entry {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}",
)
os.unlink(tmp_path)
except Exception as e:
return str(e)
return ""
def _dataset_count() -> int:
return len(_fetch_dataset())
def _init_leaderboard():
entries = _fetch_dataset()
if not entries:
return
lb = []
for e in entries:
metrics = e.get("metrics", [])
total = e.get("total_score", sum(int(m.get("score", 0)) for m in metrics))
max_s = e.get("max_score", len(metrics) * 10)
lb.append({
"text": e.get("post_text", "").strip(),
"total": total,
"max": max_s,
"pct": e.get("pct", round(total / max_s * 100) if max_s else 0),
"verdict": e.get("verdict", ""),
"date": e.get("timestamp", "")[:10],
})
_save_lb(lb)
# ── Lokales Leaderboard ────────────────────────────────────────────────────────
def _load_lb() -> list:
try:
with open(LEADERBOARD_PATH, "r", encoding="utf-8") as f:
return json.load(f)
except Exception:
return []
def _save_lb(entries: list):
try:
with open(LEADERBOARD_PATH, "w", encoding="utf-8") as f:
json.dump(entries, f, ensure_ascii=False, indent=2)
except Exception:
pass
def _add_to_lb(post_text, total, max_score, verdict):
entries = _load_lb()
entries.append({
"text": post_text.strip(),
"total": total,
"max": max_score,
"pct": round(total / max_score * 100) if max_score else 0,
"verdict": verdict,
"date": datetime.datetime.now().strftime("%Y-%m-%d"), # Auf ISO Format für sauberes Filtern umgestellt
})
_save_lb(entries)
def _render_leaderboard() -> str:
entries = _load_lb()
ds_count = _dataset_count()
# Aktuellen Monat und Jahr bestimmen (für Filter und UI)
now = datetime.datetime.now()
german_months = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]
month_name = german_months[now.month - 1]
display_month = f"{month_name} {now.year}"
# Filter-Strings für ISO ("2026-04") und falls noch alte Deutsche Dates existieren (".04.2026")
current_iso = now.strftime("%Y-%m")
current_ger = now.strftime(f".%m.%Y")
# NEU: Nur Einträge aus diesem Monat filtern!
monthly_entries = [e for e in entries if e.get("date", "").startswith(current_iso) or current_ger in e.get("date", "")]
if not monthly_entries:
ds_hint = f'
"""
best_html = "".join(entry_html(e, i, side="best") for i, e in enumerate(best))
worst_html = "".join(entry_html(e, i, side="worst") for i, e in enumerate(worst))
total_monthly_count = len(monthly_entries)
avg_pct = round(sum(e["pct"] for e in monthly_entries) / total_monthly_count)
dataset_badge = ""
if DATASET_REPO:
dataset_badge = f"""
🤗 Dataset gesamt: {ds_count}
"""
return f"""
"""
def force_sync_and_render():
_init_leaderboard()
return _render_leaderboard()
# ── Leaderboard beim Start initialisieren ─────────────────────────────────────
_init_leaderboard()
# ── LLM-Calls ─────────────────────────────────────────────────────────────────
def _call_llm(system, user, max_tokens=1024, model_id=MODEL_DEFAULT):
client = InferenceClient(provider="novita", api_key=HF_TOKEN)
resp = client.chat.completions.create(
model=model_id,
messages=[{"role": "system", "content": system},
{"role": "user", "content": user}],
max_tokens=max_tokens,
)
return resp.choices[0].message.content.strip()
def translate(text, direction):
if not text.strip():
return ""
if not HF_TOKEN:
return "Kein HF_TOKEN gefunden."
prompt = PROMPT_TO_LINKEDIN if direction == "to_linkedin" else PROMPT_FROM_LINKEDIN
try:
return _call_llm(prompt, text)
except Exception as e:
return f"Fehler: {e}"
def _extract_json(raw):
cleaned_raw = re.sub(r'```json\s*', '', raw)
cleaned_raw = re.sub(r'```\s*', '', cleaned_raw)
try:
start = cleaned_raw.find("{")
end = cleaned_raw.rfind("}") + 1
if start >= 0 and end > start:
json_str = cleaned_raw[start:end]
json_str = json_str.replace('\n', ' ').replace('\r', '')
return json.loads(json_str)
except Exception:
pass
raise ValueError(f"Kein valides JSON gefunden. Raw Output war: {raw[:100]}...")
def get_bingo(text):
if not text.strip() or not HF_TOKEN:
return "", _render_leaderboard()
last_err = None
for _ in range(3):
try:
raw = _call_llm(PROMPT_BINGO, text, max_tokens=1024)
raw = raw.replace('\n', ' ').replace('\r', '')
data = _extract_json(raw)
erlaubte_labels = ["Buzzword-Dichte", "Länge vs. Inhalt", "Selbstbeweihräuche", "Hashtag-Overload", "Sinnlosigkeits-Index"]
metrics = [m for m in data.get("metrics", []) if m.get("label") in erlaubte_labels]
data["metrics"] = metrics
total = sum(int(m.get("score", 0)) for m in metrics)
max_s = len(metrics) * 10
verdict = data.get("verdict", "Die KI war sprachlos: Kein Urteil generiert.")
data["verdict"] = verdict
# ----------------------------------
_add_to_lb(text, total, max_s, verdict)
entry = {
"timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
"post_text": text,
"total_score": total,
"max_score": max_s,
"pct": round(total / max_s * 100) if max_s else 0,
"verdict": verdict,
"metrics": metrics,
}
push_err = _push_entry(entry)
lb = _render_leaderboard()
if push_err:
lb += f'''
⚠ Dataset-Push fehlgeschlagen: {push_err}
'''
return _render_bingo(data), lb
except Exception as e:
last_err = e
print(f"DEBUG - JSON Parse Error. Raw Output war: {raw}") # Hilft dir beim Debuggen im HF Log!
return (f"
Analyse fehlgeschlagen: {last_err}
",
_render_leaderboard())
def generate_tuned_post(original_text, ton, substanz, laenge, zielgruppe, cta):
if not original_text.strip() or not HF_TOKEN:
return "Bitte zuerst einen Post eingeben."
prompt = PROMPT_AI_TUNING.format(ton=ton, substanz=substanz, laenge=laenge, zielgruppe=zielgruppe, cta=cta)
user_msg = f"""ORIGINAL POST:
{original_text}
TUNING:
- Tone: {ton}/100
- Substance: {substanz}/100
- Length: {laenge}/100
- Target Audience: {zielgruppe}
- Call to Action: {cta}"""
try:
return _call_llm(prompt, user_msg, max_tokens=800, model_id=MODEL_TUNING)
except Exception as e:
return f"Fehler: {e}"
# --- LADE ANIMATIONEN & MULTI-OUTPUT ---
def generate_tuned_post_with_loader(original_text, ton, substanz, laenge, zielgruppe, cta):
if not original_text.strip():
yield "Bitte zuerst einen Post eingeben.", "*Bitte zuerst einen Post eingeben.*"
return
yield "⏳ KI optimiert den Post nach deinen Vorgaben... Bitte warten.", "*Lädt...*"
result = generate_tuned_post(original_text, ton, substanz, laenge, zielgruppe, cta)
yield result, result
def run_translate(text, direction):
if not text.strip():
yield "", gr.update(), gr.update(), gr.update()
return
if direction == "to_linkedin":
yield ("",
gr.update(value="⏳ **Generiere epische LinkedIn-Prosa...** Bitte warten.", visible=True),
gr.update(visible=False),
gr.update())
result = translate(text, direction)
yield (result,
gr.update(value=result, visible=True),
gr.update(visible=False),
gr.update())
else:
loader_html = '
Analysiere Corporate Nonsense...
'
yield ("",
gr.update(visible=False),
gr.update(value=loader_html, visible=True),
gr.update())
result = translate(text, direction)
bingo_html, lb_html = get_bingo(text)
yield (result,
gr.update(visible=False),
gr.update(value=bingo_html, visible=True),
gr.update(value=lb_html))
def _render_bingo(data):
metrics = data.get("metrics", [])
verdict = data.get("verdict", "")
ICONS = {
"Buzzword-Dichte": "🗣️",
"Länge vs. Inhalt": "📏",
"Selbstbeweihräuche": "🪞",
"Hashtag-Overload": "#️⃣",
"Sinnlosigkeits-Index": "🌀",
}
def bar_color(s):
if s >= 8: return "#C0392B"
if s >= 5: return "#E67E22"
return "#27AE60"
rows = ""
for m in metrics:
score = int(m.get("score", 0))
label = m.get("label", "")
icon = ICONS.get(label, "")
color = bar_color(score)
rows += f"""
{icon} {label}{m.get('comment','')}{score}
"""
total = sum(int(m.get("score", 0)) for m in metrics)
max_score = len(metrics) * 10
total_pct = round(total / max_score * 100) if max_score else 0
badge_color = "#C0392B" if total_pct >= 70 else "#E67E22" if total_pct >= 40 else "#27AE60"
return f"""
Banale Wahrheit ↔ Epische LinkedIn-Prosa · powered by Llama
✨ AI Post Tuning
""")
dir_label = gr.HTML('
Klartext → LinkedIn Speech
')
with gr.Row(equal_height=True):
with gr.Column(scale=5):
input_box = gr.Textbox(label="✍️ Klartext",
placeholder="z.B. 'Ich hab heute meinen Kaffee verschuettet.'\n\nTipp: Du kannst hier auch direkt einen fertigen Text einfügen und ihn oben rechts über '✨ AI Post Tuning' optimieren lassen!",
lines=10)
with gr.Column(scale=1, min_width=120):
gr.HTML("")
translate_btn = gr.Button("Übersetzen", variant="primary", size="lg")
gr.HTML("")
swap_btn = gr.Button("Klartext 🔄 LinkedIn", variant="secondary", size="sm")
with gr.Column(scale=5):
output_box = gr.Textbox(label="💼 LinkedIn Speech",
placeholder="Die transformierte Version erscheint hier ...",
lines=10, interactive=False)
with gr.Row():
with gr.Column():
markdown_out = gr.Markdown(value="*Noch kein Ergebnis - bitte zuerst übersetzen.*", visible=True)
bingo_out = gr.HTML(value="", visible=False)
# ── AI Tuning Panel ───────────────────────────────────────────────────────
tuning_toggle_btn = gr.Button("toggle", elem_id="tuning_toggle_btn")
with gr.Row():
with gr.Column():
tuning_panel = gr.Column(visible=False, elem_classes=["tuning-card"])
with tuning_panel:
gr.HTML("""
")
with gr.Column(elem_classes=["preview-box"]):
tuning_preview = gr.Markdown(value="*Hier erscheint die formatierte Vorschau...*")
# ── Leaderboard & Infos (Tabs) ────────────────────────────────────────────
with gr.Tabs():
# TAB 1: Leaderboard (Standardmäßig geöffnet)
with gr.Tab("🏆 Leaderboard"):
with gr.Row():
with gr.Column():
lb_out = gr.HTML(value=_render_leaderboard())
hidden_sync_btn = gr.Button("sync", elem_id="hidden_sync_btn")
# TAB 2: Behind the Scenes & Soundtrack
with gr.Tab("🛠️ Info & Soundtrack"):
with gr.Row():
# Linke Spalte: Behind the Scenes (Breiter)
with gr.Column(scale=2, elem_classes=["tuning-card"]):
gr.HTML("""
🛠️
Meta-Info & Architektur
Dieses Projekt ist kein handgeschriebener Enterprise-Code, sondern ein Proof of Concept (PoC), das zu 100% mit AI-Tooling auf fast komplett freien Ressourcen umgesetzt wurde. Es zeigt, was mit modernem Stacking möglich ist:
Code Build Backend & UI: Generiert mit Claude Sonnet 4.6.
Core Engine:meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8. Läuft über die Hugging Face Inference Providers. Hinweis: Da es sich um Serverless-Instanzen handelt, kann es beim ersten Request zu kurzen "Cold Start"-Ladezeiten kommen.
Die Daten-Maschine & Das eigentliche Potenzial
Das Tool füttert sich durch Nutzung selbst. Jeder analysierte Post samt Bewertung fließt automatisiert in das öffentliche Hugging Face Dataset. Ein stetig wachsender Korpus aus LinkedIn-Prosa dient als Grundlage, um LLMs (z.B. via RAG) mit besserem Kontext zu versorgen.
Ausblick (Next Steps):
Spezialisierte LLM-Judges: Einsatz eines Multi-Agenten-Systems, in dem spezialisierte Mini-Modelle isoliert z.B. nur die "Buzzword-Dichte" evaluieren.
Automatisierter Feedback-Loop: Die punktbesten Posts aus dem Leaderboard automatisch als "Few-Shot Examples" in die Tuning-Prompts zurückspielen.
Über den Track:
Der durch den Projektkontext generierte Song liefert den Soundtrack zum Translator. Er beschreibt den Verlust von Authentizität zugunsten steriler Business-Sprache.
"Corporate buzzwords in a sterile row, watching the human nuance start to go. [...] Syntax error in the empathy code."
Genau das parodiert dieses Tool: Die Transformation von echtem Klartext in eine standardisierte Formelhaftigkeit.
""")
if not HF_TOKEN:
gr.HTML("""
Kein HF_TOKEN gefunden.
Unter Settings → Variables and secrets als HF_TOKEN hinzufügen.
""")
if not DATASET_REPO:
gr.HTML("""
💡 Dataset-Persistenz deaktiviert.
Lege ein HF Dataset an und trage den Namen als Secret DATASET_REPO
ein (z.B. mein-name/linkedin-nonsense-dataset).