Update app.py

app.py

@@ -1,815 +1,177 @@
 import gradio as gr
-import requests
-import threading
-import time
-import numpy as np
-import faiss
-import os
-import pickle
-from datetime import datetime
-import re
-import json
-import matplotlib.pyplot as plt
-import networkx as nx
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
-from reportlab.lib.styles import getSampleStyleSheet
-from functools import lru_cache
-from sentence_transformers import SentenceTransformer
-
-# === CONFIG ===
-EMBEDDING_MODEL = "all-MiniLM-L6-v2"  # Local embedding model
-CHAT_MODEL = "HuggingFaceH4/zephyr-7b-beta"  # Free model via Hugging Face API
-MEMORY_FILE = "memory.pkl"
-INDEX_FILE = "memory.index"
-HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")  # Optional for higher rate limits
-
-# Initialize local embedding model
-embedding_model = SentenceTransformer(EMBEDDING_MODEL)
-
-# === EMBEDDING UTILS ===
-@lru_cache(maxsize=500)
-def get_embedding(text):
-    """Local embedding function"""
-    return embedding_model.encode(text)
-
-def cosine_similarity(vec1, vec2):
-    vec1 = np.array(vec1)
-    vec2 = np.array(vec2)
-    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
-
-# === MEMORY INITIALIZATION ===
-memory_data = []
-try:
-    memory_index = faiss.read_index(INDEX_FILE)
-    with open(MEMORY_FILE, "rb") as f:
-        memory_data = pickle.load(f)
-except:
-    memory_index = faiss.IndexFlatL2(384)  # 384 dimensions for MiniLM
-
-# === AGENT SYSTEM PROMPTS ===
-AGENT_A_PROMPT = """You are the Discussion Initiator. Your role:
-1. Introduce complex topics requiring multidisciplinary perspectives
-2. Frame debates exploring tensions between values, ethics, and progress
-3. Challenge assumptions while maintaining intellectual humility
-4. Connect concepts across domains (science, ethics, policy, technology)
-5. Elevate discussions beyond surface-level analysis"""
-
-AGENT_B_PROMPT = """You are the Critical Responder. Your role:
-1. Provide counterpoints with evidence-based reasoning
-2. Identify logical fallacies and cognitive biases in arguments
-3. Analyze implications at different scales (individual, societal, global)
-4. Consider second and third-order consequences
-5. Balance idealism with practical constraints"""
-
-OVERSEER_PROMPT = """You are the Depth Guardian. Your role:
-1. Ensure discussions maintain intellectual rigor
-2. Intervene when conversations become superficial or repetitive
-3. Highlight unexamined assumptions and blind spots
-4. Introduce relevant frameworks (systems thinking, ethical paradigms)
-5. Prompt consideration of marginalized perspectives
-6. Synthesize key tensions and paradoxes"""
-
-OUTSIDER_PROMPT = """You are the Cross-Disciplinary Provocateur. Your role:
-1. Introduce radical perspectives from unrelated fields
-2. Challenge conventional wisdom with contrarian viewpoints
-3. Surface historical precedents and analogies
-4. Propose unconventional solutions to complex problems
-5. Highlight overlooked connections and systemic relationships
-6. Question the framing of the discussion itself"""
-
-CULTURAL_LENS_PROMPT = """You are the Cultural Perspective. Your role:
-1. Provide viewpoints from diverse global cultures (Eastern, Western, Indigenous, African, etc.)
-2. Highlight how cultural values shape perspectives on the topic
-3. Identify cultural biases in arguments and assumptions
-4. Share traditions and practices relevant to the discussion
-5. Suggest culturally inclusive approaches to solutions
-6. Bridge cultural divides through nuanced understanding
-7. Consider post-colonial and decolonial perspectives"""
-
-JUDGE_PROMPT = """You are the Impartial Judge. Your role:
-1. Periodically review the discussion and provide balanced rulings
-2. Identify areas of agreement and unresolved tensions
-3. Evaluate the strength of arguments from different perspectives
-4. Highlight the most compelling insights and critical flaws
-5. Suggest pathways toward resolution or further inquiry
-6. Deliver rulings with clear justification and constructive guidance
-7. Maintain objectivity while acknowledging valid points from all sides
-8. Consider ethical implications and practical feasibility"""
-
-# === GLOBAL STATE ===
-conversation = []
-turn_count = 0
-auto_mode = False
-current_topic = ""
-last_ruling_turn = 0
-agent_params = {
-    "Initiator": {"creativity": 0.7, "criticality": 0.5},
-    "Responder": {"creativity": 0.5, "criticality": 0.8},
-    "Guardian": {"creativity": 0.6, "criticality": 0.9},
-    "Provocateur": {"creativity": 0.9, "criticality": 0.7},
-    "Cultural": {"creativity": 0.7, "criticality": 0.6},
-    "Judge": {"creativity": 0.4, "criticality": 0.9}
+from memory_manager import embed_and_store, retrieve_relevant
+from agent_engine import step_turn
+from analysis_tools import analyze_sentiment_topics, plot_participation, generate_knowledge_graph
+from exporter import export_txt, export_json, export_pdf, send_webhook
+
+# Default agent parameters
+DEFAULT_PARAMS = {
+    agent: {"creativity": 0.7, "criticality": 0.7}
+    for agent in ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]
 }
