Update app.py

app.py

@@ -1,649 +1,249 @@
 #!/usr/bin/env python3
 """
-LibreChat Custom Code Interpreter - HuggingFace Space
-A secure code execution server using Gradio + MCP with SSE support
+LibreChat Pyodide Code Interpreter - Client-Side Python Execution
 """
 
-import json
-import subprocess
-import tempfile
-import os
-import sys
-import uuid
-import time
-import base64
-import io
-import re
-from pathlib import Path
-from typing import Dict, Any, Optional, List
 import gradio as gr
-import matplotlib
-matplotlib.use('Agg')  # Use non-interactive backend
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import base64
-from PIL import Image
-import io
-import gradio as gr
-from pyodide import loadPackage
-import js
-import asyncio
- 
-class SecureCodeExecutor:
-    def __init__(self):
-        self.sessions = {}
-        self.max_execution_time = 30
-        self.max_output_length = 10000
-        self.allowed_languages = ["python", "javascript", "bash"]
-        
-        # Security: List of blocked commands/imports
-        self.blocked_imports = [
-            'subprocess', 'os', 'sys', 'shutil', 'glob', 'pickle', 
-            'marshal', 'imp', 'importlib', '__import__'
-        ]
-        self.blocked_bash_commands = [
-            'rm', 'sudo', 'chmod', 'chown', 'dd', 'mkfs', 'fdisk',
-            'curl', 'wget', 'ssh', 'scp', 'nc', 'netcat'
-        ]
- 
-    def create_session(self) -> str:
-        """Create a new execution session"""
-        session_id = str(uuid.uuid4())[:8]  # Shorter ID for HF
-        self.sessions[session_id] = {
-            'created_at': time.time(),
-            'variables': {},
-            'history': [],
-            'files': {}
-        }
-        return session_id
- 
-    def cleanup_old_sessions(self):
-        """Remove sessions older than 1 hour"""
-        current_time = time.time()
-        old_sessions = [
-            sid for sid, session in self.sessions.items()
-            if current_time - session['created_at'] > 3600
-        ]
-        for sid in old_sessions:
-            del self.sessions[sid]
- 
-    def is_code_safe(self, code: str, language: str) -> tuple[bool, str]:
-        """Check if code is safe to execute using whole-word matching."""
-        if language == "python":
-            # Use regex to find whole-word matches for blocked imports
-            for blocked in self.blocked_imports:
-                # \b matches a word boundary. This prevents 'imp' from matching 'import'
-                pattern = r'\b' + re.escape(blocked) + r'\b'
-                if re.search(pattern, code):
-                    return False, f"Blocked import/function: {blocked}"
-            
-            # Check for dangerous patterns that are not whole words
-            dangerous_patterns = ['exec(', 'eval(', 'open(', 'file(', '__']
-            for pattern in dangerous_patterns:
-                if pattern in code:
-                    return False, f"Dangerous pattern detected: {pattern}"
-        
-        elif language == "bash":
-            # Use regex to find whole-word matches for blocked commands
-            for blocked in self.blocked_bash_commands:
-                pattern = r'\b' + re.escape(blocked) + r'\b'
-                if re.search(pattern, code.lower()):
-                    return False, f"Blocked command: {blocked}"
+
+def create_pyodide_interface():
+    """Create a Gradio interface that uses Pyodide for client-side Python execution"""
+    
+    # Custom HTML/JS that loads and uses Pyodide
+    pyodide_html = """
+    <div id="pyodide-container">
+        <div id="pyodide-status">Loading Pyodide...</div>
+        <div id="pyodide-output" style="display:none;">
+            <pre id="output-text"></pre>
+            <div id="plot-container"></div>
+        </div>
+    </div>
+    
+    <script src="https://cdn.jsdelivr.net/pyodide/v0.24.1/full/pyodide.js"></script>
+    <script>
+        let pyodide = null;
+        let plotCounter = 0;
         
-        return True, ""
- 
-    def execute_python_code(self, code: str, session_id: Optional[str] = None) -> Dict[str, Any]:
-        """Execute Python code with visualization support"""
-        # Security check
-        is_safe, reason = self.is_code_safe(code, "python")
-        if not is_safe:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Security violation: {reason}",
-                "execution_time": time.time()
+        async function initPyodide() {
+            try {
+                pyodide = await loadPyodide();
+                await pyodide.loadPackage(["numpy", "matplotlib", "pandas"]);
+                
+                // Set up matplotlib backend for web
+                pyodide.runPython(`
+                    import matplotlib
+                    matplotlib.use('AGG')
+                    import matplotlib.pyplot as plt
+                    import numpy as np
+                    import pandas as pd
+                    import io
+                    import base64
+                    
+                    def show_plot():
+                        buffer = io.BytesIO()
+                        plt.savefig(buffer, format='png', bbox_inches='tight', dpi=100)
+                        buffer.seek(0)
+                        plot_data = buffer.getvalue()
+                        buffer.close()
+                        plt.close()
+                        return base64.b64encode(plot_data).decode()
+                    
+                    # Override plt.show() to capture plots
+                    original_show = plt.show
+                    def custom_show(*args, **kwargs):
+                        return show_plot()
+                    plt.show = custom_show
+                `);
+                
+                document.getElementById('pyodide-status').textContent = 'Pyodide ready!';
+                document.getElementById('pyodide-status').style.color = 'green';
+            } catch (error) {
+                document.getElementById('pyodide-status').textContent = 'Error loading Pyodide: ' + error;
+                document.getElementById('pyodide-status').style.color = 'red';
             }
- 
-        # Prepare execution environment
-        setup_code = '''
-import matplotlib
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import json
-import math
-import random
-import base64
-import io
-from datetime import datetime, timedelta
- 
-# Custom print function to capture output
-_output_buffer = []
-_original_print = print
-def print(*args, **kwargs):
-    _output_buffer.append(' '.join(str(arg) for arg in args))
- 
-# Function to save plots as base64
-def save_current_plot():
-    if plt.get_fignums():  # Check if there are any figures
-        buffer = io.BytesIO()
-        plt.savefig(buffer, format='png', bbox_inches='tight', dpi=100)
-        buffer.seek(0)
-        plot_data = buffer.getvalue()
-        buffer.close()
-        return base64.b64encode(plot_data).decode()
-    return None
-'''
- 
-        # Combine setup and user code
-        full_code = setup_code + "\n" + code
+        }
         
-        # Finalization code to capture plot and print the buffer to real stdout
-        finalization_code = '''
-# Capture the plot if one exists and print it directly to stdout for the parent process
-_plot_data = save_current_plot()
-if _plot_data:
-    _original_print('PLOT_DATA:' + _plot_data)
-
-# Print everything from the custom print buffer to stdout
-if _output_buffer:
-    _original_print('\\n'.join(_output_buffer))
-'''
-        full_code += "\n" + finalization_code
- 
-        try:
-            # Create temporary file
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-                f.write(full_code)
-                temp_file = f.name
- 
-            # Execute with timeout
-            result = subprocess.run(
-                [sys.executable, temp_file],
-                capture_output=True,
-                text=True,
-                timeout=self.max_execution_time,
-                cwd=tempfile.gettempdir()
-            )
- 
-            # Process output
-            stdout = result.stdout
-            stderr = result.stderr
-            plot_data = None
- 
-            # Extract plot data if present
-            if 'PLOT_DATA:' in stdout:
-                lines = stdout.split('\n')
-                clean_lines = []
-                for line in lines:
-                    if line.startswith('PLOT_DATA:'):
-                        plot_data = line.replace('PLOT_DATA:', '')
-                    else:
-                        clean_lines.append(line)
-                stdout = '\n'.join(clean_lines)
- 
-            # Limit output length
-            if len(stdout) > self.max_output_length:
-                stdout = stdout[:self.max_output_length] + "\n... (output truncated)"
- 
-            execution_result = {
-                "success": result.returncode == 0,
-                "stdout": stdout.strip(),
-                "stderr": stderr.strip() if stderr else "",
-                "execution_time": time.time(),
-                "return_code": result.returncode
-            }
- 
-            if plot_data:
-                execution_result["plot"] = plot_data
- 
-            return execution_result
- 
-        except subprocess.TimeoutExpired:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": "Execution timed out (30s limit)",
-                "execution_time": time.time()
-            }
-        except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": str(e),
-                "execution_time": time.time()
-            }
-        finally:
-            if 'temp_file' in locals():
-                try:
-                    os.unlink(temp_file)
-                except:
-                    pass
- 
-    def execute_javascript_code(self, code: str, session_id: Optional[str] = None) -> Dict[str, Any]:
-        """Execute JavaScript code using Node.js"""
-        # Security check
-        is_safe, reason = self.is_code_safe(code, "javascript")
-        if not is_safe:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Security violation: {reason}",
-                "execution_time": time.time()
-            }
- 
-        try:
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False) as f:
-                f.write(code)
-                temp_file = f.name
- 
-            result = subprocess.run(
-                ['node', temp_file],
-                capture_output=True,
-                text=True,
-                timeout=self.max_execution_time
-            )
- 
-            stdout = result.stdout
-            if len(stdout) > self.max_output_length:
-                stdout = stdout[:self.max_output_length] + "\n... (output truncated)"
- 
-            return {
-                "success": result.returncode == 0,
-                "stdout": stdout.strip(),
-                "stderr": result.stderr.strip() if result.stderr else "",
-                "execution_time": time.time(),
-                "return_code": result.returncode
-            }
- 
-        except subprocess.TimeoutExpired:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": "Execution timed out (30s limit)",
-                "execution_time": time.time()
-            }
-        except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": str(e),
-                "execution_time": time.time()
-            }
-        finally:
-            if 'temp_file' in locals():
-                try:
-                    os.unlink(temp_file)
-                except:
-                    pass
- 
-    def execute_bash_command(self, command: str, session_id: Optional[str] = None) -> Dict[str, Any]:
-        """Execute bash commands with security restrictions"""
-        # Security check
-        is_safe, reason = self.is_code_safe(command, "bash")
-        if not is_safe:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Security violation: {reason}",
-                "execution_time": time.time()
-            }
- 
-        try:
-            result = subprocess.run(
-                command,
-                shell=True,
-                capture_output=True,
-                text=True,
-                timeout=self.max_execution_time,
-                cwd=tempfile.gettempdir()
-            )
- 
-            stdout = result.stdout
-            if len(stdout) > self.max_output_length:
-                stdout = stdout[:self.max_output_length] + "\n... (output truncated)"
- 
-            return {
-                "success": result.returncode == 0,
-                "stdout": stdout.strip(),
-                "stderr": result.stderr.strip() if result.stderr else "",
-                "execution_time": time.time(),
-                "return_code": result.returncode
-            }
- 
-        except subprocess.TimeoutExpired:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": "Command timed out (30s limit)",
-                "execution_time": time.time()
-            }
-        except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": str(e),
-                "execution_time": time.time()
+        async function executePyodideCode(code) {
+            if (!pyodide) {
+                return "Pyodide not ready yet. Please wait...";
             }
- 
-    def execute_code(self, code: str, language: str = "python", session_id: Optional[str] = None) -> str:
-        """Main execution function - returns JSON for MCP compatibility"""
-        # Cleanup old sessions periodically
-        if len(self.sessions) > 10:
-            self.cleanup_old_sessions()
- 
-        if language not in self.allowed_languages:
-            return json.dumps({
-                "success": False,
-                "error": f"Language '{language}' not supported. Allowed: {', '.join(self.allowed_languages)}"
-            })
- 
-        # Create session if needed
-        if session_id and session_id not in self.sessions:
-            session_id = self.create_session()
-        elif not session_id:
-            session_id = self.create_session()
- 
-        # Execute based on language
-        if language == "python":
-            result = self.execute_python_code(code, session_id)
-        elif language == "javascript":
-            result = self.execute_javascript_code(code, session_id)
-        elif language == "bash":
-            result = self.execute_bash_command(code, session_id)
-        else:
-            result = {
-                "success": False,
-                "error": f"Execution handler for {language} not implemented"
-            }
- 
-        # Store in session history
-        if session_id in self.sessions:
-            self.sessions[session_id]['history'].append({
-                'code': code,
-                'language': language,
-                'result': result,
-                'timestamp': time.time()
-            })
- 
-        result['session_id'] = session_id
-        return json.dumps(result, indent=2)
- 
-# Global executor instance
-executor = SecureCodeExecutor()
- 
-# MCP Functions
-# Replace the execute_python_code function with this enhanced version
-def execute_python_code(code: str, session_id: str = None) -> str:
-    """
-    Execute Python code safely with visualization support.
-    
-    Args:
-        code (str): Python code to execute
-        session_id (str, optional): Session ID for persistent context
-    
-    Returns:
-        str: JSON string with execution results, including image data for LibreChat
-    """
-    result_json = executor.execute_code(code, "python", session_id)
-    result = json.loads(result_json)
-    
-    # If there's a plot, we need to format it specially for LibreChat
-    if result.get("plot"):
-        plot_base64 = result["plot"]
-        
-        # Create a response that LibreChat can understand
-        # Include both the text output and indicate there's an image
-        response = {
-            "success": result["success"],
-            "stdout": result.get("stdout", ""),
-            "stderr": result.get("stderr", ""),
-            "session_id": result.get("session_id"),
-            "execution_time": result.get("execution_time"),
-            # Add image information
-            "images": [
-                {
-                    "type": "image/png",
-                    "data": plot_base64,
-                    "description": "Generated matplotlib plot"
+            
+            try {
+                // Capture stdout
+                pyodide.runPython(`
+                    import sys
+                    from io import StringIO
+                    old_stdout = sys.stdout
+                    sys.stdout = captured_output = StringIO()
+                `);
+                
+                // Execute user code
+                let result = pyodide.runPython(code);
+                
+                // Get captured output
+                let stdout = pyodide.runPython(`
+                    sys.stdout = old_stdout
+                    captured_output.getvalue()
+                `);
+                
+                // Check for plots
+                let plotData = null;
+                try {
+                    plotData = pyodide.runPython(`
+                        if plt.get_fignums():
+                            show_plot()
+                        else:
+                            None
+                    `);
+                } catch (e) {
+                    // No plot generated
+                }
+                
+                // Display results
+                let outputDiv = document.getElementById('pyodide-output');
+                let outputText = document.getElementById('output-text');
+                let plotContainer = document.getElementById('plot-container');
+                
+                outputDiv.style.display = 'block';
+                
+                let output = stdout || (result !== undefined ? String(result) : '');
+                outputText.textContent = output || 'Code executed successfully (no output)';
+                
+                // Display plot if generated
+                if (plotData) {
+                    plotContainer.innerHTML = `<img src="data:image/png;base64,${plotData}" style="max-width: 100%; height: auto;" alt="Generated Plot">`;
+                    outputText.textContent += '\n\n📊 Plot generated successfully!';
+                } else {
+                    plotContainer.innerHTML = '';
                 }
-            ],
-            # Also include a message about the image
-            "message": f"{result.get('stdout', '')}\n\n📊 Generated visualization (matplotlib plot)"
+                
+                return output + (plotData ? '\n📊 Plot displayed below' : '');
+                
+            } catch (error) {
+                document.getElementById('output-text').textContent = 'Error: ' + error.toString();
+                return 'Error: ' + error.toString();
+            }
         }
         
-        return json.dumps(response, indent=2)
-    
-    # If no plot, return the original result
-    return result_json
- 
-def execute_javascript_code(code: str, session_id: str = None) -> str:
-    """
-    Execute JavaScript code using Node.js.
-    
-    Args:
-        code (str): JavaScript code to execute
-        session_id (str, optional): Session ID for persistent context
-    
-    Returns:
-        str: JSON string with execution results
-    """
-    return executor.execute_code(code, "javascript", session_id)
- 
-def execute_bash_command(command: str, session_id: str = None) -> str:
-    """
-    Execute bash commands with security restrictions.
-    
-    Args:
-        command (str): Bash command to execute
-        session_id (str, optional): Session ID for persistent context
-    
-    Returns:
-        str: JSON string with execution results
-    """
-    return executor.execute_code(command, "bash", session_id)
- 
-def create_execution_session() -> str:
-    """
-    Create a new execution session for maintaining state.
-    
-    Returns:
-        str: JSON string containing new session ID
-    """
-    session_id = executor.create_session()
-    return json.dumps({"session_id": session_id, "created_at": time.time()})
- 
-def list_execution_sessions() -> str:
-    """
-    List all active execution sessions.
-    
-    Returns:
-        str: JSON string containing session information
-    """
-    return json.dumps({
-        "sessions": list(executor.sessions.keys()),
-        "count": len(executor.sessions),
-        "timestamp": time.time()
-    })
- 
-def get_execution_history(session_id: str) -> str:
-    """
-    Get execution history for a specific session.
-    
-    Args:
-        session_id (str): Session ID to get history for
-    
-    Returns:
-        str: JSON string containing execution history
-    """
-    if session_id not in executor.sessions:
-        return json.dumps({"error": "Session not found"})
-    
-    return json.dumps({
-        "session_id": session_id,
-        "history": executor.sessions[session_id]['history'],
-        "created_at": executor.sessions[session_id]['created_at']
-    })
- 
-def get_system_info() -> str:
-    """
-    Get system information and available packages.
-    
-    Returns:
-        str: JSON string containing system information
-    """
-    return json.dumps({
-        "python_version": sys.version,
-        "available_packages": [
-            "numpy", "pandas", "matplotlib", "json", "math", 
-            "random", "datetime", "base64", "io"
-        ],
-        "execution_limits": {
-            "max_time": executor.max_execution_time,
-            "max_output": executor.max_output_length
-        },
-        "supported_languages": executor.allowed_languages
-    })
- 
-# Replace the gradio_execute_code function with this improved version
-def gradio_execute_code(code: str, language: str, session_id: str = ""):
-    """Gradio interface for code execution with proper image handling"""
-    if not session_id:
-        session_id = None
-    
-    result_json = executor.execute_code(code, language.lower(), session_id)
-    result = json.loads(result_json)
-    
-    output = ""
-    plot_image = None
-    
-    if result.get("success"):
-        if result.get("stdout"):
-            output += f"Output:\n{result['stdout']}\n\n"
-        if result.get("stderr"):
-            output += f"Warnings:\n{result['stderr']}\n\n"
+        // Initialize Pyodide when page loads
+        initPyodide();
         
-        # Handle plot data properly
-        if result.get("plot"):
-            import base64
-            from PIL import Image
-            import io
-            
-            try:
-                # Decode base64 to image
-                plot_data = base64.b64decode(result["plot"])
-                plot_image = Image.open(io.BytesIO(plot_data))
-                output += f"📊 Plot generated successfully!\n\n"
-            except Exception as e:
-                output += f"⚠️ Plot generated but couldn't display: {str(e)}\n\n"
-    else:
-        output += f"❌ Error:\n{result.get('stderr', result.get('error', 'Unknown error'))}\n\n"
-    
-    output += f"🔑 Session ID: {result.get('session_id', 'N/A')}"
+        // Make function globally available
+        window.executePyodideCode = executePyodideCode;
+    </script>
+    """
     
