Fix examples formatting and remove RAG functionality

- Fixed examples processing in generate_zip function to use repr() instead of json.dumps()
- This ensures examples are properly formatted as Python literals for gr.ChatInterface
- Updated theme specification from gr.themes.Default() to 'default' string
- Removed RAG functionality files: rag_tool.py and vector_store.py
- Enhanced support_docs.py with placeholder comments for future image integration
- Updated export_conversation_to_markdown to include configuration metadata

app.py

@@ -1603,7 +1603,7 @@ with gr.Blocks(
             border-radius: 6px;
         }
     """,
-    theme=gr.themes.Default(),
+    theme="default",
     head="""
         <style>
             /* Additional head styles to prevent manifest issues */

rag_tool.py

@@ -1,208 +0,0 @@
-import json
-from typing import List, Dict, Any, Optional, Tuple
-from document_processor import DocumentProcessor, DocumentChunk
-from vector_store import VectorStore, SearchResult
-import os
-import tempfile
-from pathlib import Path
-
-
-class RAGTool:
-    """RAG tool for integrating document search with chat"""
-    
-    def __init__(self):
-        self.processor = DocumentProcessor(chunk_size=800, chunk_overlap=100)
-        self.vector_store = VectorStore()
-        self.processed_files = []
-        self.total_chunks = 0
-    
-    def process_uploaded_files(self, file_paths: List[str]) -> Dict[str, Any]:
-        """Process uploaded files and build vector index"""
-        
-        # Validate files
-        valid_files = []
-        errors = []
-        
-        for file_path in file_paths:
-            try:
-                # Check file size (10MB limit)
-                size_mb = os.path.getsize(file_path) / (1024 * 1024)
-                if size_mb > 10:
-                    errors.append({
-                        'file': Path(file_path).name,
-                        'error': f'File too large ({size_mb:.1f}MB). Maximum size is 10MB.'
-                    })
-                    continue
-                
-                valid_files.append(file_path)
-                
-            except Exception as e:
-                errors.append({
-                    'file': Path(file_path).name,
-                    'error': str(e)
-                })
-        
-        if not valid_files:
-            return {
-                'success': False,
-                'message': 'No valid files to process',
-                'errors': errors
-            }
-        
-        # Process files
-        all_chunks, summary = self.processor.process_multiple_files(valid_files)
-        
-        if not all_chunks:
-            return {
-                'success': False,
-                'message': 'No content extracted from files',
-                'summary': summary
-            }
-        
-        # Build vector index
-        chunk_dicts = [chunk.to_dict() for chunk in all_chunks]
-        self.vector_store.build_index(chunk_dicts, show_progress=False)
-        
-        # Update stats
-        self.processed_files = summary['files_processed']
-        self.total_chunks = len(all_chunks)
-        
-        # Calculate index size
-        index_stats = self.vector_store.get_stats()
-        
-        return {
-            'success': True,
-            'message': f'Successfully processed {len(valid_files)} files into {self.total_chunks} chunks',
-            'summary': summary,
-            'index_stats': index_stats,
-            'errors': errors
-        }
-    
-    def get_relevant_context(self, query: str, max_chunks: int = 3) -> str:
-        """Get relevant context for a query"""
-        if not self.vector_store.index:
-            return ""
-        
-        # Search for relevant chunks
-        results = self.vector_store.search(
-            query=query,
-            top_k=max_chunks,
-            score_threshold=0.3
-        )
-        
-        if not results:
-            return ""
-        
-        # Format context
-        context_parts = []
-        
-        for i, result in enumerate(results, 1):
-            file_name = result.metadata.get('file_name', 'Unknown')
-            context_parts.append(
-                f"[Document: {file_name} - Relevance: {result.score:.2f}]\n{result.text}"
-            )
-        
-        return "\n\n".join(context_parts)
-    
-    def get_serialized_data(self) -> Dict[str, Any]:
-        """Get serialized data for deployment"""
-        if not self.vector_store.index:
-            return None
-        
-        return self.vector_store.serialize()
-    
-    def get_deployment_info(self) -> Dict[str, Any]:
-        """Get information for deployment package"""
-        if not self.vector_store.index:
-            return {
-                'enabled': False,
-                'message': 'No documents processed'
-            }
-        
-        # Estimate package size increase
-        index_stats = self.vector_store.get_stats()
-        estimated_size_mb = (
-            # Index size estimation
-            (index_stats['total_chunks'] * index_stats['dimension'] * 4) / (1024 * 1024) +
-            # Chunks text size estimation
-            (sum(len(chunk['text']) for chunk in self.vector_store.chunks.values()) / (1024 * 1024))
-        ) * 1.5  # Add overhead for base64 encoding
-        
-        return {
-            'enabled': True,
-            'total_files': len(self.processed_files),
-            'total_chunks': self.total_chunks,
-            'estimated_size_mb': round(estimated_size_mb, 2),
-            'files': [f['name'] for f in self.processed_files]
-        }
-
-
-def create_rag_module_for_space(serialized_data: Dict[str, Any]) -> str:
-    """Create a minimal RAG module for the deployed space"""
-    
-    return '''# RAG Module for deployed space
-import numpy as np
-import faiss
-import base64
-import json
-
-class RAGContext:
-    def __init__(self, serialized_data):
-        # Deserialize FAISS index
-        index_bytes = base64.b64decode(serialized_data['index_base64'])
-        self.index = faiss.deserialize_index(index_bytes)
-        
-        # Restore chunks and mappings
-        self.chunks = serialized_data['chunks']
-        self.chunk_ids = serialized_data['chunk_ids']
-    
-    def get_context(self, query_embedding, max_chunks=3):
-        """Get relevant context using pre-computed embedding"""
-        if not self.index:
-            return ""
-        
-        # Normalize and search
-        faiss.normalize_L2(query_embedding)
-        scores, indices = self.index.search(query_embedding, max_chunks)
-        
-        # Format results
-        context_parts = []
-        
-        for score, idx in zip(scores[0], indices[0]):
-            if idx < 0 or score < 0.3:
-                continue
-            
-            chunk = self.chunks[self.chunk_ids[idx]]
-            file_name = chunk.get('metadata', {}).get('file_name', 'Document')
-            
-            context_parts.append(
-                f"[{file_name} - Relevance: {score:.2f}]\\n{chunk['text']}"
-            )
-        
-        return "\\n\\n".join(context_parts) if context_parts else ""
-
-# Initialize RAG context
-RAG_DATA = json.loads(\'\'\'{{rag_data_json}}\'\'\')
-rag_context = RAGContext(RAG_DATA) if RAG_DATA else None
-
-def get_rag_context(query):
-    """Get relevant context for a query"""
-    if not rag_context:
-        return ""
-    
-    # In production, you'd compute query embedding here
-    # For now, return empty (would need embedding service)
-    return ""
-'''
-
-
-def format_context_for_prompt(context: str, query: str) -> str:
-    """Format RAG context for inclusion in prompt"""
-    if not context:
-        return ""
-    
-    return f"""Relevant context from uploaded documents:
-
-{context}
-
-Please use the above context to help answer the user's question: {query}"""

