new

.env.example

@@ -1,22 +1,8 @@
-# AI Coding Assistant - Environment Configuration
-
-# Backend Server Configuration
 PORT=8000
 HOST=0.0.0.0
 DEBUG=false
-CORS_ORIGINS=http://localhost:5173,http://localhost:3000,https://*.railway.app,https://*.render.com
-
-# SmolLM2 Model Settings
 LOCAL_MODEL_PATH=models/SmolLM2-360M-Instruct-Q4_K_M.gguf
-LOCAL_MODEL_REPO=bartowski/SmolLM2-360M-Instruct-GGUF
-LOCAL_MODEL_FILE=SmolLM2-360M-Instruct-Q4_K_M.gguf
-
-# Generation Parameters
 DEFAULT_TEMPERATURE=0.7
-DEFAULT_MAX_TOKENS=1024
+DEFAULT_MAX_TOKENS=512
 DEFAULT_TOP_P=0.9
-DEFAULT_CONTEXT_LENGTH=2048
-
-# Security & Limits
-RATE_LIMIT_PER_MINUTE=60
-SECRET_KEY=generate_a_secure_random_key_here
+DEFAULT_CONTEXT_LENGTH=512

.gitattributes

@@ -1,2 +0,0 @@
-*.gguf filter=lfs diff=lfs merge=lfs -text
-models/*.gguf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,52 +1,27 @@
-# Stage 1: Build React Frontend
-FROM node:20-slim as frontend-builder
-
+# Stage 1: Build frontend
+FROM node:20-alpine AS frontend-builder
 WORKDIR /frontend
-
-# Copy package config and lock files
 COPY frontend/package*.json ./
-
-# Install packages
 RUN npm ci
-
-# Copy frontend source files
 COPY frontend/ ./
-
-# Build production static bundle
 RUN npm run build
 
-# Stage 2: Build Python Backend & Package app
+# Stage 2: Build backend
 FROM python:3.11-slim
-
 WORKDIR /app
 
-# Install compilation tools for building llama-cpp-python in backend
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    gcc \
-    g++ \
-    make \
-    python3-dev \
-    git \
     libgomp1 \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements and install dependencies
 COPY backend/requirements.txt ./backend/
-RUN pip install --no-cache-dir -r ./backend/requirements.txt
+RUN pip install --no-cache-dir --only-binary :all: -r ./backend/requirements.txt
 
-# Copy backend source code
 COPY backend/ ./backend/
-
-# Copy static frontend build from Stage 1 into frontend/dist
 COPY --from=frontend-builder /frontend/dist ./frontend/dist
 
-# Setup environments
-ENV PORT=8000
-ENV HOST=0.0.0.0
-ENV PYTHONPATH=/app
+ENV PORT=8000 HOST=0.0.0.0 PYTHONPATH=/app
 
 EXPOSE 8000
 
-# Start unified server
-CMD ["python", "backend/run.py"]
+CMD ["python", "-m", "uvicorn", "backend.app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,107 +0,0 @@
-# Antigravity AI Coding Assistant ⚡
-
-A production-ready, resource-optimized, containerized AI Coding Assistant using **Qwen2.5-Coder-0.5B-Instruct** as its core engine. Built with a Python FastAPI backend and a stunning dark-theme React + Vite + TypeScript frontend.
-
-```mermaid
-graph TD
-    User([User]) <--> |HTTP / SSE| FE[React SPA - Vite + TS]
-    subgraph Backend [FastAPI Server]
-        API[API Endpoints] <--> MGR[LLM Manager]
-        MGR --> |Check RAM / Models| Decision{Load Local GGUF?}
-        Decision -->|Yes: RAM >= 1.5GB| GGUF[Local llama-cpp-python]
-        Decision -->|No: Low memory / Failed| HF[Hugging Face Cloud API]
-    end
-    GGUF <--> |Read / Write| Models[(models/ folder)]
-    HF <--> |HTTPS Request| HFHub[Hugging Face Inference Hub]
-```
-
----
-
-## 🌟 Key Features
-
-* **Cascading Fallback Pipeline:** Automatically runs local Qwen GGUF inference. If RAM is constrained (e.g. Render Free, Railway Starter), it transparently falls back to Hugging Face serverless API.
-* **Interactive Code Playground:** Features Monaco Editor (VS Code core) with language syntax highlight selectors and quick AI commands (`Explain`, `Find Bugs`, `Refactor`, `Generate Tests`, `Summarize`).
-* **Advanced Chat Window:** Smooth response streaming (Server-Sent Events), code block copy buttons, and drag-and-drop file imports.
-* **Production Deployment Ready:** Pre-configured Dockerfiles, Docker Compose, Railway config, and Render deployment specifications.
-* **Performance Telemetry:** Live dashboards displaying generation speed (tokens/sec), latency, request tallies, and RAM footprint.
-
----
-
-## 🛠️ Tech Stack
-
-* **Frontend:** React 19, Vite, TypeScript, Tailwind CSS, Monaco Editor, Lucide Icons, Framer Motion
-* **Backend:** FastAPI, Python 3.11+, Uvicorn, llama-cpp-python, Hugging Face Hub Client, Psutil
-
----
-
-## 🚀 Quick Start (Local Setup)
-
-### Prerequisites
-* Python 3.11+
-* Node.js 20+
-
-### Step 1: Clone and Setup Workspace
-Clone this repository and navigate to the project directory:
-```bash
-git clone https://github.com/your-repo/antigravity-coder.git
-cd antigravity-coder
-```
-
-### Step 2: Install and Download GGUF Model
-Use our automated installer script:
-```bash
-# On Linux/macOS
-chmod +x scripts/setup.sh
-./scripts/setup.sh
-
-# On Windows (PowerShell)
-pip install -r backend/requirements.txt
-cd frontend; npm install; npm run build; cd ..
-python scripts/download_model.py
-```
-
-### Step 3: Run the Application
-Start the backend server:
-```bash
-# Run backend (activates virtual env if created)
-python backend/run.py
-```
-This runs the API server on `http://localhost:8000` and automatically compiles & hosts the React frontend assets. Navigate to [http://localhost:8000](http://localhost:8000) to view the application!
-
-For hot-reloading frontend development:
-```bash
-cd frontend
-npm run dev
-```
-Open [http://localhost:5173](http://localhost:5173) in your browser.
-
----
-
-## 🐳 Running with Docker
-
-Run both services in hot-reloading development mode using Docker Compose:
-```bash
-docker compose -f docker/docker-compose.yml up --build
-```
-Build and run the production-ready unified container (hosting both frontend and API on port 8000):
-```bash
-docker build -t antigravity-coder .
-docker run -p 8000:8000 antigravity-coder
-```
-
----
-
-## 🌐 Cloud Deployment
-
-Detailed step-by-step guides for deployment configurations:
-* [Railway Deployment Guide](docs/DEPLOYMENT.md#railway)
-* [Render Deployment Guide](docs/DEPLOYMENT.md#render)
-* [API Reference Documentation](docs/API.md)
-
----
-
-## 🔒 Security
-
-* Standard CORS origin protections.
-* Secure in-memory sliding rate limiter per client IP.
-* Configuration parsing using Pydantic Settings from `.env` files. Secrets are never hardcoded.

backend/app/config.py

@@ -1,57 +1,18 @@
-import os
-from typing import List
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from pydantic import Field
 
 class Settings(BaseSettings):
-    # Server settings
-    PORT: int = Field(default=8000, validation_alias="PORT")
-    HOST: str = Field(default="0.0.0.0", validation_alias="HOST")
-    DEBUG: bool = Field(default=False, validation_alias="DEBUG")
-    CORS_ORIGINS: str = Field(
-        default="http://localhost:5173,http://localhost:3000,http://localhost:8000",
-        validation_alias="CORS_ORIGINS"
-    )
+    PORT: int = Field(default=8000)
+    HOST: str = Field(default="0.0.0.0")
+    DEBUG: bool = Field(default=False)
 
-    # LLM Settings
-    INFERENCE_MODE: str = Field(default="local", validation_alias="INFERENCE_MODE")
+    LOCAL_MODEL_PATH: str = Field(default="models/SmolLM2-360M-Instruct-Q4_K_M.gguf")
 
-    # Local GGUF Settings
-    LOCAL_MODEL_PATH: str = Field(
-        default="models/SmolLM2-360M-Instruct-Q4_K_M.gguf",
-        validation_alias="LOCAL_MODEL_PATH"
-    )
-    LOCAL_MODEL_REPO: str = Field(
-        default="bartowski/SmolLM2-360M-Instruct-GGUF",
-        validation_alias="LOCAL_MODEL_REPO"
-    )
-    LOCAL_MODEL_FILE: str = Field(
-        default="SmolLM2-360M-Instruct-Q4_K_M.gguf",
-        validation_alias="LOCAL_MODEL_FILE"
-    )
+    DEFAULT_TEMPERATURE: float = Field(default=0.7)
+    DEFAULT_MAX_TOKENS: int = Field(default=512)
+    DEFAULT_TOP_P: float = Field(default=0.9)
+    DEFAULT_CONTEXT_LENGTH: int = Field(default=512)
 
-    # Generation Defaults
-    DEFAULT_TEMPERATURE: float = Field(default=0.7, validation_alias="DEFAULT_TEMPERATURE")
-    DEFAULT_MAX_TOKENS: int = Field(default=1024, validation_alias="DEFAULT_MAX_TOKENS")
-    DEFAULT_TOP_P: float = Field(default=0.9, validation_alias="DEFAULT_TOP_P")
-    DEFAULT_CONTEXT_LENGTH: int = Field(default=2048, validation_alias="DEFAULT_CONTEXT_LENGTH")
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
 
-    # Security / Limits
-    RATE_LIMIT_PER_MINUTE: int = Field(default=60, validation_alias="RATE_LIMIT_PER_MINUTE")
-    SECRET_KEY: str = Field(
-        default="dev-secret-key-must-be-changed-in-production-environments!",
-        validation_alias="SECRET_KEY"
-    )
-
-    @property
-    def cors_origins_list(self) -> List[str]:
-        return [origin.strip() for origin in self.CORS_ORIGINS.split(",") if origin.strip()]
-
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        extra="ignore"
-    )
-
-# Instantiate singleton settings
 settings = Settings()

backend/app/llm/local.py

@@ -1,5 +1,4 @@
 import os
-import sys
 import logging
 import asyncio
 from typing import AsyncIterator, List, Dict, Any, Optional
@@ -8,12 +7,10 @@ from backend.app.config import settings
 
 logger = logging.getLogger(__name__)
 
-# Safe imports for environment portability
 try:
     from llama_cpp import Llama
 except ImportError:
     Llama = None
-    logger.warning("llama-cpp-python is not installed. Local inference will be unavailable.")
 
 class LocalLLMProvider(BaseLLMProvider):
     def __init__(self):
@@ -25,144 +22,111 @@ class LocalLLMProvider(BaseLLMProvider):
     async def initialize(self) -> bool:
         if self.initialized:
             return True
-
         if Llama is None:
-            logger.error("Cannot initialize LocalLLMProvider: llama-cpp-python not installed.")
+            logger.error("llama-cpp-python not installed.")
             return False
-
         if not os.path.exists(self.model_path):
-            logger.error(f"Local GGUF model file not found at: {self.model_path}")
+            logger.error(f"Model not found: {self.model_path}")
             return False
 
         try:
-            # Determine thread count (default to CPU cores minus 1, min 1)
             threads = max(1, (os.cpu_count() or 2) - 1)
-            
-            logger.info(f"Loading local model from {self.model_path} with {threads} threads and context {self.context_length}...")
-            
-            # Since loading the model blocks, run it in a separate thread to keep event loop active
+            logger.info(
+                f"Loading model: {self.model_path} | "
+                f"ctx={self.context_length} threads={threads} "
+                f"mmap=true mlock=false n_batch=8"
+            )
+
             def load_model():
                 return Llama(
                     model_path=self.model_path,
                     n_ctx=self.context_length,
                     n_threads=threads,
-                    verbose=settings.DEBUG
+                    n_batch=8,
+                    use_mmap=True,
+                    use_mlock=False,
+                    verbose=False,
                 )
-            
+
             self.llm = await asyncio.to_thread(load_model)
             self.initialized = True
-            logger.info("Local model successfully loaded!")
+
+            model_size_mb = os.path.getsize(self.model_path) / (1024 * 1024)
+            logger.info(f"Model loaded ({model_size_mb:.0f}MB on disk, "
+                        f"memory-mapped: ~{model_size_mb * 0.1:.0f}MB RSS per active page)")
             return True
         except Exception as e:
-            logger.error(f"Failed to load local model: {e}", exc_info=True)
+            logger.error(f"Failed to load model: {e}")
             self.initialized = False
             self.llm = None
             return False
 
-    def _format_prompt(self, prompt: str, system_prompt: Optional[str] = None, messages: Optional[List[Dict[str, str]]] = None) -> str:
-        # Build standard Qwen ChatML prompt format
+    def _format_prompt(self, prompt: str, system_prompt: Optional[str] = None,
+                       messages: Optional[List[Dict[str, str]]] = None) -> str:
         formatted = ""
-        
-        # Determine system prompt
-        sys_p = system_prompt or "You are Qwen, a helpful, precise, and state-of-the-art AI programming assistant."
-        
-        # Check if messages already contain a system prompt
+        sys_p = system_prompt or "You are a helpful AI coding assistant."
         has_system = any(m.get("role") == "system" for m in messages) if messages else False
         if not has_system:
             formatted += f"<|im_start|>system\n{sys_p}<|im_end|>\n"
-            
         if messages:
             for msg in messages:
-                role = msg.get("role", "user")
-                content = msg.get("content", "")
-                formatted += f"<|im_start|>{role}\n{content}<|im_end|>\n"
+                formatted += f"<|im_start|>{msg['role']}\n{msg['content']}<|im_end|>\n"
         else:
-            # If no chat history is provided, construct a simple message pair
             formatted += f"<|im_start|>user\n{prompt}<|im_end|>\n"
-            
         formatted += "<|im_start|>assistant\n"
         return formatted
 
-    async def generate(
-        self, 
-        prompt: str, 
-        system_prompt: Optional[str] = None,
-        messages: Optional[List[Dict[str, str]]] = None,
-        temperature: float = 0.7,
-        max_tokens: int = 1024,
-        top_p: float = 0.9,
-    ) -> Dict[str, Any]:
+    async def generate(self, prompt: str, system_prompt: Optional[str] = None,
+                       messages: Optional[List[Dict[str, str]]] = None,
+                       temperature: float = 0.7, max_tokens: int = 512,
+                       top_p: float = 0.9) -> Dict[str, Any]:
         if not await self.initialize():
-            raise RuntimeError("Local LLM provider is not initialized.")
-
-        formatted_prompt = self._format_prompt(prompt, system_prompt, messages)
-        
-        def run_inference():
-            return self.llm(
-                prompt=formatted_prompt,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                top_p=top_p,
-                stop=["<|im_end|>", "<|im_start|>", "im_end", "im_start"],
-            )
+            raise RuntimeError("Local LLM not initialized.")
+        formatted = self._format_prompt(prompt, system_prompt, messages)
+
+        def run():
+            return self.llm(prompt=formatted, max_tokens=max_tokens,
+                            temperature=temperature, top_p=top_p,
+                            stop=["<|im_end|>", "<|im_start|>"])
 
-        response = await asyncio.to_thread(run_inference)
-        
-        content = response["choices"][0]["text"]
-        prompt_tokens = response["usage"]["prompt_tokens"]
-        completion_tokens = response["usage"]["completion_tokens"]
-        
+        response = await asyncio.to_thread(run)
         return {
-            "content": content,
+            "content": response["choices"][0]["text"],
             "usage": {
-                "prompt_tokens": prompt_tokens,
-                "completion_tokens": completion_tokens,
-                "total_tokens": prompt_tokens + completion_tokens
+                "prompt_tokens": response["usage"]["prompt_tokens"],
+                "completion_tokens": response["usage"]["completion_tokens"],
+                "total_tokens": response["usage"]["prompt_tokens"] + response["usage"]["completion_tokens"]
             }
         }
 
-    async def generate_stream(
-        self, 
-        prompt: str,
-        system_prompt: Optional[str] = None,
-        messages: Optional[List[Dict[str, str]]] = None,
-        temperature: float = 0.7,
-        max_tokens: int = 1024,
-        top_p: float = 0.9,
-    ) -> AsyncIterator[str]:
+    async def generate_stream(self, prompt: str, system_prompt: Optional[str] = None,
+                              messages: Optional[List[Dict[str, str]]] = None,
+                              temperature: float = 0.7, max_tokens: int = 512,
+                              top_p: float = 0.9) -> AsyncIterator[str]:
         if not await self.initialize():
-            raise RuntimeError("Local LLM provider is not initialized.")
+            raise RuntimeError("Local LLM not initialized.")
+        formatted = self._format_prompt(prompt, system_prompt, messages)
 
-        formatted_prompt = self._format_prompt(prompt, system_prompt, messages)
-        
-        # Generator for streaming
         def run_stream():
-            return self.llm(
-                prompt=formatted_prompt,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                top_p=top_p,
-                stop=["<|im_end|>", "<|im_start|>", "im_end", "im_start"],
-                stream=True
-            )
-            
+            return self.llm(prompt=formatted, max_tokens=max_tokens,
+                            temperature=temperature, top_p=top_p,
+                            stop=["<|im_end|>", "<|im_start|>"], stream=True)
+
         stream = await asyncio.to_thread(run_stream)
-        
-        async def async_generator():
+
+        async def async_gen():
             for chunk in stream:
                 text = chunk["choices"][0]["text"]
                 if text:
                     yield text
-                    # Yield CPU control to event loop
                     await asyncio.sleep(0)
-                    
-        return async_generator()
+
+        return async_gen()
 
     def get_info(self) -> Dict[str, Any]:
         return {
-            "provider_name": "local",
+            "provider": "local",
             "initialized": self.initialized,
             "model_path": self.model_path,
             "context_length": self.context_length,
-            "device": "CPU"  # Llama.cpp runs on CPU in basic config, can use GPU via CUDA wrappers
         }

backend/app/llm/manager.py

@@ -1,8 +1,6 @@
 import os
 import logging
-import asyncio
 from typing import AsyncIterator, Dict, Any, Optional
-from backend.app.config import settings
 from backend.app.llm.base import BaseLLMProvider
 from backend.app.llm.local import LocalLLMProvider
 
@@ -11,57 +9,15 @@ logger = logging.getLogger(__name__)
 class LLMManager:
     def __init__(self):
         self.provider: Optional[BaseLLMProvider] = None
-        self.is_downloading: bool = False
 
-    async def ensure_model_downloaded(self) -> bool:
-        """Downloads the GGUF model file if not exists."""
-        model_path = os.path.abspath(settings.LOCAL_MODEL_PATH)
-        if os.path.exists(model_path):
-            logger.info(f"Model file already exists at: {model_path}")
-            return True
-
-        # Ensure directory exists
-        os.makedirs(os.path.dirname(model_path), exist_ok=True)
-        
-        self.is_downloading = True
-        logger.info(f"Downloading model {settings.LOCAL_MODEL_FILE} from repo {settings.LOCAL_MODEL_REPO}...")
-        
-        try:
-            from huggingface_hub import hf_hub_download
-            
-            def download_job():
-                return hf_hub_download(
-                    repo_id=settings.LOCAL_MODEL_REPO,
-                    filename=settings.LOCAL_MODEL_FILE,
-                    local_dir=os.path.dirname(model_path),
-                    local_dir_use_symlinks=False
-                )
-            
-            # Download model in background thread to not block the main application loop
-            await asyncio.to_thread(download_job)
-            logger.info("Model download complete!")
-            self.is_downloading = False
-            return True
-        except Exception as e:
-            logger.error(f"Failed to download model automatically: {e}", exc_info=True)
-            self.is_downloading = False
-            return False
-
-    async def setup_provider(self) -> BaseLLMProvider:
-        """
-        Initializes the local LLM provider strictly.
-        """
-        logger.info("Setting up local provider for SmolLM2...")
-        await self.ensure_model_downloaded()
-        
+    async def setup_provider(self):
+        logger.info("Initializing local provider...")
         local = LocalLLMProvider()
-        # Initialize in background, do not raise exception on failure to support diagnostics
         await local.initialize()
         self.provider = local
         return local
 
     async def get_active_provider(self) -> BaseLLMProvider:
-        """Returns the active provider. Lazily initializes if needed."""
         if not self.provider:
             await self.setup_provider()
         return self.provider
@@ -75,15 +31,7 @@ class LLMManager:
         return await p.generate_stream(*args, **kwargs)
 
     async def get_status_info(self) -> Dict[str, Any]:
-        """Returns diagnostic and current provider stats."""
         p = await self.get_active_provider()
-        info = p.get_info()
-        info.update({
-            "configured_mode": "local",
-            "active_mode": "local",
-            "is_downloading": self.is_downloading
-        })
-        return info
+        return p.get_info()
 
-# Instantiate global singleton manager
 llm_manager = LLMManager()

backend/app/main.py

@@ -3,102 +3,57 @@ import time
 import uuid
 import logging
 import asyncio
-import psutil
 from contextlib import asynccontextmanager
 from typing import AsyncGenerator, Dict, Any
 
-from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi import FastAPI, HTTPException, status
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.responses import StreamingResponse
 from fastapi.staticfiles import StaticFiles
 
 from backend.app.config import settings
 from backend.app.models import (
-    ChatRequest, ChatResponse, ChatResponseChunk,
-    CodeRequest, CompletionRequest, ModelInfoResponse
+    ChatRequest, ChatResponse, CompletionRequest
 )
-from backend.app.middleware import RateLimitMiddleware, LoggingMiddleware
+from backend.app.middleware import LoggingMiddleware
 from backend.app.llm.manager import llm_manager
 from backend.app.utils import (
-    estimate_tokens, format_sse_chunk,
-    get_code_prompt, get_completion_prompt
+    estimate_tokens, format_sse_chunk, get_completion_prompt
 )
 
-# Setup logging configuration
 logging.basicConfig(
     level=logging.INFO if not settings.DEBUG else logging.DEBUG,
     format="%(asctime)s [%(levelname)s] %(name)s - %(message)s"
 )
 logger = logging.getLogger("backend.app.main")
 
-# Metrics memory store
-class SystemMetrics:
-    def __init__(self):
-        self.total_requests = 0
-        self.total_prompt_tokens = 0
-        self.total_completion_tokens = 0
-        self.total_generation_time_sec = 0.0
-
-    def add(self, prompt_tokens: int, completion_tokens: int, duration: float):
-        self.total_requests += 1
-        self.total_prompt_tokens += prompt_tokens
-        self.total_completion_tokens += completion_tokens
-        self.total_generation_time_sec += duration
-
-    def get_metrics_report(self) -> Dict[str, Any]:
-        avg_latency = (
-            self.total_generation_time_sec / self.total_requests 
-            if self.total_requests > 0 else 0.0
-        )
-        return {
-            "total_requests": self.total_requests,
-            "total_prompt_tokens": self.total_prompt_tokens,
-            "total_completion_tokens": self.total_completion_tokens,
-            "total_tokens": self.total_prompt_tokens + self.total_completion_tokens,
-            "average_latency_seconds": round(avg_latency, 4),
-            "total_generation_time_seconds": round(self.total_generation_time_sec, 2)
-        }
-
-metrics = SystemMetrics()
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Model warm-up on startup (non-blocking for fast server boot)
-    logger.info("Initializing LLM Manager and warming up model in the background...")
+    logger.info("Warming up model in background...")
     asyncio.create_task(llm_manager.setup_provider())
     yield
-    # Shutdown operations
-    logger.info("Server shutting down.")
+    logger.info("Shutting down.")
 
-# Main app instantiation
-app = FastAPI(
-    title="AI Coding Assistant API",
-    version="1.0.0",
-    lifespan=lifespan
-)
 
-# Add Middleware
-app.add_middleware(LoggingMiddleware)
-app.add_middleware(RateLimitMiddleware, limit=settings.RATE_LIMIT_PER_MINUTE)
+app = FastAPI(title="Levi AI Coder", version="1.0.0", lifespan=lifespan)
 
+app.add_middleware(LoggingMiddleware)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=settings.cors_origins_list,
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Stream Generator Helper
-async def run_stream_generator(
-    prompt: str,
-    system_prompt: str = None,
-    messages: list = None,
-    temperature: float = 0.7,
-    max_tokens: int = 1024,
+
+async def run_stream(
+    prompt: str, system_prompt: str = None, messages: list = None,
+    temperature: float = 0.7, max_tokens: int = 512,
 ) -> AsyncGenerator[str, None]:
-    start_time = time.time()
-    generated_content = ""
+    start = time.time()
+    generated = ""
     prompt_tokens = estimate_tokens(prompt)
     if messages:
         for m in messages:
@@ -106,212 +61,108 @@ async def run_stream_generator(
 
     try:
         stream = await llm_manager.generate_stream(
-            prompt=prompt,
-            system_prompt=system_prompt,
-            messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens
+            prompt=prompt, system_prompt=system_prompt,
+            messages=messages, temperature=temperature, max_tokens=max_tokens,
         )
-        
         async for chunk in stream:
-            generated_content += chunk
-            # Format SSE yield
-            yield format_sse_chunk(content=chunk, done=False)
-            
-        duration = time.time() - start_time
-        completion_tokens = estimate_tokens(generated_content)
-        metrics.add(prompt_tokens, completion_tokens, duration)
-        
-        # Send final chunk with usage metrics
-        usage_data = {
+            generated += chunk
+            yield format_sse_chunk(content=chunk)
+        duration = time.time() - start
+        completion_tokens = estimate_tokens(generated)
+        yield format_sse_chunk(content="", done=True, usage={
             "prompt_tokens": prompt_tokens,
             "completion_tokens": completion_tokens,
             "total_tokens": prompt_tokens + completion_tokens,
             "duration_ms": int(duration * 1000),
-            "tokens_per_second": round(completion_tokens / duration, 2) if duration > 0 else 0
-        }
-        yield format_sse_chunk(content="", done=True, usage=usage_data)
-        
+            "tokens_per_second": round(completion_tokens / duration, 2) if duration > 0 else 0,
+        })
     except Exception as e:
-        logger.error(f"Error in running streaming generator: {e}")
-        yield format_sse_chunk(content=f"\n[Generation Error: {e}]", done=True)
+        logger.error(f"Stream error: {e}")
+        yield format_sse_chunk(content=f"\n[Error: {e}]", done=True)
+
 
-# Standard Non-Stream Helper
-async def run_standard_generation(
-    prompt: str,
-    system_prompt: str = None,
-    messages: list = None,
-    temperature: float = 0.7,
-    max_tokens: int = 1024,
+async def run_standard(
+    prompt: str, system_prompt: str = None, messages: list = None,
+    temperature: float = 0.7, max_tokens: int = 512,
 ) -> ChatResponse:
-    start_time = time.time()
+    start = time.time()
     try:
-        response_data = await llm_manager.generate(
-            prompt=prompt,
-            system_prompt=system_prompt,
-            messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens
+        result = await llm_manager.generate(
+            prompt=prompt, system_prompt=system_prompt,
+            messages=messages, temperature=temperature, max_tokens=max_tokens,
         )
-        
-        duration = time.time() - start_time
-        usage = response_data.get("usage", {})
-        
-        prompt_tokens = usage.get("prompt_tokens", estimate_tokens(prompt))
-        completion_tokens = usage.get("completion_tokens", estimate_tokens(response_data["content"]))
-        metrics.add(prompt_tokens, completion_tokens, duration)
-        
-        # Build enriched usage dict
-        metrics_dict = {
-            "prompt_tokens": prompt_tokens,
-            "completion_tokens": completion_tokens,
-            "total_tokens": prompt_tokens + completion_tokens,
-            "duration_ms": int(duration * 1000),
-            "tokens_per_second": round(completion_tokens / duration, 2) if duration > 0 else 0
-        }
-        
-        status_info = await llm_manager.get_status_info()
-        
+        duration = time.time() - start
+        usage = result.get("usage", {})
         return ChatResponse(
             id=str(uuid.uuid4()),
-            content=response_data["content"],
-            usage=metrics_dict,
-            model=status_info.get("model_id", status_info.get("model_path", "qwen-0.5b"))
+            content=result["content"],
+            usage={
+                "prompt_tokens": usage.get("prompt_tokens", 0),
+                "completion_tokens": usage.get("completion_tokens", 0),
+                "total_tokens": usage.get("total_tokens", 0),
+                "duration_ms": int(duration * 1000),
+            },
+            model="SmolLM2-360M-Q4_K_M",
         )
     except Exception as e:
-        logger.error(f"Error in standard generation: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e)
-        )
+        logger.error(f"Generation error: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
 
-# API ENDPOINTS
 @app.post("/chat")
 async def chat(request: ChatRequest):
-    messages_list = [m.model_dump() for m in request.messages]
-    
-    # Extract system prompt if present in payload
+    msgs = [m.model_dump() for m in request.messages]
     system_prompt = None
-    user_messages = []
-    for msg in messages_list:
-        if msg["role"] == "system":
-            system_prompt = msg["content"]
+    user_msgs = []
+    for m in msgs:
+        if m["role"] == "system":
+            system_prompt = m["content"]
         else:
-            user_messages.append(msg)
-            
-    # The last user message is the primary prompt
-    last_prompt = user_messages[-1]["content"] if user_messages else ""
+            user_msgs.append(m)
+    last_prompt = user_msgs[-1]["content"] if user_msgs else ""
 
     if request.stream:
         return StreamingResponse(
-            run_stream_generator(
-                prompt=last_prompt,
-                system_prompt=system_prompt,
-                messages=messages_list,
+            run_stream(
+                prompt=last_prompt, system_prompt=system_prompt,
+                messages=msgs,
                 temperature=request.temperature or settings.DEFAULT_TEMPERATURE,
-                max_tokens=request.max_tokens or settings.DEFAULT_MAX_TOKENS
+                max_tokens=request.max_tokens or settings.DEFAULT_MAX_TOKENS,
             ),
-            media_type="text/event-stream"
-        )
-    else:
-        return await run_standard_generation(
-            prompt=last_prompt,
-            system_prompt=system_prompt,
-            messages=messages_list,
-            temperature=request.temperature or settings.DEFAULT_TEMPERATURE,
-            max_tokens=request.max_tokens or settings.DEFAULT_MAX_TOKENS
+            media_type="text/event-stream",
         )
+    return await run_standard(
+        prompt=last_prompt, system_prompt=system_prompt, messages=msgs,
+        temperature=request.temperature or settings.DEFAULT_TEMPERATURE,
+        max_tokens=request.max_tokens or settings.DEFAULT_MAX_TOKENS,
+    )
+
 
 @app.post("/complete")
 async def complete(request: CompletionRequest):
     prompt = get_completion_prompt(request.prefix, request.suffix, request.language or "python")
-    
-    # We want low temperature for completion tasks
-    temp = request.temperature or 0.2
-    max_t = request.max_tokens or 128
-    
     if request.stream:
         return StreamingResponse(
-            run_stream_generator(prompt=prompt, temperature=temp, max_tokens=max_t),
-            media_type="text/event-stream"
+            run_stream(prompt=prompt, temperature=request.temperature or 0.2,
+                       max_tokens=request.max_tokens or 128),
+            media_type="text/event-stream",
         )
-    else:
-        return await run_standard_generation(prompt=prompt, temperature=temp, max_tokens=max_t)
-
-# Helper decorator for modular code API endpoints
-def make_code_endpoint(action: str):
-    async def endpoint(request: CodeRequest):
-        prompt = get_code_prompt(action, request.code, request.language or "python", request.context)
-        temp = request.temperature or settings.DEFAULT_TEMPERATURE
-        max_t = request.max_tokens or settings.DEFAULT_MAX_TOKENS
-        
-        if request.stream:
-            return StreamingResponse(
-                run_stream_generator(prompt=prompt, temperature=temp, max_tokens=max_t),
-                media_type="text/event-stream"
-            )
-        else:
-            return await run_standard_generation(prompt=prompt, temperature=temp, max_tokens=max_t)
-    return endpoint
+    return await run_standard(prompt=prompt, temperature=request.temperature or 0.2,
+                              max_tokens=request.max_tokens or 128)
 
-# Register code utility endpoints
-app.post("/explain")(make_code_endpoint("explain"))
-app.post("/debug")(make_code_endpoint("debug"))
-app.post("/refactor")(make_code_endpoint("refactor"))
-app.post("/generate-tests")(make_code_endpoint("generate-tests"))
-app.post("/summarize")(make_code_endpoint("summarize"))
 
 @app.get("/health")
 async def health():
-    # Health check responds instantly for cloud pingers
-    status_info = await llm_manager.get_status_info()
+    info = await llm_manager.get_status_info()
     return {
-        "status": "healthy",
-        "timestamp": time.time(),
-        "active_mode": status_info.get("active_mode"),
-        "local_model_loaded": status_info.get("initialized", False),
-        "is_downloading": status_info.get("is_downloading", False)
+        "status": "ok",
+        "model_loaded": info.get("initialized", False),
     }
 
-@app.get("/metrics")
-async def get_metrics():
-    # Enriches metrics with current server state
-    report = metrics.get_metrics_report()
-    status_info = await llm_manager.get_status_info()
-    ram_stats = psutil.virtual_memory()
-    report.update({
-        "active_mode": "local",
-        "system_ram_gb": round(ram_stats.total / (1024 ** 3), 2),
-        "device": status_info.get("device", "CPU")
-    })
-    return report
-
-@app.get("/model-info", response_model=ModelInfoResponse)
-async def get_model_info():
-    status_info = await llm_manager.get_status_info()
-    
-    # Calculate memory stats
-    ram_stats = psutil.virtual_memory()
-    total_gb = ram_stats.total / (1024 ** 3)
-    used_gb = ram_stats.used / (1024 ** 3)
-    
-    local_exists = os.path.exists(settings.LOCAL_MODEL_PATH)
-    
-    return ModelInfoResponse(
-        model_name=os.path.basename(settings.LOCAL_MODEL_PATH),
-        inference_mode="local",
-        status="loaded" if status_info.get("initialized") else "loading",
-        memory_usage_gb=round(used_gb, 2),
-        total_memory_gb=round(total_gb, 2),
-        local_model_exists=local_exists,
-        local_model_path=settings.LOCAL_MODEL_PATH,
-        device=status_info.get("device", "CPU")
-    )
 
-# Serve Frontend static assets if available (production mode)
 frontend_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "frontend", "dist"))
 if os.path.exists(frontend_dir):
     app.mount("/", StaticFiles(directory=frontend_dir, html=True), name="frontend")
-    logger.info(f"Frontend dist found. Serving frontend from {frontend_dir}")
+    logger.info(f"Serving frontend from {frontend_dir}")
 else:
-    logger.warning(f"Frontend dist not found at {frontend_dir}. Running API-only server mode.")
+    logger.warning("No frontend dist found. API-only mode.")

backend/app/middleware.py

@@ -1,73 +1,21 @@
 import time
 import logging
-from collections import defaultdict
-from fastapi import Request, Response, status
-from fastapi.responses import JSONResponse
+from fastapi import Request
+from fastapi.responses import Response
 from starlette.middleware.base import BaseHTTPMiddleware
-from backend.app.config import settings
 
 logger = logging.getLogger(__name__)
 
-class RateLimiter:
-    def __init__(self, requests_per_minute: int):
-        self.limit = requests_per_minute
-        self.clients = defaultdict(list)
-
-    def is_allowed(self, ip: str) -> bool:
-        now = time.time()
-        # Clean up requests older than 60 seconds
-        self.clients[ip] = [req_time for req_time in self.clients[ip] if now - req_time < 60]
-        
-        if len(self.clients[ip]) >= self.limit:
-            return False
-            
-        self.clients[ip].append(now)
-        return True
-
-class RateLimitMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, limit: int = None):
-        super().__init__(app)
-        self.limiter = RateLimiter(limit or settings.RATE_LIMIT_PER_MINUTE)
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        # Bypass rate limits for health and metric endpoints
-        if request.url.path in ["/health", "/metrics", "/model-info"]:
-            return await call_next(request)
-
-        # Get client IP
-        client_ip = request.client.host if request.client else "unknown"
-        
-        if not self.limiter.is_allowed(client_ip):
-            logger.warning(f"Rate limit exceeded for client: {client_ip} on path {request.url.path}")
-            return JSONResponse(
-                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                content={"detail": "Too many requests. Please try again in a minute."}
-            )
-
-        return await call_next(request)
-
 class LoggingMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next) -> Response:
         start_time = time.time()
-        client_ip = request.client.host if request.client else "unknown"
-        logger.info(f"Incoming: {request.method} {request.url.path} from {client_ip}")
-
         try:
             response = await call_next(request)
             duration = time.time() - start_time
-            logger.info(
-                f"Outgoing: {request.method} {request.url.path} - "
-                f"Status: {response.status_code} - Duration: {duration:.4f}s"
-            )
+            if duration > 1.0:
+                logger.info(f"{request.method} {request.url.path} - {response.status_code} - {duration:.2f}s")
             return response
         except Exception as e:
             duration = time.time() - start_time
-            logger.error(
-                f"Exception: {request.method} {request.url.path} failed - "
-                f"Error: {e} - Duration: {duration:.4f}s",
-                exc_info=True
-            )
-            return JSONResponse(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                content={"detail": "Internal server error occurred."}
-            )
+            logger.error(f"{request.method} {request.url.path} failed - {e} - {duration:.2f}s")
+            raise

backend/app/models.py

@@ -2,31 +2,23 @@ from typing import List, Optional, Dict, Any
 from pydantic import BaseModel, Field
 
 class ChatMessage(BaseModel):
-    role: str = Field(..., description="Role of the message author (system, user, assistant)")
-    content: str = Field(..., description="Content of the message")
+    role: str
+    content: str
 
 class ChatRequest(BaseModel):
-    messages: List[ChatMessage] = Field(..., description="Conversation history including current prompt")
-    temperature: Optional[float] = Field(None, description="Controls randomness (0.0 to 1.0)")
-    max_tokens: Optional[int] = Field(None, description="Maximum number of tokens to generate")
-    top_p: Optional[float] = Field(None, description="Nucleus sampling threshold")
-    stream: Optional[bool] = Field(True, description="Whether to stream responses")
-
-class CodeRequest(BaseModel):
-    code: str = Field(..., description="The code snippet to process")
-    language: Optional[str] = Field("python", description="Programming language of the code")
-    context: Optional[str] = Field(None, description="Additional developer instructions or query context")
-    temperature: Optional[float] = Field(None)
-    max_tokens: Optional[int] = Field(None)
-    stream: Optional[bool] = Field(True)
+    messages: List[ChatMessage]
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = None
+    stream: Optional[bool] = True
 
 class CompletionRequest(BaseModel):
-    prefix: str = Field(..., description="Code before the cursor position")
-    suffix: Optional[str] = Field("", description="Code after the cursor position")
-    language: Optional[str] = Field("python")
-    max_tokens: Optional[int] = Field(128)
-    temperature: Optional[float] = Field(0.2)
-    stream: Optional[bool] = Field(False)
+    prefix: str
+    suffix: Optional[str] = ""
+    language: Optional[str] = "python"
+    max_tokens: Optional[int] = 128
+    temperature: Optional[float] = 0.2
+    stream: Optional[bool] = False
 
 class ChatResponseChunk(BaseModel):
     content: str
@@ -38,13 +30,3 @@ class ChatResponse(BaseModel):
     content: str
     usage: Dict[str, Any]
     model: str
-
-class ModelInfoResponse(BaseModel):
-    model_name: str
-    inference_mode: str  # "local" or "huggingface"
-    status: str          # "loaded", "error", "fallback"
-    memory_usage_gb: float
-    total_memory_gb: float
-    local_model_exists: bool
-    local_model_path: str
-    device: str          # "cpu", "cuda", etc.

backend/app/utils.py

@@ -1,82 +1,20 @@
-import time
-from typing import Dict, Any, List, Optional
+import json
+from typing import Dict, Any, Optional
 
 def estimate_tokens(text: str) -> int:
-    """
-    Estimates token count for Qwen/GPT-like models without heavy tokenizers.
-    Rule of thumb: 1 token ≈ 4 characters, or ~1.3 tokens per word.
-    """
     if not text:
         return 0
-    # Average of char-based and word-based estimations
-    char_est = len(text) / 4.0
-    word_est = len(text.split()) * 1.3
-    return int((char_est + word_est) / 2.0) + 1
+    return int(len(text) / 4) + 1
 
 def format_sse_chunk(content: str, done: bool = False, usage: Optional[Dict[str, Any]] = None) -> str:
-    """Format data for Server-Sent Events transmission."""
-    data = {
-        "content": content,
-        "done": done,
-        "usage": usage
-    }
-    return f"data: {json_dumps(data)}\n\n"
-
-def json_dumps(obj: Any) -> str:
-    # A safe helper for JSON serialization
-    import json
-    return json.dumps(obj)
-
-def get_code_prompt(action: str, code: str, language: str, context: Optional[str] = None) -> str:
-    """Returns specialized system/user prompts for code tasks."""
-    prompt_templates = {
-        "explain": (
-            "You are an expert software engineer. Explain this code step-by-step. "
-            "Highlight the flow of execution, core algorithms, and potential performance implications. "
-            "Write the explanation in clear, readable markdown.\n\n"
-            f"Language: {language}\n"
-            f"Code:\n```\n{code}\n```"
-        ),
-        "debug": (
-            "You are a senior debugger. Identify errors, logical bugs, edge cases, memory leaks, "
-            "or security vulnerabilities in the code below. Explain each issue found and "
-            "provide a corrected version of the code, indicating what changes were made.\n\n"
-            f"Language: {language}\n"
-            f"Code:\n```\n{code}\n```"
-        ),
-        "refactor": (
-            "You are a principal engineer. Refactor this code to improve its readability, "
-            "efficiency, and modularity. Adhere to SOLID principles and industry design patterns. "
-            "Provide the refactored code and list the improvements.\n\n"
-            f"Language: {language}\n"
-            f"Code:\n```\n{code}\n```"
-        ),
-        "generate-tests": (
-            "You are a QA automation lead. Write comprehensive unit tests for the following code snippet. "
-            "Cover typical inputs, edge cases, and error conditions. Use standard testing libraries.\n\n"
-            f"Language: {language}\n"
-            f"Code:\n```\n{code}\n```"
-        ),
-        "summarize": (
-            "Provide a brief, high-level summary of what this code does in 2-3 sentences. "
-            "Focus on the main inputs, transformations, and outputs.\n\n"
-            f"Language: {language}\n"
-            f"Code:\n```\n{code}\n```"
-        )
-    }
-
-    prompt = prompt_templates.get(action, f"Analyze the following code:\n\n```{language}\n{code}\n```")
-    if context:
-        prompt = f"Context/Instructions: {context}\n\n{prompt}"
-    return prompt
+    data = {"content": content, "done": done, "usage": usage}
+    return f"data: {json.dumps(data)}\n\n"
 
 def get_completion_prompt(prefix: str, suffix: str, language: str) -> str:
-    """Constructs instructions for code completion."""
     return (
-        f"You are a code auto-completion utility. Continue the code for the {language} language. "
-        "Your task is to fill in the missing code between the Prefix and Suffix. "
-        "Return ONLY the code that should be inserted directly at the transition point. "
-        "Do NOT write any explanations. Do NOT wrap your response in markdown code blocks.\n\n"
+        f"Continue the code for the {language} language. "
+        f"Fill in the missing code between the Prefix and Suffix. "
+        f"Return ONLY the code to insert. No explanations, no markdown.\n\n"
         f"--- PREFIX ---\n{prefix}\n"
         f"--- SUFFIX ---\n{suffix}\n"
         "--- INSERT COMPLETED CODE BELOW ---"

backend/requirements.txt

@@ -2,9 +2,5 @@ fastapi>=0.100.0
 uvicorn>=0.22.0
 pydantic>=2.0
 pydantic-settings>=2.0
-python-dotenv>=1.0.0
-requests>=2.31.0
-httpx>=0.24.0
-huggingface_hub>=0.16.0
-psutil>=5.9.0
+huggingface-hub>=0.16.0
 llama-cpp-python>=0.2.0

backend/run.py

@@ -1,11 +0,0 @@
-import uvicorn
-from backend.app.config import settings
-
-if __name__ == "__main__":
-    print(f"Starting server on http://{settings.HOST}:{settings.PORT}")
-    uvicorn.run(
-        "backend.app.main:app",
-        host=settings.HOST,
-        port=settings.PORT,
-        reload=settings.DEBUG
-    )

docker/Dockerfile.backend

@@ -1,45 +0,0 @@
-# Multi-stage build to reduce final image size
-FROM python:3.11-slim as builder
-
-WORKDIR /app
-
-# Install compilation tools needed for compiling llama-cpp-python
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    gcc \
-    g++ \
-    make \
-    python3-dev \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy backend requirements
-COPY backend/requirements.txt .
-
-# Install dependencies and build llama-cpp-python
-RUN pip install --no-cache-dir --user -r requirements.txt
-
-# Final production stage
-FROM python:3.11-slim
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgomp1 \
-    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-# Copy installed site-packages from builder stage
-COPY --from=builder /root/.local /root/.local
-ENV PATH=/root/.local/bin:$PATH
-
-# Copy backend codebase
-COPY backend/ /app/backend/
-
-ENV PORT=8000
-ENV HOST=0.0.0.0
-ENV PYTHONPATH=/app
-
-EXPOSE 8000
-
-# Start command
-CMD ["python", "backend/run.py"]

docker/Dockerfile.frontend

@@ -1,13 +0,0 @@
-FROM node:20-slim
-
-WORKDIR /app
-
-COPY frontend/package*.json ./
-
-RUN npm install
-
-COPY frontend/ ./
-
-EXPOSE 5173
-
-CMD ["npm", "run", "dev", "--", "--host"]

docker/docker-compose.yml

@@ -1,36 +0,0 @@
-version: '3.8'
-
-services:
-  backend:
-    build:
-      context: ../
-      dockerfile: docker/Dockerfile.backend
-    ports:
-      - "8000:8000"
-    volumes:
-      - ../backend:/app/backend
-      - ../models:/app/models
-    environment:
-      - PORT=8000
-      - HOST=0.0.0.0
-      - DEBUG=true
-      - INFERENCE_MODE=local
-      - LOCAL_MODEL_PATH=models/SmolLM2-360M-Instruct-Q4_K_M.gguf
-      - CORS_ORIGINS=http://localhost:5173,http://localhost:8000
-    restart: unless-stopped
-
-  frontend:
-    build:
-      context: ../
-      dockerfile: docker/Dockerfile.frontend
-    ports:
-      - "5173:5173"
-    volumes:
-      - ../frontend:/app
-      - /app/node_modules
-    environment:
-      - VITE_API_URL=http://backend:8000
-    command: npm run dev -- --host --force
-    depends_on:
-      - backend
-    restart: unless-stopped

docs/API.md

@@ -1,109 +0,0 @@
-# API Reference Documentation 📖
-
-This document details the REST API specifications for the Antigravity Coding Assistant.
-
-All APIs use JSON request bodies. Streaming endpoints support Server-Sent Events (`text/event-stream`).
-
----
-
-## Endpoints Summary
-
-| Method | Path | Description | Streaming Support |
-| :--- | :--- | :--- | :--- |
-| `POST` | `/chat` | Chat message handler | Yes |
-| `POST` | `/complete` | Code auto-completion | Yes |
-| `POST` | `/explain` | Generates explanation for a code block | Yes |
-| `POST` | `/debug` | Locates bugs and provides fixes | Yes |
-| `POST` | `/refactor` | Refactors code for quality & SOLID rules | Yes |
-| `POST` | `/generate-tests`| Creates automated unit tests | Yes |
-| `POST` | `/summarize` | Summarizes code in 2-3 sentences | Yes |
-| `GET` | `/health` | Check backend service health | No |
-| `GET` | `/metrics` | Get performance metrics telemetry | No |
-| `GET` | `/model-info` | Check active LLM provider specifications| No |
-
----
-
-## Detailed Specifications
-
-### 1. POST `/chat`
-Generates conversational assistance based on prompt history.
-
-**Request Payload:**
-```json
-{
-  "messages": [
-    { "role": "system", "content": "You are a coding assistant." },
-    { "role": "user", "content": "Write a bubble sort in Python." }
-  ],
-  "temperature": 0.7,
-  "max_tokens": 1024,
-  "top_p": 0.9,
-  "stream": true
-}
-```
-
----
-
-### 2. POST `/complete`
-Fills in missing code between a prefix and suffix (Fill-in-the-Middle).
-
-**Request Payload:**
-```json
-{
-  "prefix": "def add_numbers(a, b):\n    ",
-  "suffix": "\n\nprint(add_numbers(5, 10))",
-  "language": "python",
-  "max_tokens": 64,
-  "temperature": 0.1,
-  "stream": false
-}
-```
-
----
-
-### 3. POST `/explain` | `/debug` | `/refactor` | `/generate-tests` | `/summarize`
-Specialized endpoints for code-focused instructions.
-
-**Request Payload:**
-```json
-{
-  "code": "def double(x): return x * 2",
-  "language": "python",
-  "context": "Optimize this code",
-  "temperature": 0.7,
-  "max_tokens": 1024,
-  "stream": true
-}
-```
-
----
-
-## Response Formats
-
-### Non-Streaming Response
-Returned when `stream` parameter is `false`:
-```json
-{
-  "id": "uuid-string-here",
-  "content": "Generated text or code review block here",
-  "usage": {
-    "prompt_tokens": 42,
-    "completion_tokens": 128,
-    "total_tokens": 170,
-    "duration_ms": 1240,
-    "tokens_per_second": 103.2
-  },
-  "model": "bartowski/Qwen2.5-Coder-0.5B-Instruct-GGUF"
-}
-```
-
-### Streaming Response (SSE)
-Returned when `stream` parameter is `true`. Standard SSE format:
-```
-data: {"content": "Hello", "done": false}
-
-data: {"content": " World", "done": false}
-
-data: {"content": "", "done": true, "usage": {"prompt_tokens": 12, "completion_tokens": 2, "total_tokens": 14, "duration_ms": 230, "tokens_per_second": 8.7}}
-```
-Each data line represents a single generated text token. The final SSE chunk contains `done: true` and the generation metrics.

docs/DEPLOYMENT.md

@@ -1,47 +0,0 @@
-# Cloud Deployment Guide 🌐
-
-This document covers instructions on deploying the unified **Antigravity AI Coder** container to Railway and Render.
-
----
-
-## <a name="railway"></a> 🚄 Railway Deployment (Preferred)
-
-Railway is the recommended host because of its native support for Dockerfile builds, fast container deployments, and reliable persistent volumes.
-
-### Step 1: Create a Railway Project
-1. Log into your [Railway Console](https://railway.app/).
-2. Click **New Project** -> **Deploy from GitHub repo**.
-3. Select your repository.
-
-### Step 2: Configure Environment Variables
-Add the following variables in Railway's **Variables** tab:
-* `PORT` = `8000`
-* `HOST` = `0.0.0.0`
-* `INFERENCE_MODE` = `auto` (Routes to Hugging Face Cloud if container RAM is limited)
-* `HF_API_TOKEN` = `your_huggingface_api_token` (Strongly recommended to avoid rate limits)
-* `HF_MODEL_ID` = `Qwen/Qwen2.5-Coder-0.5B-Instruct`
-* `SECRET_KEY` = `generate-a-long-random-string`
-
-### Step 3: Mount a Persistent Volume (Optional but Recommended)
-To prevent the container from re-downloading the 397MB local model file on every restart:
-1. In the service settings, click **Volume** -> **Add Volume**.
-2. Mount the volume to: `/app/models`.
-3. Save the changes. Railway will now persist the downloaded GGUF file inside this volume.
-
----
-
-## <a name="render"></a> 💎 Render Deployment
-
-Render supports Docker builds out of the box using our blueprint `render.yaml` configuration.
-
-### Step 1: Deploy using render.yaml Blueprint
-1. Log into your [Render Dashboard](https://dashboard.render.com/).
-2. Click **New** -> **Blueprint**.
-3. Link your repository. Render will automatically read the `render.yaml` file from your repo root.
-4. Render will prompt you for:
-   * **Service Name:** `antigravity-ai-coder`
-   * **HF_API_TOKEN:** Provide your Hugging Face API key.
-
-### Step 2: Custom Scaling & Memory Fallback
-* **On Free Instances:** Render's free tier provides 512MB RAM. Since 512MB is below our local inference threshold, the backend will boot up, detect the system memory limit, and automatically switch to `huggingface` cloud fallback mode.
-* **On Paid Instances:** If you upgrade to a Starter or Standard instance (>= 2GB RAM) and keep `INFERENCE_MODE=auto`, it will download and run the GGUF model locally. The blueprint allocates a 10GB persistent disk mounted to `/app/models` to store the model file.

frontend/src/App.tsx

@@ -14,7 +14,6 @@ export const App: React.FC = () => {
     activeConversation,
     settings,
     modelInfo,
-    metrics,
     isLoading,
     error,
     updateSettings,
@@ -105,7 +104,6 @@ export const App: React.FC = () => {
               {activeTab === 'dashboard' && (
                 <Dashboard
                   modelInfo={modelInfo}
-                  metrics={metrics}
                   setActiveTab={selectTabFromNav}
                   createNewConversation={createNewConversation}
                   sendMessage={sendMessage}

frontend/src/components/ChatInterface.tsx

@@ -1,12 +1,10 @@
 import React, { useState, useRef, useEffect } from 'react';
-import { motion, AnimatePresence } from 'framer-motion';
 import { 
-  Send, Sparkles, AlertCircle, Copy, Check, 
-  Upload, Terminal, HelpCircle, FileText, Download,
-  CornerDownLeft, Paperclip, RotateCcw,
-  User, Shield, MessageSquare, Plus, Search, Code, Mic, Trash2
+  Send, AlertCircle, Copy, Check, Download,
+  Paperclip, Terminal, Plus,
+  User, Shield, Search, Code, Mic
 } from 'lucide-react';
-import type { ChatMessage, Conversation, ModelInfo } from '../types';
+import type { Conversation, ModelInfo } from '../types';
 
 interface ChatInterfaceProps {
   activeConversation: Conversation | null;

frontend/src/components/CodePlayground.tsx

@@ -1,8 +1,6 @@
 import React, { useState } from 'react';
-import { motion } from 'framer-motion';
 import { 
-  Play, Trash2, Save, Terminal, Code2, Copy, Check, ChevronDown,
-  Maximize2, RefreshCw
+  Play, Trash2, Save, Copy, Check, ChevronDown
 } from 'lucide-react';
 import { MonacoEditorWrapper } from './MonacoEditorWrapper';
 

frontend/src/components/Dashboard.tsx

@@ -1,14 +1,12 @@
 import React from 'react';
-import { motion } from 'framer-motion';
 import { 
   MessageSquare, Code, FileText, ShieldAlert, List, RefreshCw,
-  Cpu, HardDrive, Zap, BarChart2, ChevronRight, HelpCircle, Database
+  Cpu, HardDrive, Database
 } from 'lucide-react';
-import type { ModelInfo, ModelMetrics } from '../types';
+import type { ModelInfo } from '../types';
 
 interface DashboardProps {
   modelInfo: ModelInfo | null;
-  metrics: ModelMetrics | null;
   setActiveTab: (tab: string) => void;
   createNewConversation: (title?: string) => void;
   sendMessage: (msg: string) => void;
@@ -16,7 +14,6 @@ interface DashboardProps {
 
 export const Dashboard: React.FC<DashboardProps> = ({
   modelInfo,
-  metrics,
   setActiveTab,
   createNewConversation,
   sendMessage,
@@ -69,14 +66,7 @@ export const Dashboard: React.FC<DashboardProps> = ({
     }, 100);
   };
 
-  // Safe formatting variables matching image values
-  const modelName = modelInfo?.model_name.split('/').pop() || 'SmolLM2-360M';
-  const memoryUsed = modelInfo?.memory_usage_gb || 1.53;
-  const memoryTotal = modelInfo?.total_memory_gb || 7.65;
-  const memoryPercent = Math.min(100, Math.round((memoryUsed / memoryTotal) * 100)) || 20;
-
-  const latency = metrics?.average_latency_seconds || 22.13;
-  const totalTokens = metrics?.total_tokens || 816;
+  const modelName = modelInfo?.model_name || 'SmolLM2-360M-Q4_K_M';
 
   return (
     <div className="flex-1 overflow-y-auto bg-[#090810] p-6 space-y-6 font-sans max-w-[1400px] mx-auto w-full">
@@ -102,13 +92,13 @@ export const Dashboard: React.FC<DashboardProps> = ({
         </div>
       </div>
 
-      {/* Grid: System Status & Metrics */}
-      <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4 select-none">
+      {/* Grid: System Status */}
+      <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4 select-none">
         
         {/* Model Status Card */}