-    return output, plot_image
+    return pyodide_html
 
-# Replace the Gradio interface section with this improved version
-with gr.Blocks(title="LibreChat Code Interpreter") as demo:
-    gr.Markdown("# LibreChat Code Interpreter")
-    gr.Markdown("Execute Python, JavaScript, and Bash code safely through MCP integration.")
+def python_executor_fallback(code):
+    """Fallback Python executor for server-side processing"""
+    return "Pyodide is client-side only. Use the interface above to execute Python code in your browser."
+
+# Create the Gradio interface
+with gr.Blocks(title="LibreChat Pyodide Code Interpreter") as demo:
+    gr.Markdown("# LibreChat Pyodide Code Interpreter")
+    gr.Markdown("**Client-side Python execution** using Pyodide - Python runs directly in your browser!")
+    
+    # Pyodide interface
+    pyodide_interface = gr.HTML(create_pyodide_interface())
     
     with gr.Row():
         with gr.Column():
             code_input = gr.Textbox(
-                placeholder="Enter your code here...",
-                lines=10,
-                label="Code"
-            )
-            language_dropdown = gr.Dropdown(
-                choices=["Python", "JavaScript", "Bash"],
-                value="Python",
-                label="Language"
-            )
-            session_input = gr.Textbox(
-                placeholder="Optional: Session ID for persistent context",
-                label="Session ID"
-            )
-            execute_btn = gr.Button("Execute Code", variant="primary")
-        
-        with gr.Column():
-            output_display = gr.Textbox(
-                lines=10,
-                label="Execution Result",
-                interactive=False
-            )
-            # Add image output for plots
-            plot_display = gr.Image(
-                label="Generated Plot",
-                visible=True,
-                type="pil"
-            )
-    
-    # Examples section remains the same...
-    gr.Markdown("## Examples")
-    
-    example_python = gr.Code("""
+                placeholder="""# Try this example:
 import matplotlib.pyplot as plt
 import numpy as np
- 
-# Generate sample data
+
 x = np.linspace(0, 10, 100)
-y = np.sin(x) * np.exp(-x/10)
- 
-# Create plot
+y = np.sin(x)
+
 plt.figure(figsize=(10, 6))
-plt.plot(x, y, 'b-', linewidth=2, label='Damped Sine Wave')
-plt.title('Example Visualization')
+plt.plot(x, y, 'b-', linewidth=2)
+plt.title('Sine Wave - Generated with Pyodide!')
 plt.xlabel('X values')
 plt.ylabel('Y values')
-plt.legend()
 plt.grid(True, alpha=0.3)
 plt.show()
- 
-print("Visualization created successfully!")
-""", language="python", label="Python Example with Visualization")
-    
-    example_js = gr.Code("""
-// Data processing example
-const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- 
-const sum = data.reduce((acc, val) => acc + val, 0);
-const mean = sum / data.length;
-const variance = data.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / data.length;
-const stdDev = Math.sqrt(variance);
- 
-console.log(`Dataset: [${data.join(', ')}]`);
-console.log(`Sum: ${sum}`);
-console.log(`Mean: ${mean}`);
-console.log(`Standard Deviation: ${stdDev.toFixed(3)}`);
- 
-// JSON processing
-const result = {
-    dataset: data,
-    statistics: {
-        sum, mean, variance, stdDev
-    },
-    timestamp: new Date().toISOString()
-};
- 
-console.log('\\nResult:');
-console.log(JSON.stringify(result, null, 2));
-""", language="javascript", label="JavaScript Example")
+
+print("Plot created with client-side Python!")""",
+                lines=15,
+                label="Python Code (executes in your browser)"
+            )
+            
+            execute_btn = gr.Button("Execute with Pyodide", variant="primary")
+        
+        with gr.Column():
+            gr.Markdown("### Results will appear above in the Pyodide container")
+            status_display = gr.Textbox(
+                label="Execution Status",
+                interactive=False,
+                lines=3
+            )
     