support_docs.py

@@ -1,5 +1,16 @@
 """
 Support documentation module with accordion-style help sections
+
+IMAGE PLACEHOLDERS TO REPLACE:
+1. interface_overview.png - Three-tab interface overview (Getting Started)
+2. configuration_tab.png - Configuration tab screenshot (Space Settings)
+3. system_prompt_interface.png - System prompt and template interface (Assistant Configuration)
+4. preview_tab.png - Preview tab with chat interface (Preview Tab Usage)
+5. example_prompts.png - Example prompts input and display (Example Prompts)
+6. tool_settings_diagram.png - Configuration structure diagram (Tool Settings)
+7. advanced_settings.png - Temperature and token controls (Advanced Settings)
+8. deployment_process.png - Deployment process flow diagram (Deployment Process)
+9. secret.png - HuggingFace secret configuration (already exists)
 """
 
 import gradio as gr
@@ -11,25 +22,39 @@ def create_support_docs():
     
     with gr.Column():
         gr.Markdown("# Support Documentation")
+        gr.Markdown("*Under construction - images coming soon!*")
         gr.Markdown("Complete step-by-step guidance for creating and deploying chat interfaces with HuggingFace Spaces.")
         
         with gr.Accordion("🚀 Getting Started", open=True):
             gr.Markdown("""
             ### Quick Start Guide
+            This guide helps you set up your first chat interface on HuggingFace Spaces using Gradio. Follow these steps to create a functional assistant with URL grounding and example prompts.
+            """)
             