-        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all duration-300">
+        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all">
           <div className="flex items-center justify-between">
-            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Model Status</span>
+            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Model</span>
             <div className="p-1.5 bg-emerald-500/10 rounded-lg text-emerald-500">
               <Cpu size={14} />
             </div>
@@ -119,50 +109,31 @@ export const Dashboard: React.FC<DashboardProps> = ({
           </div>
         </div>
 
-        {/* Memory Allocation Card with Progress Bar */}
-        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all duration-300">
+        {/* Memory Card */}
+        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all">
           <div className="flex items-center justify-between">
-            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Memory Usage</span>
+            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Model Size</span>
             <div className="p-1.5 bg-blue-500/10 rounded-lg text-blue-500">
               <HardDrive size={14} />
             </div>
           </div>
-          <div className="space-y-2 flex-1 flex flex-col justify-end">
-            <div className="flex justify-between items-baseline">
-              <h2 className="text-sm font-bold text-white">{memoryUsed.toFixed(2)} GB <span className="text-[10px] text-[#58556f] font-normal">/ {memoryTotal.toFixed(2)} GB</span></h2>
-              <span className="text-[10px] text-blue-400 font-semibold">{memoryPercent}%</span>
-            </div>
-            <div className="w-full bg-[#1c1a30] h-1.5 rounded-full overflow-hidden">
-              <div className="bg-blue-500 h-full rounded-full" style={{ width: `${memoryPercent}%` }}></div>
-            </div>
-          </div>
-        </div>
-
-        {/* Latency Card */}
-        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all duration-300">
-          <div className="flex items-center justify-between">
-            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Avg. Latency</span>
-            <div className="p-1.5 bg-primary/10 rounded-lg text-primary">
-              <Zap size={14} />
-            </div>
-          </div>
           <div className="space-y-1 flex-1 flex flex-col justify-end">
-            <h2 className="text-xl font-bold text-white">{latency.toFixed(2)} s</h2>
-            <p className="text-[10px] text-[#58556f]">Per request</p>
+            <h2 className="text-sm font-bold text-white">~180 MB</h2>
+            <p className="text-[10px] text-[#58556f]">Q4_K_M quantized</p>
           </div>
         </div>
 
-        {/* Tokens Card */}
-        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all duration-300">
+        {/* Context Card */}
+        <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl flex flex-col gap-4 min-h-[110px] hover:border-primary/20 transition-all">
           <div className="flex items-center justify-between">
-            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Tokens Used</span>
-            <div className="p-1.5 bg-red-500/10 rounded-lg text-red-500">
-              <BarChart2 size={14} />
+            <span className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Context</span>
+            <div className="p-1.5 bg-primary/10 rounded-lg text-primary">
+              <RefreshCw size={14} />
             </div>
           </div>
           <div className="space-y-1 flex-1 flex flex-col justify-end">
-            <h2 className="text-xl font-bold text-white">{totalTokens.toLocaleString()}</h2>
-            <p className="text-[10px] text-[#58556f]">Total (Input + Output)</p>
+            <h2 className="text-xl font-bold text-white">512</h2>
+            <p className="text-[10px] text-[#58556f]">Tokens context window</p>
           </div>
         </div>
 

frontend/src/components/Navbar.tsx

@@ -1,8 +1,8 @@
 import React from 'react';
 import { motion } from 'framer-motion';
 import { 
-  Bell, Search, Sun, Moon, Cpu, Globe, 
-  CheckCircle2, AlertCircle, HelpCircle 
+  Bell, Search, Sun, Moon, Cpu, 
+  CheckCircle2, AlertCircle
 } from 'lucide-react';
 import type { ModelInfo, AppSettings } from '../types';
 

frontend/src/components/Settings.tsx

@@ -1,8 +1,5 @@
 import React, { useState } from 'react';
-import { 
-  Cpu, Sliders, AlertTriangle, ShieldCheck, Save, CheckCircle2,
-  HardDrive, Info, Activity, RefreshCw
-} from 'lucide-react';
+import { Save, CheckCircle2, AlertTriangle, RefreshCw } from 'lucide-react';
 import type { AppSettings, ModelInfo } from '../types';
 
 interface SettingsProps {
@@ -34,259 +31,115 @@ export const Settings: React.FC<SettingsProps> = ({
         clearHistory();
         setConfirmClear(false);
         setResetting(false);
-        alert('Local database log history has been successfully reset.');
+        alert('Conversation history cleared.');
       }, 800);
     } else {
       setConfirmClear(true);
     }
   };
 
-  // Safe formatting variables matching image specifications
-  const memoryUsed = modelInfo?.memory_usage_gb || 1.53;
-  const memoryTotal = modelInfo?.total_memory_gb || 7.65;
-  const memoryPercent = Math.min(100, Math.round((memoryUsed / memoryTotal) * 100)) || 20;
-
   return (
     <div className="flex-1 overflow-y-auto bg-[#090810] p-6 lg:p-8 font-sans select-none">
-      
-      {/* Settings Split Layout grid */}
       <div className="max-w-6xl grid grid-cols-1 lg:grid-cols-5 gap-8 items-start">
-        
-        {/* Left Column Form (3/5 width) */}
         <div className="lg:col-span-3 space-y-5 bg-[#131121] border border-[#1d1b2e] p-6 rounded-2xl">
-          
           <div className="border-b border-[#1d1b2e] pb-4">
-            <h2 className="text-md font-bold text-white tracking-tight">Model & Inference</h2>
-            <p className="text-[10px] text-[#9d99b3] mt-0.5">Configure how the AI model runs and generates responses.</p>
+            <h2 className="text-md font-bold text-white tracking-tight">Generation Settings</h2>
+            <p className="text-[10px] text-[#9d99b3] mt-0.5">Configure how the AI model generates responses.</p>
           </div>
-
           <div className="space-y-5 pt-1">
-            
-            {/* Inference Mode selector */}
-            <div className="space-y-1.5">
-              <label className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Inference Mode</label>
-              <select
-                className="w-full bg-[#090810] border border-[#1d1b2e] text-xs text-white rounded-xl px-3 py-2.5 outline-none font-semibold cursor-pointer"
-                disabled
-              >
-                <option>Local Inference</option>
-              </select>
-            </div>
 
-            {/* Target model selector */}
             <div className="space-y-1.5">
-              <div className="flex justify-between items-center select-none">
-                <label className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Model</label>
-                <span className="flex items-center gap-1 text-[10px] text-emerald-500 font-bold uppercase tracking-wider bg-emerald-500/10 px-2 py-0.5 rounded">
-                  <CheckCircle2 size={10} />
-                  Loaded
-                </span>
+              <label className="text-[10px] font-bold text-[#9d99b3] uppercase tracking-wider">Model</label>
+              <div className="bg-[#090810] border border-[#1d1b2e] text-xs text-white rounded-xl px-3 py-2.5 font-mono">
+                SmolLM2-360M-Instruct-Q4_K_M.gguf
               </div>
-              <select
-                className="w-full bg-[#090810] border border-[#1d1b2e] text-xs text-white rounded-xl px-3 py-2.5 outline-none font-mono cursor-default"
-                disabled
-              >
-                <option>{modelInfo?.local_model_path.split('/').pop() || 'SmolLM2-360M-Instruct-Q4_K_M.gguf'}</option>
-              </select>
             </div>
 
             <div className="h-px bg-[#1d1b2e] my-2"></div>
 
-            {/* Context length slider */}
-            <div className="space-y-2">
-              <div className="flex justify-between text-xs font-semibold">
-                <span className="text-white">Context Length</span>
-                <span className="text-primary font-mono text-[11px] bg-primary/10 px-2 py-0.5 rounded">{settings.contextLength}</span>
-              </div>
-              <input
-                type="range"
-                min="256"
-                max="4096"
-                step="256"
-                value={settings.contextLength}
-                onChange={(e) => updateSettings({ contextLength: parseInt(e.target.value) })}
-                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer focus:outline-none"
-              />
-              <p className="text-[9px] text-[#9d99b3]">Maximum context length constraints for the model.</p>
-            </div>
-
-            {/* Temperature Slider */}
             <div className="space-y-2">
               <div className="flex justify-between text-xs font-semibold">
                 <span className="text-white">Temperature</span>
                 <span className="text-primary font-mono text-[11px] bg-primary/10 px-2 py-0.5 rounded">{settings.temperature}</span>
               </div>
               <input
-                type="range"
-                min="0.1"
-                max="1.5"
-                step="0.1"
+                type="range" min="0.1" max="1.5" step="0.1"
                 value={settings.temperature}
                 onChange={(e) => updateSettings({ temperature: parseFloat(e.target.value) })}
-                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer focus:outline-none"
+                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer"
               />
-              <p className="text-[9px] text-[#9d99b3]">Controls randomness in responses.</p>
             </div>
 
-            {/* Max Output Tokens Slider */}
             <div className="space-y-2">
               <div className="flex justify-between text-xs font-semibold">
                 <span className="text-white">Max Tokens</span>
                 <span className="text-primary font-mono text-[11px] bg-primary/10 px-2 py-0.5 rounded">{settings.maxTokens}</span>
               </div>
               <input
-                type="range"
-                min="64"
-                max="2048"
-                step="64"
+                type="range" min="64" max="2048" step="64"
                 value={settings.maxTokens}
                 onChange={(e) => updateSettings({ maxTokens: parseInt(e.target.value) })}
-                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer focus:outline-none"
+                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer"
               />
-              <p className="text-[9px] text-[#9d99b3]">Maximum tokens in the response.</p>
             </div>
 
-            {/* Top P Slider */}
             <div className="space-y-2">
               <div className="flex justify-between text-xs font-semibold">
                 <span className="text-white">Top P</span>
                 <span className="text-primary font-mono text-[11px] bg-primary/10 px-2 py-0.5 rounded">{settings.topP}</span>
               </div>
               <input
-                type="range"
-                min="0.1"
-                max="1.0"
-                step="0.05"
+                type="range" min="0.1" max="1.0" step="0.05"
                 value={settings.topP}
                 onChange={(e) => updateSettings({ topP: parseFloat(e.target.value) })}
-                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer focus:outline-none"
+                className="w-full accent-primary h-1 bg-[#090810] rounded-lg appearance-none cursor-pointer"
               />
-              <p className="text-[9px] text-[#9d99b3]">Nucleus sampling probability parameter.</p>
             </div>
 
             <div className="h-px bg-[#1d1b2e] my-2"></div>
 
-            {/* Stream response switch */}
             <div className="flex items-center justify-between py-1.5">
               <div className="space-y-0.5">
-                <label className="text-xs font-bold text-white cursor-pointer" htmlFor="stream-switch">
-                  Stream Response
-                </label>
+                <label className="text-xs font-bold text-white" htmlFor="stream-switch">Stream Response</label>
                 <p className="text-[10px] text-[#9d99b3]">Stream tokens as they are generated.</p>
               </div>
-              <input
-                type="checkbox"
-                id="stream-switch"
+              <input type="checkbox" id="stream-switch"
                 checked={settings.streaming}
                 onChange={(e) => updateSettings({ streaming: e.target.checked })}
-                className="w-4.5 h-4.5 rounded text-primary focus:ring-primary accent-primary bg-background border-border cursor-pointer focus-ring"
+                className="w-4.5 h-4.5 accent-primary cursor-pointer"
               />
             </div>
 
-            {/* Keep history switch */}
-            <div className="flex items-center justify-between py-1.5">
-              <div className="space-y-0.5">
-                <label className="text-xs font-bold text-white cursor-pointer" htmlFor="history-switch">
-                  Keep Conversation History
-                </label>
-                <p className="text-[10px] text-[#9d99b3]">Maintain conversation history log records in memory.</p>
-              </div>
-              <input
-                type="checkbox"
-                id="history-switch"
-                checked={true}
-                readOnly
-                className="w-4.5 h-4.5 rounded text-primary focus:ring-primary accent-primary bg-background border-border cursor-pointer focus-ring"
-              />
-            </div>
-
-            {/* Save Button */}
             <div className="flex items-center justify-end pt-3">
-              <button
-                onClick={handleSave}
-                className="flex items-center justify-center gap-2 px-5 py-2.5 bg-[#6344d5] hover:bg-[#6344d5]/95 text-white font-bold text-xs rounded-xl shadow-md transition-all active:scale-[0.98] cursor-pointer glow-primary"
+              <button onClick={handleSave}
+                className="flex items-center justify-center gap-2 px-5 py-2.5 bg-[#6344d5] hover:bg-[#6344d5]/95 text-white font-bold text-xs rounded-xl cursor-pointer transition-all"
               >
-                {saveSuccess ? (
-                  <>
-                    <CheckCircle2 size={13} />
-                    <span>Settings Saved</span>
-                  </>
-                ) : (
-                  <>
-                    <Save size={13} />
-                    <span>Save Settings</span>
-                  </>
-                )}
+                {saveSuccess ? <><CheckCircle2 size={13} /><span>Saved</span></> : <><Save size={13} /><span>Save Settings</span></>}
               </button>
             </div>
 
           </div>
         </div>
 
-        {/* Right Column Stats (2/5 width) */}
         <div className="lg:col-span-2 space-y-6">
-          
-          {/* Model Information metadata */}
           <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl space-y-4">
-            <h3 className="text-xs font-bold text-white uppercase tracking-wider flex items-center gap-2 select-none border-b border-[#1d1b2e] pb-3">
-              <Info size={13} className="text-primary" />
-              Model Information
-            </h3>
+            <h3 className="text-xs font-bold text-white uppercase tracking-wider border-b border-[#1d1b2e] pb-3">Model Information</h3>
             <div className="space-y-3.5 text-xs select-none">
               <div className="flex justify-between">
-                <span className="text-[#9d99b3]">Model Name</span>
-                <span className="font-semibold text-white font-mono text-[11px] truncate max-w-[140px]">{modelInfo?.model_name.split('/').pop() || 'SmolLM2-360M-Instruct'}</span>
+                <span className="text-[#9d99b3]">Model</span>
+                <span className="font-semibold text-white font-mono text-[11px]">{modelInfo?.model_name || 'SmolLM2-360M-Q4_K_M'}</span>
               </div>
               <div className="flex justify-between">
-                <span className="text-[#9d99b3]">Quantization</span>
-                <span className="font-semibold text-white font-mono text-[11px]">Q4_K_M</span>
-              </div>
-              <div className="flex justify-between">
-                <span className="text-[#9d99b3]">Model Size</span>
-                <span className="font-semibold text-white font-mono text-[11px]">1.6 GB</span>
-              </div>
-              <div className="flex justify-between">
-                <span className="text-[#9d99b3]">Context Length</span>
-                <span className="font-semibold text-white font-mono text-[11px]">4096</span>
+                <span className="text-[#9d99b3]">Status</span>
+                <span className="font-semibold text-emerald-500 text-[11px]">{modelInfo?.status || 'loaded'}</span>
               </div>
               <div className="flex justify-between">
-                <span className="text-[#9d99b3]">Vocabulary Size</span>
-                <span className="font-semibold text-white font-mono text-[11px]">151,936</span>
+                <span className="text-[#9d99b3]">Quantization</span>
+                <span className="font-semibold text-white font-mono text-[11px]">Q4_K_M</span>
               </div>
               <div className="flex justify-between">
-                <span className="text-[#9d99b3]">Architecture</span>
-                <span className="font-semibold text-white font-mono text-[11px]">Transformers</span>
-              </div>
-            </div>
-          </div>
-
-          {/* System resource bars */}
-          <div className="bg-[#131121] border border-[#1d1b2e] p-5 rounded-2xl space-y-5 select-none">
-            <h3 className="text-xs font-bold text-white uppercase tracking-wider flex items-center gap-2 border-b border-[#1d1b2e] pb-3">
-              <Activity size={13} className="text-primary" />
-              System Resources
-            </h3>
-            
-            {/* RAM Usage progress bar */}
-            <div className="space-y-2">
-              <div className="flex justify-between text-xs font-semibold">
-                <span className="text-[#9d99b3]">RAM Usage</span>
-                <span className="text-white font-mono">{memoryPercent}%</span>
-              </div>
-              <div className="w-full bg-[#090810] h-1.5 rounded-full overflow-hidden">
-                <div className="bg-emerald-500 h-full" style={{ width: `${memoryPercent}%` }}></div>
-              </div>
-              <div className="text-[10px] text-[#58556f]">{memoryUsed.toFixed(2)} GB / {memoryTotal.toFixed(2)} GB</div>
-            </div>
-
-            {/* CPU Usage progress bar */}
-            <div className="space-y-2">
-              <div className="flex justify-between text-xs font-semibold">
-                <span className="text-[#9d99b3]">CPU Usage</span>
-                <span className="text-white font-mono">12%</span>
-              </div>
-              <div className="w-full bg-[#090810] h-1.5 rounded-full overflow-hidden">
-                <div className="bg-[#6344d5] h-full" style={{ width: '12%' }}></div>
+                <span className="text-[#9d99b3]">Disk Size</span>
+                <span className="font-semibold text-white font-mono text-[11px]">~180 MB</span>
               </div>
             </div>
           </div>

frontend/src/hooks/useChat.ts

@@ -1,27 +1,22 @@
-import { useState, useEffect, useCallback } from 'react';
-import type { ChatMessage, Conversation, AppSettings, ModelInfo, ModelMetrics } from '../types';
+import { useState, useEffect } from 'react';
+import type { ChatMessage, Conversation, AppSettings } from '../types';
 
-const LOCAL_STORAGE_CONVS_KEY = 'antigravity_conversations';
-const LOCAL_STORAGE_SETTINGS_KEY = 'antigravity_settings';
+const LOCAL_STORAGE_CONVS_KEY = 'levi_conversations';
+const LOCAL_STORAGE_SETTINGS_KEY = 'levi_settings';
 
 const DEFAULT_SETTINGS: AppSettings = {
-  inferenceMode: 'auto',
   temperature: 0.7,
-  maxTokens: 1024,
+  maxTokens: 512,
   topP: 0.9,
-  contextLength: 4096,
   streaming: true,
   theme: 'dark',
-  hfToken: '',
-  hfModelId: 'Qwen/Qwen2.5-Coder-0.5B-Instruct',
 };
 
 export const useChat = () => {
   const [conversations, setConversations] = useState<Conversation[]>([]);
   const [activeConversationId, setActiveConversationId] = useState<string | null>(null);
   const [settings, setSettings] = useState<AppSettings>(DEFAULT_SETTINGS);
-  const [modelInfo, setModelInfo] = useState<ModelInfo | null>(null);
-  const [metrics, setMetrics] = useState<ModelMetrics | null>(null);
+  const modelInfo = { model_name: 'SmolLM2-360M-Q4_K_M', status: 'loaded' };
   const [isLoading, setIsLoading] = useState<boolean>(false);
   const [error, setError] = useState<string | null>(null);
 
@@ -76,42 +71,7 @@ export const useChat = () => {
     localStorage.setItem(LOCAL_STORAGE_SETTINGS_KEY, JSON.stringify(settings));
   }, [settings]);
 
-  // Fetch model metadata
-  const fetchModelInfo = useCallback(async () => {
-    try {
-      const response = await fetch('/api/model-info');
-      if (response.ok) {
-        const data = await response.json();
-        setModelInfo(data);
-      }
-    } catch (e) {
-      console.error('Failed to load model info', e);
-    }
-  }, []);
-
-  // Fetch performance metrics
-  const fetchMetrics = useCallback(async () => {
-    try {
-      const response = await fetch('/api/metrics');
-      if (response.ok) {
-        const data = await response.json();
-        setMetrics(data);
-      }
-    } catch (e) {
-      console.error('Failed to load performance metrics', e);
-    }
-  }, []);
-
-  useEffect(() => {
-    fetchModelInfo();
-    fetchMetrics();
-    // Poll metrics and model status every 10 seconds
-    const interval = setInterval(() => {
-      fetchModelInfo();
-      fetchMetrics();
-    }, 10000);
-    return () => clearInterval(interval);
-  }, [fetchModelInfo, fetchMetrics]);
+  // no-op: model info is static for 512MB-optimized local mode
 
   const updateSettings = (newSettings: Partial<AppSettings>) => {
     setSettings((prev) => {
@@ -126,7 +86,7 @@ export const useChat = () => {
       id: Math.random().toString(36).substring(7),
       title: cleanTitle,
       messages: [],
-      activeModel: modelInfo?.model_name || 'Qwen2.5-Coder',
+      activeModel: 'SmolLM2-360M-Q4_K_M',
       timestamp: Date.now(),
     };
     setConversations((prev) => [newConv, ...prev]);
@@ -243,10 +203,7 @@ export const useChat = () => {
                   );
                 }
                 
-                if (chunkData.done && chunkData.usage) {
-                  fetchMetrics();
-                  fetchModelInfo();
-                }
+                if (chunkData.done && chunkData.usage) {}
               } catch (e) {
                 // Ignore incomplete JSON chunks
               }
@@ -267,8 +224,6 @@ export const useChat = () => {
               : c
           )
         );
-        fetchMetrics();
-        fetchModelInfo();
       }
     } catch (e: any) {
       console.error(e);
@@ -292,31 +247,23 @@ export const useChat = () => {
     }
   };
 
