Adapt v3 to use working v2 patterns

- Copy working structure from v2 example
- Use tuple-based chat history instead of dict format
- Simplify Gradio components (remove State, Accordion, etc)
- Use gradio>=4.0.0 instead of pinned version
- Remove complex event chaining with .then()
- Launch with server_name and server_port parameters

app.py

@@ -1,30 +1,16 @@
+#!/usr/bin/env python3
 """
-Minimal Gradio app for HuggingFace Spaces
+Hugging Face Spaces App Entry Point
 """
-import gradio as gr
-import os
 
-def chat_function(message, history):
-    """Simple chat function that echoes the message"""
-    response = f"I received your message: '{message}'. This is a test deployment."
-    return response
+import sys
+from pathlib import Path
 
-# Create interface
-with gr.Blocks() as demo:
-    gr.Markdown("# AI Assistant Multi-Agent System")
-    gr.Markdown("This is a simplified version for testing HuggingFace deployment.")
-    
-    chatbot = gr.Chatbot()
-    msg = gr.Textbox()
-    clear = gr.Button("Clear")
-    
-    def respond(message, chat_history):
-        bot_message = chat_function(message, chat_history)
-        chat_history.append((message, bot_message))
-        return "", chat_history
-    
-    msg.submit(respond, [msg, chatbot], [msg, chatbot])
-    clear.click(lambda: None, None, chatbot, queue=False)
+# Add current directory to path
+sys.path.append(str(Path(__file__).parent))
+
+# Import and run the simplified Gradio app
+from py.frontend.gradio_app_simple import main
 
 if __name__ == "__main__":
-    demo.launch()
+    main()

py/frontend/gradio_app_simple.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+Simplified Gradio Frontend for Multi-Agent System - HuggingFace Compatible
+"""
+
+import gradio as gr
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from backend.chat_history_manager import ChatHistoryManager
+from backend.api_gateway import APIGateway
+from config_loader import get_config
+from tools import agent_tools
+
+class SimpleAgentUI:
+    """Simplified Gradio UI for the multi-agent system."""
+    
+    def __init__(self):
+        """Initialize the UI."""
+        # Load configuration
+        self.config = get_config()
+        
+        # Initialize API Gateway
+        self.api_gateway = APIGateway()
+        
+        # Initialize chat history manager
+        db_path = self.config.get("conversation.database_path")
+        self.history_manager = ChatHistoryManager(db_path)
+        
+        # Initialize agents
+        self.current_agent = "document_reader"
+        self._initialize_agents()
+        
+        # Get default settings
+        self.current_model = self.config.get_default_model()
+        self.current_product = self.config.get_default_product()
+        self.current_version = self.config.get_default_version(self.current_product)
+    
+    def _initialize_agents(self):
+        """Initialize agents with current model."""
+        from langchain_openai import ChatOpenAI
+        
+        # Create LLM
+        llm = ChatOpenAI(
+            model=self.current_model,
+            temperature=0.0,
+            max_tokens=4000
+        )
+        
+        # Initialize agents
+        agent_tools.initialize_agents(llm, self.api_gateway)
+    
+    def chat_response(self, message: str, history: list, model: str, product: str, version: str):
+        """Generate a chat response."""
+        if not message.strip():
+            return history
+        
+        # Update settings if changed
+        if model != self.current_model:
+            self.current_model = model
+            self._initialize_agents()
+        
+        self.current_product = product
+        self.current_version = version
+        
+        try:
+            # Create context
+            agent_context = {
+                "product": self.current_product,
+                "version": self.current_version,
+                "model": self.current_model
+            }
+            
+            # Run agent
+            result_dict = agent_tools.run_agent(self.current_agent, message, agent_context)
+            
+            # Get response
+            response = result_dict.get("output", "No response generated")
+            new_agent_id = result_dict.get("agent_id", self.current_agent)
+            
+            # Check if agent changed
+            if new_agent_id != self.current_agent:
+                self.current_agent = new_agent_id
+                response = f"[Switched to {new_agent_id}] {response}"
+            
+            # Add agent prefix
+            agent_prefix = f"[{self.current_agent}]: "
+            response = agent_prefix + response
+            
+            # Update history
+            history.append((message, response))
+            
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            history.append((message, error_msg))
+        
+        return history
+    
+    def create_interface(self):
+        """Create the Gradio interface."""
+        with gr.Blocks(title="AI Assistant Multi-Agent System") as demo:
+            gr.Markdown("# 🤖 AI Assistant Multi-Agent System")
+            gr.Markdown("Chat with specialized agents for documentation, settings, and more.")
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(
+                        label="Chat History",
+                        height=500
+                    )
+                    
+                    msg = gr.Textbox(
+                        label="Your Message",
+                        placeholder="Ask a question...",
+                        lines=2
+                    )
+                    
+                    with gr.Row():
+                        submit_btn = gr.Button("Send", variant="primary")
+                        clear_btn = gr.Button("Clear")
+                
+                with gr.Column(scale=1):
+                    # Model selection
+                    model_options = [(m["display_name"], m["model_id"]) 
+                                   for m in self.config.get_available_models()]
+                    model_dropdown = gr.Dropdown(
+                        choices=model_options,
+                        value=self.current_model,
+                        label="AI Model"
+                    )
+                    
+                    # Product selection
+                    product_options = [(p["display_name"], p["id"]) 
+                                     for p in self.config.get_available_products()]
+                    product_dropdown = gr.Dropdown(
+                        choices=product_options,
+                        value=self.current_product,
+                        label="Product"
+                    )
+                    
+                    # Version selection
+                    version_dropdown = gr.Dropdown(
+                        choices=["1.8", "1.6", "1.5", "1.2"],
+                        value=self.current_version,
+                        label="Version"
+                    )
+                    
+                    # Current agent display
+                    agent_display = gr.Markdown(f"**Active Agent:** {self.current_agent}")
+            
+            # Event handlers
+            def respond(message, history, model, product, version):
+                """Handle chat response."""
+                updated_history = self.chat_response(message, history, model, product, version)
+                agent_status = f"**Active Agent:** {self.current_agent}"
+                return updated_history, "", agent_status
+            
+            def clear_chat():
+                """Clear chat history."""
+                return [], ""
+            
+            # Wire up events
+            submit_btn.click(
+                respond,
+                inputs=[msg, chatbot, model_dropdown, product_dropdown, version_dropdown],
+                outputs=[chatbot, msg, agent_display]
+            )
+            
+            msg.submit(
+                respond,
+                inputs=[msg, chatbot, model_dropdown, product_dropdown, version_dropdown],
+                outputs=[chatbot, msg, agent_display]
+            )
+            
+            clear_btn.click(
+                clear_chat,
+                outputs=[chatbot, msg]
+            )
+        
+        return demo
+
+def main():
+    """Main function to run the Gradio app."""
+    ui = SimpleAgentUI()
+    demo = ui.create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,2 +1,19 @@
 # Core dependencies
-gradio==4.19.2
+openai>=1.50.0
+gradio>=4.0.0
+tiktoken>=0.5.0
+
+# LangChain
+langchain
+langchain-openai
+langchain-community
+
+# Vector operations
+numpy
+
+# Utilities
+python-dotenv
+PyYAML
+pydantic
+pydantic-settings
+SQLAlchemy