-            **Three-Tab Interface:**
-            1. **Configuration Tab**: Set up your space settings, assistant configuration, and tool integrations
-            2. **Preview Tab**: Test your assistant with real API integration before deployment  
-            3. **Support Tab**: Access comprehensive documentation and help (this tab)
-            
-            **Workflow Steps:**
-            1. **Configure your Space** in the Configuration tab (space title, description, model selection)
-            2. **Set up Assistant** with system prompt and optional research template
-            3. **Enable Tools** like dynamic URL fetching or URL grounding as needed
-            4. **Preview & Test** using the Preview tab to validate your configuration
-            5. **Generate Package** with the "Generate Deployment Package" button
-            6. **Deploy to HuggingFace** following the included README instructions
+            # TODO: Add interface overview screenshot
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="interface_overview.png",  # Placeholder for interface overview screenshot
+                        label="Three-Tab Interface: Configuration, Preview, and Support",
+                        show_label=True,
+                        interactive=False,
+                        width=600,
+                        height=400,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Workflow Steps:**
+                    1. **Configure** your space settings
+                    2. **Set up** assistant with system prompt
+                    3. **Enable** tools like URL grounding
+                    4. **Preview** & test your configuration
+                    5. **Generate** deployment package
+                    6. **Deploy** to HuggingFace
+                    """)
             
+            gr.Markdown("""
             **Prerequisites:**
             - HuggingFace account (free at huggingface.co)
             - OpenRouter API key (get at openrouter.ai/keys)
@@ -39,58 +64,85 @@ def create_support_docs():
         with gr.Accordion("⚙️ Space Settings", open=False):
             gr.Markdown("""
             ### Space Configuration Fields
+            """)
             