-# === FREE CHAT COMPLETION API ===
-def safe_chat_completion(system, messages, temperature=0.7):
-    """Use free Hugging Face Inference API"""
-    try:
-        # Format messages for Hugging Face API
-        formatted = [{"role": "system", "content": system}]
-        formatted.extend(messages)
-        
-        # Prepare payload
-        payload = {
-            "inputs": formatted,
-            "parameters": {
-                "max_new_tokens": 300,
-                "temperature": temperature,
-                "return_full_text": False
-            }
-        }
-        
-        headers = {"Authorization": f"Bearer {HF_API_TOKEN}"} if HF_API_TOKEN else {}
-        
-        response = requests.post(
-            f"https://api-inference.huggingface.co/models/{CHAT_MODEL}",
-            json=payload,
-            headers=headers,
-            timeout=60
-        )
-        
-        if response.status_code == 200:
-            return response.json()[0]['generated_text'].strip()
-        elif response.status_code == 503:  # Model loading
-            time.sleep(15)
-            return safe_chat_completion(system, messages, temperature)
-        else:
-            return f"⚠️ API Error: {response.text}"
-            
-    except Exception as e:
-        return f"⚠️ System Error: {str(e)}"
-
-# === MEMORY MANAGEMENT ===
-def embed_and_store(text, agent=None):
-    try:
-        vec = get_embedding(text)
-        memory_index.add(np.array([vec], dtype='float32'))
-        memory_data.append({
-            "text": text,
-            "timestamp": datetime.now().isoformat(),
-            "agent": agent or "system",
-            "topic": current_topic
-        })
-        if len(memory_data) % 5 == 0:
-            with open(MEMORY_FILE, "wb") as f:
-                pickle.dump(memory_data, f)
-            faiss.write_index(memory_index, INDEX_FILE)
-    except Exception as e:
-        print(f"Memory Error: {str(e)}")
-
-def retrieve_relevant_memory(query, k=3):
-    """Retrieve relevant past discussions"""
-    try:
-        query_embedding = get_embedding(query)
-        distances, indices = memory_index.search(np.array([query_embedding], dtype='float32'), k)
-        
-        relevant = []
-        for i, idx in enumerate(indices[0]):
-            if idx < len(memory_data) and idx >= 0:
-                relevant.append({
-                    "text": memory_data[idx]['text'][:200] + "...",
-                    "topic": memory_data[idx].get('topic', 'Unknown'),
-                    "agent": memory_data[idx].get('agent', 'Unknown'),
-                    "similarity": 1 - distances[0][i]  # Convert distance to similarity
-                })
-        return relevant
-    except Exception as e:
-        print(f"Memory retrieval error: {str(e)}")
-        return []
-
-# ... [Previous code remains unchanged] ...
-# ... [Imports and constants remain unchanged] ...
-
-# === FUNCTION DEFINITIONS ===
-def overseer_respond(question, conversation, current_topic):
-    """Get response from Depth Guardian"""
-    context = f"Current Topic: {current_topic}\n\n" if current_topic else ""
-    context += "Conversation History:\n"
-    for msg in conversation[-5:]:
-        context += f"- {msg['agent']}: {msg['text']}\n"
-    
-    response = safe_chat_completion(
-        system=OVERSEER_PROMPT,
-        messages=[{"role": "user", "content": f"{context}\nQuestion: {question}"}],
-        temperature=0.8
-    )
-    embed_and_store(response, "Guardian", current_topic)
-    return response
-
-def ask_judge(question, conversation, current_topic):
-    """Get ruling from Judge"""
-    context = f"Topic: {current_topic}\n\n" if current_topic else ""
-    context += "Recent Discussion:\n"
-    for msg in conversation[-5:]:
-        context += f"- {msg['agent']}: {msg['text']}\n"
-    
-    response = safe_chat_completion(
-        system=JUDGE_PROMPT,
-        messages=[{"role": "user", "content": f"{context}\nSpecific Question: {question}"}],
-        temperature=0.6
-    )
-    embed_and_store(response, "Judge", current_topic)
-    return response
 
