Rename app.pyv1 to app.py

app.pyv1 → app.py

@@ -1,4 +1,4 @@
-# app.py - Advanced Discussion Simulator with Hexa-Agent System
+# app.py - DeepSeek Hexa-Agent Discussion Platform
 import gradio as gr
 import openai
 import threading
@@ -9,6 +9,14 @@ 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
+import requests
 
 # === CONFIG ===
 EMBEDDING_MODEL = "text-embedding-3-small"
@@ -18,7 +26,9 @@ INDEX_FILE = "memory.index"
 openai.api_key = os.environ.get("OPENAI_API_KEY")
 
 # === EMBEDDING UTILS ===
+@lru_cache(maxsize=500)
 def get_embedding(text, model=EMBEDDING_MODEL):
+    """Cached embedding function for performance"""
     text = text.replace("\n", " ")
     try:
         response = openai.embeddings.create(input=[text], model=model)
@@ -41,7 +51,7 @@ try:
 except:
     memory_index = faiss.IndexFlatL2(1536)
 
-# === AGENT SYSTEM PROMPTS ===
+# === AGENT SYSTEM PROMPTS (Configurable) ===
 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
@@ -97,31 +107,47 @@ 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}
+}
 
-# === CHAT COMPLETION ===
-def chat_completion(system, messages, model=CHAT_MODEL):
-    try:
-        full_messages = [{"role": "system", "content": system}] 
-        full_messages.extend(messages)
-        
+# === ERROR-HANDLED API CALLS ===
+def safe_chat_completion(system, messages, model=CHAT_MODEL, temperature=0.7, max_retries=3):
+    """Robust API call with exponential backoff"""
+    for attempt in range(max_retries):
         try:
-            response = openai.chat.completions.create(
-                model=model,
-                messages=full_messages,
-                temperature=0.75,
-                max_tokens=300
-            )
-            return response.choices[0].message.content.strip()
-        except AttributeError:
-            response = openai.ChatCompletion.create(
-                model=model,
-                messages=full_messages,
-                temperature=0.75,
-                max_tokens=300
-            )
-            return response['choices'][0]['message']['content'].strip()
-    except Exception as e:
-        return f"[API Error: {str(e)}]"
+            full_messages = [{"role": "system", "content": system}] 
+            full_messages.extend(messages)
+            
+            try:
+                response = openai.chat.completions.create(
+                    model=model,
+                    messages=full_messages,
+                    temperature=temperature,
+                    max_tokens=300
+                )
+                return response.choices[0].message.content.strip()
+            except AttributeError:
+                response = openai.ChatCompletion.create(
+                    model=model,
+                    messages=full_messages,
+                    temperature=temperature,
+                    max_tokens=300
+                )
+                return response['choices'][0]['message']['content'].strip()
+        except Exception as e:
+            if attempt < max_retries - 1:
+                wait_time = 2 ** attempt
+                print(f"API error: {e}. Retrying in {wait_time} seconds...")
+                time.sleep(wait_time)
+            else:
+                return f"⚠️ API Error: {str(e)}"
+    return "⚠️ Max retries exceeded"
 
 # === MEMORY MANAGEMENT ===
 def embed_and_store(text, agent=None):
@@ -131,7 +157,8 @@ def embed_and_store(text, agent=None):
         memory_data.append({
             "text": text,
             "timestamp": datetime.now().isoformat(),
-            "agent": agent or "system"
+            "agent": agent or "system",
+            "topic": current_topic
         })
         if len(memory_data) % 5 == 0:
             with open(MEMORY_FILE, "wb") as f:
@@ -140,6 +167,26 @@ def embed_and_store(text, agent=None):
     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 []
+
 # === CONVERSATION UTILITIES ===
 def format_convo():
     return "\n".join([f"**{m['agent']}**: {m['text']}" for m in conversation])
@@ -182,6 +229,13 @@ def detect_superficiality():
                 
     return superficial_count > depth_count * 2
 