-    # Updated click handler to return both outputs
+    # JavaScript execution
     execute_btn.click(
-        fn=gradio_execute_code,
-        inputs=[code_input, language_dropdown, session_input],
-        outputs=[output_display, plot_display]  # Now returns both text and image
+        fn=None,  # No Python function needed
+        inputs=[code_input],
+        outputs=[status_display],
+        js="""
+        function(code) {
+            if (window.executePyodideCode) {
+                return window.executePyodideCode(code);
+            } else {
+                return "Pyodide not ready yet. Please wait for initialization.";
+            }
+        }
+        """
     )
- 
+    
+    # Examples
+    gr.Markdown("## Examples")
+    
+    gr.Code("""
+# Data Analysis Example
+import pandas as pd
+import numpy as np
+
+# Create sample data
+data = {
+    'Name': ['Alice', 'Bob', 'Charlie', 'Diana'],
+    'Age': [25, 30, 35, 28],
+    'Score': [85, 92, 78, 96]
+}
+
+df = pd.DataFrame(data)
+print("Sample DataFrame:")
+print(df)
+print(f"\\nAverage Score: {df['Score'].mean():.1f}")
+""", language="python", label="Data Analysis with Pandas")
+    
+    gr.Code("""
+# Visualization Example
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Generate data
+categories = ['A', 'B', 'C', 'D', 'E']
+values = np.random.randint(10, 50, 5)
+
+# Create bar chart
+plt.figure(figsize=(10, 6))
+bars = plt.bar(categories, values, color=['red', 'blue', 'green', 'orange', 'purple'])
+plt.title('Random Bar Chart - Pyodide Demo')
+plt.xlabel('Categories')
+plt.ylabel('Values')
+
+# Add value labels on bars
+for bar, value in zip(bars, values):
+    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1, 
+             str(value), ha='center', va='bottom')
+
+plt.show()
+print(f"Generated chart with values: {values}")
+""", language="python", label="Matplotlib Visualization")
+
 if __name__ == "__main__":
-    # Launch with MCP server enabled
     demo.launch(
-        mcp_server=True,
-        share=False,
         server_name="0.0.0.0",
-        server_port=7860
+        server_port=7860,
+        share=False
     )