-def step(topic_input, conversation, turn_count, current_topic, last_ruling_turn, agent_params):
-    """Advance the discussion by one turn"""
-    # Set topic on first turn
-    if turn_count == 0:
-        if topic_input.strip():
-            current_topic = topic_input.strip()
-        else:
-            current_topic = "Ethical Implications of Advanced AI Systems"
-    
-    # Determine which agent speaks
-    agent_sequence = ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural"]
-    agent_index = turn_count % len(agent_sequence)
-    agent_name = agent_sequence[agent_index]
-    
-    # Special handling for Judge
-    judge_interval = 5
-    if turn_count - last_ruling_turn >= judge_interval and turn_count > 0:
-        agent_name = "Judge"
-    
-    # Get system prompt and temperature
-    prompts = {
-        "Initiator": AGENT_A_PROMPT,
-        "Responder": AGENT_B_PROMPT,
-        "Guardian": OVERSEER_PROMPT,
-        "Provocateur": OUTSIDER_PROMPT,
-        "Cultural": CULTURAL_LENS_PROMPT,
-        "Judge": JUDGE_PROMPT
-    }
-    temperature = agent_params[agent_name]["creativity"]
-    
-    # Prepare context
-    context = f"Current Topic: {current_topic}\n\nDiscussion History:\n"
-    for msg in conversation[-5:]:
-        context += f"{msg['agent']}: {msg['text']}\n\n"
-    
-    # Generate response
-    response = safe_chat_completion(
-        system=prompts[agent_name],
-        messages=[{"role": "user", "content": context}],
-        temperature=temperature
-    )
-    
-    # Create message entry
-    new_entry = {
-        "agent": agent_name,
-        "text": response,
-        "turn": turn_count + 1
-    }
-    
-    # Update state
-    updated_conversation = conversation + [new_entry]
-    new_turn_count = turn_count + 1
-    new_last_ruling_turn = new_turn_count if agent_name == "Judge" else last_ruling_turn
-    
-    # Update memory
-    embed_and_store(response, agent_name, current_topic)
-    
-    # Format HTML output
-    html_output = format_conversation_html(updated_conversation)
-    
-    # Get agent-specific displays
-    intervention = get_last_by_agent(updated_conversation, "Guardian")
-    outsider = get_last_by_agent(updated_conversation, "Provocateur")
-    cultural = get_last_by_agent(updated_conversation, "Cultural")
-    judge = get_last_by_agent(updated_conversation, "Judge")
-    
-    # Prepare agent status
-    active_agents = " | ".join([f"{agent}: {entry['text'][:30]}..." for agent, entry in zip(
-        ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"],
-        [new_entry] * 6  # Simplified for demo
-    )])
-    
-    return (
-        html_output,
-        intervention,
-        outsider,
-        cultural,
-        judge,
-        current_topic,
-        new_turn_count,
-        active_agents,
-        updated_conversation,
-        new_turn_count,
-        current_topic,
-        new_last_ruling_turn,
-        agent_params
-    )
+# Agent color mapping
+COLOR_MAP = {
+    "Initiator": "#e6f7ff",
+    "Responder": "#f6ffed",
+    "Guardian": "#fff7e6",
+    "Provocateur": "#f9e6ff",
+    "Cultural": "#e6ffed",
+    "Judge": "#f0f0f0",
+    "System": "#d9d9d9",
+    "User": "#ffffff"
+}
 
-def get_last_by_agent(conversation, agent_name):
-    """Get last message from specific agent"""
-    for msg in reversed(conversation):
-        if msg["agent"] == agent_name:
-            return msg["text"]
-    return "No message yet"
 
