ocs4dev.py

import os
import glob
import gradio as gr
from dotenv import load_dotenv
from typing import List, Dict, Any, Tuple, Optional
import uuid
import torch
from huggingface_hub import hf_hub_download
import warnings
warnings.filterwarnings("ignore")

# Updated imports to avoid deprecation warnings
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain_text_splitters import CharacterTextSplitter
from langchain_core.documents import Document
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# Modern LangChain chains (replacing deprecated ConversationalRetrievalChain)
from langchain.chains import create_history_aware_retriever, create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain

# Multi-provider LLM support
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_anthropic import ChatAnthropic
from langchain_google_genai import ChatGoogleGenerativeAI

# Supabase integration (pre-configured by admin)
from langchain_community.vectorstores import SupabaseVectorStore
from supabase.client import Client, create_client

# Hugging Face Transformers for local Qwen model
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import accelerate

# Configuration
DEFAULT_MODEL = "Qwen/Qwen2.5-Coder-7B-Instruct-AWQ"  # Quantized version for better performance
TOP_K_DOCUMENTS = 5

# Model configurations for each provider
MODEL_CONFIGS = {
    "openai": {
        "budget": "gpt-4o-mini",
        "premium": "o4-mini"
    },
    "anthropic": {
        "budget": "claude-3-5-sonnet-20241022",
        "premium": "claude-4-sonnet-20250109"
    },
    "google": {
        "budget": "gemini-2.0-flash-exp",
        "premium": "gemini-2.0-flash-thinking-exp-1219"
    }
}

# Load environment variables
load_dotenv(override=True)

