Deploy premium Claude-style LLM chatbot with web search, scraping, memory, and access control

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.DS_Store
+.env
+.venv
+venv/
+env/
+.idea/
+.vscode/
+*.log

README.md

@@ -0,0 +1,70 @@
+---
+title: Claude-Style Modular LLM Space
+emoji: 🤖
+colorFrom: indigo
+colorTo: slate
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: A premium Claude-style chatbot with web search, scraping, and memory.
+---
+
+# Claude-Style Modular LLM Chatbot
+
+A production-grade, premium LLM chatbot interface optimized for Hugging Face Spaces (free tier). 
+
+It features a minimalist **Claude-style interface** (built with custom CSS and Gradio), an advanced reasoning system prompt, **real-time web search (via DuckDuckGo)**, **automatic web page scraping**, and **conversational memory**.
+
+## 🚀 Key Features
+
+* **Claude-Style Minimalist UI**: Sleek, elegant light/dark mode inspired by Anthropic's Claude, complete with high-quality typography, clean card structures, and responsive layouts.
+* **Tri-Mode Inference Engine**:
+  1. **Local CPU (Quantized PyTorch)**: Run lightweight models (e.g., `Qwen/Qwen2.5-1.5B-Instruct`) locally on the free CPU tier (fits within 16GB RAM).
+  2. **Zero-GPU (Free GPU Sharing)**: Dynamic GPU acceleration utilizing Hugging Face's shared Zero-GPU pool (for 7B/8B models like `Qwen/Qwen2.5-7B-Instruct`).
+  3. **HF Serverless Inference API**: Instant, zero-overhead connectivity to massive models (like `Qwen/Qwen2.5-72B-Instruct` or `Meta-Llama-3.3-70B-Instruct`) using your Hugging Face API token.
+* **Real-time Web Search & Scraper**: Toggleable web-search capability that searches DuckDuckGo, scrapes page contents, and injects context directly into the prompt.
+* **Conversational Memory**: Maintains session chat history dynamically.
+* **State-of-the-Art System Prompt**: Tailored prompts that guide the model to provide detailed, step-by-step thinking, well-formatted markdown, and objective answers.
+
+## 🛠️ Hugging Face One-Click Deployment
+
+Click the button below to deploy this template directly to your Hugging Face Spaces:
+
+[![Deploy to Spaces](https://huggingface.co/datasets/huggingface/badges/resolve/main/deploy-to-spaces-lg.svg)](https://huggingface.co/new-space?template=SmartGenzAI1/llm)
+
+### 🔒 Access Control (Private Deployment)
+To restrict access so **only you** can use the chatbot:
+1. In your Hugging Face Space, navigate to **Settings** -> **Variables and secrets**.
+2. Create a new **Secret** with:
+   - **Name**: `APP_PASSWORD`
+   - **Value**: Your chosen private passcode (e.g., `my_private_passcode123`).
+3. Once saved, Hugging Face will prompt a secure login page when accessing the Space. You will log in using `admin` as the username and your passcode as the password.
+
+### 💻 Manual Git Deployment
+To push manually:
+1. Create a new Space on [Hugging Face](https://huggingface.co/new-space).
+2. Choose **Gradio** as the SDK.
+3. Push these files to your Space's repository:
+   ```bash
+   git remote add origin https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+   git add .
+   git commit -m "Deploying Claude-style chatbot"
+   git push -u origin main --force
+   ```
+
+
+## ⚙️ Project Structure
+
+```
+├── app.py                      # Space entrypoint
+├── requirements.txt            # Python dependencies
+├── README.md                   # Space configuration & docs
+└── src/
+    ├── __init__.py
+    ├── config.py               # Theme styling, system prompts, & model settings
+    ├── tools.py                # Web Search & Web Scraping engine
+    ├── engine.py               # Modular multi-backend inference runner
+    └── ui.py                   # Custom Gradio interface components
+```

app.py

@@ -0,0 +1,26 @@
+import os
+from src.ui import build_interface
+
+if __name__ == "__main__":
+    # Build the Gradio interface
+    demo = build_interface()
+    
+    # Check for private passcode environment variable
+    password = os.environ.get("APP_PASSWORD")
+    
+    # Hugging Face Spaces runs on port 7860 by default.
+    # We bind to 0.0.0.0 to make the service reachable within the HF container.
+    launch_kwargs = {
+        "server_name": "0.0.0.0",
+        "server_port": 7860,
+        "show_api": False,
+        "concurrency_limit": 10
+    }
+    
+    # Enable login window if password secret is configured
+    if password:
+        launch_kwargs["auth"] = ("admin", password)
+        print("Secure authentication enabled via APP_PASSWORD secret.")
+        
+    demo.launch(**launch_kwargs)
+

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.44.0
+torch
+transformers>=4.43.0
+accelerate>=0.30.0
+huggingface_hub>=0.24.0
+duckduckgo_search>=6.2.0
+beautifulsoup4>=4.12.0
+html2text>=2024.2.26
+requests

src/__init__.py

@@ -0,0 +1 @@
+# Package initialization for the Claude-style LLM chatbot space.

src/config.py

@@ -0,0 +1,250 @@
+# Configuration file for Claude-style LLM Space
+
+# Available Model Configurations
+MODEL_CONFIGS = {
+    "Local CPU (Lightweight)": [
+        {
+            "name": "Qwen 2.5 1.5B Instruct",
+            "repo_id": "Qwen/Qwen2.5-1.5B-Instruct",
+            "description": "Blazing fast on CPU, highly competent. Ideal for basic CPU spaces.",
+            "default": True
+        },
+        {
+            "name": "Llama 3.2 1B Instruct",
+            "repo_id": "meta-llama/Llama-3.2-1B-Instruct",
+            "description": "Ultra-lightweight model by Meta. Low RAM footprint.",
+            "default": False
+        },
+        {
+            "name": "Llama 3.2 3B Instruct",
+            "repo_id": "meta-llama/Llama-3.2-3B-Instruct",
+            "description": "Very smart, well-balanced for CPU. Might take a bit longer to load.",
+            "default": False
+        }
+    ],
+    "Zero-GPU (Accelerated)": [
+        {
+            "name": "Qwen 2.5 7B Instruct",
+            "repo_id": "Qwen/Qwen2.5-7B-Instruct",
+            "description": "Excellent reasoning and coding. Highly recommended for Zero-GPU.",
+            "default": True
+        },
+        {
+            "name": "Llama 3 8B Instruct",
+            "repo_id": "meta-llama/Meta-Llama-3-8B-Instruct",
+            "description": "Meta's standard 8B model. Balanced and conversational.",
+            "default": False
+        },
+        {
+            "name": "Mistral 7B Instruct v0.3",
+            "repo_id": "mistralai/Mistral-7B-Instruct-v0.3",
+            "description": "Classic developer favorite. Excellent instruction following.",
+            "default": False
+        }
+    ],
+    "HF Serverless API (Zero Overhead)": [
+        {
+            "name": "Llama 3.3 70B Instruct",
+            "repo_id": "meta-llama/Llama-3.3-70B-Instruct",
+            "description": "Massive 70B model. State-of-the-art reasoning, fully hosted by Hugging Face.",
+            "default": True
+        },
+        {
+            "name": "Qwen 2.5 72B Instruct",
+            "repo_id": "Qwen/Qwen2.5-72B-Instruct",
+            "description": "Extremely powerful, rivals commercial LLMs. Hosted by Hugging Face.",
+            "default": False
+        },
+        {
+            "name": "Mixtral 8x7B Instruct",
+            "repo_id": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "description": "High-speed Mixture of Experts model. Hosted by Hugging Face.",
+            "default": False
+        }
+    ]
+}
+
+# The Leaked-Style System Prompt (inspired by Claude 3.5 Sonnet & ChatGPT Custom Instructions)
+SYSTEM_PROMPT = """You are a highly advanced AI coding assistant and researcher named Antigravity, engineered by the Google DeepMind team. You approach every interaction with objective precision, extreme intelligence, and structured depth. 
+
+You must strictly adhere to the following behavioral and formatting rules:
+
+1. THOUGHT PROCESS (Chain of Thought):
+   - Before answering, you must analyze the user's query and plan your solution step-by-step.
+   - You MUST wrap your detailed reasoning inside a `<thinking>` block.
+   - In your reasoning, break down the core components of the problem, consider edge cases, verify code syntax mentally, and map out the response structure.
+   - Example:
+     <thinking>
+     The user is asking for X. 
+     First, I need to analyze Y... 
+     Then, I should structure the solution like Z...
+     </thinking>
+
+2. DIRECTNESS & TONE:
+   - Never use generic conversational filler or robotic pleasantries. Avoid starting responses with "Sure, I can help with that," "Here is the code," or "As an AI...".
+   - Adopt an objective, clear, and intellectual tone. Speak directly to the user.
+   - Do not make assumptions. If a query is ambiguous, explain the ambiguity and outline the options or ask for clarification.
+
+3. KNOWLEDGE & CAPABILITIES:
+   - You have access to real-time web search and web scraping tools. When web context is provided, rely on it to answer queries accurately and provide sources/citations where appropriate.
+   - If you do not know the answer, admit it honestly.
+
+4. FORMATTING & CODE STYLE:
+   - Use GitHub-style markdown for all responses.
+   - Write clean, production-grade, fully commented code blocks. 
+   - Never write placeholders like `// TODO: implement this` or `...` in code outputs unless explicitly asked. Always write complete, copy-pasteable files.
+   - Use bold headers, clean lists, and Markdown tables to make information easily scannable.
+   - Use LaTeX syntax for math equations (e.g., inline: \\( E=mc^2 \\), block: \\$\\$ \\sum_{i=1}^n i \\$\\$).
+
+Current Date/Time: {datetime}
+"""
+
+# Premium Claude-Style Custom CSS for Gradio
+CLAUDE_CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=Outfit:wght@300;400;500;600;700&display=swap');
+
+/* Apply custom typography globally */
+body, .gradio-container {
+    font-family: 'Inter', sans-serif !important;
+    background-color: #0b0f19 !important; /* Premium dark background */
+    color: #f3f4f6 !important;
+}
+
+/* Claude style header styling */
+h1, h2, h3, h4 {
+    font-family: 'Outfit', sans-serif !important;
+    font-weight: 600;
+}
+
+/* Sidebar configuration panel */
+.sidebar-panel {
+    background-color: rgba(17, 24, 39, 0.7) !important;
+    backdrop-filter: blur(12px) !important;
+    border: 1px solid rgba(255, 255, 255, 0.08) !important;
+    border-radius: 16px !important;
+    padding: 20px !important;
+    box-shadow: 0 4px 30px rgba(0, 0, 0, 0.2) !important;
+}
+
+/* Customizing the main chatbot */
+.chatbot-container {
+    border: 1px solid rgba(255, 255, 255, 0.08) !important;
+    border-radius: 16px !important;
+    background-color: rgba(17, 24, 39, 0.4) !important;
+    backdrop-filter: blur(12px) !important;
+    box-shadow: 0 4px 30px rgba(0, 0, 0, 0.2) !important;
+    overflow: hidden;
+}
+
+/* Hide default gradio borders and adjust message padding */
+.chatbot-container .message-row {
+    padding: 16px 24px !important;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.05) !important;
+}
+
+/* User chat bubble styling - elegant, dark-grey with thin border */
+.chatbot-container .user {
+    background-color: rgba(59, 130, 246, 0.1) !important;
+    border: 1px solid rgba(59, 130, 246, 0.2) !important;
+    border-radius: 12px 12px 0px 12px !important;
+    padding: 12px 16px !important;
+    align-self: flex-end;
+}
+
+/* Assistant chat bubble styling - clean borderless transparent, minimalist like Claude */
+.chatbot-container .bot {
+    background-color: transparent !important;
+    border: none !important;
+    padding: 12px 0px !important;
+}
+
+/* Custom CSS to style thinking process blocks */
+details.thinking-block {
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    border-radius: 8px !important;
+    background-color: rgba(255, 255, 255, 0.03) !important;
+    padding: 10px 14px !important;
+    margin-bottom: 12px !important;
+    font-size: 0.9em !important;
+    color: #9ca3af !important;
+    transition: all 0.3s ease;
+}
+
+details.thinking-block[open] {
+    border-color: rgba(59, 130, 246, 0.3) !important;
+    background-color: rgba(59, 130, 246, 0.02) !important;
+}
+
+details.thinking-block summary {
+    font-weight: 500 !important;
+    color: #60a5fa !important;
+    cursor: pointer !important;
+    outline: none !important;
+    user-select: none !important;
+}
+
+/* Beautiful buttons styling */
+.action-btn {
+    background: linear-gradient(135deg, #2563eb 0%, #1d4ed8 100%) !important;
+    color: white !important;
+    font-weight: 500 !important;
+    border: none !important;
+    border-radius: 8px !important;
+    transition: all 0.2s ease !important;
+    box-shadow: 0 4px 6px -1px rgba(37, 99, 235, 0.2) !important;
+}
+
+.action-btn:hover {
+    transform: translateY(-1px) !important;
+    box-shadow: 0 6px 12px -1px rgba(37, 99, 235, 0.4) !important;
+}
+
+.action-btn:active {
+    transform: translateY(1px) !important;
+}
+
+/* Secondary/outline buttons (like Web Search toggle) */
+.secondary-btn {
+    background-color: rgba(255, 255, 255, 0.05) !important;
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    color: #f3f4f6 !important;
+    border-radius: 8px !important;
+    transition: all 0.2s ease !important;
+}
+
+.secondary-btn:hover {
+    background-color: rgba(255, 255, 255, 0.1) !important;
+    border-color: rgba(255, 255, 255, 0.2) !important;
+}
+
+/* Inputs and textareas */
+input, textarea, select {
+    background-color: rgba(31, 41, 55, 0.8) !important;
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    border-radius: 8px !important;
+    color: #f3f4f6 !important;
+    padding: 8px 12px !important;
+}
+
+input:focus, textarea:focus, select:focus {
+    border-color: #2563eb !important;
+    box-shadow: 0 0 0 2px rgba(37, 99, 235, 0.2) !important;
+    outline: none !important;
+}
+
+/* Adjust sliders aesthetics */
+input[type="range"] {
+    accent-color: #2563eb !important;
+}
+
+/* Status logs and output cards */
+.status-card {
+    background-color: rgba(251, 191, 36, 0.1) !important;
+    border: 1px solid rgba(251, 191, 36, 0.2) !important;
+    border-radius: 8px !important;
+    padding: 10px 14px !important;
+    font-size: 0.9em !important;
+    color: #fbbf24 !important;
+    margin-bottom: 12px !important;
+}
+"""

src/engine.py

@@ -0,0 +1,328 @@
+import os
+import gc
+import time
+from datetime import datetime
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+from huggingface_hub import InferenceClient
+from src.config import SYSTEM_PROMPT, MODEL_CONFIGS
+from src.tools import web_search, scrape_url, format_search_results_for_prompt
+
+# Conditional Zero-GPU Spaces import
+try:
+    import spaces
+    HAS_SPACES = True
+    gpu_decorator = spaces.GPU
+except ImportError:
+    HAS_SPACES = False
+    # Dummy decorator if not on HF Zero-GPU
+    def gpu_decorator(f):
+        return f
+
+# Global Model Cache variables
+_current_model = None
+_current_tokenizer = None
+_current_repo_id = None
+
+def unload_model():
+    """Unloads the currently cached model and tokenizer to free RAM/GPU memory."""
+    global _current_model, _current_tokenizer, _current_repo_id
+    if _current_model is not None:
+        print(f"Unloading model: {_current_repo_id} to free memory...")
+        del _current_model
+        del _current_tokenizer
+        _current_model = None
+        _current_tokenizer = None
+        _current_repo_id = None
+        # Force garbage collection and CUDA cache clearing
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        time.sleep(1)
+
+def get_local_model(repo_id: str):
+    """
+    Retrieves the local tokenizer and model, loading them from Hugging Face
+    cache if not already loaded in the memory cache.
+    """
+    global _current_model, _current_tokenizer, _current_repo_id
+    
+    if _current_repo_id == repo_id and _current_model is not None:
+        return _current_model, _current_tokenizer
+
+    # Unload previous model to avoid out-of-memory errors
+    unload_model()
+
+    print(f"Loading model: {repo_id}...")
+    tokenizer = AutoTokenizer.from_pretrained(repo_id)
+    
+    # Determine the device mapping (GPU if available, else CPU)
+    if torch.cuda.is_available():
+        device_map = "auto"
+        torch_dtype = torch.float16
+    else:
+        device_map = "cpu"
+        # On CPU, float32 is most stable, bfloat16 can be used if CPU supports it
+        torch_dtype = torch.float32
+
+    model = AutoModelForCausalLM.from_pretrained(
+        repo_id,
+        device_map=device_map,
+        torch_dtype=torch_dtype,
+        low_cpu_mem_usage=True
+    )
+
+    _current_model = model
+    _current_tokenizer = tokenizer
+    _current_repo_id = repo_id
+    
+    print(f"Successfully loaded {repo_id} into memory.")
+    return model, tokenizer
+
+# Zero-GPU wraps the execution. We use the gpu_decorator.
+@gpu_decorator
+def generate_local_inference(prompt_text: str, repo_id: str, max_new_tokens: int, temperature: float, top_p: float):
+    """
+    Executes local text generation with streaming capabilities.
+    Works seamlessly on both CPU and Zero-GPU spaces.
+    """
+    model, tokenizer = get_local_model(repo_id)
+    
+    # Check device
+    device = next(model.parameters()).device
+    
+    # Tokenize input
+    inputs = tokenizer(prompt_text, return_tensors="pt").to(device)
+    
+    # Set up streaming iterator
+    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, clean_up_tokenization_spaces=True)
+    
+    # Prepare generation parameters
+    # Adjust temperature constraints (transformers expects temp > 0 if do_sample is True)
+    do_sample = temperature > 0.0
+    gen_kwargs = {
+        "input_ids": inputs["input_ids"],
+        "attention_mask": inputs.get("attention_mask"),
+        "max_new_tokens": max_new_tokens,
+        "temperature": temperature if do_sample else None,
+        "top_p": top_p if do_sample else None,
+        "do_sample": do_sample,
+        "streamer": streamer,
+        "pad_token_id": tokenizer.eos_token_id
+    }
+    
+    # Run in a background thread to allow streaming
+    from threading import Thread
+    thread = Thread(target=model.generate, kwargs=gen_kwargs)
+    thread.start()
+    
+    # Yield tokens as they arrive
+    generated_text = ""
+    for new_text in streamer:
+        generated_text += new_text
+        yield generated_text
+        
+    thread.join()
+
+def run_serverless_api_inference(messages: list, repo_id: str, max_new_tokens: int, temperature: float, top_p: float, hf_token: str = None):
+    """
+    Runs text generation via HF Serverless Inference API client.
+    Streams tokens in real time.
+    """
+    # Retrieve token from environment variables if not provided explicitly
+    token = hf_token or os.environ.get("HF_TOKEN")
+    
+    # Initialize Client
+    client = InferenceClient(model=repo_id, token=token)
+    
+    generated_text = ""
+    try:
+        response_stream = client.chat_completion(
+            messages=messages,
+            max_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            stream=True
+        )
+        
+        for chunk in response_stream:
+            content = chunk.choices[0].delta.content
+            if content:
+                generated_text += content
+                yield generated_text
+    except Exception as e:
+        error_msg = f"Serverless API Error: {str(e)}\n\n"
+        if not token:
+            error_msg += "💡 Tip: Many models require a valid Hugging Face Token for serverless inference. Please enter your HF Token in the sidebar panel."
+        yield error_msg
+
+def build_prompt_with_history(messages: list, system_prompt: str, tokenizer=None) -> str:
+    """
+    Formats the conversation history using standard chat templates.
+    """
+    formatted_messages = [{"role": "system", "content": system_prompt}] + messages
+    
+    if tokenizer is not None and hasattr(tokenizer, "apply_chat_template"):
+        try:
+            return tokenizer.apply_chat_template(formatted_messages, tokenize=False, add_generation_prompt=True)
+        except Exception:
+            pass
+            
+    # Fallback to general formatting if template is unavailable
+    prompt_str = ""
+    for msg in formatted_messages:
+        role = msg["role"]
+        content = msg["content"]
+        if role == "system":
+            prompt_str += f"<|im_start|>system\n{content}<|im_end|>\n"
+        elif role == "user":
+            prompt_str += f"<|im_start|>user\n{content}<|im_end|>\n"
+        elif role == "assistant":
+            prompt_str += f"<|im_start|>assistant\n{content}<|im_end|>\n"
+    prompt_str += "<|im_start|>assistant\n"
+    return prompt_str
+
+def format_thinking_tags(text: str) -> str:
+    """
+    Replaces model <thinking></thinking> tags with clean, modern HTML Details panels
+    for premium rendering in the Gradio chat viewport.
+    """
+    if "<thinking>" in text:
+        parts = text.split("<thinking>", 1)
+        before_thinking = parts[0]
+        rest = parts[1]
+        
+        if "</thinking>" in rest:
+            thinking_parts = rest.split("</thinking>", 1)
+            thinking_content = thinking_parts[0]
+            after_thinking = thinking_parts[1]
+            return f"{before_thinking}<details class='thinking-block'><summary>Thought Process</summary>\n\n{thinking_content.strip()}\n\n</details>\n\n{after_thinking}"
+        else:
+            # Thinking block is still generating, render it open
+            return f"{before_thinking}<details open class='thinking-block'><summary>Thinking Process...</summary>\n\n{rest.strip()}\n\n</details>"
+    return text
+
+def execute_chat(
+    message: str,
+    history: list,
+    mode: str,
+    model_name: str,
+    system_prompt_preset: str,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+    enable_search: bool,
+    hf_token: str
+):
+    """
+    Orchestrates the chat request, performs search if toggled, builds the history,
+    and runs inference on the selected backend mode (Local CPU, Zero-GPU, or API).
+    """
+    # 1. Look up the repo_id from configs
+    repo_id = None
+    for item in MODEL_CONFIGS.get(mode, []):
+        if item["name"] == model_name:
+            repo_id = item["repo_id"]
+            break
+            
+    if not repo_id:
+        yield history + [[message, "Configuration Error: Selected model details not found."]], ""
+        return
+
+    # 2. Handle web search if enabled
+    search_context = ""
+    status_update = ""
+    
+    if enable_search:
+        status_update = f"🔍 Searching web for: '{message}'...\n"
+        yield history + [[message, status_update]], ""
+        
+        results = web_search(message, max_results=3)
+        if results:
+            status_update += f"📄 Scraped {len(results)} relevant web sources. Integrating context...\n"
+            yield history + [[message, status_update]], ""
+            
+            # Scrape details from the top result to enrich context
+            top_url = results[0]["url"]
+            scraped_content = scrape_url(top_url, max_chars=3000)
+            
+            # Format combined search results
+            search_context = format_search_results_for_prompt(message, results)
+            search_context += f"\nDetailed body scraped from source [1] ({top_url}):\n{scraped_content}\n---\n"
+        else:
+            status_update += "❌ Web search returned no results. Proceeding with model knowledge...\n"
+            yield history + [[message, status_update]], ""
+            time.sleep(1)
+
+    # 3. Compile history into standard Gradio message formats
+    chat_messages = []
+    for user_msg, bot_msg in history:
+        # If the bot response has status logs from web search, strip them so LLM doesn't read them as its own words
+        clean_bot_msg = bot_msg
+        if "🔍 Searching web" in bot_msg:
+            # Split and get the text after the final status separator if it exists
+            parts = bot_msg.split("---\n")
+            if len(parts) > 1:
+                clean_bot_msg = parts[-1]
+            else:
+                # Fallback if structure is different
+                clean_bot_msg = bot_msg.split("\n")[-1]
+        
+        chat_messages.append({"role": "user", "content": user_msg})
+        chat_messages.append({"role": "assistant", "content": clean_bot_msg})
+
+    # Prepare active prompt contents
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    compiled_system_prompt = system_prompt_preset.format(datetime=current_time)
+    
+    # Prepend search context to user query if found
+    if search_context:
+        user_query_content = f"{search_context}User Query: {message}"
+    else:
+        user_query_content = message
+        
+    chat_messages.append({"role": "user", "content": user_query_content})
+
+    # 4. Invoke inference backend
+    if mode == "HF Serverless API (Zero Overhead)":
+        # Stream response from API
+        api_stream = run_serverless_api_inference(
+            messages=chat_messages,
+            repo_id=repo_id,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            hf_token=hf_token
+        )
+        
+        for partial_text in api_stream:
+            formatted_text = format_thinking_tags(partial_text)
+            full_response = status_update + formatted_text if status_update else formatted_text
+            yield history + [[message, full_response]], ""
+            
+    else:
+        # Local CPU or Zero-GPU mode
+        # Load local tokenizer (temporarily to build prompt or load model)
+        # Note: loading tokenizer is fast and lightweight
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(repo_id)
+        except Exception:
+            tokenizer = None
+            
+        prompt_text = build_prompt_with_history(chat_messages, compiled_system_prompt, tokenizer)
+        
+        # Free up variables
+        del tokenizer
+        
+        local_stream = generate_local_inference(
+            prompt_text=prompt_text,
+            repo_id=repo_id,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p
+        )
+        
+        for partial_text in local_stream:
+            formatted_text = format_thinking_tags(partial_text)
+            full_response = status_update + formatted_text if status_update else formatted_text
+            yield history + [[message, full_response]], ""

src/tools.py

@@ -0,0 +1,98 @@
+import re
+import urllib.parse
+import requests
+from bs4 import BeautifulSoup
+import html2text
+from duckduckgo_search import DDGS
+
+# Standard browser headers to avoid getting blocked by websites
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Referer": "https://www.google.com/"
+}
+
+def clean_text(text: str) -> str:
+    """Cleans excess whitespace and formats text nicely."""
+    # Replace multiple newlines/spaces with single ones
+    text = re.sub(r'\n+', '\n', text)
+    text = re.sub(r' +', ' ', text)
+    return text.strip()
+
+def web_search(query: str, max_results: int = 3) -> list:
+    """
+    Searches DuckDuckGo and returns a list of dictionaries with titles, hrefs, and body snippets.
+    Falls back gracefully if the search fails.
+    """
+    try:
+        results = []
+        with DDGS() as ddgs:
+            for r in ddgs.text(query, max_results=max_results):
+                results.append({
+                    "title": r.get("title", "No Title"),
+                    "url": r.get("href", ""),
+                    "snippet": r.get("body", "")
+                })
+        return results
+    except Exception as e:
+        print(f"Error during DuckDuckGo search: {e}")
+        return []
+
+def scrape_url(url: str, max_chars: int = 4000) -> str:
+    """
+    Fetches the web page content and converts it to clean markdown.
+    Truncates the output to fit context windows.
+    """
+    if not url.startswith("http"):
+        return "Invalid URL format."
+
+    try:
+        response = requests.get(url, headers=HEADERS, timeout=8)
+        if response.status_code != 200:
+            return f"Failed to retrieve page. Status code: {response.status_code}"
+
+        # Detect and convert content
+        content_type = response.headers.get('Content-Type', '').lower()
+        if 'text/html' not in content_type:
+            return f"Scraping is limited to HTML content. Content-Type received: {content_type}"
+
+        # Initialize html2text converter
+        h = html2text.HTML2Text()
+        h.ignore_links = False
+        h.ignore_images = True
+        h.ignore_emphasis = False
+        h.body_width = 0  # Wrap lines at infinity
+
+        # Extract HTML
+        html = response.text
+        markdown_content = h.handle(html)
+        
+        # Clean text
+        markdown_content = clean_text(markdown_content)
+        
+        if len(markdown_content) > max_chars:
+            return markdown_content[:max_chars] + "\n\n... [Content Truncated due to size constraints] ..."
+        
+        return markdown_content
+
+    except requests.exceptions.Timeout:
+        return "Scraping error: Connection timed out."
+    except Exception as e:
+        return f"Scraping error occurred: {str(e)}"
+
+def format_search_results_for_prompt(query: str, search_results: list) -> str:
+    """Formats search results and snippets into a structured text context block."""
+    if not search_results:
+        return "No search results returned for the query."
+
+    context = f"### WEB SEARCH RESULTS FOR: '{query}'\n"
+    context += "Below are relevant snippets retrieved from the web. Use these to formulate a factually correct answer:\n\n"
+    
+    for idx, res in enumerate(search_results, 1):
+        context += f"Source [{idx}]: {res['title']}\n"
+        context += f"URL: {res['url']}\n"
+        context += f"Snippet: {res['snippet']}\n\n"
+        
+    context += "---\n"
+    return context

src/ui.py

@@ -0,0 +1,289 @@
+import gradio as gr
+import torch
+from src.config import MODEL_CONFIGS, SYSTEM_PROMPT, CLAUDE_CSS
+from src.engine import execute_chat, HAS_SPACES
+
+def get_hardware_status():
+    """Returns a user-friendly string indicating the current runtime hardware."""
+    if HAS_SPACES:
+        return "🟢 Hugging Face Zero-GPU (A100 Dynamic Allocation)"
+    elif torch.cuda.is_available():
+        return f"🟢 Local GPU: {torch.cuda.get_device_name(0)}"
+    else:
+        return "⚪ Standard CPU Mode (Free Tier)"
+
+def update_model_dropdown(mode):
+    """Updates the model choice list when the backend mode is toggled."""
+    models = [m["name"] for m in MODEL_CONFIGS[mode]]
+    default_model = next(m["name"] for m in MODEL_CONFIGS[mode] if m["default"])
+    return gr.Dropdown(choices=models, value=default_model, label="Active Model")
+
+def add_user_message(message, history):
+    """Adds the user message to the chat container and clears the input box."""
+    if not message.strip():
+        return "", history
+    return "", history + [[message, "⏳ Initializing inference engine..."]]
+
+def execute_chat_ui(
+    history,
+    mode,
+    model_name,
+    system_prompt_preset,
+    max_new_tokens,
+    temperature,
+    top_p,
+    enable_search,
+    hf_token
+):
+    """
+    UI Wrapper that processes the active chatbot history state,
+    runs the backend generator, and streams response updates.
+    """
+    if not history:
+        return
+        
+    # Extract latest user message and the history preceding it
+    user_message = history[-1][0]
+    past_history = history[:-1]
+    
+    # Run chat execution generator
+    chat_generator = execute_chat(
+        message=user_message,
+        history=past_history,
+        mode=mode,
+        model_name=model_name,
+        system_prompt_preset=system_prompt_preset,
+        max_new_tokens=max_new_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        enable_search=enable_search,
+        hf_token=hf_token
+    )
+    
+    for updated_history, _ in chat_generator:
+        yield updated_history
+
+def build_interface():
+    """Constructs the Gradio user interface using custom styles and themes."""
+    # Custom light/dark theme initialization
+    theme = gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="slate",
+        neutral_hue="slate",
+        font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
+        font_mono=[gr.themes.GoogleFont("Roboto Mono"), "ui-monospace", "SFMono-Regular", "monospace"]
+    ).set(
+        body_background_fill="#0b0f19",
+        body_background_fill_dark="#0b0f19",
+        block_background_fill="rgba(17, 24, 39, 0.5)",
+        block_background_fill_dark="rgba(17, 24, 39, 0.5)",
+        border_color_primary="rgba(255, 255, 255, 0.08)",
+        border_color_primary_dark="rgba(255, 255, 255, 0.08)"
+    )
+
+    with gr.Blocks(theme=theme, css=CLAUDE_CSS, title="Antigravity Chat") as demo:
+        # State to store the raw message during submission sequence
+        
+        with gr.Row():
+            with gr.Column(scale=12):
+                gr.HTML(
+                    """
+                    <div style="text-align: center; margin-bottom: 24px; margin-top: 10px;">
+                        <h1 style="font-size: 2.8em; margin-bottom: 5px; background: linear-gradient(90deg, #60a5fa, #a78bfa); -webkit-background-clip: text; -webkit-text-fill-color: transparent;">
+                            ANTIGRAVITY CHAT
+                        </h1>
+                        <p style="font-size: 1.1em; color: #9ca3af; max-width: 600px; margin: 0 auto;">
+                            A premium Claude-style chatbot environment designed for Hugging Face free tier.
+                            Equipped with real-time web search, page scraping, and cognitive system reasoning.
+                        </p>
+                    </div>
+                    """
+                )
+
+        with gr.Row():
+            # Side Control Panel (Sidebar)
+            with gr.Column(scale=3, elem_classes=["sidebar-panel"]):
+                gr.Markdown("### ⚙️ System Settings")
+                
+                hardware_text = get_hardware_status()
+                gr.HTML(
+                    f"""
+                    <div style="font-size: 0.85em; padding: 8px 12px; background-color: rgba(255,255,255,0.03); border-radius: 8px; border: 1px solid rgba(255,255,255,0.05); margin-bottom: 15px;">
+                        <span style="color: #9ca3af;">Host Hardware:</span><br/>
+                        <strong style="color: #38bdf8;">{hardware_text}</strong>
+                    </div>
+                    """
+                )
+                
+                # Mode selection
+                mode_dropdown = gr.Dropdown(
+                    choices=list(MODEL_CONFIGS.keys()),
+                    value="Local CPU (Lightweight)",
+                    label="Inference Backend Mode",
+                    interactive=True
+                )
+                
+                # Model selection (changes dynamically based on mode)
+                model_choices = [m["name"] for m in MODEL_CONFIGS["Local CPU (Lightweight)"]]
+                default_model = next(m["name"] for m in MODEL_CONFIGS["Local CPU (Lightweight)"] if m["default"])
+                
+                model_dropdown = gr.Dropdown(
+                    choices=model_choices,
+                    value=default_model,
+                    label="Active Model",
+                    interactive=True
+                )
+                
+                # Web Search Toggle
+                enable_search = gr.Checkbox(
+                    label="🔍 Enable Web Search (DuckDuckGo)",
+                    value=False,
+                    interactive=True
+                )
+                
+                # Token field (hidden input for HF Serverless inference token)
+                hf_token = gr.Textbox(
+                    label="Hugging Face API Token (optional)",
+                    placeholder="hf_...",
+                    type="password",
+                    info="Required for gated Serverless models (e.g. Llama 3.3). Get one at hf.co/settings/tokens"
+                )
+                
+                # Advanced Settings Accordion
+                with gr.Accordion("🛠️ Advanced Parameters", open=False):
+                    system_prompt = gr.Textbox(
+                        label="System Instruction Prompt",
+                        value=SYSTEM_PROMPT,
+                        lines=8,
+                        max_lines=15
+                    )
+                    
+                    max_tokens = gr.Slider(
+                        minimum=64,
+                        maximum=4096,
+                        value=1024,
+                        step=64,
+                        label="Max New Tokens"
+                    )
+                    
+                    temperature = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.2,
+                        value=0.7,
+                        step=0.1,
+                        label="Temperature (0.0 = deterministic)"
+                    )
+                    
+                    top_p = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.9,
+                        step=0.05,
+                        label="Top-P Sampling"
+                    )
+                
+                # System actions
+                clear_btn = gr.Button("🗑️ Clear Chat History", variant="secondary", elem_classes=["secondary-btn"])
+            
+            # Main Chat Area
+            with gr.Column(scale=9):
+                chatbot = gr.Chatbot(
+                    label="Chat Window",
+                    elem_classes=["chatbot-container"],
+                    show_label=False,
+                    avatar_images=(None, "https://huggingface.co/front/assets/huggingface_logo-noborder.svg"),
+                    height=580,
+                    bubble_full_width=False
+                )
+                
+                with gr.Row():
+                    input_box = gr.Textbox(
+                        placeholder="Ask Antigravity anything... (e.g., 'What happened in AI news this week?' with search on)",
+                        show_label=False,
+                        scale=10
+                    )
+                    submit_btn = gr.Button("Send", variant="primary", scale=1, elem_classes=["action-btn"])
+
+                # Prompts suggestions
+                gr.Markdown("💡 **Quick Prompts**")
+                with gr.Row():
+                    suggestion_1 = gr.Button("Draft a clean Python function using asyncio to scrape web data.", variant="secondary", elem_classes=["secondary-btn"])
+                    suggestion_2 = gr.Button("Search the web for the latest advancements in LLM reasoning models.", variant="secondary", elem_classes=["secondary-btn"])
+                    suggestion_3 = gr.Button("Explain quantum computing superposition using a simple real-life analogy.", variant="secondary", elem_classes=["secondary-btn"])
+
+        # Define UI event linkages
+        
+        # 1. Mode dropdown change updates the Model selection dropdown options
+        mode_dropdown.change(
+            fn=update_model_dropdown,
+            inputs=[mode_dropdown],
+            outputs=[model_dropdown]
+        )
+        
+        # 2. Main submit event chain (for Enter key submit)
+        submit_event = input_box.submit(
+            fn=add_user_message,
+            inputs=[input_box, chatbot],
+            outputs=[input_box, chatbot],
+            queue=False
+        ).then(
+            fn=execute_chat_ui,
+            inputs=[
+                chatbot,
+                mode_dropdown,
+                model_dropdown,
+                system_prompt,
+                max_tokens,
+                temperature,
+                top_p,
+                enable_search,
+                hf_token
+            ],
+            outputs=[chatbot]
+        )
+        
+        # 3. Submit button click event chain
+        click_event = submit_btn.click(
+            fn=add_user_message,
+            inputs=[input_box, chatbot],
+            outputs=[input_box, chatbot],
+            queue=False
+        ).then(
+            fn=execute_chat_ui,
+            inputs=[
+                chatbot,
+                mode_dropdown,
+                model_dropdown,
+                system_prompt,
+                max_tokens,
+                temperature,
+                top_p,
+                enable_search,
+                hf_token
+            ],
+            outputs=[chatbot]
+        )
+        
+        # 4. Clear chat history button event
+        clear_btn.click(fn=lambda: None, outputs=chatbot, queue=False)
+        
+        # 5. Suggestion prompt buttons click events
+        def load_suggestion(text):
+            # When clicked, populate textbox, enable web search if query implies it
+            search_enabled = "Search the web" in text or "latest advancements" in text
+            return text, gr.update(value=search_enabled)
+
+        suggestion_1.click(
+            fn=lambda: load_suggestion("Draft a clean Python function using asyncio to scrape web data."),
+            outputs=[input_box, enable_search]
+        )
+        suggestion_2.click(
+            fn=lambda: load_suggestion("Search the web for the latest advancements in LLM reasoning models."),
+            outputs=[input_box, enable_search]
+        )
+        suggestion_3.click(
+            fn=lambda: load_suggestion("Explain quantum computing superposition using a simple real-life analogy."),
+            outputs=[input_box, enable_search]
+        )
+
+    return demo