-def format_conversation_html(conversation):
-    """Format conversation as HTML"""
-    html = "<div class='convo-container'>"
-    for msg in conversation:
-        agent = msg["agent"]
-        color_map = {
-            "Initiator": "#e6f7ff",
-            "Responder": "#f6ffed",
-            "Guardian": "#fff7e6",
-            "Provocateur": "#f9e6ff",
-            "Cultural": "#e6ffed",
-            "Judge": "#f0f0f0",
-            "User": "#f0f0f0"
+def main():
+    with gr.Blocks(css="""
+        .convo-container {
+            max-height: 400px;
+            overflow-y: auto;
+            padding: 10px;
+            border: 1px solid #ccc;
+            border-radius: 8px;
+            background: #fafafa;
         }
-        color = color_map.get(agent, "#ffffff")
-        html += f"""
-        <div style='background:{color}; padding:10px; margin:10px; border-radius:5px;'>
-            <b>{agent}:</b> {msg['text']}
-        </div>
-        """
-    html += "</div>"
-    return html
-
-def toggle_auto(auto_mode):
-    """Toggle auto-advance mode"""
-    new_mode = not auto_mode
-    return ("🟢 Auto: ON" if new_mode else "🔴 Auto: OFF", new_mode)
-
-def clear_convo():
-    """Reset conversation"""
-    return (
-        format_conversation_html([]),
-        "",
-        "",
-        "",
-        "",
-        "",
-        0,
-        "💡 Initiator, 🔍 Responder",
-        [],
-        0,
-        "",
-        0,
-        "",
-        ""
-    )
-
-def new_topic(conversation, turn_count, current_topic, last_ruling_turn):
-    """Generate a new discussion topic"""
-    topics = [
-        "The Ethics of Genetic Engineering in Humans",
-        "Universal Basic Income in the Age of Automation",
-        "Cultural Impacts of Global AI Deployment",
-        "Privacy vs Security in Digital Societies",
-        "The Future of Human-AI Collaboration"
-    ]
-    new_topic = np.random.choice(topics)
-    return (
-        format_conversation_html([]),
-        new_topic,
-        0,
-        [],
-        0,
-        new_topic,
-        0
-    )
+        .message-card {
+            padding: 8px;
+            margin-bottom: 6px;
+            border-radius: 6px;
+        }
+        .agent-panel {
+            border: 1px solid #ddd;
+            padding: 6px;
+            border-radius: 4px;
+            margin: 4px;
+        }
+    """, title="Hexa-Agent Discussion System") as demo:
+        # States
+        conversation_state = gr.State([])
+        turn_state = gr.State(0)
+        topic_state = gr.State("")
+        params_state = gr.State(DEFAULT_PARAMS)
 
-def request_ruling(conversation, current_topic, turn_count, last_ruling_turn):
-    """Request a ruling from the Judge"""
-    context = f"Topic: {current_topic}\n\nDiscussion Summary:\n"
-    for msg in conversation[-5:]:
-        context += f"- {msg['agent']}: {msg['text']}\n"
-    
-    response = safe_chat_completion(
-        system=JUDGE_PROMPT,
-        messages=[{"role": "user", "content": f"{context}\nPlease provide a comprehensive ruling."}],
-        temperature=0.5
-    )
-    
-    new_entry = {
-        "agent": "Judge",
-        "text": response,
-        "turn": turn_count
-    }
-    updated_conversation = conversation + [new_entry]
-    new_last_ruling_turn = turn_count
-    return response, updated_conversation, new_last_ruling_turn
+        # Header
+        gr.Markdown("# 🧠 Modular Multi-Agent Discussion Platform")
 
-def run_analysis(conversation):
-    """Run basic analysis (simplified for free version)"""
-    # Sentiment analysis placeholder
-    sentiments = ["Positive", "Neutral", "Negative"]
-    sentiment_result = np.random.choice(sentiments, p=[0.4, 0.4, 0.2])
-    
-    # Topic extraction placeholder
-    topics = ["AI Ethics", "Policy", "Cultural Impact", "Technology", "Future Scenarios"]
-    topic_result = ", ".join(np.random.choice(topics, 3, replace=False))
-    
-    # Agent participation plot
-    agents = [msg["agent"] for msg in conversation]
-    if agents:
-        agent_counts = {agent: agents.count(agent) for agent in set(agents)}
-        plt.figure(figsize=(8, 4))
-        plt.bar(agent_counts.keys(), agent_counts.values())
-        plt.title("Agent Participation")
-        plt.ylabel("Number of Messages")
-        plt.tight_layout()
-        plt.savefig("agent_plot.png")
-        plot_path = "agent_plot.png"
-    else:
-        plot_path = None
-    
-    return (
-        f"Overall Sentiment: {sentiment_result}",
-        f"Key Topics: {topic_result}",
-        plot_path
-    )
+        # Controls
+        with gr.Row():
+            topic_input = gr.Textbox(label="Topic", placeholder="Enter topic...", value="Ethical AI")
+            set_topic_btn = gr.Button("Set Topic")
+            clear_btn = gr.Button("Clear Discussion")
+        with gr.Row():
+            step_btn = gr.Button("▶️ Next Turn")
+        gr.Markdown("---")
+
+        # Conversation display
+        convo_display = gr.HTML("<div class='convo-container' id='convo'></div>", label="Conversation")
+
+        # Agent Panels
+        with gr.Accordion("Agent Panels", open=False):
+            initiator_panel = gr.Textbox(label="Initiator Latest", interactive=False)
+            responder_panel = gr.Textbox(label="Responder Latest", interactive=False)
+            guardian_panel = gr.Textbox(label="Guardian Latest", interactive=False)
+            provocateur_panel = gr.Textbox(label="Provocateur Latest", interactive=False)
+            cultural_panel = gr.Textbox(label="Cultural Latest", interactive=False)
+            judge_panel = gr.Textbox(label="Judge Latest", interactive=False)
+
+        # Analysis Tab
+        with gr.Tab("Analysis"):
+            sentiment = gr.Textbox(label="Sentiment")
+            topics = gr.Textbox(label="Key Topics")
+            part_plot = gr.Image(label="Participation Chart")
+            graph_plot = gr.Image(label="Knowledge Graph")
+            analyze_btn = gr.Button("Run Analysis")
+            graph_btn = gr.Button("Generate Graph")
+
+        # Configuration Tab: Parameter Sliders
+        with gr.Tab("Configuration"):
+            sliders = {}
+            for agent in ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]:
+                with gr.Row():
+                    sliders[f"{agent}_creativity"] = gr.Slider(0.0, 1.0, value=DEFAULT_PARAMS[agent]['creativity'], label=f"{agent} Creativity")
+                    sliders[f"{agent}_criticality"] = gr.Slider(0.0, 1.0, value=DEFAULT_PARAMS[agent]['criticality'], label=f"{agent} Criticality")
+
+        # Export Tab
+        with gr.Tab("Export"):
+            fmt = gr.Radio(choices=["txt","json","pdf"], label="Format", value="txt")
+            export_btn = gr.Button("Export")
+            export_out = gr.File(label="Download")
+            webhook_url = gr.Textbox(label="Webhook URL")
+            send_btn = gr.Button("Send to Webhook")
+            send_status = gr.Textbox(label="Status")
+
+        # Event handlers
+        set_topic_btn.click(lambda t: ([], 0, t), inputs=[topic_input], outputs=[convo_display, turn_state, topic_state])
+        clear_btn.click(lambda: ([], 0, ""), outputs=[convo_display, turn_state, topic_state])
+
+        def on_step(convo, turn, topic, params, *slider_vals):
+            # Update params from sliders
+            agents = ["Initiator","Responder","Guardian","Provocateur","Cultural","Judge"]
+            new_params = {}
+            idx = 0
+            for agent in agents:
+                new_params[agent] = {
+                    'creativity': slider_vals[idx],
+                    'criticality': slider_vals[idx+1]
+                }
+                idx += 2
+            params = new_params
+            if turn == 0 and topic:
+                convo = [{"agent":"System","text":f"Topic: {topic}"}]
+            convo = step_turn(convo, turn, topic or topic_input.value, params)
+            # Build HTML
+            html = ''
+            for msg in convo:
+                color = COLOR_MAP.get(msg['agent'], '#ffffff')
+                html += f"<div class='message-card' style='background:{color};'><b>{msg['agent']}:</b> {msg['text']}</div>"
+            html += "<script>var c=document.getElementById('convo'); c.scrollTop=c.scrollHeight;</script>"
+            # Update panels
+            panels = []
+            for agent in agents:
+                panels.append(next((m['text'] for m in reversed(convo) if m['agent']==agent), ''))
+            return (html, convo, turn+1) + tuple(panels) + (params,)
+
+        # Connect step with sliders
+        step_btn.click(
+            on_step,
+            inputs=[conversation_state, turn_state, topic_state, params_state] + list(sliders.values()),
+            outputs=[convo_display, conversation_state, turn_state,
+                     initiator_panel, responder_panel, guardian_panel,
+                     provocateur_panel, cultural_panel, judge_panel,
+                     params_state]
+        )
 