class OCS4DevAssistant:
    def __init__(self):
        self.setup_environment()
        self.setup_local_model()
        self.setup_vector_store()
        self.chat_history = []
        self.current_provider = "local"
        self.current_model_tier = "budget"

    def setup_environment(self):
        """Setup environment variables - only Supabase required for vector store"""
        # Supabase credentials (pre-configured by admin)
        self.supabase_url = os.getenv('SUPABASE_URL')
        self.supabase_key = os.getenv('SUPABASE_SERVICE_KEY')

        if not self.supabase_url or not self.supabase_key:
            print("⚠️  Supabase not configured. Vector search will be disabled.")
            self.supabase_url = None
            self.supabase_key = None

        # API keys (provided by users in UI)
        self.openai_api_key = os.getenv('OPENAI_API_KEY')
        self.anthropic_api_key = os.getenv('ANTHROPIC_API_KEY')
        self.google_api_key = os.getenv('GOOGLE_API_KEY')

    def setup_local_model(self):
        """Initialize the local Qwen2.5-Coder model"""
        print("🚀 Loading Qwen2.5-Coder-7B-Instruct (AWQ quantized)...")

        try:
            # Check if CUDA is available
            device = "cuda" if torch.cuda.is_available() else "cpu"
            print(f"Using device: {device}")

            # Load tokenizer
            self.tokenizer = AutoTokenizer.from_pretrained(
                DEFAULT_MODEL,
                trust_remote_code=True
            )

            # Load quantized model
            self.local_model = AutoModelForCausalLM.from_pretrained(
                DEFAULT_MODEL,
                torch_dtype=torch.float16 if device == "cuda" else torch.float32,
                device_map="auto" if device == "cuda" else None,
                trust_remote_code=True,
                low_cpu_mem_usage=True
            )

            # Create pipeline for easier inference
            self.local_pipeline = pipeline(
                "text-generation",
                model=self.local_model,
                tokenizer=self.tokenizer,
                torch_dtype=torch.float16 if device == "cuda" else torch.float32,
                device_map="auto" if device == "cuda" else None,
                max_new_tokens=1024,
                temperature=0.3,
                do_sample=True,
                pad_token_id=self.tokenizer.eos_token_id
            )

            print("✅ Local Qwen2.5-Coder model loaded successfully!")

        except Exception as e:
            print(f"❌ Error loading local model: {e}")
            print("Model will be downloaded on first use...")
            self.local_model = None
            self.local_pipeline = None
            self.tokenizer = None

    def setup_vector_store(self):
        """Initialize vector store for retrieval only"""
        if not self.supabase_url or not self.supabase_key:
            self.vector_store = None
            print("⚠️  Supabase credentials not found. Vector store disabled.")
            print("    To enable, set SUPABASE_URL and SUPABASE_SERVICE_KEY environment variables.")
            return

        try:
            self.supabase_client = create_client(self.supabase_url, self.supabase_key)

            # Test connection and check if data exists
            response = self.supabase_client.table("fintech_api_docs").select("count").execute()
            doc_count = len(response.data) if response.data else 0

            if doc_count == 0:
                print("⚠️  Supabase connected but no documents found in the database.")
                print("    Run the populate_supabase.py tool to add documents first.")
            else:
                print(f"✅ Supabase connected! Documents available: {doc_count}")

            # Use OpenAI embeddings for retrieval
            # Note: This requires a valid OpenAI API key for similarity search
            if self.openai_api_key:
                self.embeddings = OpenAIEmbeddings(
                    model="text-embedding-3-small",
                    openai_api_key=self.openai_api_key
                )
            else:
                print("⚠️  No OpenAI API key found. Using fallback embeddings.")
                print("    For best results, provide an OpenAI API key.")
                # Fallback: still create embeddings object but searches may not work properly
                self.embeddings = OpenAIEmbeddings(
                    model="text-embedding-3-small",
                    openai_api_key="dummy-key"
                )

            # Initialize vector store as retriever only
            self.vector_store = SupabaseVectorStore(
                client=self.supabase_client,
                embedding=self.embeddings,
                table_name="fintech_api_docs",
                query_name="match_documents"
            )

            print("✅ Vector store initialized as retriever!")

        except Exception as e:
            print(f"❌ Vector store setup failed: {e}")
            print("    Ensure your Supabase table 'fintech_api_docs' exists with proper schema.")
            print("    Run the populate_supabase.py tool to set up the database.")
            self.vector_store = None

    def get_llm_instance(self, provider: str, tier: str, api_key: Optional[str] = None):
        """Get LLM instance based on provider and tier"""
        if provider == "local":
            return self.local_pipeline

        if not api_key:
            raise ValueError(f"API key required for {provider}")

        model_name = MODEL_CONFIGS[provider][tier]

        if provider == "openai":
            return ChatOpenAI(
                model=model_name,
                temperature=0.3,
                max_tokens=1000,
                openai_api_key=api_key
            )
        elif provider == "anthropic":
            return ChatAnthropic(
                model=model_name,
                temperature=0.3,
                max_tokens=1000,
                anthropic_api_key=api_key
            )
        elif provider == "google":
            return ChatGoogleGenerativeAI(
                model=model_name,
                temperature=0.3,
                max_output_tokens=1000,
                google_api_key=api_key
            )
        else:
            raise ValueError(f"Unsupported provider: {provider}")

    def generate_local_response(self, prompt: str, context: str = "") -> str:
        """Generate response using local Qwen model"""
        if not self.local_pipeline or not self.tokenizer:
            # Try to load model if not loaded
            self.setup_local_model()

        if not self.local_pipeline or not self.tokenizer:
            return "❌ Local model not available. Please use API providers or check your setup."

        # Format prompt for Qwen2.5-Coder
        system_prompt = f"""You are ocs4dev, a specialized fintech API integration assistant. You help developers integrate fintech APIs including MTN MoMo, Pesapal, and Sentezo.

Your expertise includes:
- API authentication and security
- Code examples and implementation
- Error handling and debugging
- Testing and best practices
- Payment gateway integration

Always provide practical, code-focused responses with examples.

Context: {context}"""

        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": prompt}
        ]

        # Apply chat template
        formatted_prompt = self.tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=True
        )

        try:
            # Generate response
            outputs = self.local_pipeline(
                formatted_prompt,
                max_new_tokens=1024,
                temperature=0.3,
                do_sample=True,
                pad_token_id=self.tokenizer.eos_token_id
            )

            # Extract generated text
            response = outputs[0]["generated_text"]

            # Remove the input prompt from response
            if formatted_prompt in response:
                response = response.replace(formatted_prompt, "").strip()

            return response

        except Exception as e:
            return f"❌ Error generating response: {str(e)}"

    def get_retrieval_context(self, query: str) -> str:
        """Get relevant context from vector store"""
        if not self.vector_store:
            return ""

        try:
            docs = self.vector_store.similarity_search(query, k=TOP_K_DOCUMENTS)
            context = "\n\n".join([doc.page_content for doc in docs])
            return context
        except Exception as e:
            print(f"Error retrieving context: {e}")
            return ""

    def create_retrieval_chain(self, llm, provider: str):
        """Create retrieval chain for API models"""
        if not self.vector_store:
            return None

        # Create retriever
        retriever = self.vector_store.as_retriever(
            search_type="similarity",
            search_kwargs={"k": TOP_K_DOCUMENTS}
        )

        # Contextualize question prompt
        contextualize_q_system_prompt = """
        You are ocs4dev, a fintech API integration expert. Given a chat history and the latest user question
        which might reference context in the chat history, formulate a standalone question
        which can be understood without the chat history. Focus on fintech API integration.

        Do NOT answer the question, just reformulate it if needed and otherwise return it as is.
        """

        contextualize_q_prompt = ChatPromptTemplate.from_messages([
            ("system", contextualize_q_system_prompt),
            MessagesPlaceholder("chat_history"),
            ("human", "{input}"),
        ])

        # Create history-aware retriever
        history_aware_retriever = create_history_aware_retriever(
            llm, retriever, contextualize_q_prompt
        )

        # Question answering prompt
        qa_system_prompt = """
        You are ocs4dev, a specialized fintech API integration assistant. Use the following context
        to help developers integrate fintech APIs (MTN MoMo, Pesapal, Sentezo, etc.).

        Your responses should:
        1. Be technically accurate and detailed
        2. Include relevant code examples and snippets
        3. Provide step-by-step implementation guidance
        4. Include error handling best practices
        5. Reference specific API endpoints and parameters
        6. Suggest testing approaches

        Format code blocks properly with language specification for syntax highlighting.
        Always provide practical, actionable advice.

        Context: {context}
        """

        qa_prompt = ChatPromptTemplate.from_messages([
            ("system", qa_system_prompt),
            MessagesPlaceholder("chat_history"),
            ("human", "{input}"),
        ])

        # Create document chain
        question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)

        # Create final RAG chain
        rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)

        return rag_chain

    def update_model_config(self, provider: str, tier: str, api_key: str = None):
        """Update current model configuration"""
        self.current_provider = provider
        self.current_model_tier = tier

        if provider != "local" and api_key:
            if provider == "openai":
                self.openai_api_key = api_key
            elif provider == "anthropic":
                self.anthropic_api_key = api_key
            elif provider == "google":
                self.google_api_key = api_key

    def chat(self, message: str, history: List[Tuple[str, str]], provider: str, tier: str, api_key: str = None) -> str:
        """Main chat function - returns full response (streaming handled by Gradio)"""
        try:
            # Update model configuration
            self.update_model_config(provider, tier, api_key)

            if provider == "local":
                # Use local model with context
                context = self.get_retrieval_context(message)
                return self.generate_local_response(message, context)
            else:
                # Use API model
                api_key_map = {
                    "openai": self.openai_api_key,
                    "anthropic": self.anthropic_api_key,
                    "google": self.google_api_key
                }

                current_api_key = api_key or api_key_map.get(provider)
                if not current_api_key:
                    return f"❌ No API key provided for {provider}. Please enter your API key in the settings."

                # Get LLM instance
                llm = self.get_llm_instance(provider, tier, current_api_key)

                # Create retrieval chain
                rag_chain = self.create_retrieval_chain(llm, provider)

                if not rag_chain:
                    # Fallback to simple context if no vector store
                    context = self.get_retrieval_context(message)
                    simple_prompt = f"Context: {context}\n\nQuestion: {message}\n\nProvide a detailed response about fintech API integration."
                    return llm.invoke(simple_prompt).content

                # Convert Gradio history to LangChain format
                chat_history = []
                for human, assistant in history:
                    chat_history.append(HumanMessage(content=human))
                    chat_history.append(AIMessage(content=assistant))

                # Invoke RAG chain
                response = rag_chain.invoke({
                    "input": message,
                    "chat_history": chat_history
                })

                return response["answer"]

        except Exception as e:
            return f"❌ Error processing request: {str(e)}"