+def batch_cosine_similarity(embeddings):
+    """Efficient batch similarity calculation"""
+    norms = np.linalg.norm(embeddings, axis=1)
+    dot_matrix = np.dot(embeddings, embeddings.T)
+    norm_matrix = np.outer(norms, norms)
+    return dot_matrix / norm_matrix
+
 def detect_repetition():
     """Check if recent messages are conceptually similar"""
     if len(conversation) < 4:
@@ -189,8 +243,12 @@ def detect_repetition():
         
     recent = [m['text'] for m in conversation[-4:]]
     embeddings = [get_embedding(text) for text in recent]
-    similarity = cosine_similarity(embeddings[-1], embeddings[-3])
-    return similarity > 0.82
+    
+    # Use batch processing for efficiency
+    similarity_matrix = batch_cosine_similarity(np.array(embeddings))
+    
+    # Check similarity between current and previous messages
+    return any(similarity_matrix[-1][i] > 0.82 for i in range(len(embeddings)-1))
 
 def detect_cultural_relevance():
     """Check if cultural perspectives are needed"""
@@ -231,7 +289,7 @@ def detect_judgment_opportunity():
 # === AGENT FUNCTIONS ===
 def generate_topic():
     """Generate a complex discussion topic"""
-    topic = chat_completion(
+    topic = safe_chat_completion(
         "Generate a complex discussion topic requiring multidisciplinary and multicultural analysis",
         [{"role": "user", "content": "Create a topic addressing tensions between technological progress, ethics, and cultural values"}]
     )
@@ -241,13 +299,31 @@ def outsider_comment():
     """Generate outsider perspective"""
     context = "\n".join([f"{m['agent']}: {m['text']}" for m in conversation[-4:]])
     prompt = f"Conversation Context:\n{context}\n\nProvide your cross-disciplinary perspective:"
-    return chat_completion(OUTSIDER_PROMPT, [{"role": "user", "content": prompt}])
+    
+    # Apply agent parameters
+    params = agent_params["Provocateur"]
+    temp = 0.5 + params["creativity"] * 0.5  # Map to 0.5-1.0 range
+    
+    return safe_chat_completion(
+        OUTSIDER_PROMPT, 
+        [{"role": "user", "content": prompt}],
+        temperature=temp
+    )
 
 def cultural_perspective():
     """Generate cultural diversity perspective"""
     context = "\n".join([f"{m['agent']}: {m['text']}" for m in conversation[-4:]])
     prompt = f"Conversation Context:\n{context}\n\nProvide diverse cultural perspectives on this topic:"
-    return chat_completion(CULTURAL_LENS_PROMPT, [{"role": "user", "content": prompt}])
+    
+    # Apply agent parameters
+    params = agent_params["Cultural"]
+    temp = 0.5 + params["creativity"] * 0.5
+    
+    return safe_chat_completion(
+        CULTURAL_LENS_PROMPT, 
+        [{"role": "user", "content": prompt}],
+        temperature=temp
+    )
 
 def judge_ruling():
     """Generate final judgment or ruling"""
@@ -271,7 +347,15 @@ Your ruling should:
 5. Consider ethical and practical implications
 6. Provide constructive guidance for next steps"""
     
-    ruling = chat_completion(JUDGE_PROMPT, [{"role": "user", "content": prompt}])
+    # Apply agent parameters
+    params = agent_params["Judge"]
+    temp = 0.3 + params["criticality"] * 0.4  # More critical = lower temperature
+    
+    ruling = safe_chat_completion(
+        JUDGE_PROMPT, 
+        [{"role": "user", "content": prompt}],
+        temperature=temp
+    )
     last_ruling_turn = turn_count
     return ruling
 
@@ -282,29 +366,42 @@ def step(topic_input=""):
     # Initialize new discussion
     if not conversation:  
         current_topic = topic_input or generate_topic()
-        msg = chat_completion(
+        
+        # Retrieve relevant memory
+        memory_context = retrieve_relevant_memory(current_topic)
+        context_str = ""
+        if memory_context:
+            context_str = "\n\nRelevant past discussions:\n" + "\n".join(
+                [f"- {item['agent']} on '{item['topic']}': {item['text']}" 
+                 for item in memory_context]
+            )
+        
+        msg = safe_chat_completion(
             AGENT_A_PROMPT, 
-            [{"role": "user", "content": f"Initiate a deep discussion on: {current_topic}"}]
+            [{"role": "user", "content": f"Initiate a deep discussion on: {current_topic}{context_str}"}],
+            temperature=0.5 + agent_params["Initiator"]["creativity"] * 0.5
         )
         conversation.append({"agent": "💡 Initiator", "text": msg})
         embed_and_store(msg, "Initiator")
         turn_count = 1
         last_ruling_turn = 0
-        return format_convo(), "", "", "", "", current_topic
+        return format_convo(), "", "", "", "", current_topic, turn_count, ""
     
     # Critical Responder engages
     last_msg = conversation[-1]['text']
-    b_msg = chat_completion(
+    b_msg = safe_chat_completion(
         AGENT_B_PROMPT, 
-        [{"role": "user", "content": f"Topic: {current_topic}\n\nLast statement: {last_msg}"}]
+        [{"role": "user", "content": f"Topic: {current_topic}\n\nLast statement: {last_msg}"}],
+        temperature=0.4 + agent_params["Responder"]["criticality"] * 0.4
     )
     conversation.append({"agent": "🔍 Responder", "text": b_msg})
     embed_and_store(b_msg, "Responder")
     
     # Initiator counters
-    a_msg = chat_completion(
+    a_msg = safe_chat_completion(
         AGENT_A_PROMPT, 
-        [{"role": "user", "content": f"Topic: {current_topic}\n\nCritical response: {b_msg}"}]
+        [{"role": "user", "content": f"Topic: {current_topic}\n\nCritical response: {b_msg}"}],
+        temperature=0.5 + agent_params["Initiator"]["creativity"] * 0.5
     )
     conversation.append({"agent": "💡 Initiator", "text": a_msg})
     embed_and_store(a_msg, "Initiator")
@@ -314,7 +411,11 @@ def step(topic_input=""):
     if turn_count % 3 == 0 or detect_repetition() or detect_superficiality():
         context = "\n".join([m['text'] for m in conversation[-4:]])
         prompt = f"Topic: {current_topic}\n\nDiscussion Context:\n{context}\n\nDeepen the analysis:"
-        intervention = chat_completion(OVERSEER_PROMPT, [{"role": "user", "content": prompt}])
+        intervention = safe_chat_completion(
+            OVERSEER_PROMPT, 
+            [{"role": "user", "content": prompt}],
+            temperature=0.5 + agent_params["Guardian"]["criticality"] * 0.4
+        )
         conversation.append({"agent": "⚖️ Depth Guardian", "text": intervention})
         embed_and_store(intervention, "Overseer")
     
@@ -342,96 +443,281 @@ def step(topic_input=""):
         embed_and_store(judge_msg, "Judge")
     
     turn_count += 1
-    return format_convo(), intervention, outsider_msg, cultural_msg, judge_msg, current_topic
+    return format_convo(), intervention, outsider_msg, cultural_msg, judge_msg, current_topic, turn_count, ""
 
-# === OVERSEER QUERY HANDLER ===
-def overseer_respond(query):
+# === ANALYSIS & VISUALIZATION ===
+def analyze_conversation():
+    """Generate insights about the discussion"""
+    # Count agent contributions
+    agent_counts = {}
+    for msg in conversation:
+        agent = msg['agent'].split()[0]  # Remove emoji
+        agent_counts[agent] = agent_counts.get(agent, 0) + 1
+    
+    # Sentiment analysis
+    sentiment_prompt = f"Analyze overall sentiment of this discussion:\n{format_convo()}"
+    sentiment = safe_chat_completion(
+        "You are a sentiment analysis expert. Provide a brief assessment of the discussion tone.",
+        [{"role": "user", "content": sentiment_prompt}]
+    )
+    
+    # Topic extraction
+    topic_prompt = f"Extract key topics from this discussion:\n{format_convo()}"
+    topics = safe_chat_completion(
+        "You are a topic extraction expert. List the top 5 topics as a JSON array.",
+        [{"role": "user", "content": topic_prompt}]
+    )
+    
     try:
-        context = "\n".join([m['text'] for m in conversation[-3:]]) if conversation else "No context"
-        messages = [{"role": "user", "content": f"Discussion Topic: {current_topic}\n\nRecent context:\n{context}\n\nQuery: {query}"}]
-        return chat_completion(OVERSEER_PROMPT, messages)
+        topics = json.loads(topics)
+    except:
+        topics = ["Topic extraction failed"]
+    
+    return {
+        "agents": list(agent_counts.keys()),
+        "counts": [agent_counts.get(a, 0) for a in list(agent_counts.keys())],
+        "topics": topics,
+        "sentiment": sentiment
+    }
+
+def generate_knowledge_graph():
+    """Create a knowledge graph of discussion concepts"""
+    # Extract entities and relationships
+    extraction_prompt = f"""
+    Analyze this discussion and extract:
+    1. Key concepts (nouns, important terms)
+    2. Relationships between concepts (verb phrases)
+    
+    Discussion:
+    {format_convo()}
+    
+    Return as JSON: {{"concepts": ["list", "of", "concepts"], "relationships": [["concept1", "relationship", "concept2"]]}}
+    """
+    
+    try:
+        graph_data = safe_chat_completion(
+            "You are a knowledge graph extraction expert.",
+            [{"role": "user", "content": extraction_prompt}]
+        )
+        graph_data = json.loads(graph_data)
+        
+        # Create graph visualization
+        G = nx.DiGraph()
+        G.add_nodes_from(graph_data["concepts"])
+        
+        for rel in graph_data["relationships"]:
+            if len(rel) == 3:
+                G.add_edge(rel[0], rel[2], label=rel[1])
+        
+        plt.figure(figsize=(10, 8))
+        pos = nx.spring_layout(G, seed=42)
+        nx.draw(G, pos, with_labels=True, node_size=2000, node_color="skyblue", font_size=10)
+        edge_labels = nx.get_edge_attributes(G, 'label')
+        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+        plt.title("Discussion Knowledge Graph")
+        plt.savefig("knowledge_graph.png")
+        return "knowledge_graph.png"
     except Exception as e:
-        return f"[Overseer Error: {str(e)}]"
+        print(f"Graph error: {str(e)}")
+        return None
+
+# === EXPORT FUNCTIONS ===
+def export_pdf_report():
+    """Generate PDF report of discussion"""
+    filename = f"discussion_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+    doc = SimpleDocTemplate(filename, pagesize=letter)
+    styles = getSampleStyleSheet()
+    story = []
+    
+    # Title
+    story.append(Paragraph(f"Discussion Report: {current_topic}", styles['Title']))
+    story.append(Spacer(1, 12))
+    
+    # Summary
+    analysis = analyze_conversation()
+    story.append(Paragraph("Discussion Summary", styles['Heading2']))
+    story.append(Paragraph(f"<b>Turn Count:</b> {turn_count}", styles['BodyText']))
+    story.append(Paragraph(f"<b>Sentiment:</b> {analysis['sentiment']}", styles['BodyText']))
+    story.append(Spacer(1, 12))
+    
+    # Key Topics
+    story.append(Paragraph("Key Topics", styles['Heading2']))
+    for topic in analysis['topics']:
+        story.append(Paragraph(f"- {topic}", styles['BodyText']))
+    story.append(Spacer(1, 12))
+    
+    # Full Conversation
+    story.append(Paragraph("Full Discussion", styles['Heading2']))
+    for msg in conversation:
+        story.append(Paragraph(f"<b>{msg['agent']}:</b> {msg['text']}", styles['BodyText']))
+        story.append(Spacer(1, 6))
+    
+    doc.build(story)
+    return filename
+
+def export_json_data():
+    """Export conversation as JSON"""
+    filename = f"discussion_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    with open(filename, 'w') as f:
+        json.dump({
+            "topic": current_topic,
+            "turns": turn_count,
+            "conversation": conversation,
+            "analysis": analyze_conversation()
+        }, f, indent=2)
+    return filename
 
-# === JUDGE RULING HANDLER ===
-def request_ruling():
+def export_text_transcript():
+    """Export as plain text"""
+    filename = f"transcript_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+    with open(filename, 'w') as f:
+        f.write(f"Discussion Topic: {current_topic}\n\n")
+        f.write("Participants:\n")
+        agents = set(msg['agent'] for msg in conversation)
+        for agent in agents:
+            f.write(f"- {agent}\n")
+        
+        f.write("\nConversation:\n")
+        for msg in conversation:
+            f.write(f"{msg['agent']}: {msg['text']}\n\n")
+    return filename
+
+# === INTEGRATION FUNCTIONS ===
+def send_to_webhook(url):
+    """Send discussion data to external webhook"""
     try:
-        ruling = judge_ruling()
-        conversation.append({"agent": "⚖️ Judge", "text": ruling})
-        embed_and_store(ruling, "Judge")
-        return ruling
+        payload = {
+            "topic": current_topic,
+            "turns": turn_count,
+            "conversation": conversation,
+            "timestamp": datetime.now().isoformat()
+        }
+        response = requests.post(url, json=payload, timeout=10)
+        if response.status_code == 200:
+            return "✅ Data sent successfully!"
+        else:
+            return f"⚠️ Error {response.status_code}: {response.text}"
     except Exception as e:
-        return f"[Judge Error: {str(e)}]"
-
-# === AUTO MODE HANDLER ===
-def auto_loop():
-    global auto_mode
-    while auto_mode:
-        step()
-        time.sleep(6)
-
-def toggle_auto():
-    global auto_mode
-    auto_mode = not auto_mode
-    if auto_mode:
-        threading.Thread(target=auto_loop, daemon=True).start()
-    return "🔴 Auto: OFF" if not auto_mode else "🟢 Auto: ON"
+        return f"⚠️ Connection error: {str(e)}"
 
 # === GRADIO UI ===
-with gr.Blocks(title="Advanced Discussion Simulator") as demo:
-    gr.Markdown("# 🧠 Advanced Discussion Simulator")
-    gr.Markdown("### Hexa-Agent System for Complex Discourse")
+with gr.Blocks(theme=gr.themes.Soft(), title="DeepSeek Discussion Platform") as demo:
+    gr.Markdown("# 🧠 DeepSeek Hexa-Agent Discussion System")
+    gr.Markdown("### AI-Powered Complex Discourse Analysis")
     
+    # Status panel
     with gr.Row():
-        topic_display = gr.Textbox(label="Current Topic", interactive=False)
+        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)
     
-    with gr.Row():
-        convo_display = gr.Markdown(
-            value="**Discussion will appear here**", 
-            elem_id="convo-display",
-            elem_classes="convo-scroll"
+    # 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"
         )
         
-    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.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.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### ⚖️ Depth Guardian")
-            intervention_display = gr.Textbox(label="", interactive=False)
-        with gr.Column(scale=1):
-            gr.Markdown("### 🌐 Cross-Disciplinary")
-            outsider_display = gr.Textbox(label="", interactive=False)
-        with gr.Column(scale=1):
-            gr.Markdown("### 🌍 Cultural Lens")
-            cultural_display = gr.Textbox(label="", interactive=False)
+    with gr.Tab("Agent Perspectives"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### ⚖️ Depth Guardian")
+                intervention_display = gr.Textbox(label="", interactive=False)
+            with gr.Column(scale=1):
+                gr.Markdown("### 🌐 Cross-Disciplinary")
+                outsider_display = gr.Textbox(label="", interactive=False)
+            with gr.Column(scale=1):
+                gr.Markdown("### 🌍 Cultural Lens")
+                cultural_display = gr.Textbox(label="", interactive=False)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                gr.Markdown("### ⚖️ Final Judgment")
+                judge_display = gr.Textbox(label="", interactive=False, lines=4)
     
-    with gr.Row():
-        with gr.Column(scale=3):
-            gr.Markdown("### ⚖️ Final Judgment")
-            judge_display = gr.Textbox(label="", interactive=False, lines=4)
+    with gr.Tab("Analysis Dashboard"):
+        gr.Markdown("### Conversation Insights")
+        with gr.Row():
+            sentiment_display = gr.Textbox(label="Discussion Sentiment", interactive=False)
+            topics_display = gr.JSON(label="Key Topics")
+        
+        with gr.Row():
+            agent_plot = gr.Plot(label="Agent Participation")
+            analysis_btn = gr.Button("Generate Insights", variant="primary")
+        
+        with gr.Row():
+            gr.Markdown("### Knowledge Graph")
+            graph_btn = gr.Button("Generate Knowledge Graph", variant="secondary")
+            graph_display = gr.Image(label="Concept Relationships", interactive=False)
+    
+    with gr.Tab("Collaboration"):
+        gr.Markdown("### Real-Time Collaboration")
+        with gr.Row():
+            user_input = gr.Textbox(label="Your Contribution", placeholder="Add your perspective...")
+            submit_btn = gr.Button("Add to Discussion")
+        
+        with gr.Row():
+            voting_btn = gr.Button("👍 Vote for Current Direction")
+            flag_btn = gr.Button("🚩 Flag Issue")
+        
+        with gr.Row():
+            user_feedback = gr.Textbox(label="Community Feedback", interactive=False)
     
-    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.Tab("Export & Integrate"):
+        with gr.Row():
+            format_radio = gr.Radio(
+                ["PDF Report", "JSON Data", "Text Transcript"], 
+                label="Export Format",
+                value="PDF Report"
+            )
+            export_btn = gr.Button("Export Discussion", variant="primary")
+            export_result = gr.File(label="Download File")
+        
         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?")
+            gr.Markdown("### API Integration")
+            webhook_url = gr.Textbox(label="Webhook URL", placeholder="https://your-platform.com/webhook")
+            integrate_btn = gr.Button("Connect to External Platform", variant="secondary")
+            integration_status = gr.Textbox(label="Status", interactive=False)
+    
+    with gr.Tab("Agent Configuration"):
+        gr.Markdown("### Customize Agent Behavior")
         with gr.Row():
-            overseer_out = gr.Textbox(label="Depth Guardian Response", interactive=False)
-            judge_out = gr.Textbox(label="Judge's Response", interactive=False)
+            for agent in ["Initiator", "Responder", "Guardian", "Provocateur", "Cultural", "Judge"]:
+                with gr.Column():
+                    gr.Markdown(f"#### {agent}")
+                    agent_params[f"{agent}_creativity"] = gr.Slider(
+                        0.0, 1.0, value=agent_params[agent]["creativity"], 
+                        label="Creativity", interactive=True
+                    )
+                    agent_params[f"{agent}_critical"] = gr.Slider(
+                        0.0, 1.0, value=agent_params[agent]["criticality"], 
+                        label="Criticality", interactive=True
+                    )
     
-    # Custom CSS for scrollable conversation
+    # Custom CSS
     demo.css = """
-    .convo-scroll {
+    .convo-container {
         max-height: 400px;
         overflow-y: auto;
-        padding: 10px;
+        padding: 15px;
         border: 1px solid #e0e0e0;
-        border-radius: 5px;
+        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;
     }
     """
     
@@ -441,40 +727,129 @@ with gr.Blocks(title="Advanced Discussion Simulator") as demo:
         conversation = []
         turn_count = 0
         current_topic = ""
-        return "**New discussion started**", "", "", "", "", "", ""
+        return (
+            "<div class='convo-container'>New discussion started</div>", 
+            "", "", "", "", "", 0, "",
+            {"agents": [], "counts": []}, "", None, ""
+        )
     
     def new_topic():
-        clear_convo()
+        clear_result = clear_convo()
         topic = generate_topic()
-        return "", "", "", "", "", topic, topic
+        return clear_result[:6] + (topic,) + clear_result[7:]
     
     def ask_judge(query):
         try:
             context = "\n".join([m['text'] for m in conversation[-3:]]) if conversation else "No context"
             messages = [{"role": "user", "content": f"Discussion Topic: {current_topic}\n\nRecent context:\n{context}\n\nSpecific Question: {query}"}]
-            return chat_completion(JUDGE_PROMPT, messages)
+            return safe_chat_completion(JUDGE_PROMPT, messages)
         except Exception as e:
             return f"[Judge Error: {str(e)}]"
     
+    def run_analysis():
+        analysis = analyze_conversation()
+        
+        # Create agent participation plot
+        plt.figure(figsize=(8, 5))
+        plt.bar(analysis["agents"], analysis["counts"], color='skyblue')
+        plt.title("Agent Participation")
+        plt.ylabel("Number of Contributions")
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        plt.savefig("agent_participation.png")
+        
+        return (
+            analysis["sentiment"],
+            analysis["topics"],
+            "agent_participation.png",
+            analysis
+        )
+    
+    def export_handler(format):
+        if format == "PDF Report":
+            return export_pdf_report()
+        elif format == "JSON Data":
+            return export_json_data()
+        else:
+            return export_text_transcript()
+    
+    def add_user_contribution(text):
+        if text.strip():
+            conversation.append({"agent": "👤 You", "text": text})
+            return format_convo(), f"✅ Added: '{text[:30]}...'"
+        return format_convo(), "Please enter text"
+    
+    def update_agent_params(*args):
+        # Update global agent_params based on UI sliders
+        params = agent_params.copy()
+        for agent in params.keys():
+            params[agent]["creativity"] = globals()[f"{agent}_creativity"].value
+            params[agent]["criticality"] = globals()[f"{agent}_critical"].value
+        return "Agent parameters updated!"
+    
+    # Connect UI components
     step_btn.click(
         step, 
-        inputs=[topic_input],
-        outputs=[convo_display, intervention_display, outsider_display, cultural_display, judge_display, topic_display]
+        inputs=[topic_display],
+        outputs=[
+            convo_display, intervention_display, outsider_display, 
+            cultural_display, judge_display, topic_display, turn_counter, agent_status
+        ]
+    )
+    qbox.submit(ask_judge, inputs=gr.Textbox(), outputs=gr.Textbox())
+    auto_btn.click(
+        lambda: ("🟢 Auto: ON" if not auto_mode else "🔴 Auto: OFF"),
+        outputs=auto_btn
     )
-    qbox.submit(overseer_respond, inputs=qbox, outputs=overseer_out)
-    ruling_qbox.submit(ask_judge, inputs=ruling_qbox, outputs=judge_out)
-    auto_btn.click(toggle_auto, outputs=auto_btn)
     clear_btn.click(
         clear_convo, 
-        outputs=[convo_display, intervention_display, outsider_display, cultural_display, judge_display, topic_display, overseer_out]
+        outputs=[
+            convo_display, intervention_display, outsider_display, 
+            cultural_display, judge_display, topic_display, turn_counter,
+            agent_status, agent_plot, graph_display
+        ]
     )
     topic_btn.click(
         new_topic,
-        outputs=[convo_display, intervention_display, outsider_display, cultural_display, judge_display, topic_display, overseer_out]
+        outputs=[convo_display, topic_display, turn_counter]
     )
     ruling_btn.click(
-        request_ruling,
+        lambda: judge_ruling(),
         outputs=[judge_display]
     )
+    analysis_btn.click(
+        run_analysis,
+        outputs=[sentiment_display, topics_display, agent_plot, topics_display]
+    )
+    graph_btn.click(
+        generate_knowledge_graph,
+        outputs=[graph_display]
+    )
+    export_btn.click(
+        export_handler,
+        inputs=[format_radio],
+        outputs=[export_result]
+    )
+    integrate_btn.click(
+        send_to_webhook,
+        inputs=[webhook_url],
+        outputs=[integration_status]
+    )
+    submit_btn.click(
+        add_user_contribution,
+        inputs=[user_input],
+        outputs=[convo_display, user_feedback]
+    )
+    
+    # Connect all agent parameter sliders
+    param_components = [globals()[f"{agent}_{param}"] 
+                       for agent in agent_params.keys() 
+                       for param in ["creativity", "critical"]]
+    for comp in param_components:
+        comp.change(
+            update_agent_params,
+            inputs=param_components,
+            outputs=[gr.Textbox(visible=False)]
+        )
 
 demo.launch()