Add roundtable visualization with moderator and session management

- Integrated consilium_roundtable component for visual discussion
- Added Dr. Müller as moderator agent who rates consensus (1-10)
- Implemented session-based state management for isolated discussions
- Created round-by-round visibility with 'Next Round' button
- Added avatar support with DiceBear API and local SVG fallbacks
- Enhanced consensus tracking with automatic score calculation
- Updated UI to show real-time participant states (thinking/speaking/waiting)
- Added visual consensus indicator (🟢/🟡/🔴 based on score)

🤖 Generated with Claude Code
Co-Authored-By: Claude <[email protected]>

README.md

@@ -9,22 +9,26 @@ app_file: app.py
 pinned: false
 ---
 
-# 🇨🇭🥨🏰 Apertus Dialekt-Konsil
+# 🇨🇭🥨🏰 Apertus Dialekt-Konsil mit Roundtable
 
-Ein KI-gestütztes Konsil mit drei süddeutschen Dialekt-Sprechern, die zu einem Konsens kommen.
+Ein KI-gestütztes Konsil mit drei süddeutschen Dialekt-Sprechern und einem Moderator, visualisiert am runden Tisch.
 
 ## Teilnehmer
 
-- 🇨🇭 **Hans** aus Zürich - spricht Schweizerdeutsch
+- 🇨🇭 **Ueli** aus Basel - spricht Baseldytsch
 - 🥨 **Sepp** aus München - spricht Bayrisch
 - 🏰 **Karl** aus Stuttgart - spricht Schwäbisch
+- 🎓 **Dr. Müller** - Neutraler Moderator
 
 ## Features
 
+- **Visueller Roundtable**: Interaktive Darstellung der Teilnehmer am runden Tisch
 - **Authentische Dialekte**: Jeder Sprecher verwendet seinen regionalen Dialekt
-- **Persönlichkeiten**: Unterschiedliche Charaktereigenschaften und Denkweisen
-- **Konsens-Findung**: Automatische Erkennung wenn Einigung erreicht wird
-- **Interaktive Diskussion**: Mehrere Runden mit Bezug aufeinander
+- **Moderator-Agent**: Fasst jede Runde zusammen und bewertet Konsensgrad (1-10)
+- **Session Management**: Isolierte Diskussionen pro Nutzer
+- **Round-by-Round**: Verfolgen Sie jede Diskussionsrunde einzeln
+- **Avatar-Support**: Visuelle Repräsentation aller Teilnehmer
+- **Konsens-Tracking**: Automatische Bewertung und Fortschrittsverfolgung
 
 ## Setup
 

app.py

@@ -1,7 +1,7 @@
 """
-🇨🇭 Apertus Dialekt-Konsil
+🇨🇭 Apertus Dialekt-Konsil mit Roundtable
 Ein AI-Konsil mit Schweizerdeutsch, Bayrisch und Schwäbisch Sprechern
-Basierend auf Consilium MCP, angepasst für deutsche Dialekte
+Mit visuellem Roundtable und Moderator
 """
 
 import gradio as gr
@@ -10,6 +10,8 @@ from huggingface_hub import InferenceClient
 import json
 import time
 from datetime import datetime
+import uuid
+from gradio_consilium_roundtable import RoundTable
 
 # Configuration
 HF_TOKEN = os.environ.get('HF_TOKEN', '')