def create_gradio_interface():
    """Create the Gradio interface optimized for HuggingFace Spaces"""
    print("🚀 Starting ocs4dev - Your Fintech API Integration Assistant")

    # Initialize assistant
    try:
        assistant = OCS4DevAssistant()
        print("✅ ocs4dev initialized successfully!")
    except Exception as e:
        print(f"❌ Failed to initialize ocs4dev: {e}")
        return None

    # Custom CSS for better styling and copy buttons
    custom_css = """
    .warning-box {
        background-color: #fff3cd;
        border: 1px solid #ffeaa7;
        border-radius: 8px;
        padding: 12px;
        margin: 10px 0;
        font-size: 14px;
        color: #856404 !important;
    }
    .model-info {
        background-color: #e3f2fd;
        border-left: 4px solid #2196f3;
        padding: 12px;
        margin: 10px 0;
        border-radius: 4px;
        color: #1565c0 !important;
    }
    .feature-box {
        background-color: #f8f9fa;
        border: 1px solid #dee2e6;
        border-radius: 8px;
        padding: 15px;
        margin: 10px 0;
        color: #212529 !important;
    }
    .code-block {
        background-color: #f8f9fa;
        border: 1px solid #e9ecef;
        border-radius: 6px;
        padding: 12px;
        margin: 8px 0;
        position: relative;
        font-family: 'Courier New', monospace;
        color: #212529 !important;
    }
    .copy-button {
        position: absolute;
        top: 8px;
        right: 8px;
        background: #007bff;
        color: white;
        border: none;
        padding: 4px 8px;
        border-radius: 4px;
        cursor: pointer;
        font-size: 12px;
    }
    .copy-button:hover {
        background: #0056b3;
    }
    /* Hide Gradio footer */
    .footer {
        display: none !important;
    }

    /* Overlay backdrop */
    .sidebar-backdrop {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background: rgba(0, 0, 0, 0.5);
        z-index: 999;
        display: none;
    }

    .sidebar-backdrop.show {
        display: block;
    }

    /* Sidebar as overlay */
    .sidebar-container {
        position: fixed;
        left: 0;
        top: 0;
        height: 100vh;
        width: 400px; /* Wider sidebar for better text display */
        max-width: 90vw; /* Responsive on mobile */
        background: var(--background-fill-primary);
        border-right: 1px solid var(--border-color-primary);
        transform: translateX(-100%);
        transition: transform 0.3s ease;
        z-index: 1000;
        overflow-y: auto;
        overflow-x: hidden;
        padding: 20px;
        padding-top: 60px; /* Space for close button */
        box-sizing: border-box;
        box-shadow: 2px 0 10px rgba(0, 0, 0, 0.1);
    }

    .sidebar-container.open {
        transform: translateX(0);
    }

    /* Fix white spaces in sidebar */
    .sidebar-container .gr-form {
        gap: 0 !important;
    }

    .sidebar-container .gr-box {
        border: none !important;
        background: transparent !important;
    }

    .sidebar-container .gr-padded {
        padding: 8px !important;
    }

    .sidebar-container .gr-panel {
        background: var(--background-fill-secondary) !important;
        padding: 12px !important;
        border-radius: 8px;
        margin-bottom: 12px;
    }

    /* Style sidebar content */
    .sidebar-container h2 {
        color: var(--body-text-color) !important;
        margin-bottom: 20px;
        font-size: 1.5rem;
    }

    .sidebar-container .gr-markdown h2 {
        color: var(--body-text-color) !important;
        margin-top: 0;
    }

    /* Remove unwanted white borders and backgrounds */
    .sidebar-container .gradio-container {
        background: transparent !important;
        border: none !important;
    }

    .sidebar-container .gr-form {
        background: transparent !important;
        border: none !important;
        gap: 12px !important;
    }

    .sidebar-container .gr-input-wrapper {
        margin: 0 !important;
    }

    .sidebar-container .gr-group {
        background: var(--background-fill-secondary) !important;
        border: 1px solid var(--border-color-primary) !important;
        border-radius: 8px;
        padding: 12px;
        margin-bottom: 12px;
    }

    /* Ensure text visibility in sidebar */
    .sidebar-container * {
        color: var(--body-text-color) !important;
    }

    .sidebar-title {
        font-size: 1.5rem !important;
        font-weight: bold !important;
        margin-bottom: 20px !important;
        color: var(--body-text-color) !important;
    }

    .sidebar-toggle {
        position: fixed;
        left: 20px;
        top: 20px;
        z-index: 998;
        background: var(--button-primary-background-fill);
        color: var(--button-primary-text-color);
        border: none;
        padding: 12px 16px;
        border-radius: 8px;
        cursor: pointer;
        font-size: 18px;
        transition: all 0.3s ease;
        box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
    }

    .sidebar-toggle:hover {
        background: var(--button-primary-background-fill-hover);
        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);
    }

    .sidebar-close {
        position: absolute;
        right: 20px;
        top: 20px;
        background: transparent;
        border: none;
        font-size: 24px;
        cursor: pointer;
        color: var(--body-text-color);
        padding: 5px;
        border-radius: 4px;
        transition: background 0.2s ease;
        z-index: 1001;
    }

    .sidebar-close:hover {
        background: var(--background-fill-secondary);
    }

    /* Main content stays in place */
    .main-content {
        min-height: 100vh;
        padding-left: 70px; /* Space for menu button */
    }

    /* Custom chat styling */
    .chat-container {
        max-width: 100%;
        margin: 0 auto;
        padding: 20px;
    }

    /* Dark mode specific fixes */
    .dark .sidebar-container {
        background: var(--background-fill-primary);
    }

    .dark .warning-box {
        background-color: #2d2d2d;
        border: 1px solid #ffc107;
        color: #ffc107 !important;
    }
    .dark .model-info {
        background-color: #1a1a1a;
        border-left: 4px solid #64b5f6;
        color: #64b5f6 !important;
    }
    .dark .feature-box {
        background-color: #2d2d2d;
        border: 1px solid #495057;
        color: #e9ecef !important;
    }

    /* Responsive adjustments */
    @media (max-width: 768px) {
        .sidebar-container {
            width: 85vw;
        }
        .main-content {
            padding-left: 60px;
        }
    }
    """

    # Create the interface
    def chat_with_config(message, history, provider, tier, openai_key, anthropic_key, google_key):
        """Chat function with configuration"""
        api_key = None
        if provider == "openai":
            api_key = openai_key
        elif provider == "anthropic":
            api_key = anthropic_key
        elif provider == "google":
            api_key = google_key

        return assistant.chat(message, history, provider, tier, api_key)

    # Create interface
    with gr.Blocks(
        title="ocs4dev - Fintech API Assistant",
        theme=gr.themes.Soft(
            primary_hue="blue",
            secondary_hue="gray",
            neutral_hue="slate",
        ),
        css=custom_css,
        fill_height=True,
        js="""
        function() {
            // Add sidebar toggle functionality with backdrop
            const backdrop = document.createElement('div');
            backdrop.className = 'sidebar-backdrop';
            document.body.appendChild(backdrop);

            const toggleButton = document.createElement('button');
            toggleButton.innerHTML = '☰';
            toggleButton.className = 'sidebar-toggle';
            toggleButton.title = 'Open Settings';

            const sidebar = document.querySelector('.sidebar-container');

            // Add close button to sidebar
            const closeButton = document.createElement('button');
            closeButton.innerHTML = '✕';
            closeButton.className = 'sidebar-close';
            closeButton.title = 'Close Settings';
            sidebar.insertBefore(closeButton, sidebar.firstChild);

            function openSidebar() {
                sidebar.classList.add('open');
                backdrop.classList.add('show');
                document.body.style.overflow = 'hidden';
            }

            function closeSidebar() {
                sidebar.classList.remove('open');
                backdrop.classList.remove('show');
                document.body.style.overflow = '';
            }

            toggleButton.onclick = openSidebar;
            closeButton.onclick = closeSidebar;
            backdrop.onclick = closeSidebar;

            // ESC key to close
            document.addEventListener('keydown', (e) => {
                if (e.key === 'Escape' && sidebar.classList.contains('open')) {
                    closeSidebar();
                }
            });

            document.body.appendChild(toggleButton);
        }
        """
    ) as interface:

        # Header
        with gr.Column(elem_classes="main-content"):
            gr.Markdown("# 🏦 ocs4dev - Your Fintech API Integration Assistant")
            gr.Markdown("*Specialized AI assistant for integrating fintech APIs including MTN MoMo, Airtel, Pesapal etc*")

            # Main chat interface
            chatbot = gr.Chatbot(
                height=500,
                placeholder="Ask me about fintech API integration, authentication, code examples, or best practices...",
                label="ocs4dev Assistant",
                show_copy_button=True,  # Enable copy button for chat messages
                render_markdown=True,
                elem_classes="chat-container"
            )

            msg = gr.Textbox(
                placeholder="How do I authenticate with MTN MoMo API?",
                label="Your Question",
                lines=2,
                show_copy_button=True  # Enable copy button for input
            )

            with gr.Row():
                clear = gr.Button("Clear", variant="secondary")
                submit = gr.Button("Send", variant="primary")

            # Example questions
            gr.Examples(
                examples=[
                    "How do I authenticate with MTN MoMo API?",
                    "Show me a Pesapal payment integration example",
                    "What are the required headers for Sentezo API?",
                    "How do I handle payment webhooks?",
                    "Best practices for API error handling",
                    "How to test API integrations in sandbox mode?",
                    "Show me a complete payment flow implementation",
                    "How to secure API keys in production?",
                    "What's the difference between sandbox and production?",
                    "How do I implement payment status callbacks?"
                ],
                inputs=msg,
                label="💡 Example Questions"
            )

        # Sidebar (hidden by default)
        with gr.Column(elem_classes="sidebar-container", elem_id="settings-sidebar"):
            gr.Markdown("## ⚙️ Configuration", elem_classes="sidebar-title")

            # Model provider selection
            with gr.Group():
                provider = gr.Radio(
                    choices=["local", "openai", "anthropic", "google"],
                    value="local",
                    label="Model Provider",
                    info="Local model is free but requires GPU. API models need keys.",
                    elem_classes="provider-selector"
                )

                tier = gr.Radio(
                    choices=["budget", "premium"],
                    value="budget",
                    label="Model Tier",
                    info="Budget models are faster/cheaper, Premium models are more capable",
                    elem_classes="tier-selector"
                )

            # API Keys Section
            with gr.Accordion("🔑 API Keys", open=True, elem_classes="api-keys-section"):
                gr.HTML('<div class="warning-box">⚠️ <strong>Security Warning:</strong> Create test API keys for this app and delete them after use. Never share production keys.</div>')

                with gr.Group():
                    openai_key = gr.Textbox(
                        placeholder="sk-...",
                        label="OpenAI API Key",
                        type="password",
                        info="Budget: gpt-4o-mini | Premium: o4-mini (advanced reasoning)",
                        elem_classes="api-key-input"
                    )

                    anthropic_key = gr.Textbox(
                        placeholder="sk-ant-...",
                        label="Anthropic API Key",
                        type="password",
                        info="Budget: claude-3.5-sonnet | Premium: claude-4-sonnet",
                        elem_classes="api-key-input"
                    )

                    google_key = gr.Textbox(
                        placeholder="AI...",
                        label="Google API Key",
                        type="password",
                        info="Budget: gemini-2.0-flash | Premium: gemini-2.0-flash-thinking",
                        elem_classes="api-key-input"
                    )

            # Updated model information
            gr.HTML('<div class="model-info">🚀 <strong>Pro Tip:</strong> Add your API keys above for faster and better responses. Local model works but API models provide superior performance!</div>')

            # Features
            with gr.Accordion("✨ Features", open=False, elem_classes="features-section"):
                gr.HTML('''
                <div class="feature-box">
                    <strong>🔧 Code-Focused:</strong> Optimized for API integration tasks<br>
                    <strong>🔒 Secure:</strong> No API keys stored permanently<br>
                    <strong>📋 Copy-Friendly:</strong> Easy code copying with built-in buttons<br>
                    <strong>🚀 Fast:</strong> Multiple model options for best performance<br>
                    <strong>🔄 Multi-Provider:</strong> Switch between AI models seamlessly
                </div>
                ''')

        # Chat functionality with simple response
        def respond(message, history, provider, tier, openai_key, anthropic_key, google_key):
            """Handle chat responses with simulated streaming"""
            if not message:
                return history, ""

            # Add user message to history
            history = history or []

            # Get the full response
            bot_message = chat_with_config(message, history, provider, tier, openai_key, anthropic_key, google_key)

            # Simulate streaming by yielding partial responses
            partial = ""
            words = bot_message.split(" ")

            # Stream words in chunks for smooth appearance
            chunk_size = 3  # Words per chunk
            for i in range(0, len(words), chunk_size):
                chunk = " ".join(words[i:i+chunk_size])
                partial += chunk + " "
                yield history + [(message, partial.strip())], ""

            # Final update with complete response
            yield history + [(message, bot_message)], ""

        # Connect the interface
        submit.click(
            respond,
            inputs=[msg, chatbot, provider, tier, openai_key, anthropic_key, google_key],
            outputs=[chatbot, msg]
        )

        msg.submit(
            respond,
            inputs=[msg, chatbot, provider, tier, openai_key, anthropic_key, google_key],
            outputs=[chatbot, msg]
        )

        clear.click(lambda: ([], ""), outputs=[chatbot, msg])

        # Footer
        gr.Markdown("---")
        gr.Markdown("Built with ❤️ by Aaron | Using Qwen2.5-Coder, LangChain, and Gradio | [GitHub](https://github.com/aaron-official/ocs4dev.git)")

    return interface

def populate_knowledge_base_standalone():
    """[DEPRECATED] Use the separate populate_supabase.py tool instead"""
    print("⚠️  This function is deprecated!")
    print("    Please use the separate 'populate_supabase.py' tool to populate the vector database.")
    print("    ")
    print("    Usage:")
    print("    $ python populate_supabase.py --knowledge-base ./knowledge-base")
    print("    ")
    print("    The tool will:")
    print("    1. Load all markdown files from your knowledge base directory")
    print("    2. Split them into chunks for better retrieval")
    print("    3. Generate embeddings using OpenAI")
    print("    4. Store everything in your Supabase vector database")
    print("    ")
    print("    Make sure you have set these environment variables:")
    print("    - SUPABASE_URL")
    print("    - SUPABASE_SERVICE_KEY")
    print("    - OPENAI_API_KEY")
    return False

def main():
    """Main function optimized for HuggingFace Spaces"""
    interface = create_gradio_interface()
    if interface:
        # HuggingFace Spaces optimized launch
        interface.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=True,  # Enable public URL for HF Spaces
            inbrowser=False,  # Don't open browser in server environment
            show_error=True,
            quiet=False,
            max_threads=10  # Limit concurrent requests
        )

if __name__ == "__main__":
    main()