-  const executeCodeAction = async (action: 'explain' | 'debug' | 'refactor' | 'generate-tests' | 'summarize', code: string, language: string, context?: string): Promise<string> => {
+  const executeCodeAction = async (action: string, code: string, language: string, context?: string): Promise<string> => {
     setIsLoading(true);
     setError(null);
     try {
-      const response = await fetch(`/api/${action}`, {
+      const prompt = `${action} the following ${language} code:\n\n${code}${context ? '\n\nContext: ' + context : ''}`;
+      const response = await fetch('/api/chat', {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          code,
-          language,
-          context,
+          messages: [{ role: 'user', content: prompt }],
           temperature: settings.temperature,
           max_tokens: settings.maxTokens,
           stream: false,
         }),
       });
-
-      if (!response.ok) {
-        throw new Error(`API failed: ${response.statusText}`);
-      }
-
+      if (!response.ok) throw new Error(`API failed: ${response.statusText}`);
       const result = await response.json();
-      fetchMetrics();
       return result.content;
     } catch (e: any) {
       console.error(e);
@@ -367,7 +314,6 @@ export const useChat = () => {
     activeConversation,
     settings,
     modelInfo,
-    metrics,
     isLoading,
     error,
     updateSettings,
@@ -377,6 +323,5 @@ export const useChat = () => {
     executeCodeAction,
     getCompletion,
     clearHistory,
-    fetchModelInfo,
   };
 };

frontend/src/types.ts

@@ -15,35 +15,13 @@ export interface Conversation {
 
 export interface ModelInfo {
   model_name: string;
-  inference_mode: string;
   status: string;
-  memory_usage_gb: number;
-  total_memory_gb: number;
-  local_model_exists: boolean;
-  local_model_path: string;
-  device: string;
-}
-
-export interface ModelMetrics {
-  total_requests: number;
-  total_prompt_tokens: number;
-  total_completion_tokens: number;
-  total_tokens: number;
-  average_latency_seconds: number;
-  total_generation_time_seconds: number;
-  active_mode: string;
-  system_ram_gb: number;
-  device: string;
 }
 
 export interface AppSettings {
-  inferenceMode: 'auto' | 'local' | 'huggingface';
   temperature: number;
   maxTokens: number;
   topP: number;
-  contextLength: number;
   streaming: boolean;
   theme: 'dark' | 'light';
-  hfToken: string;
-  hfModelId: string;
 }

models/.gitkeep

@@ -1 +0,0 @@
-# Keep this folder so that models can be downloaded here

render.yaml

@@ -25,3 +25,7 @@ services:
         generateValue: true
       - key: HF_API_TOKEN
         sync: false # Set in Render UI
+    disk:
+      name: models-storage
+      mountPath: /app/models
+      sizeGB: 10

scripts/download_model.py

@@ -2,38 +2,24 @@ import os
 import sys
 
 def download_model():
-    # Read settings from environment variables or use default
-    repo_id = os.getenv("LOCAL_MODEL_REPO", "bartowski/Qwen2.5-Coder-0.5B-Instruct-GGUF")
-    filename = os.getenv("LOCAL_MODEL_FILE", "Qwen2.5-Coder-0.5B-Instruct-Q4_K_M.gguf")
-    model_path = os.getenv("LOCAL_MODEL_PATH", "models/Qwen2.5-Coder-0.5B-Instruct-Q4_K_M.gguf")
-    
+    repo_id = os.getenv("LOCAL_MODEL_REPO", "bartowski/SmolLM2-360M-Instruct-GGUF")
+    filename = os.getenv("LOCAL_MODEL_FILE", "SmolLM2-360M-Instruct-Q4_K_M.gguf")
+    model_path = os.getenv("LOCAL_MODEL_PATH", "models/SmolLM2-360M-Instruct-Q4_K_M.gguf")
+
     target_dir = os.path.dirname(os.path.abspath(model_path))
     os.makedirs(target_dir, exist_ok=True)
-    
-    print(f"============================================================")
-    print(f"Starting Qwen GGUF model downloader...")
-    print(f"Source HF Repo: {repo_id}")
-    print(f"Target Filename: {filename}")
-    print(f"Destination Dir: {target_dir}")
-    print(f"============================================================")
-    
+
+    print(f"Downloading {filename} (~180MB) from {repo_id}...")
     try:
         from huggingface_hub import hf_hub_download
-        
-        print("Downloading GGUF file (approx. 397MB)...")
-        hf_hub_download(
-            repo_id=repo_id,
-            filename=filename,
-            local_dir=target_dir,
-            local_dir_use_symlinks=False
-        )
-        print("Model file downloaded successfully!")
-        print(f"Located at: {os.path.abspath(model_path)}")
+        hf_hub_download(repo_id=repo_id, filename=filename,
+                        local_dir=target_dir, local_dir_use_symlinks=False)
+        print(f"Saved to {os.path.abspath(model_path)}")
     except ImportError:
-        print("Error: 'huggingface_hub' package is not installed. Please run: pip install huggingface_hub")
+        print("Run: pip install huggingface_hub")
         sys.exit(1)
     except Exception as e:
-        print(f"Error downloading model: {e}")
+        print(f"Download failed: {e}")
         sys.exit(1)
 
 if __name__ == "__main__":

scripts/setup.sh

@@ -1,50 +1,18 @@
 #!/bin/bash
-# Antigravity Coder Setup Script
-
 set -e
 
-echo "=== Starting Antigravity Coder Installation ==="
-
-# Check requirements
-if ! command -v python3 &> /dev/null; then
-    echo "Error: Python 3 is not installed. Please install Python 3.11+."
-    exit 1
-fi
+echo "=== Levi AI Coder Setup ==="
 
-if ! command -v node &> /dev/null; then
-    echo "Error: Node.js is not installed. Please install Node.js 20+."
-    exit 1
-fi
-
-# 1. Setup Python Virtual Environment
-echo "Setting up Python virtual environment..."
 python3 -m venv venv
 source venv/bin/activate
-
-# 2. Install Python Dependencies
-echo "Installing backend dependencies (this may compile llama-cpp-python)..."
 pip install --upgrade pip
 pip install -r backend/requirements.txt
 
-# 3. Install Frontend Dependencies
-echo "Installing frontend dependencies..."
 cd frontend
 npm install
-cd ..
-
-# 4. Build Frontend Assets
-echo "Compiling frontend assets..."
-cd frontend
 npm run build
 cd ..
 
-# 5. Pre-download local model
-echo "Downloading Qwen2.5-Coder model..."
-source venv/bin/activate
 python scripts/download_model.py
 
-echo "============================================="
-echo "Setup Complete!"
-echo "To start the backend: source venv/bin/activate && python backend/run.py"
-echo "To start frontend dev server: cd frontend && npm run dev"
-echo "============================================="
+echo "=== Done! Run: source venv/bin/activate && python -m uvicorn backend.app.main:app --host 0.0.0.0 --port 8000 ==="

tests/__init__.py

@@ -1 +0,0 @@
-# Test package

tests/test_backend.py

@@ -1,61 +0,0 @@
-import os
-import sys
-import unittest
-from fastapi.testclient import TestClient
-
-# Ensure python paths are mapped correctly
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-from backend.app.main import app
-from backend.app.utils import estimate_tokens, get_code_prompt, get_completion_prompt
-from backend.app.config import settings
-
-class TestBackendUtilities(unittest.TestCase):
-    def test_token_estimation(self):
-        # Verify basic estimation boundaries
-        self.assertEqual(estimate_tokens(""), 0)
-        
-        sample_text = "def hello_world():\n    print('Hello World')"
-        tokens = estimate_tokens(sample_text)
-        self.assertGreater(tokens, 0)
-        self.assertLess(tokens, len(sample_text))
-
-    def test_prompt_constructors(self):
-        # Test code prompt builder
-        prompt = get_code_prompt("explain", "print(10)", "python")
-        self.assertIn("print(10)", prompt)
-        self.assertIn("explain", prompt.lower())
-
-        # Test code completion prompt builder
-        completion_prompt = get_completion_prompt("def add(a, b):", "return a + b", "python")
-        self.assertIn("def add(a, b):", completion_prompt)
-        self.assertIn("return a + b", completion_prompt)
-
-class TestAPIEndpoints(unittest.TestCase):
-    def setUp(self):
-        self.client = TestClient(app)
-
-    def test_health_check(self):
-        response = self.client.get("/health")
-        self.assertEqual(response.status_code, 200)
-        data = response.json()
-        self.assertEqual(data["status"], "healthy")
-        self.assertIn("active_mode", data)
-
-    def test_metrics_endpoints(self):
-        response = self.client.get("/metrics")
-        self.assertEqual(response.status_code, 200)
-        data = response.json()
-        self.assertIn("total_requests", data)
-        self.assertIn("average_latency_seconds", data)
-
-    def test_model_info(self):
-        response = self.client.get("/model-info")
-        self.assertEqual(response.status_code, 200)
-        data = response.json()
-        self.assertIn("model_name", data)
-        self.assertIn("inference_mode", data)
-        self.assertIn("device", data)
-
-if __name__ == "__main__":
-    unittest.main()