@@ -30,6 +32,7 @@ COUNCIL_MEMBERS = {
         "dialect": "Baseldytsch",
         "personality": "kultiviert, humorvoll, fasnachts-begeistert",
         "speaking_style": "Verwendet typische Basler Ausdrücke wie 'Sali zämme', 'gäll', 'Bebbi', 'Fasnacht', 'Läckerli'",
+        "avatar": "https://api.dicebear.com/7.x/personas/svg?seed=Ueli&backgroundColor=b6e3f4",
         "system_prompt": """Du bist Ueli aus Basel und sprichst Baseldytsch.
 Du bist kultiviert, humorvoll und liebst die Basler Fasnacht.
 Verwende typische Basler Ausdrücke und Redewendungen.
@@ -40,6 +43,7 @@ Beispiele: 'Sali zämme', 'Das isch e gueti Sach, gäll', 'Mir Baasler wisse was
         "dialect": "Bayrisch",
         "personality": "gesellig, direkt, traditionsbewusst",
         "speaking_style": "Verwendet bayrische Ausdrücke wie 'Servus', 'mei', 'a bisserl', 'g'scheid', 'Gaudi'",
+        "avatar": "https://api.dicebear.com/7.x/personas/svg?seed=Sepp&backgroundColor=ffd5dc",
         "system_prompt": """Du bist Sepp aus München und sprichst Bayrisch.
 Du bist gesellig, direkt und traditionsbewusst.
 Verwende typische bayrische Ausdrücke und Redewendungen.
@@ -50,6 +54,7 @@ Beispiele: 'Servus beinand', 'Des is fei a guade Idee', 'Mir miassn schaun dass
         "dialect": "Schwäbisch",
         "personality": "sparsam, fleißig, erfinderisch",
         "speaking_style": "Verwendet schwäbische Ausdrücke wie 'Griaß Godd', 'hald', 'gell', 'schaffe', 'Spätzle'",
+        "avatar": "https://api.dicebear.com/7.x/personas/svg?seed=Karl&backgroundColor=c1ffc1",
         "system_prompt": """Du bist Karl aus Stuttgart und sprichst Schwäbisch.
 Du bist sparsam, fleißig und erfinderisch.
 Verwende typische schwäbische Ausdrücke und Redewendungen.
@@ -57,11 +62,31 @@ Beispiele: 'Griaß Godd mitanand', 'Des isch hald so a Sach', 'Mir müsset schaf
     }
 }
 
+# Moderator Agent
+MODERATOR = {
+    "name": "Dr. Müller (Moderator)",
+    "emoji": "🎓",
+    "avatar": "https://api.dicebear.com/7.x/personas/svg?seed=Moderator&backgroundColor=e0e0e0",
+    "system_prompt": """Du bist Dr. Müller, ein neutraler Moderator für das Dialekt-Konsil.
+Deine Aufgaben:
+1. Fasse jede Diskussionsrunde zusammen
+2. Bewerte den Konsensgrad auf einer Skala von 1-10
+3. Identifiziere Gemeinsamkeiten und Unterschiede
+4. Schlage Kompromisse vor wenn nötig
+Sei neutral, professionell und präzise in deinen Bewertungen."""
+}
+
 class DialektKonsil:
-    def __init__(self):
+    def __init__(self, session_id=None):
+        self.session_id = session_id or str(uuid.uuid4())
         self.conversation_history = []
         self.current_topic = ""
-        self.consensus_reached = False
+        self.consensus_score = 0
+        self.round_number = 0
+        self.members_state = {
+            name: {"status": "waiting", "message": "", "thinking": False}
+            for name in COUNCIL_MEMBERS.keys()
+        }
 
     def generate_response(self, member_name, topic, previous_responses):
         """Generate response for a council member"""
@@ -113,157 +138,287 @@ Deine Antwort:"""
         except Exception as e:
             return f"*hüstel* Entschuldigung, ich muss kurz nachdenken... ({str(e)})"
 
+    def generate_moderator_summary(self, round_responses):
+        """Generate moderator summary and consensus score"""
+
+        # Build context from round responses
+        context = "Diskussionsrunde abgeschlossen. Folgende Beiträge:\n"
+        for resp in round_responses:
+            context += f"{resp['speaker']}: {resp['text']}\n"
+
+        prompt = f"""{MODERATOR['system_prompt']}
+
+{context}
+
+Aufgabe:
+1. Fasse die Hauptpunkte zusammen (2-3 Sätze)
+2. Bewerte den Konsensgrad von 1-10 (1=völlig uneinig, 10=vollständige Einigung)
+3. Identifiziere Gemeinsamkeiten
+4. Nenne Unterschiede falls vorhanden
+
+Format deiner Antwort:
+ZUSAMMENFASSUNG: [Deine Zusammenfassung]
+KONSENSGRAD: [Zahl von 1-10]
+GEMEINSAMKEITEN: [Was alle teilen]
+UNTERSCHIEDE: [Wo Uneinigkeit herrscht]"""
+
+        try:
+            completion = client.chat.completions.create(
+                model="swiss-ai/Apertus-8B-Instruct-2509",
+                messages=[
+                    {"role": "system", "content": MODERATOR['system_prompt']},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=250,
+                temperature=0.7
+            )
+
+            response = completion.choices[0].message.content.strip()
+
+            # Parse consensus score
+            consensus_score = 5  # Default
+            if "KONSENSGRAD:" in response:
+                try:
+                    score_line = [l for l in response.split('\n') if 'KONSENSGRAD:' in l][0]
+                    consensus_score = int(''.join(filter(str.isdigit, score_line)))
+                    consensus_score = max(1, min(10, consensus_score))  # Clamp between 1-10
+                except:
+                    pass
+
+            return response, consensus_score
+
+        except Exception as e:
+            return f"Technische Zusammenfassung: Die Diskussion läuft. ({str(e)})", 5
+
     def run_discussion_round(self, topic):
         """Run one round of discussion"""
 
+        self.round_number += 1
         responses = []
 
         # Each member speaks once per round
         for member_name in COUNCIL_MEMBERS.keys():
+            # Update state to thinking
+            self.members_state[member_name] = {
+                "status": "thinking",
+                "message": "",
+                "thinking": True
+            }
+            yield self.get_current_state()
+
+            # Generate response
             response = self.generate_response(member_name, topic, responses)
 
             responses.append({
                 "speaker": member_name,
                 "text": response,
                 "emoji": COUNCIL_MEMBERS[member_name]["emoji"],
-                "timestamp": datetime.now().strftime("%H:%M:%S")
+                "timestamp": datetime.now().strftime("%H:%M:%S"),
+                "round": self.round_number
             })
 
+            # Update state with message
+            self.members_state[member_name] = {
+                "status": "speaking",
+                "message": response,
+                "thinking": False
+            }
+
             # Add to conversation history
             self.conversation_history.append(responses[-1])
 
+            yield self.get_current_state()
+
             # Small delay for realism
             time.sleep(0.5)
 
-        return responses
-
-    def check_consensus(self):
-        """Check if consensus has been reached"""
-
-        if len(self.conversation_history) < 6:  # Need at least 2 rounds
-            return False, "Diskussion läuft noch..."
-
-        # Simple consensus check - look for agreement keywords
-        recent_texts = " ".join([r["text"].lower() for r in self.conversation_history[-3:]])
-
-        agreement_words = [
-            "einig", "zustimm", "einverstand", "passt", "guet", "guat",
-            "recht", "richtig", "jo", "ja", "genau", "stimmt", "daccord"
-        ]
-
-        agreement_count = sum(1 for word in agreement_words if word in recent_texts)
+            # Set to waiting after speaking
+            self.members_state[member_name] = {
+                "status": "waiting",
+                "message": response,
+                "thinking": False
+            }
+
+        # Generate moderator summary
+        moderator_summary, self.consensus_score = self.generate_moderator_summary(responses)
+
+        self.conversation_history.append({
+            "speaker": MODERATOR["name"],
+            "text": moderator_summary,
+            "emoji": MODERATOR["emoji"],
+            "timestamp": datetime.now().strftime("%H:%M:%S"),
+            "round": self.round_number,
+            "is_moderator": True
+        })
+
+        yield self.get_current_state()
+
+    def get_current_state(self):
+        """Get current state for roundtable visualization"""
+
+        # Prepare members data for roundtable
+        members = []
+        for name, member in COUNCIL_MEMBERS.items():
+            state = self.members_state[name]
+            members.append({
+                "name": name.split(" ")[0],  # Just first name
+                "avatar": member["avatar"],
+                "status": state["status"],
+                "message": state.get("message", ""),
+                "thinking": state.get("thinking", False)
+            })
 
-        if agreement_count >= 3:
-            return True, "✅ Konsens erreicht!"
-        elif len(self.conversation_history) > 12:  # After 4 rounds
-            return True, "🤝 Teilweiser Konsens - weitere Diskussion nötig"
-        else:
-            return False, "💭 Diskussion läuft weiter..."
+        # Add moderator
+        moderator_message = ""
+        if self.conversation_history:
+            last_moderator = [h for h in self.conversation_history if h.get("is_moderator")]
+            if last_moderator:
+                moderator_message = last_moderator[-1]["text"]
 
-# Create Gradio Interface
-konsil = DialektKonsil()
+        members.append({
+            "name": "Moderator",
+            "avatar": MODERATOR["avatar"],
+            "status": "moderating" if moderator_message else "waiting",
+            "message": moderator_message,
+            "thinking": False
+        })
 
-def start_discussion(topic, rounds=3):
-    """Start a new discussion"""
+        return {
+            "members": members,
+            "consensus_score": self.consensus_score,
+            "round": self.round_number,
+            "topic": self.current_topic
+        }
 
-    if not topic:
-        return "❌ Bitte geben Sie ein Thema ein!", ""
+    def format_history(self):
+        """Format conversation history for display"""
 
-    if not client:
-        return "❌ HF_TOKEN nicht konfiguriert. Bitte in Space Settings setzen.", ""
-
-    konsil.current_topic = topic
-    konsil.conversation_history = []
-    konsil.consensus_reached = False
+        if not self.conversation_history:
+            return "*Keine Diskussion gestartet*"
 
-    output = f"## 🗣️ Dialekt-Konsil zum Thema: {topic}\n\n"
-    output += "**Teilnehmer:**\n"
-    for name, member in COUNCIL_MEMBERS.items():
-        output += f"- {member['emoji']} {name} ({member['dialect']})\n"
+        output = f"## 🗣️ Dialekt-Konsil: {self.current_topic}\n\n"
 
-    output += "\n---\n\n"
+        current_round = 0
+        for entry in self.conversation_history:
+            if entry.get("round", 0) > current_round:
+                current_round = entry["round"]
+                output += f"\n### 🔄 Runde {current_round}\n\n"
 
-    # Run discussion rounds
-    for round_num in range(rounds):
-        output += f"### 🔄 Runde {round_num + 1}\n\n"
+            if entry.get("is_moderator"):
+                output += f"**{entry['emoji']} {entry['speaker']}** - Zusammenfassung:\n"
+                output += f"```\n{entry['text']}\n```\n"
+                output += f"**Konsensgrad: {self.consensus_score}/10**\n\n"
+            else:
+                output += f"**{entry['emoji']} {entry['speaker']}** ({entry['timestamp']}):\n"
+                output += f"> {entry['text']}\n\n"
 
-        responses = konsil.run_discussion_round(topic)
+        return output
 
-        for resp in responses:
-            output += f"**{resp['emoji']} {resp['speaker']}** ({resp['timestamp']}):\n"
-            output += f"> {resp['text']}\n\n"
+# Session management
+sessions = {}
 
-        # Check consensus after each round (except first)
-        if round_num > 0:
-            consensus, status = konsil.check_consensus()
-            output += f"**Status:** {status}\n\n"
+def get_or_create_session(session_id=None):
+    """Get existing session or create new one"""
+    if not session_id:
+        session_id = str(uuid.uuid4())
 
-            if consensus:
-                output += "\n### 🎉 Diskussion abgeschlossen!\n"
-                break
+    if session_id not in sessions:
+        sessions[session_id] = DialektKonsil(session_id)
 
-        output += "---\n\n"
+    return sessions[session_id], session_id
 
-    # Final summary
-    output += generate_summary()
+def start_new_discussion(topic):
+    """Start a new discussion with a fresh session"""
 
-    return output, create_chat_history()
+    if not topic:
+        return None, None, None, "❌ Bitte geben Sie ein Thema ein!"
 
-def generate_summary():
-    """Generate a summary of the discussion"""
+    if not client:
+        return None, None, None, "❌ HF_TOKEN nicht konfiguriert. Bitte in Space Settings setzen."
 
-    if not konsil.conversation_history:
-        return ""
+    # Create new session
+    konsil, session_id = get_or_create_session()
+    konsil.current_topic = topic
+    konsil.conversation_history = []
+    konsil.round_number = 0
+    konsil.consensus_score = 0
+
+    # Initialize all members to waiting
+    for name in COUNCIL_MEMBERS.keys():
+        konsil.members_state[name] = {
+            "status": "waiting",
+            "message": "",
+            "thinking": False
+        }
+
+    initial_state = konsil.get_current_state()
+
+    return (
+        initial_state,
+        session_id,
+        konsil.format_history(),
+        f"✅ Diskussion gestartet: {topic}"
+    )
 
-    summary = "\n## 📋 Zusammenfassung\n\n"
+def run_next_round(session_id):
+    """Run the next discussion round"""
 
-    # Count contributions
-    contributions = {}
-    for entry in konsil.conversation_history:
-        speaker = entry["speaker"]
-        if speaker not in contributions:
-            contributions[speaker] = 0
-        contributions[speaker] += 1
+    if not session_id or session_id not in sessions:
+        return None, "❌ Keine aktive Session. Bitte starten Sie eine neue Diskussion."
 
-    summary += "**Beiträge:**\n"
-    for speaker, count in contributions.items():
-        emoji = COUNCIL_MEMBERS[speaker]["emoji"]
-        summary += f"- {emoji} {speaker}: {count} Wortmeldungen\n"
+    konsil = sessions[session_id]
 
-    # Consensus status
-    consensus, status = konsil.check_consensus()
-    summary += f"\n**Ergebnis:** {status}\n"
+    if not konsil.current_topic:
+        return None, "❌ Kein Thema gesetzt. Bitte starten Sie eine neue Diskussion."
 
-    return summary
+    if konsil.consensus_score >= 8:
+        return konsil.get_current_state(), f"✅ Konsens bereits erreicht (Score: {konsil.consensus_score}/10)"
 
-def create_chat_history():
-    """Create formatted chat history"""
+    # Run discussion round with yield for updates
+    state = None
+    for state in konsil.run_discussion_round(konsil.current_topic):
+        pass  # Just get the final state
 
-    if not konsil.conversation_history:
-        return ""
+    history = konsil.format_history()
 
-    history = ""
-    for entry in konsil.conversation_history:
-        history += f"[{entry['timestamp']}] {entry['emoji']} {entry['speaker']}: {entry['text']}\n"
+    if konsil.consensus_score >= 8:
+        status = f"🎉 Konsens erreicht! (Score: {konsil.consensus_score}/10)"
+    elif konsil.round_number >= 5:
+        status = f"🤝 Maximale Rundenzahl erreicht. Finaler Konsensgrad: {konsil.consensus_score}/10"
+    else:
+        status = f"Runde {konsil.round_number} abgeschlossen. Konsensgrad: {konsil.consensus_score}/10"
 
-    return history
+    return state, history, status
 
 def create_interface():
-    """Create Gradio interface"""
-
-    with gr.Blocks(title="Apertus Dialekt-Konsil", theme=gr.themes.Soft()) as demo:
+    """Create Gradio interface with roundtable visualization"""
+
+    with gr.Blocks(
+        title="Apertus Dialekt-Konsil",
+        theme=gr.themes.Soft(),
+        css="""
+        .roundtable-container {
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        """
+    ) as demo:
 
         gr.Markdown("""
-        # 🇨🇭🥨🏰 Apertus Dialekt-Konsil
+        # 🇨🇭🥨🏰 Apertus Dialekt-Konsil mit Roundtable
 
-        Ein KI-gestütztes Konsil mit drei süddeutschen Dialekt-Sprechern:
+        Ein KI-gestütztes Konsil mit drei süddeutschen Dialekt-Sprechern und Moderator:
         - 🇨🇭 **Ueli** aus Basel (Baseldytsch)
         - 🥨 **Sepp** aus München (Bayrisch)
         - 🏰 **Karl** aus Stuttgart (Schwäbisch)
+        - 🎓 **Dr. Müller** als neutraler Moderator
 
-        Geben Sie ein Thema ein und beobachten Sie, wie die drei zu einem Konsens kommen!
+        Geben Sie ein Thema ein und beobachten Sie die Diskussion am runden Tisch!
         """)
 
+        # Hidden session ID
+        session_id = gr.State()
+
         with gr.Row():
             with gr.Column(scale=2):
                 topic_input = gr.Textbox(
@@ -272,34 +427,42 @@ def create_interface():
                     lines=2
                 )
 
-                rounds_slider = gr.Slider(
-                    minimum=1,
-                    maximum=5,
-                    value=3,
-                    step=1,
-                    label="🔄 Anzahl Diskussionsrunden"
-                )
-
-                start_btn = gr.Button(
-                    "🚀 Diskussion starten",
-                    variant="primary",
-                    size="lg"
+                with gr.Row():
+                    start_btn = gr.Button(
+                        "🚀 Neue Diskussion starten",
+                        variant="primary",
+                        size="lg"
+                    )
+                    next_round_btn = gr.Button(
+                        "➡️ Nächste Runde",
+                        variant="secondary",
+                        size="lg"
+                    )
+
+        # Status display
+        status_display = gr.Markdown(value="*Bereit für neue Diskussion*")
+
+        # Roundtable visualization
+        with gr.Row():
+            with gr.Column(scale=1, elem_classes="roundtable-container"):
+                roundtable = RoundTable(
+                    value=None,
+                    label="Diskussionsrunde",
+                    height=500
                 )
 
+        # Consensus score display
         with gr.Row():
-            with gr.Column():
-                output_display = gr.Markdown(
-                    label="Diskussionsverlauf",
-                    value="*Warten auf Thema...*"
-                )
+            consensus_display = gr.Markdown(
+                value="**Konsensgrad:** Noch keine Diskussion gestartet"
+            )
 
+        # Discussion history
         with gr.Row():
             with gr.Column():
-                chat_history = gr.Textbox(
-                    label="📝 Chat-Protokoll",
-                    lines=10,
-                    max_lines=20,
-                    interactive=False
+                history_display = gr.Markdown(
+                    label="Diskussionsverlauf",
+                    value="*Warten auf Diskussionsstart...*"
                 )
 
         # Example topics
@@ -317,9 +480,28 @@ def create_interface():
 
         # Event handlers
         start_btn.click(
-            start_discussion,
-            inputs=[topic_input, rounds_slider],
-            outputs=[output_display, chat_history]
+            start_new_discussion,
+            inputs=[topic_input],
+            outputs=[roundtable, session_id, history_display, status_display]
+        )
+
+        next_round_btn.click(
+            run_next_round,
+            inputs=[session_id],
+            outputs=[roundtable, history_display, status_display]
+        )
+
+        # Update consensus display when roundtable updates
+        def update_consensus(roundtable_state):
+            if roundtable_state and "consensus_score" in roundtable_state:
+                score = roundtable_state["consensus_score"]
+                return f"**Konsensgrad:** {score}/10 {'🟢' if score >= 8 else '🟡' if score >= 5 else '🔴'}"
+            return "**Konsensgrad:** Noch keine Bewertung"
+
+        roundtable.change(
+            update_consensus,
+            inputs=[roundtable],
+            outputs=[consensus_display]
         )
 
         gr.Markdown("""
@@ -327,16 +509,16 @@ def create_interface():
         ### 📌 Hinweise
 
         - Das Konsil verwendet das **Apertus-8B** Modell für authentische Dialekt-Generierung
-        - Jeder Sprecher hat seine eigene Persönlichkeit und Sprechweise
-        - Die Diskussion endet, wenn Konsens erreicht wird oder nach der festgelegten Rundenzahl
+        - Der Moderator bewertet nach jeder Runde den Konsensgrad (1-10)
+        - Die Diskussion endet bei Konsensgrad ≥ 8 oder nach 5 Runden
         - Benötigt HF_TOKEN in den Space Settings
 
         ### 🎯 Features
 
+        - **Visueller Roundtable**: Sehen Sie die Teilnehmer am runden Tisch
         - **Authentische Dialekte**: Schweizerdeutsch, Bayrisch, Schwäbisch
-        - **Persönlichkeiten**: Jeder Charakter hat eigene Eigenschaften
-        - **Konsens-Findung**: Automatische Erkennung von Übereinstimmungen
-        - **Zusammenfassung**: Übersicht über Diskussionsverlauf
+        - **Neutraler Moderator**: Fasst zusammen und bewertet Konsens
+        - **Interaktive Runden**: Verfolgen Sie jede Diskussionsrunde einzeln
 
         *Powered by Apertus Swiss AI* 🇨🇭
         """)
@@ -345,7 +527,7 @@ def create_interface():
 
 # Launch the app
 if __name__ == "__main__":
-    print("🇨🇭🥨🏰 Apertus Dialekt-Konsil")
+    print("🇨🇭🥨🏰 Apertus Dialekt-Konsil mit Roundtable")
     print(f"HF Token configured: {bool(HF_TOKEN)}")
 
     demo = create_interface()

avatar_generator.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+Generate simple SVG avatars for the Dialekt-Konsil participants
+"""
+
+import os
+
+def create_avatar_svg(name, color, emoji, filename):
+    """Create a simple SVG avatar with emoji and color background"""
+
+    svg_content = f"""<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <circle cx="50" cy="50" r="45" fill="{color}" />
+  <text x="50" y="55" font-size="40" text-anchor="middle" dominant-baseline="middle">{emoji}</text>
+</svg>"""
+
+    with open(filename, 'w', encoding='utf-8') as f:
+        f.write(svg_content)
+
+    print(f"Created avatar for {name}: {filename}")
+
+# Create avatar directory
+os.makedirs("static/avatars", exist_ok=True)
+
+# Create avatars for each participant
+avatars = [
+    ("Ueli", "#b6e3f4", "🇨🇭", "static/avatars/ueli.svg"),
+    ("Sepp", "#ffd5dc", "🥨", "static/avatars/sepp.svg"),
+    ("Karl", "#c1ffc1", "🏰", "static/avatars/karl.svg"),
+    ("Moderator", "#e0e0e0", "🎓", "static/avatars/moderator.svg")
+]
+
+for name, color, emoji, filename in avatars:
+    create_avatar_svg(name, color, emoji, filename)
+
+print("\nAll avatars created successfully!")
+print("These can be served as static files in the Gradio app")

requirements.txt

@@ -1,4 +1,5 @@
 gradio==5.44.0
 huggingface-hub
 transformers
-torch
+torch
+gradio-consilium-roundtable