-            **Space Title**
-            - The name that will appear on HuggingFace and in your chat interface
-            - Keep it descriptive but concise (e.g., "Biology Course Assistant")
-            
-            **Space Description**
-            - Brief explanation of what your assistant does
-            - Will appear in the HuggingFace Space listing and at the top of your chat
+            # TODO: Add configuration tab screenshot
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="configuration_tab.png",  # Placeholder for configuration tab screenshot
+                        label="Configuration Tab Interface",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=400,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Key Configuration Fields:**
+                    
+                    **Space Title** - Display name for your assistant
+                    
+                    **Space Description** - Brief explanation of purpose
+                    
+                    **Model Selection** - Choose from optimized models:
+                    - **Gemma 3 27B** - Open-source, sustainable
+                    - **Gemini 2.0 Flash** - Fast, reliable
+                    - **Claude 3.5 Haiku** - Complex reasoning
+                    
+                    **API Key Variable** - Default: `OPENROUTER_API_KEY`
+                    
+                    **Access Code** - Optional student protection
+                    """)
             
-            **Model Selection**
+            gr.Markdown("""
+            **Model Comparison:**
             - **[google/gemma-3-27b-it](https://openrouter.ai/models/google/gemma-3-27b-it)**: Open-source, sustainable option with excellent performance
             - **[google/gemini-2.0-flash-001](https://openrouter.ai/models/google/gemini-2.0-flash-001)**: Fast, reliable, good for general tasks
-            - **[mistralai/mistral-medium](https://openrouter.ai/models/mistralai/mistral-medium)**: Good for technical topics
-            - **[openai/gpt-4o-nano](https://openrouter.ai/models/openai/gpt-4o-nano)**: Balanced performance and cost
             - **[anthropic/claude-3.5-haiku](https://openrouter.ai/models/anthropic/claude-3.5-haiku)**: Great for complex reasoning and analysis
-            
-            **API Key Variable Name**
-            - Default: `OPENROUTER_API_KEY`
-            - This is the secret name you'll create in HuggingFace Space settings
-            - Only change if you have specific naming requirements
-            
-            **Access Code (Optional)**
-            - Leave empty for public access
-            - Set a code to restrict access to students/specific users
-            - Code is stored securely as an environment variable
             """)
         
-        with gr.Accordion("🤖 Assistant Configuration", open=False):
+        with gr.Accordion("🤖 Space Configuration", open=False):
             gr.Markdown("""
             ### System Prompt Design
+            """)
             
-            The system prompt defines your assistant's personality, knowledge, and behavior.
+            # TODO: Add system prompt interface screenshot
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="system_prompt_interface.png",  # Placeholder for system prompt interface
+                        label="System Prompt Configuration Interface",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=300,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Template System:**
+                    
+                    **Research Template** - Pre-configured for academic use
+                    - MLA citation formatting
+                    - Fact-checking emphasis
+                    - Auto-enables URL fetching
+                    
+                    **Socratic Template** - Pedagogical questioning
+                    - Constructivist learning approach
+                    - Critical thinking focus
+                    
+                    **Custom Prompt** - Build your own
+                    """)
             
+            gr.Markdown("""
             **Best Practices:**
             - Be specific about the assistant's role and purpose
             - Include behavioral guidelines and constraints
             - Mention the intended audience (students, researchers, etc.)
             - List key capabilities and tasks
             
-            **Research Template**
-            - Pre-configured for academic research assistance
-            - Includes MLA citation formatting
-            - Emphasizes fact-checking and evidence-based responses
-            - Automatically enables dynamic URL fetching
-            
-            **Custom Categories**
-            - Break down your system prompt into structured sections:
-              - **Role and Purpose**: What is the assistant and what does it do?
-              - **Intended Audience**: Who will use this assistant?
-              - **Key Tasks**: What specific capabilities should it have?
-              - **Additional Context**: Extra instructions or constraints
-            
             ### Copy-Pasteable System Prompts
             
             **Biology Course Assistant:**
@@ -127,9 +179,36 @@ def create_support_docs():
         with gr.Accordion("🔬 Preview Tab Usage", open=False):
             gr.Markdown("""
             ### Testing Your Assistant Before Deployment
+            """)
             
-            The Preview tab provides a sandbox environment to test your assistant with real API integration.
+            # TODO: Add preview tab screenshot
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="preview_tab.png",  # Placeholder for preview tab screenshot
+                        label="Preview Tab with Active Chat Interface",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=400,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Preview Features:**
+                    
+                    **Real API Integration** - Uses actual OpenRouter API
+                    
+                    **Configuration Display** - Shows current setup
+                    
+                    **URL Testing** - Add up to 4 URLs for context
+                    
+                    **Chat Export** - Download conversation logs
+                    
+                    **Clear Function** - Reset chat history
+                    """)
             
+            gr.Markdown("""
             **How to Use the Preview:**
             1. **Configure First**: Complete your setup in the Configuration tab
             2. **Click Preview Button**: Use "Preview Deployment Package" to activate the preview
@@ -137,18 +216,9 @@ def create_support_docs():
             4. **Test URL Context**: Add URLs to test grounding functionality
             5. **Export Conversations**: Save chat logs for analysis
             
-            **Preview Features:**
-            - **Real API Integration**: Uses actual OpenRouter API when `OPENROUTER_API_KEY` is set
-            - **Configuration Display**: Shows your current assistant setup
-            - **URL Testing**: Add up to 4 URLs for context testing
-            - **Dynamic URL Management**: Add/remove URL fields as needed
-            - **Chat Export**: Download conversation logs as markdown files
-            - **Clear Function**: Reset chat history for new tests
-            
             **Preview Requirements:**
             - Set `OPENROUTER_API_KEY` environment variable for real API testing
             - Without API key: Shows configuration but no actual chat responses
-            - All other features (URL fetching, configuration) work without API key
             
             **Testing Best Practices:**
             - Test different types of queries to validate assistant behavior
@@ -160,20 +230,36 @@ def create_support_docs():
         with gr.Accordion("💬 Example Prompts", open=False):
             gr.Markdown("""
             ### Creating Effective Example Prompts
+            """)
             
-            Example prompts appear as clickable suggestions in your chat interface.
-            
-            **Guidelines:**
-            - Write 3-6 clear, specific examples
-            - Show the range of what your assistant can do
-            - Match your intended use cases
-            - Include URLs if your assistant can process them
-            
-            **Format:**
-            - One prompt per line
-            - Keep each prompt under 100 characters for better display
-            - Use natural, conversational language
+            # TODO: Add example prompts interface screenshot
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="example_prompts.png",  # Placeholder for example prompts interface
+                        label="Example Prompts Interface and Display",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=300,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Guidelines:**
+                    
+                    **Format** - One prompt per line
+                    
+                    **Length** - Under 100 characters each
+                    
+                    **Content** - Show assistant capabilities
+                    
+                    **Language** - Natural and conversational
+                    
+                    **URLs** - Include if assistant processes them
+                    """)
             
+            gr.Markdown("""
             **Examples by Use Case:**
             
             **Course Assistant:**
@@ -201,40 +287,42 @@ def create_support_docs():
         with gr.Accordion("🔧 Tool Settings & Configuration", open=False):
             gr.Markdown("""
             ### Configuration Tab Structure
+            """)
             
-            **Main Configuration Fields** (always visible):
-            - **Space Title**: Display name for your HuggingFace Space
-            - **Space Description**: Brief explanation shown in space listing
-            - **Model Selection**: Choose from optimized OpenRouter models
-            - **API Key Variable**: Secret name for HuggingFace Space settings (default: `OPENROUTER_API_KEY`)
-            - **Access Code**: Optional password protection for student access
-            
-            **Assistant Configuration Accordion** (open by default):
-            - **System Prompt**: Main field defining assistant behavior and knowledge
-            - **Research Template**: Pre-configured academic research assistant checkbox
-            - **Web Search Integration**: Enable crawl4ai web search capabilities
-            # Document RAG functionality removed
-            - **URL Grounding**: Add up to 4 static URLs for context (dynamic add/remove)
-            - **Example Prompts**: Clickable suggestions for users (one per line)
-            - **Dynamic URL Fetching**: Hidden field (always enabled) for runtime URL processing
-            
-            **Advanced Settings Accordion**:
-            - **Temperature**: Response creativity control (0.0-2.0)
-            - **Max Tokens**: Response length limit (50-4096)
-            
-            **Action Buttons**:
-            - **Preview Deployment Package**: Activate Preview tab testing
-            - **Generate Deployment Package**: Create downloadable zip file
+            # TODO: Add tool settings diagram
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="tool_settings_diagram.png",  # Placeholder for tool settings structure diagram
+                        label="Configuration Tab Structure and Tool Integration",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=400,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Main Configuration Fields:**
+                    - Space Title & Description
+                    - Model Selection
+                    - API Key Variable
+                    - Access Code (optional)
+                    
+                    **Assistant Configuration:**
+                    - System Prompt
+                    - Template Selection
+                    - URL Grounding (2-4 URLs)
+                    - Example Prompts
+                    
+                    **Advanced Settings:**
+                    - Temperature (0.0-2.0)
+                    - Max Tokens (50-4096)
+                    """)
             
+            gr.Markdown("""
             ### Tool Integration Options
             
-            **Web Search (crawl4ai)**
-            - Real-time web searching using DuckDuckGo
-            - Advanced content extraction and crawling
-            - Automatically enabled with Research Template
-            
-            # Document RAG functionality removed
-            
             **URL Grounding (Static Context)**
             - Add 2-4 URLs for consistent context across all responses
             - Content fetched once during generation and cached
@@ -250,20 +338,36 @@ def create_support_docs():
         with gr.Accordion("🎛️ Advanced Settings", open=False):
             gr.Markdown("""
             ### Model Parameters
+            """)
             
-            **Temperature (0.0 - 2.0)**
-            - **0.0-0.3**: Very focused, deterministic responses
-            - **0.4-0.7**: Balanced creativity and consistency (recommended)
-            - **0.8-1.2**: More creative and varied responses
-            - **1.3-2.0**: Highly creative, potentially unpredictable
-            
-            **Max Response Tokens (50-4096)**
-            - Controls maximum length of assistant responses
-            - **50-200**: Short, concise answers
-            - **200-500**: Medium responses (recommended for most cases)
-            - **500-1000**: Longer, detailed explanations
-            - **1000+**: Extended analysis and comprehensive responses
+            # TODO: Add advanced settings interface screenshot
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="advanced_settings.png",  # Placeholder for advanced settings interface
+                        label="Advanced Settings: Temperature and Token Controls",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=300,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Temperature (0.0 - 2.0)**
+                    - **0.0-0.3**: Very focused, deterministic
+                    - **0.4-0.7**: Balanced (recommended)
+                    - **0.8-1.2**: More creative and varied
+                    - **1.3-2.0**: Highly creative, unpredictable
+                    
+                    **Max Response Tokens (50-4096)**
+                    - **50-200**: Short, concise answers
+                    - **200-500**: Medium responses (recommended)
+                    - **500-1000**: Longer, detailed explanations
+                    - **1000+**: Extended analysis
+                    """)
             
+            gr.Markdown("""
             **Token Usage Notes:**
             - Tokens include both input (your prompt + context) and output
             - Longer contexts (URLs) use more input tokens
@@ -273,6 +377,37 @@ def create_support_docs():
         with gr.Accordion("🚀 Deployment Process", open=False):
             gr.Markdown("""
             ### Quick Deployment Guide
+            """)
+            
+            # TODO: Add deployment process diagram
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        value="deployment_process.png",  # Placeholder for deployment process diagram
+                        label="Complete Deployment Process Flow",
+                        show_label=True,
+                        interactive=False,
+                        width=500,
+                        height=300,
+                        container=False
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Deployment Steps:**
+                    
+                    **1. Generate Package** - Download zip file
+                    
+                    **2. Create Space** - New HuggingFace Space (Gradio SDK)
+                    
+                    **3. Upload Files** - app.py and requirements.txt
+                    
+                    **4. Add API Key** - Secret configuration
+                    
+                    **5. Deploy & Test** - Wait for build, then test
+                    """)
+            
+            gr.Markdown("""
+            **Detailed Steps:**
             
             **1. Generate & Upload**
             - Click "Generate Deployment Package" → download zip
@@ -355,8 +490,6 @@ def create_support_docs():
             - Check for typos in the access code
             - Case-sensitive matching
             
-            # Document RAG functionality removed
-            
             **URLs not fetching content**
             - Check URLs are publicly accessible
             - Some sites block automated requests
@@ -429,17 +562,58 @@ def create_support_docs():
             - Language practice partners
             """)
 
-def export_conversation_to_markdown(conversation_history):
-    """Export conversation history to markdown format"""
+def export_conversation_to_markdown(conversation_history, config_metadata=None):
+    """Export conversation history to markdown format with configuration metadata"""
     if not conversation_history:
         return "No conversation to export."
     
     markdown_content = f"""# Conversation Export
 Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
 
----
+"""
+    
+    # Add configuration metadata if provided
+    if config_metadata:
+        markdown_content += """## Configuration Information
 
 """
+        
+        # Add basic configuration details
+        if config_metadata.get('name'):
+            markdown_content += f"**Assistant Name:** {config_metadata['name']}\n"
+        if config_metadata.get('description'):
+            markdown_content += f"**Description:** {config_metadata['description']}\n"
+        if config_metadata.get('model'):
+            markdown_content += f"**Model:** {config_metadata['model']}\n"
+        if config_metadata.get('temperature'):
+            markdown_content += f"**Temperature:** {config_metadata['temperature']}\n"
+        if config_metadata.get('max_tokens'):
+            markdown_content += f"**Max Tokens:** {config_metadata['max_tokens']}\n"
+        
+        # Add URL grounding information
+        grounding_urls = []
+        for i in range(1, 5):
+            url = config_metadata.get(f'url{i}')
+            if url and url.strip():
+                grounding_urls.append(url.strip())
+        
+        if grounding_urls:
+            markdown_content += f"\n**URL Grounding ({len(grounding_urls)} URLs):**\n"
+            for i, url in enumerate(grounding_urls, 1):
+                markdown_content += f"- URL {i}: {url}\n"
+        
+        # Add feature flags
+        if config_metadata.get('enable_dynamic_urls'):
+            markdown_content += f"\n**Dynamic URL Fetching:** Enabled\n"
+        
+        # Add system prompt
+        if config_metadata.get('system_prompt'):
+            system_prompt = config_metadata['system_prompt']
+            markdown_content += f"\n**System Prompt:**\n```\n{system_prompt}\n```\n"
+        
+        markdown_content += "\n---\n\n"
+    else:
+        markdown_content += "---\n\n"
     
     for i, message in enumerate(conversation_history):
         if isinstance(message, dict):

vector_store.py

@@ -1,308 +0,0 @@
-import numpy as np
-import pickle
-import base64
-from typing import List, Dict, Any, Tuple, Optional
-import json
-from dataclasses import dataclass
-
-try:
-    from sentence_transformers import SentenceTransformer
-    HAS_SENTENCE_TRANSFORMERS = True
-except ImportError:
-    HAS_SENTENCE_TRANSFORMERS = False
-
-try:
-    import faiss
-    HAS_FAISS = True
-except ImportError:
-    HAS_FAISS = False
-
-
-@dataclass
-class SearchResult:
-    chunk_id: str
-    text: str
-    score: float
-    metadata: Dict[str, Any]
-
-
-class VectorStore:
-    def __init__(self, embedding_model: str = "all-MiniLM-L6-v2"):
-        self.embedding_model_name = embedding_model
-        self.embedding_model = None
-        self.index = None
-        self.chunks = {}  # chunk_id -> chunk data
-        self.chunk_ids = []  # Ordered list for FAISS index mapping
-        self.dimension = 384  # Default for all-MiniLM-L6-v2
-        
-        if HAS_SENTENCE_TRANSFORMERS:
-            self._initialize_model()
-    
-    def _initialize_model(self):
-        """Initialize the embedding model"""
-        if not HAS_SENTENCE_TRANSFORMERS:
-            raise ImportError("sentence-transformers not installed")
-        
-        try:
-            print(f"Loading embedding model: {self.embedding_model_name}")
-            print("This may take a moment on first run as the model downloads...")
-            
-            # Set environment variables to prevent multiprocessing issues
-            import os
-            os.environ['TOKENIZERS_PARALLELISM'] = 'false'
-            os.environ['OMP_NUM_THREADS'] = '1'
-            os.environ['MKL_NUM_THREADS'] = '1'
-            
-            # Initialize with specific settings to avoid multiprocessing issues
-            self.embedding_model = SentenceTransformer(
-                self.embedding_model_name,
-                device='cpu',  # Force CPU to avoid GPU/multiprocessing conflicts
-                cache_folder=None,  # Use default cache
-                # Additional parameters to reduce memory usage
-                use_auth_token=False,
-                trust_remote_code=False  # Security best practice
-            )
-            
-            # Disable multiprocessing for stability in web apps
-            if hasattr(self.embedding_model, 'pool'):
-                self.embedding_model.pool = None
-            
-            # Additional stability measures for Gradio environment
-            if hasattr(self.embedding_model, '_modules'):
-                for module in self.embedding_model._modules.values():
-                    if hasattr(module, 'num_workers'):
-                        module.num_workers = 0
-            
-            # Update dimension based on model
-            self.dimension = self.embedding_model.get_sentence_embedding_dimension()
-            print(f"Model loaded successfully, dimension: {self.dimension}")
-        except Exception as e:
-            print(f"Failed to initialize embedding model: {e}")
-            # Provide more specific error messages
-            if "connection" in str(e).lower() or "timeout" in str(e).lower():
-                raise RuntimeError(f"Network error downloading model '{self.embedding_model_name}'. "
-                                 f"Please check your internet connection and try again: {e}")
-            elif "memory" in str(e).lower() or "out of memory" in str(e).lower():
-                raise RuntimeError(f"Insufficient memory to load model '{self.embedding_model_name}'. "
-                                 f"Try using a smaller model or increase available memory: {e}")
-            else:
-                raise RuntimeError(f"Could not load embedding model '{self.embedding_model_name}': {e}")
-    
-    def create_embeddings(self, texts: List[str], batch_size: int = 8) -> np.ndarray:
-        """Create embeddings for a list of texts"""
-        if not self.embedding_model:
-            self._initialize_model()
-        
-        # Use smaller batch size for stability
-        embeddings = []
-        
-        try:
-            print(f"Creating embeddings for {len(texts)} text chunks...")
-            for i in range(0, len(texts), batch_size):
-                batch = texts[i:i + batch_size]
-                print(f"Processing batch {i//batch_size + 1}/{(len(texts) + batch_size - 1)//batch_size}")
-                
-                batch_embeddings = self.embedding_model.encode(
-                    batch,
-                    convert_to_numpy=True,
-                    show_progress_bar=False,
-                    device='cpu',  # Force CPU to avoid GPU conflicts
-                    normalize_embeddings=False,  # We'll normalize later with FAISS
-                    batch_size=min(batch_size, 4)  # Extra safety on batch size
-                )
-                embeddings.append(batch_embeddings)
-                
-                # Import gc for garbage collection
-                import gc
-                gc.collect()  # Force garbage collection between batches
-                    
-        except Exception as e:
-            # Log the error and provide a helpful message
-            print(f"Error creating embeddings: {e}")
-            if "cuda" in str(e).lower() or "gpu" in str(e).lower():
-                raise RuntimeError(f"GPU/CUDA error encountered. The model is configured to use CPU only. Error: {e}")
-            elif "memory" in str(e).lower() or "out of memory" in str(e).lower():
-                raise RuntimeError(f"Out of memory while creating embeddings. Try uploading smaller files or fewer files at once: {e}")
-            else:
-                raise RuntimeError(f"Failed to create embeddings: {e}")
-        
-        return np.vstack(embeddings) if embeddings else np.array([])
-    
-    def build_index(self, chunks: List[Dict[str, Any]], show_progress: bool = True):
-        """Build FAISS index from chunks"""
-        if not HAS_FAISS:
-            raise ImportError("faiss-cpu not installed")
-        
-        # Extract texts and build embeddings
-        texts = [chunk['text'] for chunk in chunks]
-        
-        if show_progress:
-            print(f"Creating embeddings for {len(texts)} chunks...")
-        
-        embeddings = self.create_embeddings(texts)
-        
-        # Build FAISS index
-        if show_progress:
-            print("Building FAISS index...")
-        
-        # Use IndexFlatIP for inner product (cosine similarity with normalized vectors)
-        self.index = faiss.IndexFlatIP(self.dimension)
-        
-        # Normalize embeddings for cosine similarity
-        faiss.normalize_L2(embeddings)
-        
-        # Add to index
-        self.index.add(embeddings)
-        
-        # Store chunks and maintain mapping
-        self.chunks = {}
-        self.chunk_ids = []
-        
-        for chunk in chunks:
-            chunk_id = chunk['chunk_id']
-            self.chunks[chunk_id] = chunk
-            self.chunk_ids.append(chunk_id)
-        
-        if show_progress:
-            print(f"Index built with {len(chunks)} chunks")
-    
-    def search(self, query: str, top_k: int = 5, score_threshold: float = 0.3) -> List[SearchResult]:
-        """Search for similar chunks"""
-        if not self.index or not self.chunks:
-            return []
-        
-        # Create query embedding
-        query_embedding = self.create_embeddings([query])
-        
-        # Normalize for cosine similarity
-        faiss.normalize_L2(query_embedding)
-        
-        # Search
-        scores, indices = self.index.search(query_embedding, min(top_k, len(self.chunks)))
-        
-        # Convert to results
-        results = []
-        
-        for score, idx in zip(scores[0], indices[0]):
-            if idx < 0 or score < score_threshold:
-                continue
-            
-            chunk_id = self.chunk_ids[idx]
-            chunk = self.chunks[chunk_id]
-            
-            result = SearchResult(
-                chunk_id=chunk_id,
-                text=chunk['text'],
-                score=float(score),
-                metadata=chunk.get('metadata', {})
-            )
-            results.append(result)
-        
-        return results
-    
-    def serialize(self) -> Dict[str, Any]:
-        """Serialize the vector store for deployment"""
-        if not self.index:
-            raise ValueError("No index to serialize")
-        
-        # Serialize FAISS index
-        index_bytes = faiss.serialize_index(self.index)
-        index_base64 = base64.b64encode(index_bytes).decode('utf-8')
-        
-        return {
-            'index_base64': index_base64,
-            'chunks': self.chunks,
-            'chunk_ids': self.chunk_ids,
-            'dimension': self.dimension,
-            'model_name': self.embedding_model_name
-        }
-    
-    @classmethod
-    def deserialize(cls, data: Dict[str, Any]) -> 'VectorStore':
-        """Deserialize a vector store from deployment data"""
-        if not HAS_FAISS:
-            raise ImportError("faiss-cpu not installed")
-        
-        store = cls(embedding_model=data['model_name'])
-        
-        # Deserialize FAISS index
-        index_bytes = base64.b64decode(data['index_base64'])
-        store.index = faiss.deserialize_index(index_bytes)
-        
-        # Restore chunks and mappings
-        store.chunks = data['chunks']
-        store.chunk_ids = data['chunk_ids']
-        store.dimension = data['dimension']
-        
-        return store
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """Get statistics about the vector store"""
-        return {
-            'total_chunks': len(self.chunks),
-            'index_size': self.index.ntotal if self.index else 0,
-            'dimension': self.dimension,
-            'model': self.embedding_model_name
-        }
-
-
-class LightweightVectorStore:
-    """Lightweight version for deployed spaces without embedding model"""
-    
-    def __init__(self, serialized_data: Dict[str, Any]):
-        if not HAS_FAISS:
-            raise ImportError("faiss-cpu not installed")
-        
-        # Deserialize FAISS index
-        index_bytes = base64.b64decode(serialized_data['index_base64'])
-        self.index = faiss.deserialize_index(index_bytes)
-        
-        # Restore chunks and mappings
-        self.chunks = serialized_data['chunks']
-        self.chunk_ids = serialized_data['chunk_ids']
-        self.dimension = serialized_data['dimension']
-        
-        # For query embedding, we'll need to include pre-computed embeddings
-        # or use a lightweight embedding service
-        self.query_embeddings_cache = serialized_data.get('query_embeddings_cache', {})
-    
-    def search_with_embedding(self, query_embedding: np.ndarray, top_k: int = 5, score_threshold: float = 0.3) -> List[SearchResult]:
-        """Search using pre-computed query embedding"""
-        if not self.index or not self.chunks:
-            return []
-        
-        # Normalize for cosine similarity
-        faiss.normalize_L2(query_embedding)
-        
-        # Search
-        scores, indices = self.index.search(query_embedding, min(top_k, len(self.chunks)))
-        
-        # Convert to results
-        results = []
-        
-        for score, idx in zip(scores[0], indices[0]):
-            if idx < 0 or score < score_threshold:
-                continue
-            
-            chunk_id = self.chunk_ids[idx]
-            chunk = self.chunks[chunk_id]
-            
-            result = SearchResult(
-                chunk_id=chunk_id,
-                text=chunk['text'],
-                score=float(score),
-                metadata=chunk.get('metadata', {})
-            )
-            results.append(result)
-        
-        return results
-
-
-# Utility functions
-def estimate_index_size(num_chunks: int, dimension: int = 384) -> float:
-    """Estimate the size of the index in MB"""
-    # Rough estimation: 4 bytes per float * dimension * num_chunks
-    bytes_size = 4 * dimension * num_chunks
-    # Add overhead for index structure and metadata
-    overhead = 1.2
-    return (bytes_size * overhead) / (1024 * 1024)