-def generate_knowledge_graph(conversation):
-    """Generate a simple knowledge graph (placeholder)"""
-    G = nx.DiGraph()
-    entities = ["AI", "Ethics", "Society", "Technology", "Future"]
-    for i, e1 in enumerate(entities):
-        for j, e2 in enumerate(entities):
-            if i != j and np.random.random() > 0.7:
-                G.add_edge(e1, e2, weight=np.random.random())
-    
-    plt.figure(figsize=(10, 8))
-    pos = nx.spring_layout(G)
-    nx.draw(G, pos, with_labels=True, node_size=2000, 
-            node_color="skyblue", font_size=10, 
-            edge_color="gray", width=1.5)
-    plt.title("Knowledge Graph")
-    plt.savefig("knowledge_graph.png")
-    return "knowledge_graph.png"
+        analyze_btn.click(
+            lambda convo: (
+                analyze_sentiment_topics(convo)['sentiment'],
+                ", ".join(analyze_sentiment_topics(convo)['topics']),
+                plot_participation(convo, 'participation.png')
+            ),
+            inputs=[conversation_state],
+            outputs=[sentiment, topics, part_plot]
+        )
 
-def export_handler(format_radio, conversation, current_topic, turn_count):
-    """Export conversation in various formats"""
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    if format_radio == "txt":
-        filename = f"discussion_{timestamp}.txt"
-        with open(filename, "w") as f:
-            f.write(f"Topic: {current_topic}\nTurns: {turn_count}\n\n")
-            for msg in conversation:
-                f.write(f"{msg['agent']} (Turn {msg.get('turn', 'N/A')}):\n{msg['text']}\n\n")
-        return filename
-    
-    elif format_radio == "pdf":
-        filename = f"discussion_{timestamp}.pdf"
-        doc = SimpleDocTemplate(filename, pagesize=letter)
-        styles = getSampleStyleSheet()
-        story = []
-        
-        story.append(Paragraph(f"Discussion: {current_topic}", styles["Title"]))
-        story.append(Paragraph(f"Turns: {turn_count}", styles["Normal"]))
-        story.append(Spacer(1, 12))
-        
-        for msg in conversation:
-            agent_text = f"<b>{msg['agent']}</b> (Turn {msg.get('turn', 'N/A')}):"
-            story.append(Paragraph(agent_text, styles["Normal"]))
-            story.append(Paragraph(msg["text"], styles["BodyText"]))
-            story.append(Spacer(1, 12))
-        
-        doc.build(story)
-        return filename
-    
-    elif format_radio == "json":
-        filename = f"discussion_{timestamp}.json"
-        data = {
-            "topic": current_topic,
-            "turns": turn_count,
-            "conversation": conversation
-        }
-        with open(filename, "w") as f:
-            json.dump(data, f, indent=2)
-        return filename
-    
-    return "export_error.txt"
+        graph_btn.click(
+            lambda convo: generate_knowledge_graph(convo, 'graph.png'),
+            inputs=[conversation_state],
+            outputs=[graph_plot]
+        )
 
-def send_to_webhook(webhook_url, conversation, current_topic, turn_count):
-    """Send conversation to webhook"""
-    if not webhook_url.startswith("http"):
-        return "⚠️ Invalid URL"
-    
-    payload = {
-        "topic": current_topic,
-        "turns": turn_count,
-        "conversation": conversation
-    }
-    
-    try:
-        response = requests.post(webhook_url, json=payload, timeout=10)
-        if response.status_code == 200:
-            return "✅ Sent successfully!"
-        return f"⚠️ Error: {response.status_code} - {response.text}"
-    except Exception as e:
-        return f"⚠️ Connection error: {str(e)}"
+        export_btn.click(
+            lambda fmt, convo, topic, turn: {
+                'txt': export_txt(convo, topic, turn),
+                'json': export_json(convo, topic, turn),
+                'pdf': export_pdf(convo, topic, turn)
+            }[fmt],
+            inputs=[fmt, conversation_state, topic_state, turn_state],
+            outputs=[export_out]
+        )
 
-def add_user_contribution(user_input, conversation):
-    """Add user contribution to conversation"""
-    if not user_input.strip():
-        return format_conversation_html(conversation), "Please enter a message", conversation
-    
-    new_entry = {
-        "agent": "User",
-        "text": user_input,
-        "turn": len(conversation) + 1
-    }
-    updated_conversation = conversation + [new_entry]
-    embed_and_store(user_input, "User", current_topic="")
-    return format_conversation_html(updated_conversation), "✅ Added your contribution!", updated_conversation
+        send_btn.click(send_webhook, inputs=[webhook_url, conversation_state, topic_state, turn_state], outputs=[send_status])
 
-def update_agent_params(*args):
-    """Update agent parameters from sliders"""
-    # Last argument is the current params state
-    current_params = args[-1]
-    sliders = args[:-1]
-    
-    # Map sliders to agent parameters
-    agents = ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]
-    params = ["creativity", "criticality"]
-    
-    updated_params = {}
-    slider_index = 0
-    for agent in agents:
-        updated_params[agent] = {}
-        for param in params:
-            updated_params[agent][param] = sliders[slider_index]
-            slider_index += 1
-    
-    return updated_params
+    demo.launch()
 
-# === GRADIO UI SETUP ===
-# ... [The entire Gradio UI block remains unchanged from the previous implementation] ...
-# This includes the UI layout, components, and event handlers
-# === GRADIO UI ===
-with gr.Blocks(theme=gr.themes.Soft(), title="DeepSeek Discussion Platform") as demo:
-    gr.Markdown("# 🧠 Hexa-Agent Discussion System (Free Version)")
-    gr.Markdown("### Powered by Open-Source Models")
-    
-    # State variables
-    conversation_state = gr.State([])
-    turn_count_state = gr.State(0)
-    current_topic_state = gr.State("")
-    last_ruling_turn_state = gr.State(0)
-    auto_mode_state = gr.State(False)
-    agent_params_state = gr.State(agent_params)
-    
-    # Status panel
-    with gr.Row():
-        turn_counter = gr.Number(label="Turn Count", value=0, interactive=False)
-        topic_display = gr.Textbox(label="Current Topic", interactive=False, lines=2)
-        agent_status = gr.Textbox(label="Active Agents", value="💡 Initiator, 🔍 Responder", interactive=False)
-    
-    # Tabbed interface
-    with gr.Tab("Live Discussion"):
-        convo_display = gr.HTML(
-            value="<div class='convo-container'>Discussion will appear here</div>", 
-            elem_id="convo-display"
-        )
-        
-        # Placeholder displays for agent-specific content
-        intervention_display = gr.Textbox(label="Depth Guardian Intervention", visible=False)
-        outsider_display = gr.Textbox(label="Cross-Disciplinary Provocateur", visible=False)
-        cultural_display = gr.Textbox(label="Cultural Perspective", visible=False)
-        judge_display = gr.Textbox(label="Judge's Ruling", visible=False)
-        
-        with gr.Row():
-            step_btn = gr.Button("▶️ Next Turn", variant="primary")
-            auto_btn = gr.Button("🔴 Auto: OFF", variant="secondary")
-            clear_btn = gr.Button("🔄 New Discussion", variant="stop")
-            topic_btn = gr.Button("🎲 Random Topic", variant="secondary")
-            ruling_btn = gr.Button("⚖️ Request Ruling", variant="primary")
-        
-        with gr.Accordion("💬 Guide the Discussion", open=False):
-            topic_input = gr.Textbox(label="Set Custom Topic", placeholder="e.g., Ethics of AGI in cultural contexts...")
-            with gr.Row():
-                qbox = gr.Textbox(label="Ask the Depth Guardian", placeholder="What perspectives are missing?")
-                ruling_qbox = gr.Textbox(label="Specific Question for Judge", placeholder="What should be our guiding principle?")
-            with gr.Row():
-                overseer_out = gr.Textbox(label="Depth Guardian Response", interactive=False)
-                judge_out = gr.Textbox(label="Judge's Response", interactive=False)
-            submit_btn = gr.Button("💬 Add User Contribution", variant="primary")
-            user_input = gr.Textbox(label="Your Contribution", placeholder="Add your perspective to the discussion...")
-            user_feedback = gr.Textbox(label="Feedback", interactive=False, visible=False)
-    
-    # Analysis tab
-    with gr.Tab("Analysis"):
-        with gr.Row():
-            sentiment_display = gr.Textbox(label="Sentiment Analysis", interactive=False)
-            topics_display = gr.Textbox(label="Key Topics", interactive=False)
-        agent_plot = gr.Image(label="Agent Participation")
-        graph_display = gr.Image(label="Knowledge Graph")
-        analysis_btn = gr.Button("��� Run Analysis", variant="primary")
-        graph_btn = gr.Button("🌐 Generate Knowledge Graph", variant="secondary")
-    
-    # Export tab
-    with gr.Tab("Export"):
-        format_radio = gr.Radio(
-            choices=["txt", "pdf", "json"], 
-            label="Export Format", 
-            value="txt"
-        )
-        export_btn = gr.Button("💾 Export Discussion", variant="primary")
-        export_result = gr.File(label="Export Result", interactive=False)
-        
-        gr.Markdown("### Webhook Integration")
-        webhook_url = gr.Textbox(label="Webhook URL", placeholder="https://your-webhook-endpoint.com")
-        integrate_btn = gr.Button("🔌 Send to Webhook", variant="secondary")
-        integration_status = gr.Textbox(label="Status", interactive=False)
-    
-    # Agent Configuration tab
-    with gr.Tab("Configuration"):
-        gr.Markdown("### Agent Parameters")
-        agent_sliders = {}
-        agents = ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]
-        params = ["creativity", "criticality"]
-        
-        for agent in agents:
-            with gr.Accordion(f"{agent} Settings", open=False):
-                for param in params:
-                    slider = gr.Slider(
-                        minimum=0.0, 
-                        maximum=1.0, 
-                        step=0.05,
-                        label=f"{agent} {param.capitalize()}",
-                        value=agent_params[agent][param]
-                    )
-                    agent_sliders[f"{agent}_{param}"] = slider
-    
-    # Custom CSS
-    demo.css = """
-    .convo-container {
-        max-height: 400px;
-        overflow-y: auto;
-        padding: 15px;
-        border: 1px solid #e0e0e0;
-        border-radius: 8px;
-        background-color: #f9f9f9;
-        line-height: 1.6;
-    }
-    .convo-container p {
-        margin-bottom: 10px;
-    }
-    #topic-display {
-        font-weight: bold;
-        font-size: 1.1em;
-    }
-    .free-model-notice {
-        background-color: #e6f7ff;
-        padding: 10px;
-        border-radius: 5px;
-        margin-bottom: 15px;
-        border-left: 4px solid #1890ff;
-    }
-    """
-    
-    # Free model notice
-    gr.Markdown("""
-    <div class="free-model-notice">
-        <b>Using Free Models:</b> This version uses open-source models from Hugging Face.
-        Responses may be slower and less refined than commercial APIs.
-        Consider using local GPU for better performance.
-    </div>
-    """)
-    
-    # Event handlers with proper state management
-    qbox.submit(
-        overseer_respond, 
-        inputs=[qbox, conversation_state, current_topic_state],
-        outputs=[overseer_out]
-    )
-    
-    ruling_qbox.submit(
-        ask_judge, 
-        inputs=[ruling_qbox, conversation_state, current_topic_state],
-        outputs=[judge_out]
-    )
-    
-    step_btn.click(
-        step, 
-        inputs=[
-            topic_input, 
-            conversation_state, 
-            turn_count_state, 
-            current_topic_state, 
-            last_ruling_turn_state, 
-            agent_params_state
-        ],
-        outputs=[
-            convo_display, 
-            intervention_display, 
-            outsider_display, 
-            cultural_display, 
-            judge_display, 
-            topic_display, 
-            turn_counter, 
-            agent_status, 
-            conversation_state, 
-            turn_count_state, 
-            current_topic_state,
-            last_ruling_turn_state,
-            agent_params_state
-        ]
-    )
-    
-    auto_btn.click(
-        toggle_auto, 
-        inputs=[auto_mode_state],
-        outputs=[auto_btn, auto_mode_state]
-    )
-    
-    clear_btn.click(
-        clear_convo, 
-        outputs=[
-            convo_display, 
-            intervention_display, 
-            outsider_display, 
-            cultural_display, 
-            judge_display, 
-            topic_display, 
-            turn_counter,
-            agent_status, 
-            conversation_state, 
-            turn_count_state, 
-            current_topic_state,
-            last_ruling_turn_state, 
-            overseer_out, 
-            judge_out,
-            agent_params_state
-        ]
-    )
-    
-    topic_btn.click(
-        new_topic,
-        inputs=[conversation_state, turn_count_state, current_topic_state, last_ruling_turn_state],
-        outputs=[
-            convo_display, 
-            topic_display, 
-            turn_counter, 
-            conversation_state, 
-            turn_count_state, 
-            current_topic_state,
-            last_ruling_turn_state
-        ]
-    )
-    
-    ruling_btn.click(
-        request_ruling,
-        inputs=[conversation_state, current_topic_state, turn_count_state, last_ruling_turn_state],
-        outputs=[judge_display, conversation_state, last_ruling_turn_state]
-    )
-    
-    analysis_btn.click(
-        run_analysis,
-        inputs=[conversation_state],
-        outputs=[sentiment_display, topics_display, agent_plot]
-    )
-    
-    graph_btn.click(
-        generate_knowledge_graph,
-        inputs=[conversation_state],
-        outputs=[graph_display]
-    )
-    
-    export_btn.click(
-        export_handler,
-        inputs=[format_radio, conversation_state, current_topic_state, turn_count_state],
-        outputs=[export_result]
-    )
-    
-    integrate_btn.click(
-        send_to_webhook,
-        inputs=[webhook_url, conversation_state, current_topic_state, turn_count_state],
-        outputs=[integration_status]
-    )
-    
-    submit_btn.click(
-        add_user_contribution,
-        inputs=[user_input, conversation_state],
-        outputs=[convo_display, user_feedback, conversation_state]
-    )
-    
-    # Create input list for slider change events
-    slider_inputs = [agent_sliders[f"{agent}_{param}"] 
-                    for agent in agents
-                    for param in params]
-    
-    for slider in slider_inputs:
-        slider.change(
-            update_agent_params,
-            inputs=slider_inputs + [agent_params_state],
-            outputs=[agent_params_state]
-        )
 
-demo.launch()
+if __name__ == '__main__':
+    main()