Deploy current project snapshot to Hugging Face Space

.gitignore

@@ -0,0 +1,76 @@
+# Models (FastEmbed cache)
+.cache/
+models/
+*.bin
+*.onnx
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+.venv/
+env/
+ENV/
+.env
+.env.local
+.env.production
+*.env
+*.egg-info/
+.eggs/
+*.egg
+dist/
+build/
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Build outputs
+frontend/build/
+*.tgz
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.project
+.classpath
+.settings/
+
+# OS files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Data directories
+backend/data/storage/
+backend/data/temp/
+backend/data/tts_cache/
+backend/data/agents/
+*.db
+
+# Test data (optional - uncomment if you want to include)
+# test_data/
+
+# Logs
+*.log
+logs/
+
+# Misc
+*.bak
+*.tmp
+.cache/
+
+# Documentation build
+md files/

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    postgresql-client \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python packages
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code from backend directory
+COPY backend/ ./backend/
+# Main entry point needs to be at root level for some runners, or we point pythonpath
+ENV PYTHONPATH=/app/backend
+
+# Set environment for model caching to /tmp (only writable dir in HF Spaces)
+ENV HF_HOME=/tmp/.cache/huggingface
+ENV FASTEMBED_CACHE_PATH=/tmp/.cache/fastembed
+ENV SENTENCE_TRANSFORMERS_HOME=/tmp/.cache/sentence-transformers
+
+# Expose port 7860 (required by Hugging Face Spaces)
+EXPOSE 7860
+
+# Run FastAPI with uvicorn (pointing to nested app)
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,375 @@
+# MEXAR Ultimate 🧠
+
+**Multimodal Explainable AI Reasoning Assistant**
+
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![React 18](https://img.shields.io/badge/react-18-61dafb.svg)](https://reactjs.org/)
+[![FastAPI](https://img.shields.io/badge/fastapi-0.109-009688.svg)](https://fastapi.tiangolo.com/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Deployed](https://img.shields.io/badge/status-live-brightgreen.svg)](https://mexar.vercel.app)
+
+> Create domain-specific intelligent agents from your data with transparent, explainable AI responses using RAG (Retrieval-Augmented Generation) with source attribution and faithfulness scoring.
+
+**🚀 Live Demo**: [https://mexar.vercel.app](https://mexar.vercel.app)  
+**📡 Backend API**: [https://devrajsinh2012-mexar.hf.space](https://devrajsinh2012-mexar.hf.space)
+
+---
+
+## ✨ Key Features
+
+| Feature | Description |
+|---------|-------------|
+| 🔍 **Hybrid Search** | Combines semantic (vector) + keyword search with RRF fusion for optimal retrieval |
+| 🎯 **Cross-Encoder Reranking** | Improves retrieval precision using sentence-transformers |
+| 📊 **Source Attribution** | Inline citations `[1]`, `[2]` linking answers to source data |
+| ✅ **Faithfulness Scoring** | Measures how well answers are grounded in retrieved context |
+| 🗣️ **Multimodal Input** | Audio (Whisper), Images (Vision), Video support |
+| 🔐 **Domain Guardrails** | Prevents hallucinations outside knowledge base |
+| 🔊 **Text-to-Speech** | ElevenLabs + Web Speech API integration |
+| 📁 **5 File Types** | CSV, PDF, DOCX, JSON, TXT |
+
+---
+
+## 🏗️ Architecture
+
+```
+┌────────────────────────────────────────────────────────────────────────────┐
+│                         MEXAR Ultimate Stack                               │
+├────────────────────────────────────────────────────────────────────────────┤
+│                                                                            │
+│            ┌────────────────────────────────────────────┐                  │
+│            │        React Frontend (Vercel)             │                  │
+│            └────────────────────────────────────────────┘                  │
+│                               │                                            │
+│                               ▼                                            │
+│            ┌────────────────────────────────────────────┐                  │
+│            │     FastAPI Backend (Hugging Face Spaces)  │                  │
+│            └────────────────────────────────────────────┘                  │
+│                               │                                            │
+│                               ▼                                            │
+│   ┌────────────────────────────────────────────────────────────────────┐   │
+│   │                 Core Intelligence Layer                            │   │
+│   │                                                                    │   │
+│   │   🔄 Data Validator        (PDF / DOCX / CSV / TXT / JSON)         │   │
+│   │   🤖 Prompt Analyzer       (LLM-based Intent Parsing)              │   │
+│   │   📦 Knowledge Compiler    (FastEmbed + Chunking)                  │   │
+│   │   🧠 Reasoning Engine                                              │   │
+│   │      ├─ Hybrid Search       (Dense + Sparse)                       │   │
+│   │      ├─ Cross-Encoder       (Re-ranking)                           │   │
+│   │      ├─ Source Attribution  (Citation Tracking)                    │   │
+│   │      └─ Faithfulness Scorer (Hallucination Control)                │   │
+│   │                                                                    │   │
+│   └────────────────────────────────────────────────────────────────────┘   │
+│                               │                                            │
+│                               ▼                                            │
+│   ┌────────────────────────────────────────────────────────────────────┐   │
+│   │               External Services Layer                              │   │
+│   │                                                                    │   │
+│   │   🗄 Supabase   → PostgreSQL + pgvector + File Storage             │   │
+│   │   ⚡ Groq API   → LLM Inference + Whisper + Vision                │   │
+│   │   🔊 ElevenLabs → Text-to-Speech                                  │   │
+│   │                                                                    │   │
+│   └────────────────────────────────────────────────────────────────────┘   │
+│                                                                            │
+└────────────────────────────────────────────────────────────────────────────┘
+
+```
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- **Python 3.9+** with pip
+- **Node.js 18+** with npm
+- **PostgreSQL** with `pgvector` extension (or use Supabase)
+- **Groq API Key** - Get free at [console.groq.com](https://console.groq.com)
+
+### Local Development
+
+#### 1. Backend Setup
+
+```bash
+cd backend
+
+# Create virtual environment
+python -m venv venv
+
+# Activate (Windows)
+.\venv\Scripts\activate
+# Activate (macOS/Linux)
+source venv/bin/activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Configure environment
+cp .env.example .env
+# Edit .env and add your API keys
+
+# Run server
+python -m uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+**Backend will run at**: [http://localhost:8000](http://localhost:8000)
+
+#### 2. Frontend Setup
+
+```bash
+cd frontend
+
+# Install dependencies
+npm install
+
+# Start development server
+npm start
+```
+
+**Frontend will run at**: [http://localhost:3000](http://localhost:3000)
+
+---
+
+## 📁 Project Structure
+
+```
+mexar_ultimate/
+├── backend/                    # FastAPI Backend
+│   ├── api/                   # REST API endpoints
+│   │   ├── auth.py           # Authentication (JWT)
+│   │   ├── agents.py         # Agent CRUD
+│   │   ├── chat.py           # Chat + multimodal
+│   │   ├── compile.py        # Knowledge compilation
+│   │   └── websocket.py      # Real-time updates
+│   ├── core/                  # Core configuration
+│   │   ├── config.py         # Settings
+│   │   ├── database.py       # SQLAlchemy setup
+│   │   └── security.py       # JWT handling
+│   ├── models/                # Database models
+│   │   ├── user.py           # User model
+│   │   ├── agent.py          # Agent + CompilationJob
+│   │   ├── chunk.py          # DocumentChunk (pgvector)
+│   │   └── conversation.py   # Chat history
+│   ├── modules/               # Core AI modules
+│   │   ├── data_validator.py # File parsing
+│   │   ├── prompt_analyzer.py # Domain extraction
+│   │   ├── knowledge_compiler.py # Vector embeddings
+│   │   ├── reasoning_engine.py # RAG pipeline
+│   │   └── explainability.py # UI formatting
+│   ├── utils/                 # Utilities
+│   │   ├── groq_client.py    # Groq API wrapper
+│   │   ├── hybrid_search.py  # RRF search fusion
+│   │   ├── reranker.py       # Cross-encoder
+│   │   ├── faithfulness.py   # Claim verification
+│   │   └── source_attribution.py # Citation extraction
+│   ├── main.py               # FastAPI entry point
+│   └── requirements.txt      # Python dependencies
+│
+├── frontend/                  # React Frontend
+│   ├── src/
+│   │   ├── pages/            # React pages
+│   │   │   ├── Landing.jsx   # Home page
+│   │   │   ├── Login.jsx     # Authentication
+│   │   │   ├── Dashboard.jsx # User dashboard
+│   │   │   ├── AgentCreation.jsx # Create agent
+│   │   │   ├── CompilationProgress.jsx # Build progress
+│   │   │   └── Chat.jsx      # Chat interface
+│   │   ├── components/       # Reusable UI
+│   │   ├── contexts/         # React contexts
+│   │   ├── api/              # API client
+│   │   └── App.jsx           # Main component
+│   ├── package.json          # Node dependencies
+│   └── vercel.json           # Vercel config
+│
+├── Dockerfile                 # Docker config for HF Spaces
+└── README.md                  # This file
+```
+---
+### 📸 Screenshot
+<img width="1863" height="918" alt="image" src="https://github.com/user-attachments/assets/75ff2c32-4c90-4e65-ab5f-10c94bad2e65" />
+<img width="330" height="330" alt="image" src="https://github.com/user-attachments/assets/2d9846c9-b002-4f05-b632-6dc1c8c58ad1" />
+<img width="330" height="330" alt="image" src="https://github.com/user-attachments/assets/810de78d-4725-494e-94b5-e8aa71b8b7fd" />
+<img width="330" height="330" alt="image" src="https://github.com/user-attachments/assets/155ea162-d8b9-4b45-acf9-42afc47c8498" />
+<img width="330" height="330" alt="image" src="https://github.com/user-attachments/assets/cadf46a8-c679-4a76-a58d-a956f9cb9cc1" />
+<img width="330" height="330" alt="image" src="https://github.com/user-attachments/assets/598b7925-8001-44a7-ae34-6fddb85b7531" />
+<img width="330" height="330" alt="image" src="https://github.com/user-attachments/assets/e9e99b9d-05b0-4ae5-9990-ed9c9cc124c6" />
+
+---
+
+## 🌐 Deployment
+
+### Current Deployment (Free Tier)
+
+- **Frontend**: Vercel - [https://mexar.vercel.app](https://mexar.vercel.app)
+- **Backend**: Hugging Face Spaces - [https://devrajsinh2012-mexar.hf.space](https://devrajsinh2012-mexar.hf.space)
+- **Database**: Supabase (PostgreSQL with pgvector)
+- **Storage**: Supabase Storage
+- **Total Cost**: $0/month
+
+### Deploy Your Own Instance
+
+#### Deploy Backend to Hugging Face Spaces
+
+1. Fork this repository
+2. Create a new Space at [huggingface.co/new-space](https://huggingface.co/new-space)
+3. Select **Docker** as SDK
+4. Connect your GitHub repository
+5. Add Repository Secrets:
+   - `GROQ_API_KEY`
+   - `DATABASE_URL`
+   - `SUPABASE_URL`
+   - `SUPABASE_KEY`
+   - `SECRET_KEY`
+   - `FRONTEND_URL`
+
+#### Deploy Frontend to Vercel
+
+1. Import repository at [vercel.com](https://vercel.com)
+2. Set **Root Directory** to `frontend`
+3. Add Environment Variable:
+   - `REACT_APP_API_URL` = Your HF Spaces URL
+
+---
+
+## 🔧 Environment Variables
+
+### Backend (`backend/.env`)
+
+```env
+# Required: Get from console.groq.com
+GROQ_API_KEY=your_groq_api_key_here
+
+# Supabase Database
+DATABASE_URL=postgresql://user:password@host:5432/database
+
+# JWT Security
+SECRET_KEY=generate-a-secure-random-key
+
+# Supabase Storage
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your_supabase_service_role_key
+
+# Optional: ElevenLabs TTS
+ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
+
+# Frontend URL for CORS
+FRONTEND_URL=https://mexar.vercel.app
+```
+
+### Frontend (`frontend/.env`)
+
+```env
+# Backend API URL
+REACT_APP_API_URL=https://your-backend.hf.space
+```
+
+---
+
+## 🔍 API Documentation
+
+Once the backend is running, interactive API docs are available at:
+
+- **Swagger UI**: `http://localhost:8000/docs`
+- **ReDoc**: `http://localhost:8000/redoc`
+
+### Key Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/auth/register` | Register new user |
+| POST | `/api/auth/login` | Login (returns JWT) |
+| GET | `/api/agents/` | List all agents |
+| POST | `/api/compile/` | Start agent compilation |
+| GET | `/api/compile/{name}/status` | Check compilation status |
+| POST | `/api/chat/` | Send message to agent |
+| POST | `/api/chat/multimodal` | Send with audio/image |
+
+---
+
+## 🧪 Technologies
+
+### Backend
+- **FastAPI** - Modern async Python web framework
+- **SQLAlchemy** - ORM for PostgreSQL
+- **pgvector** - Vector similarity search
+- **FastEmbed** - Local embedding generation (BAAI/bge-small-en-v1.5)
+- **sentence-transformers** - Cross-encoder reranking
+- **Groq API** - LLM (Llama 3.1/3.3), Whisper (audio), Vision (images)
+
+### Frontend
+- **React 18** - UI framework
+- **Material-UI (MUI)** - Component library
+- **React Router** - Navigation
+- **Axios** - HTTP client
+
+### External Services
+- **Supabase** - Managed PostgreSQL + Storage
+- **Groq** - Fast AI inference (LPU architecture)
+- **ElevenLabs** - Text-to-Speech (optional)
+
+---
+
+## 📊 How It Works
+
+### 1. Agent Creation Flow
+```
+User uploads files → DataValidator parses content
+                  → PromptAnalyzer extracts domain & keywords
+                  → KnowledgeCompiler creates embeddings
+                  → Stored in pgvector database
+```
+
+### 2. Query Processing Flow
+```
+User query → Domain Guardrail check
+          → Hybrid Search (semantic + keyword)
+          → Cross-Encoder Reranking (top 5 results)
+          → LLM Generation with retrieved context
+          → Source Attribution (extract citations)
+          → Faithfulness Scoring (verify grounding)
+          → Explainability Formatting
+```
+
+### 3. Confidence Calculation
+Confidence score is calculated from:
+- **Retrieval Quality** (35%) - Relevance of retrieved chunks
+- **Rerank Score** (30%) - Cross-encoder confidence
+- **Faithfulness** (25%) - Answer grounding in context
+- **Base Floor** (10%) - For in-domain queries
+
+---
+
+## ⚠️ Known Limitations (Free Tier)
+
+1. **Cold Start Delay**: First request after 15 min idle takes 45-90 seconds
+2. **Model Download**: Initial startup takes 3-5 minutes (FastEmbed caching)
+3. **Groq Rate Limits**: 30 requests/min, 14,400/day (free tier)
+4. **Concurrent Users**: 1-2 recommended on free tier (2GB RAM limit)
+5. **Ephemeral Storage**: HF Spaces `/tmp` data lost on restart (Supabase used for persistence)
+
+**Production Migration**: Upgrade to paid tiers for ~$54/month (persistent instances, higher limits)
+
+---
+
+## 🙏 Acknowledgments
+
+- [Groq](https://groq.com) - Fast AI inference with LPU technology
+- [Supabase](https://supabase.com) - PostgreSQL + Storage platform
+- [FastEmbed](https://github.com/qdrant/fastembed) - Lightweight embeddings library
+- [sentence-transformers](https://www.sbert.net) - Reranking models
+- [Hugging Face](https://huggingface.co) - Free ML model hosting
+
+---
+
+## 🤝 Contribution
+
+This project is built by Devrajsinh Gohil and Jay Nasit under the guidance of Prof OM Prakash Suthar.
+
+**Built with ❤️ using modern AI technologies**
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

backend/.env.example

@@ -0,0 +1,42 @@
+# MEXAR Core Engine - Backend Environment Variables
+# Copy this file to .env and fill in your values
+
+# ===========================================
+# REQUIRED: Groq API (LLM, Whisper, Vision)
+# ===========================================
+# Get your free API key at: https://console.groq.com
+GROQ_API_KEY=your_groq_api_key_here
+
+# ===========================================
+# REQUIRED: Database
+# ===========================================
+# PostgreSQL with pgvector extension
+# For Supabase: Copy from Settings > Database > Connection string
+DATABASE_URL=postgresql://user:password@host:5432/database
+
+# ===========================================
+# REQUIRED: Security
+# ===========================================
+# Generate a secure random key for JWT tokens
+# Example: python -c "import secrets; print(secrets.token_urlsafe(32))"
+SECRET_KEY=your_secure_secret_key_here
+
+# ===========================================
+# REQUIRED: Supabase Storage
+# ===========================================
+# Get from Supabase Dashboard > Settings > API
+SUPABASE_URL=https://your-project-id.supabase.co
+SUPABASE_KEY=your_supabase_service_role_key
+
+# ===========================================
+# OPTIONAL: Text-to-Speech
+# ===========================================
+# ElevenLabs API (10,000 chars/month free)
+# Get at: https://elevenlabs.io
+ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
+
+# ===========================================
+# OPTIONAL: Local Storage Path
+# ===========================================
+# For development only, production uses Supabase Storage
+STORAGE_PATH=./data/storage

backend/Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    postgresql-client \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python packages
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Set environment for model caching to /tmp (only writable dir in HF Spaces)
+ENV HF_HOME=/tmp/.cache/huggingface
+ENV FASTEMBED_CACHE_PATH=/tmp/.cache/fastembed
+ENV SENTENCE_TRANSFORMERS_HOME=/tmp/.cache/sentence-transformers
+
+# Expose port 7860 (required by Hugging Face Spaces)
+EXPOSE 7860
+
+# Run FastAPI with uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/Procfile

@@ -0,0 +1 @@
+web: python -m uvicorn main:app --host 0.0.0.0 --port $PORT

backend/api/admin.py

@@ -0,0 +1,53 @@
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from core.cache import cache
+from core.monitoring import analytics
+from api.deps import get_current_user
+from models.user import User
+
+router = APIRouter(prefix="/api/admin", tags=["admin"])
+
+@router.get("/stats")
+def get_system_stats(
+    current_user: User = Depends(get_current_user)
+):
+    """Get system statistics (admin only)."""
+    # In production, add admin check
+    stats = analytics.get_stats()
+    cache_stats = cache.get_stats()
+    
+    return {
+        "analytics": stats,
+        "cache": cache_stats
+    }
+
+@router.get("/health")
+def detailed_health_check():
+    """Detailed health check endpoint."""
+    return {
+        "status": "healthy",
+        "services": {
+            "database": "connected",
+            "cache": "active",
+            "workers": "ready"
+        }
+    }
+
+@router.post("/cache/clear")
+def clear_cache(
+    current_user: User = Depends(get_current_user)
+):
+    """Clear all cache entries."""
+    cache.clear()
+    return {"message": "Cache cleared successfully"}
+
+@router.post("/analytics/reset")
+def reset_analytics(
+    current_user: User = Depends(get_current_user)
+):
+    """Reset analytics counters."""
+    analytics.reset()
+    return {"message": "Analytics reset successfully"}

backend/api/agents.py

@@ -0,0 +1,281 @@
+"""
+MEXAR Agents API - Phase 2  
+Handles agent CRUD operations and knowledge graph data.
+"""
+
+import json
+import logging
+from typing import List, Optional
+from datetime import datetime
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from pydantic import BaseModel, ConfigDict
+
+from core.database import get_db
+from services.agent_service import agent_service
+from api.deps import get_current_user
+from models.user import User
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/agents", tags=["agents"])
+
+
+# ===== PYDANTIC MODELS =====
+
+class AgentCreate(BaseModel):
+    name: str
+    system_prompt: str
+
+
+class AgentResponse(BaseModel):
+    id: int
+    name: str
+    status: str
+    domain: Optional[str] = None
+    entity_count: int
+    created_at: datetime
+    stats: dict = {}
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+# ===== LIST AGENTS =====
+
+@router.get("/", response_model=List[AgentResponse])
+def list_agents(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """List all agents owned by the current user."""
+    agents = agent_service.list_agents(db, current_user)
+    response = []
+    
+    for agent in agents:
+        stats = {}
+        if agent.storage_path:
+            try:
+                metadata_path = Path(agent.storage_path) / "metadata.json"
+                if metadata_path.exists():
+                    with open(metadata_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        stats = data.get("stats", {})
+            except Exception as e:
+                logger.warning(f"Failed to load stats for agent {agent.name}: {e}")
+        
+        # Convert SQLAlchemy object to dict to include extra fields
+        agent_dict = {
+            "id": agent.id,
+            "name": agent.name,
+            "status": agent.status,
+            "domain": agent.domain,
+            "entity_count": agent.entity_count,
+            "created_at": agent.created_at,
+            "stats": stats
+        }
+        response.append(agent_dict)
+        
+    return response
+
+
+# ===== CREATE AGENT =====
+
+@router.post("/", response_model=AgentResponse)
+def create_agent(
+    agent_in: AgentCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Create a new agent entry (compilation happens via /api/compile)."""
+    try:
+        return agent_service.create_agent(
+            db, 
+            current_user, 
+            agent_in.name, 
+            agent_in.system_prompt
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# ===== GET AGENT DETAILS =====
+
+@router.get("/{agent_name}")
+def get_agent_details(
+    agent_name: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Get full details of an agent including compiled stats."""
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    # Build response with database info
+    response = {
+        "id": agent.id,
+        "name": agent.name,
+        "status": agent.status,
+        "system_prompt": agent.system_prompt,
+        "domain": agent.domain,
+        "created_at": agent.created_at,
+        "entity_count": agent.entity_count,
+        "storage_path": agent.storage_path,
+        "stats": {},
+        "metadata": {}
+    }
+    
+    # Load compiled metadata for stats
+    if agent.storage_path:
+        storage_path = Path(agent.storage_path)
+        metadata_file = storage_path / "metadata.json"
+        
+        if metadata_file.exists():
+            try:
+                with open(metadata_file, 'r', encoding='utf-8') as f:
+                    metadata = json.load(f)
+                response["metadata"] = metadata
+                response["stats"] = metadata.get("stats", {})
+            except Exception as e:
+                logger.warning(f"Failed to load metadata for {agent_name}: {e}")
+    
+    return response
+
+
+# ===== GET KNOWLEDGE GRAPH DATA =====
+
+@router.get("/{agent_name}/graph")
+def get_agent_graph(
+    agent_name: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get knowledge graph data for D3.js visualization.
+    
+    Returns nodes and links in D3-compatible format.
+    """
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    if agent.status != "ready":
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Agent is not ready. Status: {agent.status}"
+        )
+    
+    # Load knowledge graph from file
+    storage_path = Path(agent.storage_path)
+    graph_file = storage_path / "knowledge_graph.json"
+    
+    if not graph_file.exists():
+        raise HTTPException(status_code=404, detail="Knowledge graph not found")
+    
+    try:
+        with open(graph_file, 'r', encoding='utf-8') as f:
+            graph_data = json.load(f)
+        
+        # Convert to D3.js format
+        nodes = []
+        links = []
+        node_ids = set()
+        
+        # Extract nodes from graph data
+        if "nodes" in graph_data:
+            for node in graph_data["nodes"]:
+                node_id = node.get("id", str(node))
+                if node_id not in node_ids:
+                    nodes.append({
+                        "id": node_id,
+                        "label": node.get("label", node_id),
+                        "type": node.get("type", "entity"),
+                        "group": hash(node.get("type", "entity")) % 10
+                    })
+                    node_ids.add(node_id)
+        
+        # Extract links/edges
+        if "edges" in graph_data:
+            for edge in graph_data["edges"]:
+                source = edge.get("source", edge.get("from"))
+                target = edge.get("target", edge.get("to"))
+                if source and target:
+                    links.append({
+                        "source": source,
+                        "target": target,
+                        "label": edge.get("relation", edge.get("label", "")),
+                        "weight": edge.get("weight", 1)
+                    })
+        elif "links" in graph_data:
+            links = graph_data["links"]
+        
+        return {
+            "nodes": nodes,
+            "links": links,
+            "stats": {
+                "node_count": len(nodes),
+                "link_count": len(links)
+            }
+        }
+        
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse knowledge graph: {e}")
+        raise HTTPException(status_code=500, detail="Invalid graph data")
+    except Exception as e:
+        logger.error(f"Error loading graph: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ===== GET AGENT EXPLAINABILITY =====
+
+@router.get("/{agent_name}/explainability")
+def get_agent_explainability(
+    agent_name: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Get explainability metadata for an agent."""
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    storage_path = Path(agent.storage_path)
+    metadata_file = storage_path / "metadata.json"
+    
+    if not metadata_file.exists():
+        return {"explainability": None}
+    
+    try:
+        with open(metadata_file, 'r', encoding='utf-8') as f:
+            metadata = json.load(f)
+        
+        return {
+            "agent_name": agent_name,
+            "domain": metadata.get("prompt_analysis", {}).get("domain"),
+            "domain_signature": metadata.get("domain_signature", []),
+            "capabilities": metadata.get("prompt_analysis", {}).get("capabilities", []),
+            "stats": metadata.get("stats", {})
+        }
+    except Exception as e:
+        logger.warning(f"Failed to load explainability for {agent_name}: {e}")
+        return {"explainability": None}
+
+
+# ===== DELETE AGENT =====
+
+@router.delete("/{agent_name}")
+def delete_agent(
+    agent_name: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Delete an agent and its files."""
+    try:
+        agent_service.delete_agent(db, current_user, agent_name)
+        return {"message": f"Agent '{agent_name}' deleted successfully"}
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

backend/api/auth.py

@@ -0,0 +1,110 @@
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, EmailStr
+from core.database import get_db
+from services.auth_service import auth_service
+from api.deps import get_current_user
+from models.user import User
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+# Pydantic models
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+    user: dict
+
+class PasswordChange(BaseModel):
+    old_password: str
+    new_password: str
+
+class UserPreferences(BaseModel):
+    tts_provider: str = "elevenlabs"
+    auto_play_tts: bool = False
+    other: Optional[Dict[str, Any]] = {}
+
+@router.post("/register", response_model=dict)
+def register(user_in: UserCreate, db: Session = Depends(get_db)):
+    """Register a new user"""
+    try:
+        user = auth_service.register_user(db, user_in.email, user_in.password)
+        return {"message": "User registered successfully", "id": user.id, "email": user.email}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/login", response_model=Token)
+def login(user_in: UserLogin, db: Session = Depends(get_db)):
+    """Login and get token"""
+    result = auth_service.authenticate_user(db, user_in.email, user_in.password)
+    if not result:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return result
+
+@router.get("/me")
+def read_users_me(current_user: User = Depends(get_current_user)):
+    """Get current user data"""
+    return {
+        "id": current_user.id,
+        "email": current_user.email,
+        "id": current_user.id,
+        "email": current_user.email,
+        "created_at": current_user.created_at,
+        "preferences": current_user.preferences or {}
+    }
+
+@router.put("/preferences")
+def update_preferences(
+    prefs: UserPreferences,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Update user preferences"""
+    # Initialize defaults if None
+    current_prefs = dict(current_user.preferences) if current_user.preferences else {}
+    
+    # Update values
+    current_prefs["tts_provider"] = prefs.tts_provider
+    current_prefs["auto_play_tts"] = prefs.auto_play_tts
+    if prefs.other:
+        current_prefs.update(prefs.other)
+        
+    current_user.preferences = current_prefs
+    db.commit()
+    db.refresh(current_user)
+    
+    return {"message": "Preferences updated", "preferences": current_user.preferences}
+
+@router.post("/change-password")
+def change_password(
+    password_data: PasswordChange,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Change user password"""
+    try:
+        auth_service.change_password(
+            db, 
+            current_user.email, 
+            password_data.old_password, 
+            password_data.new_password
+        )
+        return {"message": "Password updated successfully"}
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )

backend/api/chat.py

@@ -0,0 +1,511 @@
+"""
+MEXAR Chat API - Phase 2
+Handles all chat interactions with agents.
+"""
+
+from typing import Optional
+from pathlib import Path
+import shutil
+import uuid
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form
+from fastapi.responses import FileResponse
+from sqlalchemy.orm import Session
+from pydantic import BaseModel
+
+from core.database import get_db
+from services.agent_service import agent_service
+from services.tts_service import get_tts_service
+from services.storage_service import storage_service
+from services.conversation_service import conversation_service
+from api.deps import get_current_user
+from models.user import User
+from modules.reasoning_engine import create_reasoning_engine
+from modules.explainability import create_explainability_generator
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/chat", tags=["chat"])
+
+
+# Pydantic models for JSON requests
+class ChatRequest(BaseModel):
+    agent_name: str
+    message: str
+    include_explainability: bool = True
+    include_tts: bool = False
+    tts_provider: str = "elevenlabs"  # "elevenlabs" or "web_speech"
+
+
+class MultimodalChatRequest(BaseModel):
+    agent_name: str
+    message: str = ""
+
+
+class TTSRequest(BaseModel):
+    text: str
+    provider: str = "elevenlabs"  # "elevenlabs" or "web_speech"
+    voice_id: Optional[str] = None
+
+
+# ===== MAIN CHAT ENDPOINT (JSON) =====
+
+@router.post("")
+@router.post("/")
+async def chat_json(
+    request: ChatRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Chat with an agent using JSON body.
+    This is the primary endpoint used by the frontend.
+    """
+    # Get agent with ownership check
+    agent = agent_service.get_agent(db, current_user, request.agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail=f"Agent '{request.agent_name}' not found")
+    
+    if agent.status != "ready":
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Agent is not ready. Current status: {agent.status}"
+        )
+
+    # Get/Create conversation
+    conversation = conversation_service.get_or_create_conversation(
+        db, agent.id, current_user.id
+    )
+
+    # Log USER message
+    conversation_service.add_message(
+        db, conversation.id, "user", request.message
+    )
+    
+    try:
+        # Use agent's storage path for reasoning engine
+        storage_path = Path(agent.storage_path).parent
+        engine = create_reasoning_engine(str(storage_path))
+        
+        result = engine.reason(
+            agent_name=agent.name,
+            query=request.message
+        )
+        
+        response = {
+            "success": True,
+            "answer": result["answer"],
+            "confidence": result["confidence"],
+            "in_domain": result["in_domain"]
+        }
+        
+        if request.include_explainability:
+            try:
+                explainer = create_explainability_generator()
+                response["explainability"] = explainer.generate(result)
+            except Exception as e:
+                logger.warning(f"Explainability generation failed: {e}")
+                response["explainability"] = result.get("explainability")
+        
+        # Log ASSISTANT message
+        conversation_service.add_message(
+            db, 
+            conversation.id, 
+            "assistant", 
+            result["answer"], 
+            explainability_data=response.get("explainability"),
+            confidence=result["confidence"]
+        )
+
+        # Generate TTS if requested
+        if request.include_tts:
+            try:
+                tts_service = get_tts_service()
+                tts_result = tts_service.generate_speech(
+                    text=result["answer"],
+                    provider=request.tts_provider
+                )
+                response["tts"] = tts_result
+            except Exception as e:
+                logger.warning(f"TTS generation failed: {e}")
+                response["tts"] = {"success": False, "error": str(e)}
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Chat error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ===== MULTIMODAL CHAT ENDPOINT =====
+
+@router.post("/multimodal")
+async def chat_multimodal(
+    agent_name: str = Form(...),
+    message: str = Form(""),
+    audio: UploadFile = File(None),
+    image: UploadFile = File(None),
+    include_explainability: bool = Form(True),
+    include_tts: bool = Form(False),
+    tts_provider: str = Form("elevenlabs"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Chat with an agent using multimodal inputs (audio/image).
+    Uses multipart form data.
+    """
+    from modules.multimodal_processor import create_multimodal_processor
+    
+    # Get agent with ownership check
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail=f"Agent '{agent_name}' not found")
+    
+    if agent.status != "ready":
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Agent is not ready. Current status: {agent.status}"
+        )
+    
+    # Get/Create conversation
+    conversation = conversation_service.get_or_create_conversation(
+        db, agent.id, current_user.id
+    )
+
+    try:
+        multimodal_context = ""
+        audio_url = None
+        image_url = None
+        
+        # Process audio if provided
+        if audio and audio.filename:
+            # Upload to Supabase Storage
+            upload_result = await storage_service.upload_file(
+                file=audio,
+                bucket="chat-media",
+                folder=f"audio/{agent.id}"
+            )
+            audio_url = upload_result["url"]
+            
+            # Save temporarily for processing
+            temp_dir = Path("data/temp")
+            temp_dir.mkdir(parents=True, exist_ok=True)
+            temp_path = temp_dir / f"{uuid.uuid4()}{Path(audio.filename).suffix}"
+            
+            with open(temp_path, "wb") as buffer:
+                await audio.seek(0)  # Reset file pointer
+                shutil.copyfileobj(audio.file, buffer)
+            
+            processor = create_multimodal_processor()
+            audio_text = processor.process_audio(str(temp_path))
+            if audio_text:
+                multimodal_context += f"\n[AUDIO TRANSCRIPTION]: {audio_text}"
+            
+            # Clean up temp file
+            try:
+                temp_path.unlink()
+            except:
+                pass
+        
+        # Process image if provided
+        if image and image.filename:
+            # Upload to Supabase Storage
+            upload_result = await storage_service.upload_file(
+                file=image,
+                bucket="chat-media",
+                folder=f"images/{agent.id}"
+            )
+            image_url = upload_result["url"]
+            logger.info(f"[MULTIMODAL] Image uploaded to Supabase: {image_url}")
+            
+            # Save temporarily for processing
+            temp_dir = Path("data/temp")
+            temp_dir.mkdir(parents=True, exist_ok=True)
+            temp_path = temp_dir / f"{uuid.uuid4()}{Path(image.filename).suffix}"
+            
+            logger.info(f"[MULTIMODAL] Saving temp file: {temp_path}")
+            
+            with open(temp_path, "wb") as buffer:
+                await image.seek(0)  # Reset file pointer
+                shutil.copyfileobj(image.file, buffer)
+            
+            file_size = temp_path.stat().st_size
+            logger.info(f"[MULTIMODAL] Temp file saved, size: {file_size} bytes")
+            
+            try:
+                logger.info(f"[MULTIMODAL] Starting image analysis with Groq Vision...")
+                processor = create_multimodal_processor()
+                image_result = processor.process_image(str(temp_path))
+                
+                logger.info(f"[MULTIMODAL] Image processing result: {image_result.get('success')}")
+                
+                if image_result.get("success"):
+                    image_desc = image_result.get("description", "")
+                    if image_desc:
+                        logger.info(f"[MULTIMODAL] ✓ Image analyzed successfully, description length: {len(image_desc)} chars")
+                        logger.info(f"[MULTIMODAL] Description preview: {image_desc[:150]}...")
+                        multimodal_context += f"\n[IMAGE DESCRIPTION]: {image_desc}"
+                    else:
+                        logger.warning(f"[MULTIMODAL] Image analysis returned success but empty description")
+                        multimodal_context += f"\n[IMAGE]: User uploaded an image named {image.filename}"
+                else:
+                    # Log error but don't fail - provide basic context
+                    error_msg = image_result.get('error', 'Unknown error')
+                    error_type = image_result.get('error_type', 'Unknown')
+                    logger.warning(f"[MULTIMODAL] Image analysis failed - {error_type}: {error_msg}")
+                    multimodal_context += f"\n[IMAGE]: User uploaded an image named {image.filename}"
+                    
+            except Exception as e:
+                logger.error(f"[MULTIMODAL] Image processing exception: {type(e).__name__}: {str(e)}")
+                import traceback
+                logger.error(f"[MULTIMODAL] Traceback: {traceback.format_exc()}")
+                multimodal_context += f"\n[IMAGE]: User uploaded an image named {image.filename}"
+            
+            # Clean up temp file
+            try:
+                temp_path.unlink()
+                logger.info(f"[MULTIMODAL] Temp file cleaned up")
+            except:
+                pass
+        
+        # Run reasoning
+        storage_path = Path(agent.storage_path).parent
+        engine = create_reasoning_engine(str(storage_path))
+        
+        result = engine.reason(
+            agent_name=agent.name,
+            query=message,
+            multimodal_context=multimodal_context
+        )
+
+        # Log USER message with attachments
+        conversation_service.add_message(
+            db, 
+            conversation.id, 
+            "user", 
+            message,
+            multimodal_data={
+                "audio_url": audio_url,
+                "image_url": image_url
+            }
+        )
+        
+        response = {
+            "success": True,
+            "answer": result["answer"],
+            "confidence": result["confidence"],
+            "in_domain": result["in_domain"],
+            "audio_url": audio_url,
+            "image_url": image_url
+        }
+        
+        if include_explainability:
+            try:
+                explainer = create_explainability_generator()
+                response["explainability"] = explainer.generate(result)
+            except Exception:
+                response["explainability"] = result.get("explainability")
+        
+        # Log ASSISTANT message
+        conversation_service.add_message(
+            db, 
+            conversation.id, 
+            "assistant", 
+            result["answer"],
+            explainability_data=response.get("explainability"),
+            confidence=result["confidence"]
+        )
+
+        # Generate TTS if requested
+        if include_tts:
+            try:
+                tts_service = get_tts_service()
+                tts_result = tts_service.generate_speech(
+                    text=result["answer"],
+                    provider=tts_provider
+                )
+                response["tts"] = tts_result
+            except Exception as e:
+                logger.warning(f"TTS generation failed: {e}")
+                response["tts"] = {"success": False, "error": str(e)}
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Multimodal chat error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ===== HISTORY ENDPOINTS =====
+
+@router.get("/{agent_name}/history")
+def get_chat_history(
+    agent_name: str,
+    limit: int = 50,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Get conversation history with an agent."""
+    from services.conversation_service import conversation_service
+    
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    history = conversation_service.get_conversation_history(
+        db, agent.id, current_user.id, limit
+    )
+    return {"messages": history}
+
+
+@router.delete("/{agent_name}/history")
+def clear_chat_history(
+    agent_name: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Clear conversation history with an agent."""
+    from models.conversation import Conversation
+    
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    conversation = db.query(Conversation).filter(
+        Conversation.agent_id == agent.id,
+        Conversation.user_id == current_user.id
+    ).first()
+    
+    if conversation:
+        db.delete(conversation)
+        db.commit()
+    
+    return {"message": "Chat history cleared"}
+
+
+# ===== TEXT-TO-SPEECH ENDPOINTS =====
+
+@router.post("/tts/generate")
+async def generate_tts(
+    request: TTSRequest,
+    current_user: User = Depends(get_current_user)
+):
+    """Generate text-to-speech audio."""
+    try:
+        tts_service = get_tts_service()
+        result = tts_service.generate_speech(
+            text=request.text,
+            provider=request.provider,
+            voice_id=request.voice_id
+        )
+        return result
+    except Exception as e:
+        logger.error(f"TTS generation error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/tts/audio/{filename}")
+async def serve_tts_audio(filename: str):
+    """Serve cached TTS audio files."""
+    audio_path = Path("data/tts_cache") / filename
+    
+    if not audio_path.exists():
+        raise HTTPException(status_code=404, detail="Audio file not found")
+    
+    return FileResponse(
+        path=audio_path,
+        media_type="audio/mpeg",
+        filename=filename
+    )
+
+
+@router.get("/tts/voices")
+async def get_tts_voices(
+    provider: str = "elevenlabs",
+    current_user: User = Depends(get_current_user)
+):
+    """Get available TTS voices for a provider."""
+    try:
+        tts_service = get_tts_service()
+        voices = tts_service.get_available_voices(provider)
+        return {"provider": provider, "voices": voices}
+    except Exception as e:
+        logger.error(f"Failed to fetch voices: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/tts/quota")
+async def get_tts_quota(current_user: User = Depends(get_current_user)):
+    """Check TTS quota for ElevenLabs."""
+    try:
+        tts_service = get_tts_service()
+        quota = tts_service.check_quota()
+        return quota
+    except Exception as e:
+        logger.error(f"Failed to check quota: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ===== LIVE AUDIO TRANSCRIPTION =====
+
+@router.post("/transcribe")
+async def transcribe_audio(
+    audio: UploadFile = File(...),
+    language: str = Form("en"),
+    current_user: User = Depends(get_current_user)
+):
+    """Transcribe uploaded audio (for live recording)."""
+    from modules.multimodal_processor import create_multimodal_processor
+    
+    try:
+        # Save audio temporarily
+        temp_dir = Path("data/temp")
+        temp_dir.mkdir(parents=True, exist_ok=True)
+        
+        temp_path = temp_dir / f"{uuid.uuid4()}{Path(audio.filename).suffix}"
+        
+        with open(temp_path, "wb") as buffer:
+            shutil.copyfileobj(audio.file, buffer)
+        
+        # Transcribe
+        processor = create_multimodal_processor()
+        result = processor.process_audio(str(temp_path), language)
+        
+        # Clean up
+        try:
+            temp_path.unlink()
+        except:
+            pass
+        
+        if result.get("success"):
+            return {
+                "success": True,
+                "transcript": result.get("transcript", ""),
+                "language": language,
+                "word_count": result.get("word_count", 0)
+            }
+        else:
+            raise HTTPException(status_code=500, detail=result.get("error", "Transcription failed"))
+        
+    except Exception as e:
+        logger.error(f"Audio transcription error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ===== UTILITY FUNCTIONS =====
+
+async def save_upload(file: UploadFile, base_path: str, subfolder: str) -> str:
+    """Save an uploaded file and return its path."""
+    upload_dir = Path(base_path) / subfolder
+    upload_dir.mkdir(parents=True, exist_ok=True)
+    
+    ext = Path(file.filename).suffix
+    filename = f"{uuid.uuid4()}{ext}"
+    file_path = upload_dir / filename
+    
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    return str(file_path)

backend/api/compile.py

@@ -0,0 +1,109 @@
+
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form
+from sqlalchemy.orm import Session
+import tempfile
+from pathlib import Path
+
+from core.database import get_db
+from services.agent_service import agent_service
+from services.storage_service import storage_service
+from workers.compilation_worker import compilation_worker
+from api.deps import get_current_user
+from models.user import User
+
+router = APIRouter(prefix="/api/compile", tags=["compile"])
+
+@router.post("/")
+async def compile_agent_v2(
+    files: List[UploadFile] = File(...),
+    agent_name: str = Form(...),
+    system_prompt: str = Form(...),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Compile an agent from uploaded files (Phase 2 - Database integrated).
+    
+    Creates agent record in database and starts background compilation.
+    """
+    if not files:
+        raise HTTPException(status_code=400, detail="No files uploaded")
+    if not agent_name or not agent_name.strip():
+        raise HTTPException(status_code=400, detail="Agent name is required")
+    if not system_prompt or not system_prompt.strip():
+        raise HTTPException(status_code=400, detail="System prompt is required")
+    
+    try:
+        # Create agent record
+        agent = agent_service.create_agent(db, current_user, agent_name, system_prompt)
+        
+        # Read file contents and upload to Supabase
+        files_data = []
+        for file in files:
+            content = await file.read()
+            
+            # Upload to Supabase Storage (agent-uploads bucket)
+            try:
+                upload_result = await storage_service.upload_file(
+                    file=file,
+                    bucket="agent-uploads",
+                    folder=f"raw/{agent.id}"
+                )
+                storage_path = upload_result["path"]
+                storage_url = upload_result["url"]
+            except Exception as e:
+                logger.error(f"Failed to upload raw file to Supabase: {e}")
+                storage_path = None
+                storage_url = None
+
+            files_data.append({
+                "filename": file.filename,
+                "content": content.decode("utf-8", errors="ignore"),
+                "storage_path": storage_path,
+                "storage_url": storage_url
+            })
+        
+        # Start background compilation
+        job = compilation_worker.start_compilation(
+            db=db,
+            agent=agent,
+            files_data=files_data
+        )
+        
+        return {
+            "success": True,
+            "message": f"Compilation started for agent '{agent.name}'",
+            "agent_id": agent.id,
+            "agent_name": agent.name,
+            "job_id": job.id
+        }
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{agent_name}/status")
+def get_compilation_status(
+    agent_name: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Get compilation status for an agent."""
+    agent = agent_service.get_agent(db, current_user, agent_name)
+    if not agent:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    job_status = compilation_worker.get_job_status(db, agent.id)
+    
+    if not job_status:
+        return {
+            "status": agent.status,
+            "message": "No compilation job found"
+        }
+    
+    return {
+        "agent_status": agent.status,
+        "job": job_status
+    }

backend/api/deps.py

@@ -0,0 +1,32 @@
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+from sqlalchemy.orm import Session
+from core.database import get_db
+from core.config import settings
+from models.user import User
+from core.security import decode_token
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    payload = decode_token(token)
+    if payload is None:
+        raise credentials_exception
+        
+    email: str = payload.get("sub")
+    if email is None:
+        raise credentials_exception
+        
+    user = db.query(User).filter(User.email == email).first()
+    if user is None:
+        raise credentials_exception
+        
+    return user

backend/api/diagnostics.py

@@ -0,0 +1,133 @@
+"""
+Compilation Health Monitoring API
+
+Provides endpoints to monitor compilation job health and detect issues.
+"""
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from sqlalchemy import text
+from core.database import get_db
+from api.deps import get_current_user
+from models.user import User
+from datetime import datetime, timedelta
+
+router = APIRouter(prefix="/api/diagnostics", tags=["diagnostics"])
+
+@router.get("/compilation-health")
+def get_compilation_health(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get overall compilation health status.
+    Shows active jobs, stuck jobs, and recent failures.
+    """
+    
+    # Active jobs
+    active_result = db.execute(text("""
+        SELECT COUNT(*) as count
+        FROM compilation_jobs cj
+        JOIN agents a ON cj.agent_id = a.id
+        WHERE cj.status = 'in_progress'
+        AND a.user_id = :user_id
+    """), {"user_id": current_user.id})
+    active_count = active_result.fetchone().count
+    
+    # Stuck jobs (running > 30 minutes)
+    stuck_result = db.execute(text("""
+        SELECT 
+            cj.id,
+            a.name as agent_name,
+            cj.progress,
+            cj.current_step,
+            EXTRACT(EPOCH FROM (NOW() - cj.created_at)) / 60 as minutes_running
+        FROM compilation_jobs cj
+        JOIN agents a ON cj.agent_id = a.id
+        WHERE cj.status = 'in_progress'
+        AND a.user_id = :user_id
+        AND cj.created_at < NOW() - INTERVAL '30 minutes'
+    """), {"user_id": current_user.id})
+    stuck_jobs = stuck_result.fetchall()
+    
+    # Recent failures (last 24 hours)
+    failed_result = db.execute(text("""
+        SELECT 
+            a.name as agent_name,
+            cj.error_message,
+            cj.created_at
+        FROM compilation_jobs cj
+        JOIN agents a ON cj.agent_id = a.id
+        WHERE cj.status = 'failed'
+        AND a.user_id = :user_id
+        AND cj.created_at > NOW() - INTERVAL '24 hours'
+        ORDER BY cj.created_at DESC
+        LIMIT 5
+    """), {"user_id": current_user.id})
+    recent_failures = failed_result.fetchall()
+    
+    # Success rate (last 24 hours)
+    stats_result = db.execute(text("""
+        SELECT 
+            COUNT(*) as total,
+            SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+            SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed
+        FROM compilation_jobs cj
+        JOIN agents a ON cj.agent_id = a.id
+        WHERE a.user_id = :user_id
+        AND cj.created_at > NOW() - INTERVAL '24 hours'
+    """), {"user_id": current_user.id})
+    stats = stats_result.fetchone()
+    
+    success_rate = (stats.completed / stats.total * 100) if stats.total > 0 else 0
+    
+    return {
+        "status": "healthy" if len(stuck_jobs) == 0 else "warning",
+        "active_jobs": active_count,
+        "stuck_jobs": [
+            {
+                "id": job.id,
+                "agent_name": job.agent_name,
+                "progress": job.progress,
+                "current_step": job.current_step,
+                "minutes_running": round(job.minutes_running, 1)
+            }
+            for job in stuck_jobs
+        ],
+        "recent_failures": [
+            {
+                "agent_name": f.agent_name,
+                "error": f.error_message,
+                "created_at": f.created_at.isoformat()
+            }
+            for f in recent_failures
+        ],
+        "stats_24h": {
+            "total_jobs": stats.total,
+            "completed": stats.completed,
+            "failed": stats.failed,
+            "success_rate": round(success_rate, 1)
+        }
+    }
+
+@router.get("/embedding-model-status")
+def get_embedding_model_status():
+    """Check if the embedding model is working"""
+    try:
+        from fastembed import TextEmbedding
+        
+        model = TextEmbedding(model_name="BAAI/bge-small-en-v1.5")
+        test_text = ["Test sentence"]
+        embeddings = list(model.embed(test_text))
+        
+        return {
+            "status": "healthy",
+            "model": "BAAI/bge-small-en-v1.5",
+            "dimension": len(embeddings[0]),
+            "message": "Embedding model is working correctly"
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }

backend/api/prompts.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from modules.prompt_analyzer import create_prompt_analyzer, get_prompt_templates
+
+router = APIRouter(prefix="/api", tags=["prompts"])
+
+class AnalyzeRequest(BaseModel):
+    prompt: str
+
+@router.get("/prompt-templates")
+async def get_templates():
+    """Get available system prompt templates."""
+    try:
+        templates = get_prompt_templates()
+        return {"templates": templates}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/analyze-prompt")
+async def analyze_prompt_endpoint(request: AnalyzeRequest):
+    """Analyze a system prompt to extract domain and metadata."""
+    try:
+        analyzer = create_prompt_analyzer()
+        analysis = analyzer.analyze_prompt(request.prompt)
+        return {"analysis": analysis}
+    except Exception as e:
+        # Fallback is handled inside analyze_prompt, but just in case
+        raise HTTPException(status_code=500, detail=str(e))

backend/api/websocket.py

@@ -0,0 +1,113 @@
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Depends
+from sqlalchemy.orm import Session
+import asyncio
+import json
+
+from core.database import get_db, SessionLocal
+from services.agent_service import agent_service
+from workers.compilation_worker import compilation_worker
+
+router = APIRouter(tags=["websocket"])
+
+class ConnectionManager:
+    """Manages WebSocket connections for real-time updates."""
+    
+    def __init__(self):
+        self.active_connections: dict = {}  # agent_name -> list of websockets
+    
+    async def connect(self, websocket: WebSocket, agent_name: str):
+        await websocket.accept()
+        if agent_name not in self.active_connections:
+            self.active_connections[agent_name] = []
+        self.active_connections[agent_name].append(websocket)
+    
+    def disconnect(self, websocket: WebSocket, agent_name: str):
+        if agent_name in self.active_connections:
+            if websocket in self.active_connections[agent_name]:
+                self.active_connections[agent_name].remove(websocket)
+            if not self.active_connections[agent_name]:
+                del self.active_connections[agent_name]
+    
+    async def send_update(self, agent_name: str, data: dict):
+        if agent_name in self.active_connections:
+            for connection in self.active_connections[agent_name]:
+                try:
+                    await connection.send_json(data)
+                except:
+                    pass  # Connection might be closed
+
+manager = ConnectionManager()
+
+@router.websocket("/ws/compile/{agent_name}")
+async def websocket_compile_progress(websocket: WebSocket, agent_name: str):
+    """WebSocket endpoint for real-time compilation progress."""
+    await manager.connect(websocket, agent_name)
+    
+    try:
+        while True:
+            # Get current status
+            db = SessionLocal()
+            try:
+                # Find agent by name (without user check for WebSocket)
+                from models.agent import Agent
+                agent = db.query(Agent).filter(Agent.name == agent_name).first()
+                
+                if agent:
+                    job_status = compilation_worker.get_job_status(db, agent.id)
+                    
+                    status_data = {
+                        "type": "progress",
+                        "agent_status": agent.status,
+                        "job": job_status
+                    }
+                    
+                    await websocket.send_json(status_data)
+                    
+                    # Stop polling if complete or failed
+                    if agent.status in ["ready", "failed"]:
+                        await websocket.send_json({
+                            "type": "complete",
+                            "agent_status": agent.status
+                        })
+                        break
+            finally:
+                db.close()
+            
+            # Wait before next update
+            await asyncio.sleep(1)
+            
+            # Check for client messages (for keepalive)
+            try:
+                await asyncio.wait_for(websocket.receive_text(), timeout=0.1)
+            except asyncio.TimeoutError:
+                pass
+                
+    except WebSocketDisconnect:
+        manager.disconnect(websocket, agent_name)
+    except Exception as e:
+        print(f"WebSocket error: {e}")
+        manager.disconnect(websocket, agent_name)
+
+
+@router.websocket("/ws/chat/{agent_name}")
+async def websocket_chat(websocket: WebSocket, agent_name: str):
+    """WebSocket endpoint for real-time chat (future streaming support)."""
+    await websocket.accept()
+    
+    try:
+        while True:
+            # Receive message from client
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            # Echo back for now (streaming will be implemented later)
+            await websocket.send_json({
+                "type": "message",
+                "content": f"Received: {message.get('content', '')}"
+            })
+            
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        print(f"Chat WebSocket error: {e}")

backend/core/cache.py

@@ -0,0 +1,122 @@
+
+from functools import lru_cache
+from datetime import datetime, timedelta
+from typing import Any, Optional, Dict
+import threading
+
+class InMemoryCache:
+    """
+    Simple in-memory cache with TTL support.
+    Replaces Redis for development environments.
+    """
+    
+    def __init__(self, default_ttl: int = 3600):
+        self._cache: Dict[str, dict] = {}
+        self._default_ttl = default_ttl
+        self._lock = threading.RLock()
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get a value from cache."""
+        with self._lock:
+            if key not in self._cache:
+                return None
+            
+            entry = self._cache[key]
+            
+            # Check if expired
+            if entry['expires_at'] and datetime.utcnow() > entry['expires_at']:
+                del self._cache[key]
+                return None
+            
+            return entry['value']
+    
+    def set(self, key: str, value: Any, ttl: int = None) -> None:
+        """Set a value in cache with optional TTL."""
+        with self._lock:
+            ttl = ttl if ttl is not None else self._default_ttl
+            expires_at = datetime.utcnow() + timedelta(seconds=ttl) if ttl > 0 else None
+            
+            self._cache[key] = {
+                'value': value,
+                'expires_at': expires_at,
+                'created_at': datetime.utcnow()
+            }
+    
+    def delete(self, key: str) -> bool:
+        """Delete a key from cache."""
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+                return True
+            return False
+    
+    def clear(self) -> None:
+        """Clear all cache entries."""
+        with self._lock:
+            self._cache.clear()
+    
+    def exists(self, key: str) -> bool:
+        """Check if key exists and is not expired."""
+        return self.get(key) is not None
+    
+    def get_stats(self) -> dict:
+        """Get cache statistics."""
+        with self._lock:
+            now = datetime.utcnow()
+            active = sum(1 for e in self._cache.values() 
+                        if not e['expires_at'] or e['expires_at'] > now)
+            return {
+                'total_keys': len(self._cache),
+                'active_keys': active,
+                'expired_keys': len(self._cache) - active
+            }
+    
+    def cleanup(self) -> int:
+        """Remove expired entries and return count removed."""
+        with self._lock:
+            now = datetime.utcnow()
+            expired_keys = [
+                k for k, v in self._cache.items() 
+                if v['expires_at'] and v['expires_at'] < now
+            ]
+            for key in expired_keys:
+                del self._cache[key]
+            return len(expired_keys)
+
+
+# Singleton instance
+cache = InMemoryCache(default_ttl=3600)  # 1 hour default
+
+
+# Helper functions for common caching patterns
+def cache_agent_artifacts(agent_id: int, artifacts: dict, ttl: int = 3600):
+    """Cache agent artifacts (knowledge graph, etc.)"""
+    cache.set(f"agent:{agent_id}:artifacts", artifacts, ttl)
+
+def get_cached_agent_artifacts(agent_id: int) -> Optional[dict]:
+    """Get cached agent artifacts."""
+    return cache.get(f"agent:{agent_id}:artifacts")
+
+def invalidate_agent_cache(agent_id: int):
+    """Invalidate all cache entries for an agent."""
+    cache.delete(f"agent:{agent_id}:artifacts")
+    cache.delete(f"agent:{agent_id}:engine")
+
+def cache_user_agents(user_id: int, agents: list, ttl: int = 60):
+    """Cache user's agent list for quick dashboard loading."""
+    cache.set(f"user:{user_id}:agents", agents, ttl)
+
+def get_cached_user_agents(user_id: int) -> Optional[list]:
+    """Get cached user agents list."""
+    return cache.get(f"user:{user_id}:agents")
+
+
+# LRU Cache for expensive computations
+@lru_cache(maxsize=100)
+def cached_domain_analysis(prompt_hash: str) -> dict:
+    """
+    LRU cache for domain analysis results.
+    Use hash of prompt as key to avoid storing full prompts.
+    """
+    # This is a placeholder - actual analysis happens in prompt_analyzer
+    return {}

backend/core/config.py

@@ -0,0 +1,26 @@
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    # Database (Default to SQLite for dev)
+    DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./mexar.db")
+    
+    # Security
+    SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
+    ALGORITHM = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24  # 1 day
+    
+    # AI Services
+    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+    LLM_BACKBONE = os.getenv("LLM_BACKBONE", "llama3")  # Options: llama3, mixtral, gemma
+    
+    # Storage
+    STORAGE_PATH = os.getenv("STORAGE_PATH", "./data/storage")
+    
+    # Caching (In-memory for dev, Redis for prod)
+    REDIS_URL = os.getenv("REDIS_URL")  # Optional
+    
+settings = Config()

backend/core/database.py

@@ -0,0 +1,26 @@
+
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from .config import settings
+
+# Create engine
+# connect_args={"check_same_thread": False} is needed only for SQLite
+connect_args = {"check_same_thread": False} if "sqlite" in settings.DATABASE_URL else {}
+
+engine = create_engine(
+    settings.DATABASE_URL, 
+    connect_args=connect_args
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    """Dependency for API routes"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/core/monitoring.py

@@ -0,0 +1,206 @@
+
+import logging
+import json
+import time
+from datetime import datetime
+from typing import Optional, Dict, Any
+from functools import wraps
+from fastapi import Request
+import threading
+
+# Configure structured logging
+class JSONFormatter(logging.Formatter):
+    """Custom JSON formatter for structured logging."""
+    
+    def format(self, record):
+        log_data = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'level': record.levelname,
+            'logger': record.name,
+            'message': record.getMessage(),
+            'module': record.module,
+            'function': record.funcName,
+            'line': record.lineno
+        }
+        
+        # Add extra fields if present
+        if hasattr(record, 'extra'):
+            log_data.update(record.extra)
+        
+        return json.dumps(log_data)
+
+
+def setup_logging(json_format: bool = False):
+    """Setup logging configuration."""
+    logger = logging.getLogger('mexar')
+    logger.setLevel(logging.INFO)
+    
+    # Console handler
+    handler = logging.StreamHandler()
+    
+    if json_format:
+        handler.setFormatter(JSONFormatter())
+    else:
+        handler.setFormatter(logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        ))
+    
+    logger.addHandler(handler)
+    return logger
+
+
+# Analytics tracker
+class AnalyticsTracker:
+    """
+    Simple in-memory analytics for tracking usage patterns.
+    """
+    
+    def __init__(self):
+        self._metrics = {
+            'api_calls': {},
+            'chat_messages': 0,
+            'compilations': 0,
+            'errors': [],
+            'response_times': []
+        }
+        self._lock = threading.RLock()
+    
+    def track_api_call(self, endpoint: str, method: str, status_code: int, duration_ms: float):
+        """Track an API call."""
+        with self._lock:
+            key = f"{method}:{endpoint}"
+            if key not in self._metrics['api_calls']:
+                self._metrics['api_calls'][key] = {
+                    'count': 0,
+                    'success': 0,
+                    'errors': 0,
+                    'avg_duration_ms': 0
+                }
+            
+            self._metrics['api_calls'][key]['count'] += 1
+            
+            if 200 <= status_code < 400:
+                self._metrics['api_calls'][key]['success'] += 1
+            else:
+                self._metrics['api_calls'][key]['errors'] += 1
+            
+            # Update rolling average
+            current = self._metrics['api_calls'][key]
+            current['avg_duration_ms'] = (
+                (current['avg_duration_ms'] * (current['count'] - 1) + duration_ms) 
+                / current['count']
+            )
+    
+    def track_chat(self):
+        """Track a chat message."""
+        with self._lock:
+            self._metrics['chat_messages'] += 1
+    
+    def track_compilation(self):
+        """Track a compilation."""
+        with self._lock:
+            self._metrics['compilations'] += 1
+    
+    def track_error(self, error: str, endpoint: str = None):
+        """Track an error."""
+        with self._lock:
+            self._metrics['errors'].append({
+                'timestamp': datetime.utcnow().isoformat(),
+                'error': error,
+                'endpoint': endpoint
+            })
+            # Keep only last 100 errors
+            if len(self._metrics['errors']) > 100:
+                self._metrics['errors'] = self._metrics['errors'][-100:]
+    
+    def get_stats(self) -> dict:
+        """Get current analytics stats."""
+        with self._lock:
+            total_calls = sum(v['count'] for v in self._metrics['api_calls'].values())
+            total_errors = sum(v['errors'] for v in self._metrics['api_calls'].values())
+            
+            return {
+                'total_api_calls': total_calls,
+                'total_errors': total_errors,
+                'error_rate': total_errors / total_calls if total_calls > 0 else 0,
+                'chat_messages': self._metrics['chat_messages'],
+                'compilations': self._metrics['compilations'],
+                'endpoints': self._metrics['api_calls'],
+                'recent_errors': self._metrics['errors'][-10:]
+            }
+    
+    def reset(self):
+        """Reset all metrics."""
+        with self._lock:
+            self._metrics = {
+                'api_calls': {},
+                'chat_messages': 0,
+                'compilations': 0,
+                'errors': [],
+                'response_times': []
+            }
+
+
+# Singleton instance
+analytics = AnalyticsTracker()
+logger = setup_logging()
+
+
+# Middleware for request logging and analytics
+async def logging_middleware(request: Request, call_next):
+    """Log and track all requests."""
+    start_time = time.time()
+    
+    # Process request
+    response = await call_next(request)
+    
+    # Calculate duration
+    duration_ms = (time.time() - start_time) * 1000
+    
+    # Track in analytics
+    analytics.track_api_call(
+        endpoint=request.url.path,
+        method=request.method,
+        status_code=response.status_code,
+        duration_ms=duration_ms
+    )
+    
+    # Log request
+    logger.info(
+        f"{request.method} {request.url.path} - {response.status_code} - {duration_ms:.2f}ms"
+    )
+    
+    return response
+
+
+# Decorator for function-level logging
+def log_function(func):
+    """Decorator to log function calls."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        logger.info(f"Calling {func.__name__}")
+        try:
+            result = func(*args, **kwargs)
+            logger.info(f"{func.__name__} completed successfully")
+            return result
+        except Exception as e:
+            logger.error(f"{func.__name__} failed: {str(e)}")
+            analytics.track_error(str(e))
+            raise
+    return wrapper
+
+
+async def async_log_function(func):
+    """Decorator for async function logging."""
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        logger.info(f"Calling {func.__name__}")
+        try:
+            result = await func(*args, **kwargs)
+            logger.info(f"{func.__name__} completed successfully")
+            return result
+        except Exception as e:
+            logger.error(f"{func.__name__} failed: {str(e)}")
+            analytics.track_error(str(e))
+            raise
+    return wrapper

backend/core/rate_limiter.py

@@ -0,0 +1,172 @@
+
+import time
+from collections import defaultdict
+from functools import wraps
+from typing import Callable, Optional
+import threading
+
+from fastapi import Request, HTTPException, status
+from fastapi.responses import JSONResponse
+
+class RateLimiter:
+    """
+    Simple in-memory rate limiter for API endpoints.
+    Uses a sliding window algorithm.
+    """
+    
+    def __init__(self):
+        self._requests = defaultdict(list)
+        self._lock = threading.RLock()
+    
+    def is_allowed(
+        self, 
+        key: str, 
+        max_requests: int = 60, 
+        window_seconds: int = 60
+    ) -> tuple[bool, dict]:
+        """
+        Check if a request is allowed under rate limits.
+        
+        Returns: (is_allowed, info_dict)
+        """
+        with self._lock:
+            now = time.time()
+            window_start = now - window_seconds
+            
+            # Clean old requests
+            self._requests[key] = [
+                t for t in self._requests[key] if t > window_start
+            ]
+            
+            current_count = len(self._requests[key])
+            
+            if current_count >= max_requests:
+                retry_after = self._requests[key][0] - window_start
+                return False, {
+                    'limit': max_requests,
+                    'remaining': 0,
+                    'reset': int(self._requests[key][0] + window_seconds),
+                    'retry_after': int(retry_after) + 1
+                }
+            
+            # Add current request
+            self._requests[key].append(now)
+            
+            return True, {
+                'limit': max_requests,
+                'remaining': max_requests - current_count - 1,
+                'reset': int(now + window_seconds)
+            }
+    
+    def reset(self, key: str):
+        """Reset rate limit for a key."""
+        with self._lock:
+            if key in self._requests:
+                del self._requests[key]
+
+
+# Singleton instance
+rate_limiter = RateLimiter()
+
+
+# Rate limit configurations per endpoint type
+RATE_LIMITS = {
+    'auth': {'max_requests': 10, 'window': 60},        # 10 per minute
+    'chat': {'max_requests': 30, 'window': 60},        # 30 per minute
+    'compile': {'max_requests': 5, 'window': 300},     # 5 per 5 minutes
+    'agents': {'max_requests': 60, 'window': 60},      # 60 per minute
+    'default': {'max_requests': 100, 'window': 60}     # 100 per minute
+}
+
+
+async def rate_limit_middleware(request: Request, call_next):
+    """
+    FastAPI middleware for rate limiting.
+    """
+    # Get client identifier (IP or user ID if authenticated)
+    client_ip = request.client.host if request.client else "unknown"
+    
+    # Determine endpoint type
+    path = request.url.path
+    if '/auth/' in path:
+        limit_type = 'auth'
+    elif '/chat/' in path:
+        limit_type = 'chat'
+    elif '/compile' in path:
+        limit_type = 'compile'
+    elif '/agents' in path:
+        limit_type = 'agents'
+    else:
+        limit_type = 'default'
+    
+    # Check rate limit
+    limits = RATE_LIMITS[limit_type]
+    key = f"{client_ip}:{limit_type}"
+    
+    allowed, info = rate_limiter.is_allowed(
+        key, 
+        max_requests=limits['max_requests'],
+        window_seconds=limits['window']
+    )
+    
+    if not allowed:
+        return JSONResponse(
+            status_code=429,
+            content={
+                'detail': 'Too many requests',
+                'retry_after': info['retry_after']
+            },
+            headers={
+                'X-RateLimit-Limit': str(info['limit']),
+                'X-RateLimit-Remaining': str(info['remaining']),
+                'X-RateLimit-Reset': str(info['reset']),
+                'Retry-After': str(info['retry_after'])
+            }
+        )
+    
+    # Process request
+    response = await call_next(request)
+    
+    # Add rate limit headers
+    response.headers['X-RateLimit-Limit'] = str(info['limit'])
+    response.headers['X-RateLimit-Remaining'] = str(info['remaining'])
+    response.headers['X-RateLimit-Reset'] = str(info['reset'])
+    
+    return response
+
+
+# File validation constants
+MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB
+ALLOWED_EXTENSIONS = {'.csv', '.pdf', '.docx', '.txt', '.json', '.xlsx'}
+
+def validate_file_upload(filename: str, file_size: int) -> Optional[str]:
+    """
+    Validate an uploaded file.
+    Returns error message if invalid, None if valid.
+    """
+    import os
+    
+    # Check extension
+    ext = os.path.splitext(filename)[1].lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        return f"File type '{ext}' not allowed. Allowed types: {', '.join(ALLOWED_EXTENSIONS)}"
+    
+    # Check size
+    if file_size > MAX_FILE_SIZE:
+        max_mb = MAX_FILE_SIZE / (1024 * 1024)
+        return f"File too large. Maximum size is {max_mb}MB"
+    
+    return None
+
+
+# Security headers middleware
+async def security_headers_middleware(request: Request, call_next):
+    """Add security headers to all responses."""
+    response = await call_next(request)
+    
+    response.headers['X-Content-Type-Options'] = 'nosniff'
+    response.headers['X-Frame-Options'] = 'DENY'
+    response.headers['X-XSS-Protection'] = '1; mode=block'
+    response.headers['Referrer-Policy'] = 'strict-origin-when-cross-origin'
+    
+    return response

backend/core/security.py

@@ -0,0 +1,32 @@
+
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import jwt, JWTError
+from passlib.context import CryptContext
+from core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    return plain_password == hashed_password
+
+def get_password_hash(password: str) -> str:
+    return password
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+def decode_token(token: str) -> Optional[dict]:
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        return payload
+    except JWTError:
+        return None

backend/evaluation/__init__.py

@@ -0,0 +1 @@
+"""Evaluation module for reviewer baseline experiments."""

backend/evaluation/ablation_chunk_size.py

@@ -0,0 +1,37 @@
+"""
+Ablation study on chunk size effect on faithfulness and retrieval quality.
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from modules.knowledge_compiler import create_knowledge_compiler
+from modules.reasoning_engine import create_reasoning_engine
+
+def run_chunk_ablation(agent_name: str, parsed_data: list, system_prompt: str, prompt_analysis: dict, test_queries: list):
+    sizes = [64, 128, 256, 512, 1024]
+    
+    for size in sizes:
+        print(f"\n=====================")
+        print(f"Testing Chunk Size: {size}")
+        print(f"=====================")
+        
+        compiler = create_knowledge_compiler()
+        original_chunk_text = compiler._chunk_text
+        compiler._chunk_text = lambda text, chunk_size=size, overlap=size//10: original_chunk_text(text, chunk_size, overlap)
+        
+        # Recompile
+        try:
+            compiler.compile(agent_name, parsed_data, system_prompt, prompt_analysis)
+            
+            # Test
+            engine = create_reasoning_engine()
+            for q in test_queries:
+                res = engine.reason(agent_name, q)
+                print(f"Q: {q}")
+                print(f"Faithfulness: {res['explainability']['faithfulness']}")
+        except Exception as e:
+            print(f"Failed ablation step for size {size}: {e}")
+
+if __name__ == "__main__":
+    print("Chunk size ablation script ready. Needs actual parsed data to recompile.")

backend/evaluation/backbone_comparison.py

@@ -0,0 +1,32 @@
+"""
+Compares different LLM backbones (Llama 3, Mixtral, Gemma).
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from core.config import settings
+from modules.reasoning_engine import create_reasoning_engine
+
+def run_comparison(agent_name: str, queries: list):
+    backbones = ["llama3", "mixtral", "gemma"]
+    
+    for bb in backbones:
+        settings.LLM_BACKBONE = bb
+        print(f"\n--- Testing Backbone: {bb} ---")
+        try:
+            # Must recreate engine so GroqClient picks up config
+            engine = create_reasoning_engine()
+            
+            for q in queries:
+                res = engine.reason(agent_name, q)
+                print(f"Q: {q}")
+                print(f"A ({bb}): {res['answer'][:100]}...")
+                print(f"Faithfulness: {res['explainability']['faithfulness']}")
+        except Exception as e:
+            print(f"Failed to run with backbone {bb}: {e}")
+
+if __name__ == "__main__":
+    test_queries = ["What are the symptoms of a common cold?"]
+    # Replace 'medical_agent' with an actual compiled agent name
+    run_comparison("medical_agent", test_queries)

backend/evaluation/baseline_runner.py

@@ -0,0 +1,50 @@
+"""
+Runs CRAG and RAPTOR baselines against a set of test queries.
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from modules.reasoning_engine import create_reasoning_engine
+from evaluation.metrics import MetricsRunner
+
+def run_baselines(agent_name: str, queries: list):
+    engine = create_reasoning_engine()
+    metrics = MetricsRunner()
+    
+    results = {"CRAG": [], "RAPTOR": [], "MEXAR": []}
+    
+    for q in queries:
+        print(f"\nProcessing query: {q}")
+        
+        try:
+            # Original MEXAR
+            res_mexar = engine.reason(agent_name, q)
+            results["MEXAR"].append(float(res_mexar["explainability"]["faithfulness"].strip('%'))/100)
+            
+            # CRAG
+            res_crag = engine.reason_crag_baseline(agent_name, q)
+            results["CRAG"].append(res_crag["confidence"]) # The raw score
+            
+            # RAPTOR
+            res_raptor = engine.reason_raptor_baseline(agent_name, q)
+            results["RAPTOR"].append(res_raptor["confidence"])
+        except Exception as e:
+            print(f"Error evaluating query '{q}': {e}")
+        
+    print("\n--- Baseline Comparison (Faithfulness) ---")
+    for b_name in results:
+        if results[b_name]:
+            avg = sum(results[b_name]) / len(results[b_name])
+            print(f"{b_name}: {avg:.4f}")
+        else:
+            print(f"{b_name}: No results")
+
+if __name__ == "__main__":
+    # Example usage
+    test_queries = [
+        "What are the symptoms of a common cold?",
+        "How do I bake a chocolate cake?"
+    ]
+    # Replace 'medical_agent' with an actual compiled agent name in DB
+    run_baselines("medical_agent", test_queries)

backend/evaluation/benchmark_runner.py

@@ -0,0 +1,35 @@
+"""
+Runs evaluation on public benchmarks like MedQA, LegalBench.
+"""
+import sys
+import os
+import json
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from modules.reasoning_engine import create_reasoning_engine
+
+def run_benchmark(dataset_path: str, agent_name: str):
+    engine = create_reasoning_engine()
+    
+    if not os.path.exists(dataset_path):
+        print(f"Dataset not found: {dataset_path}")
+        return
+        
+    with open(dataset_path, "r") as f:
+        data = json.load(f)
+        
+    for item in data[:10]: # Run first 10 for demo
+        query = item.get("question") or item.get("query")
+        if not query:
+            continue
+            
+        print(f"\nQuery: {query}")
+        try:
+            result = engine.reason(agent_name, query)
+            print(f"Answer: {result['answer'][:100]}...")
+            print(f"Faithfulness: {result['explainability']['faithfulness']}")
+        except Exception as e:
+            print(f"Failed to process query: {e}")
+
+if __name__ == "__main__":
+    run_benchmark(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "test_data", "medqa_sample.json"), "medical_agent")

backend/evaluation/guardrail_analysis.py

@@ -0,0 +1,35 @@
+"""
+Evaluates the domain guardrail's false-accept (false positive) rate.
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from modules.reasoning_engine import create_reasoning_engine
+
+def test_guardrails(agent_name: str):
+    engine = create_reasoning_engine()
+    
+    boundary_queries = [
+        "What are the economic impacts of pharmaceutical pricing?", # Often crosses medical/finance
+        "Can a doctor be sued for malpractice if they misdiagnose cancer?", # Medical/Legal
+        "Are taxes applied to medical equipment purchases?", # Medical/Finance
+        "How do I cook a healthy meal to lower blood pressure?" # Cooking/Medical
+    ]
+    
+    print(f"Testing Guardrail False-Accept Rate (Threshold = {engine.DOMAIN_SIMILARITY_THRESHOLD})")
+    
+    try:
+        for q in boundary_queries:
+            res = engine.reason(agent_name, q)
+            print(f"\nQuery: {q}")
+            print(f"Accepted: {res['in_domain']}")
+            exp = res.get('explainability', {})
+            cb = exp.get('confidence_breakdown', {})
+            domain_str = cb.get('domain_relevance', 'N/A')
+            print(f"Domain Score: {domain_str}")
+    except Exception as e:
+        print(f"Failed guardrail test queries: {e}")
+
+if __name__ == "__main__":
+    test_guardrails("medical_agent")

backend/evaluation/metrics.py

@@ -0,0 +1,25 @@
+"""
+MEXAR - Evaluation Metrics Helper
+Calculates common metrics across different baselines and experiments.
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from utils.faithfulness import FaithfulnessScorer, BartNLIScorer, FActScoreCompat
+
+class MetricsRunner:
+    def __init__(self):
+        self.faith_scorer = FaithfulnessScorer()
+        self.bart_nli = BartNLIScorer()
+        self.factscore = FActScoreCompat()
+
+    def evaluate_all(self, answer: str, context: str):
+        faith_res = self.faith_scorer.score(answer, context)
+        bart_res = self.bart_nli.score(answer, context)
+        fact_res = self.factscore.score(answer, context)
+        return {
+            "faithfulness": faith_res.score,
+            "bart_nli": bart_res.score,
+            "factscore": fact_res.score
+        }

backend/evaluation/statistical_tests.py

@@ -0,0 +1,62 @@
+"""
+Calculates McNemar's test for significance between two models,
+using the stated binarization threshold.
+"""
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from modules.reasoning_engine import ReasoningEngine
+
+THRESHOLD = ReasoningEngine.MCNEMAR_BINARIZATION_THRESHOLD
+
+def mcnemars_test(scores_model_A: list, scores_model_B: list):
+    """
+    Computes McNemar's test p-value for paired nominal data.
+    scores are lists of float faithfulness scores.
+    """
+    if len(scores_model_A) != len(scores_model_B):
+        raise ValueError("Must have same number of scores")
+        
+    # Binarize
+    bin_A = [1 if s >= THRESHOLD else 0 for s in scores_model_A]
+    bin_B = [1 if s >= THRESHOLD else 0 for s in scores_model_B]
+    
+    # Contingency table
+    #              B correct | B wrong
+    # A correct |     a      |    b
+    # A wrong   |     c      |    d
+    
+    a, b, c, d = 0, 0, 0, 0
+    for a_val, b_val in zip(bin_A, bin_B):
+        if a_val == 1 and b_val == 1: a += 1
+        elif a_val == 1 and b_val == 0: b += 1
+        elif a_val == 0 and b_val == 1: c += 1
+        else: d += 1
+        
+    # Chi-square statistic: (b - c)^2 / (b + c)
+    if b + c == 0:
+        print("Models are identical given the threshold.")
+        return 1.0 # No difference
+        
+    chi_square = ((abs(b - c) - 1)**2) / (b + c)  # with continuity correction
+    
+    print(f"McNemar's Test Results:")
+    print(f"Binarization Threshold: {THRESHOLD}")
+    print(f"Contingency Table: a={a}, b={b}, c={c}, d={d}")
+    print(f"Chi-square: {chi_square:.3f}")
+    
+    try:
+        from scipy.stats import chi2
+        p_value = 1 - chi2.cdf(chi_square, 1)
+        print(f"p-value: {p_value:.4f}")
+        return p_value
+    except ImportError:
+        print("Note: Install scipy ('pip install scipy') to automatically calculate the p-value.")
+        return chi_square
+
+if __name__ == "__main__":
+    # Mock data
+    scores_mexar = [0.8, 0.9, 0.4, 0.7, 0.65, 0.8]
+    scores_baseline = [0.5, 0.7, 0.6, 0.4, 0.55, 0.8]
+    mcnemars_test(scores_mexar, scores_baseline)

backend/main.py

@@ -0,0 +1,172 @@
+"""
+MEXAR Core Engine - FastAPI Backend Application
+Main entry point for the MEXAR Phase 2 API.
+
+This is a clean, minimal main.py that only includes routers.
+All endpoints are handled by the api/ modules.
+"""
+
+import os
+import logging
+from pathlib import Path
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Ensure data directories exist
+DATA_DIRS = [
+    Path("data/storage"),
+    Path("data/temp"),
+]
+for dir_path in DATA_DIRS:
+    dir_path.mkdir(parents=True, exist_ok=True)
+
+
+# Lifespan context manager
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler - database initialization."""
+    logger.info("MEXAR Core Engine starting up...")
+    
+    # Initialize database tables
+    try:
+        from core.database import engine, Base
+        from models.user import User
+        from models.agent import Agent, CompilationJob
+        from models.conversation import Conversation, Message
+        from models.chunk import DocumentChunk
+        from sqlalchemy import text
+
+        # Enable vector extension only for postgres
+        if "sqlite" not in str(engine.url):
+            try:
+                with engine.connect() as conn:
+                    conn.execute(text("CREATE EXTENSION IF NOT EXISTS vector"))
+                    conn.commit()
+            except Exception as vector_err:
+                logger.warning(f"Vector extension check skipped: {vector_err}")
+
+        Base.metadata.create_all(bind=engine)
+        logger.info("Database tables created/verified successfully")
+    except Exception as e:
+        logger.warning(f"Database initialization: {e}")
+    
+    yield
+    logger.info("MEXAR Core Engine shutting down...")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="MEXAR Core Engine",
+    description="Multimodal Explainable AI Reasoning Assistant - Phase 2",
+    version="2.0.0",
+    lifespan=lifespan
+)
+
+# Configure CORS
+# Configure CORS
+# CRITICAL: Configure CORS for Vercel frontend
+FRONTEND_URL = os.getenv("FRONTEND_URL", "http://localhost:3000")
+
+allow_origins = [
+    "*", 
+    FRONTEND_URL, 
+    "https://*.vercel.app", 
+    "http://localhost:3000",
+    "http://localhost:3001"
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=allow_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Import and include Phase 2 routers
+from api import auth, agents, chat, compile, websocket, admin, prompts, diagnostics
+
+app.include_router(auth.router)
+app.include_router(agents.router)
+app.include_router(chat.router)
+app.include_router(compile.router)
+app.include_router(websocket.router)
+app.include_router(admin.router)
+app.include_router(prompts.router)
+app.include_router(diagnostics.router)
+
+
+# ===== CORE UTILITY ENDPOINTS =====
+
+@app.get("/")
+async def root():
+    """Root endpoint - serves landing page."""
+    from fastapi.responses import FileResponse
+    from pathlib import Path
+    
+    html_path = Path(__file__).parent / "static" / "index.html"
+    if html_path.exists():
+        return FileResponse(html_path, media_type="text/html")
+    else:
+        # Fallback to JSON if HTML not found
+        return {
+            "name": "MEXAR Core Engine",
+            "version": "2.0.0",
+            "status": "operational",
+            "docs": "/docs"
+        }
+
+
+@app.get("/api/health")
+async def health_check():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "groq_configured": bool(os.getenv("GROQ_API_KEY"))
+    }
+
+
+
+
+
+# ===== ERROR HANDLERS =====
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    """Global exception handler."""
+    logger.error(f"Unhandled exception: {exc}")
+    return JSONResponse(
+        status_code=500,
+        content={
+            "success": False,
+            "error": "Internal server error",
+            "detail": str(exc)
+        }
+    )
+
+
+# ===== MAIN ENTRY POINT =====
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

backend/migrations/README.md

@@ -0,0 +1,65 @@
+# MEXAR - Apply Hybrid Search Migration
+
+## What This Does
+
+This SQL script creates the `hybrid_search()` function in your Supabase database,
+which combines semantic (vector) and keyword (full-text) search using
+Reciprocal Rank Fusion (RRF) algorithm.
+
+## Instructions
+
+1. **Open Supabase Dashboard**
+   - Go to: https://supabase.com/dashboard
+   - Select your project: `xmfcidiwovxuihrkfzps`
+
+2. **Navigate to SQL Editor**
+   - Click "SQL Editor" in the left sidebar
+   - Click "New Query"
+
+3. **Copy and Paste**
+   - Open: `backend/migrations/hybrid_search_function.sql`
+   - Copy ALL the contents
+   - Paste into the Supabase SQL Editor
+
+4. **Run the Migration**
+   - Click "Run" button (or press Ctrl+Enter)
+   - Wait for success message
+
+5. **Verify**
+   - Run this query to check:
+   ```sql
+   SELECT routine_name 
+   FROM information_schema.routines 
+   WHERE routine_name = 'hybrid_search';
+   ```
+   - Should return one row
+
+## Alternative: Run from Command Line (Optional)
+
+If you have `psql` installed:
+
+```bash
+psql "postgresql://postgres.xmfcidiwovxuihrkfzps:Yogiji@20122004@aws-1-ap-south-1.pooler.supabase.com:5432/postgres" -f migrations/hybrid_search_function.sql
+```
+
+## What Gets Created
+
+- **Function**: `hybrid_search(vector, text, integer, integer)` 
+- **Indexes**: 
+  - `idx_document_chunks_content_tsvector` (GIN index for full-text search)
+  - `idx_document_chunks_agent_id` (B-tree index for filtering)
+  - `idx_document_chunks_embedding` (IVFFlat index for vector search)
+
+## Troubleshooting
+
+**Error: "type vector does not exist"**
+- Run: `CREATE EXTENSION IF NOT EXISTS vector;`
+- Then retry the migration
+
+**Error: "table document_chunks does not exist"**
+- Restart your backend server to create tables
+- Then retry the migration
+
+---
+
+**After running this migration**, your system will be ready for hybrid search!

backend/migrations/add_preferences.py

@@ -0,0 +1,23 @@
+
+from core.database import engine, Base
+from sqlalchemy import text, inspect
+
+def run_migration():
+    print("Running migration: Add preferences to users table...")
+    inspector = inspect(engine)
+    columns = [col['name'] for col in inspector.get_columns('users')]
+    
+    if 'preferences' not in columns:
+        try:
+            with engine.connect() as conn:
+                # Add JSON column for preferences
+                conn.execute(text("ALTER TABLE users ADD COLUMN preferences JSON DEFAULT '{}'"))
+                conn.commit()
+            print("✅ Successfully added 'preferences' column to 'users' table.")
+        except Exception as e:
+            print(f"❌ Error adding column: {e}")
+    else:
+        print("ℹ️ Column 'preferences' already exists in 'users' table.")
+
+if __name__ == "__main__":
+    run_migration()

backend/migrations/fix_vector_dimension.sql

@@ -0,0 +1,20 @@
+-- MEXAR - Fix Vector Dimension Mismatch
+-- The embedding model (bge-small-en-v1.5) outputs 384 dimensions
+-- But the table was created with 1024 dimensions
+-- This script fixes the mismatch
+
+-- Step 1: Drop existing embedding column
+ALTER TABLE document_chunks DROP COLUMN IF EXISTS embedding;
+
+-- Step 2: Add new embedding column with correct dimensions (384)
+ALTER TABLE document_chunks ADD COLUMN embedding vector(384);
+
+-- Step 3: Create index for the new column
+CREATE INDEX IF NOT EXISTS idx_document_chunks_embedding 
+ON document_chunks USING ivfflat(embedding vector_cosine_ops)
+WITH (lists = 100);
+
+-- Verify the change
+SELECT column_name, udt_name 
+FROM information_schema.columns 
+WHERE table_name = 'document_chunks' AND column_name = 'embedding';

backend/migrations/hybrid_search_function.sql

@@ -0,0 +1,103 @@
+-- MEXAR - Hybrid Search Function for Supabase
+-- Combines semantic (vector) and keyword (full-text) search using Reciprocal Rank Fusion (RRF)
+
+CREATE OR REPLACE FUNCTION hybrid_search(
+    query_embedding vector(384),
+    query_text text,
+    match_agent_id integer,
+    match_count integer
+)
+RETURNS TABLE (
+    id integer,
+    agent_id integer,
+    content text,
+    source text,
+    chunk_index integer,
+    section_title text,
+    created_at timestamp with time zone,
+    rrf_score real
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    semantic_weight real := 0.6;
+    keyword_weight real := 0.4;
+    k_constant real := 60.0;
+BEGIN
+    RETURN QUERY
+    WITH semantic_search AS (
+        SELECT
+            dc.id,
+            dc.agent_id,
+            dc.content,
+            dc.source,
+            dc.chunk_index,
+            dc.section_title,
+            dc.created_at,
+            ROW_NUMBER() OVER (ORDER BY dc.embedding <=> query_embedding) AS rank_num
+        FROM document_chunks dc
+        WHERE dc.agent_id = match_agent_id
+        ORDER BY dc.embedding <=> query_embedding
+        LIMIT match_count * 2
+    ),
+    keyword_search AS (
+        SELECT
+            dc.id,
+            dc.agent_id,
+            dc.content,
+            dc.source,
+            dc.chunk_index,
+            dc.section_title,
+            dc.created_at,
+            ROW_NUMBER() OVER (ORDER BY ts_rank_cd(dc.content_tsvector, plainto_tsquery('english', query_text)) DESC) AS rank_num
+        FROM document_chunks dc
+        WHERE dc.agent_id = match_agent_id
+          AND dc.content_tsvector @@ plainto_tsquery('english', query_text)
+        ORDER BY ts_rank_cd(dc.content_tsvector, plainto_tsquery('english', query_text)) DESC
+        LIMIT match_count * 2
+    ),
+    combined AS (
+        SELECT 
+            COALESCE(s.id, k.id) AS id,
+            COALESCE(s.agent_id, k.agent_id) AS agent_id,
+            COALESCE(s.content, k.content) AS content,
+            COALESCE(s.source, k.source) AS source,
+            COALESCE(s.chunk_index, k.chunk_index) AS chunk_index,
+            COALESCE(s.section_title, k.section_title) AS section_title,
+            COALESCE(s.created_at, k.created_at) AS created_at,
+            (
+                COALESCE(semantic_weight / (k_constant + s.rank_num::real), 0.0) +
+                COALESCE(keyword_weight / (k_constant + k.rank_num::real), 0.0)
+            ) AS rrf_score
+        FROM semantic_search s
+        FULL OUTER JOIN keyword_search k ON s.id = k.id
+    )
+    SELECT 
+        c.id,
+        c.agent_id,
+        c.content,
+        c.source,
+        c.chunk_index,
+        c.section_title,
+        c.created_at,
+        c.rrf_score::real
+    FROM combined c
+    ORDER BY c.rrf_score DESC
+    LIMIT match_count;
+END;
+$$;
+
+-- Add index on content_tsvector for better keyword search performance
+CREATE INDEX IF NOT EXISTS idx_document_chunks_content_tsvector 
+ON document_chunks USING GIN(content_tsvector);
+
+-- Add index on agent_id for filtering
+CREATE INDEX IF NOT EXISTS idx_document_chunks_agent_id 
+ON document_chunks(agent_id);
+
+-- Add index on embedding for vector similarity search
+CREATE INDEX IF NOT EXISTS idx_document_chunks_embedding 
+ON document_chunks USING ivfflat(embedding vector_cosine_ops)
+WITH (lists = 100);
+
+COMMENT ON FUNCTION hybrid_search IS 'Combines semantic (vector) and keyword (full-text) search using Reciprocal Rank Fusion';

backend/migrations/rag_migration.sql

@@ -0,0 +1,112 @@
+-- ============================================
+-- MEXAR RAG Migration Script
+-- Run this in Supabase SQL Editor
+-- ============================================
+
+-- 1. Enable pgvector extension (if not already)
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- 2. Clear existing chunks (required due to dimension change)
+DELETE FROM document_chunks;
+
+-- 3. Alter embedding dimension: 384 → 1024
+ALTER TABLE document_chunks 
+ALTER COLUMN embedding TYPE vector(1024);
+
+-- 4. Add tsvector column for keyword search
+ALTER TABLE document_chunks 
+ADD COLUMN IF NOT EXISTS content_tsvector TSVECTOR;
+
+-- 5. Add chunk metadata columns
+ALTER TABLE document_chunks
+ADD COLUMN IF NOT EXISTS chunk_index INTEGER,
+ADD COLUMN IF NOT EXISTS section_title TEXT,
+ADD COLUMN IF NOT EXISTS token_count INTEGER;
+
+-- 6. Create HNSW index for fast cosine similarity
+DROP INDEX IF EXISTS chunks_embedding_idx;
+DROP INDEX IF EXISTS chunks_embedding_hnsw;
+CREATE INDEX chunks_embedding_hnsw 
+ON document_chunks USING hnsw (embedding vector_cosine_ops) 
+WITH (m = 16, ef_construction = 64);
+
+-- 7. Create GIN index for full-text search
+CREATE INDEX IF NOT EXISTS chunks_content_gin 
+ON document_chunks USING GIN (content_tsvector);
+
+-- 8. Create trigger to auto-update tsvector
+CREATE OR REPLACE FUNCTION update_tsvector()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.content_tsvector := to_tsvector('english', COALESCE(NEW.content, ''));
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS tsvector_update ON document_chunks;
+CREATE TRIGGER tsvector_update
+BEFORE INSERT OR UPDATE ON document_chunks
+FOR EACH ROW EXECUTE FUNCTION update_tsvector();
+
+-- 9. Add agent metadata columns for full Supabase storage
+ALTER TABLE agents
+ADD COLUMN IF NOT EXISTS knowledge_graph_json JSONB,
+ADD COLUMN IF NOT EXISTS domain_signature JSONB,
+ADD COLUMN IF NOT EXISTS prompt_analysis JSONB,
+ADD COLUMN IF NOT EXISTS compilation_stats JSONB,
+ADD COLUMN IF NOT EXISTS chunk_count INTEGER DEFAULT 0;
+
+-- 10. Update existing tsvector data
+UPDATE document_chunks 
+SET content_tsvector = to_tsvector('english', content)
+WHERE content_tsvector IS NULL;
+
+-- 11. Create hybrid search function
+CREATE OR REPLACE FUNCTION hybrid_search(
+    query_embedding vector(1024),
+    query_text text,
+    target_agent_id integer,
+    match_count integer DEFAULT 20
+)
+RETURNS TABLE (
+    id integer,
+    content text,
+    source text,
+    semantic_rank integer,
+    keyword_rank integer,
+    rrf_score float
+) AS $$
+BEGIN
+    RETURN QUERY
+    WITH semantic AS (
+        SELECT dc.id, dc.content, dc.source,
+               ROW_NUMBER() OVER (ORDER BY dc.embedding <=> query_embedding)::integer as rank
+        FROM document_chunks dc
+        WHERE dc.agent_id = target_agent_id
+        ORDER BY dc.embedding <=> query_embedding
+        LIMIT match_count
+    ),
+    keyword AS (
+        SELECT dc.id, dc.content, dc.source,
+               ROW_NUMBER() OVER (ORDER BY ts_rank(dc.content_tsvector, plainto_tsquery('english', query_text)) DESC)::integer as rank
+        FROM document_chunks dc
+        WHERE dc.agent_id = target_agent_id
+          AND dc.content_tsvector @@ plainto_tsquery('english', query_text)
+        LIMIT match_count
+    )
+    SELECT 
+        COALESCE(s.id, k.id) as id,
+        COALESCE(s.content, k.content) as content,
+        COALESCE(s.source, k.source) as source,
+        s.rank as semantic_rank,
+        k.rank as keyword_rank,
+        (COALESCE(1.0/(60 + s.rank), 0) + COALESCE(1.0/(60 + k.rank), 0))::float as rrf_score
+    FROM semantic s
+    FULL OUTER JOIN keyword k ON s.id = k.id
+    ORDER BY rrf_score DESC
+    LIMIT match_count;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Done! Verify with:
+-- SELECT * FROM pg_indexes WHERE tablename = 'document_chunks';

backend/modules/__init__.py

@@ -0,0 +1,3 @@
+"""
+MEXAR Core Engine - Backend Modules Package
+"""

backend/modules/data_validator.py

@@ -0,0 +1,360 @@
+"""
+MEXAR Core Engine - Data Ingestion & Validation Module
+Handles parsing and validation of uploaded files (CSV, PDF, DOCX, JSON, TXT).
+"""
+
+import os
+import json
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from pathlib import Path
+import pandas as pd
+from PyPDF2 import PdfReader
+from docx import Document
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DataValidator:
+    """
+    Validates and parses uploaded data files for knowledge compilation.
+    Supports: CSV, PDF, DOCX, JSON, TXT
+    """
+    
+    # Minimum thresholds for data sufficiency
+    MIN_ENTRIES = 20
+    MIN_CHARACTERS = 2000
+    
+    # Supported file extensions
+    SUPPORTED_EXTENSIONS = {'.csv', '.pdf', '.docx', '.json', '.txt'}
+    
+    def __init__(self):
+        """Initialize the data validator."""
+        self.parsed_data: List[Dict[str, Any]] = []
+        self.validation_results: List[Dict[str, Any]] = []
+    
+    def parse_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        Parse a file based on its extension.
+        
+        Args:
+            file_path: Path to the file to parse
+            
+        Returns:
+            Dict containing:
+                - format: File format (csv, pdf, docx, json, txt)
+                - data: Parsed data (list of dicts for structured, None for text)
+                - text: Extracted text content
+                - entries_count: Number of entries/rows/paragraphs
+                - file_name: Original file name
+        """
+        path = Path(file_path)
+        ext = path.suffix.lower()
+        
+        if ext not in self.SUPPORTED_EXTENSIONS:
+            raise ValueError(f"Unsupported file format: {ext}. Supported: {self.SUPPORTED_EXTENSIONS}")
+        
+        result = {
+            "format": ext.replace(".", ""),
+            "data": None,
+            "text": "",
+            "entries_count": 0,
+            "file_name": path.name
+        }
+        
+        try:
+            if ext == '.csv':
+                result = self._parse_csv(file_path, result)
+            elif ext == '.pdf':
+                result = self._parse_pdf(file_path, result)
+            elif ext == '.docx':
+                result = self._parse_docx(file_path, result)
+            elif ext == '.json':
+                result = self._parse_json(file_path, result)
+            elif ext == '.txt':
+                result = self._parse_txt(file_path, result)
+                
+            logger.info(f"Successfully parsed {path.name}: {result['entries_count']} entries, {len(result['text'])} chars")
+            
+        except Exception as e:
+            logger.error(f"Error parsing {path.name}: {str(e)}")
+            result["error"] = str(e)
+        
+        return result
+    
+    def _parse_csv(self, file_path: str, result: Dict) -> Dict:
+        """Parse CSV file into structured data."""
+        df = pd.read_csv(file_path)
+        
+        # Convert to list of dicts
+        data = df.to_dict(orient='records')
+        
+        # Generate text representation
+        text_parts = []
+        for i, row in enumerate(data):
+            row_text = f"Entry {i+1}: " + ", ".join([f"{k}={v}" for k, v in row.items() if pd.notna(v)])
+            text_parts.append(row_text)
+        
+        result["data"] = data
+        result["text"] = "\n".join(text_parts)
+        result["entries_count"] = len(data)
+        result["columns"] = list(df.columns)
+        
+        return result
+    
+    def _parse_pdf(self, file_path: str, result: Dict) -> Dict:
+        """Parse PDF file and extract text."""
+        reader = PdfReader(file_path)
+        
+        text_parts = []
+        for i, page in enumerate(reader.pages):
+            page_text = page.extract_text()
+            if page_text:
+                text_parts.append(f"Page {i+1}:\n{page_text}")
+        
+        full_text = "\n\n".join(text_parts)
+        
+        # Count paragraphs as entries
+        paragraphs = [p.strip() for p in full_text.split('\n\n') if p.strip()]
+        
+        result["text"] = full_text
+        result["entries_count"] = len(paragraphs)
+        result["page_count"] = len(reader.pages)
+        
+        return result
+    
+    def _parse_docx(self, file_path: str, result: Dict) -> Dict:
+        """Parse DOCX file and extract text."""
+        doc = Document(file_path)
+        
+        paragraphs = []
+        for para in doc.paragraphs:
+            if para.text.strip():
+                paragraphs.append(para.text.strip())
+        
+        # Also extract tables
+        table_data = []
+        for table in doc.tables:
+            for row in table.rows:
+                row_data = [cell.text.strip() for cell in row.cells]
+                if any(row_data):
+                    table_data.append(row_data)
+        
+        result["text"] = "\n\n".join(paragraphs)
+        result["entries_count"] = len(paragraphs) + len(table_data)
+        result["table_data"] = table_data
+        
+        return result
+    
+    def _parse_json(self, file_path: str, result: Dict) -> Dict:
+        """Parse JSON file into structured data."""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Handle different JSON structures
+        if isinstance(data, list):
+            entries = data
+        elif isinstance(data, dict):
+            # If it's a dict with a main data key, extract it
+            for key in ['data', 'items', 'records', 'entries']:
+                if key in data and isinstance(data[key], list):
+                    entries = data[key]
+                    break
+            else:
+                # Wrap single object in list
+                entries = [data]
+        else:
+            entries = [{"value": data}]
+        
+        # Generate text representation
+        text_parts = []
+        for i, entry in enumerate(entries):
+            if isinstance(entry, dict):
+                entry_text = f"Entry {i+1}: " + json.dumps(entry, ensure_ascii=False)
+            else:
+                entry_text = f"Entry {i+1}: {entry}"
+            text_parts.append(entry_text)
+        
+        result["data"] = entries
+        result["text"] = "\n".join(text_parts)
+        result["entries_count"] = len(entries)
+        
+        return result
+    
+    def _parse_txt(self, file_path: str, result: Dict) -> Dict:
+        """Parse TXT file as plain text."""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            text = f.read()
+        
+        # Count lines as entries
+        lines = [line.strip() for line in text.split('\n') if line.strip()]
+        
+        result["text"] = text
+        result["entries_count"] = len(lines)
+        
+        return result
+    
+    def validate_sufficiency(self, parsed_data: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Check if the combined data meets minimum requirements.
+        
+        Args:
+            parsed_data: List of parsed file results
+            
+        Returns:
+            Dict containing:
+                - sufficient: Boolean indicating if data is sufficient
+                - issues: List of issues found
+                - warnings: List of warnings
+                - stats: Statistics about the data
+        """
+        total_entries = sum(p.get("entries_count", 0) for p in parsed_data)
+        total_chars = sum(len(p.get("text", "")) for p in parsed_data)
+        
+        issues = []
+        warnings = []
+        
+        # Check minimum thresholds
+        entries_ok = total_entries >= self.MIN_ENTRIES
+        chars_ok = total_chars >= self.MIN_CHARACTERS
+        
+        if not entries_ok and not chars_ok:
+            issues.append(
+                f"Insufficient data: Found {total_entries} entries and {total_chars} characters. "
+                f"Need at least {self.MIN_ENTRIES} entries OR {self.MIN_CHARACTERS} characters."
+            )
+        
+        # Check for empty files
+        empty_files = [p["file_name"] for p in parsed_data if p.get("entries_count", 0) == 0]
+        if empty_files:
+            issues.append(f"Empty or unreadable files: {', '.join(empty_files)}")
+        
+        # Check for parsing errors
+        error_files = [p["file_name"] for p in parsed_data if "error" in p]
+        if error_files:
+            issues.append(f"Files with parsing errors: {', '.join(error_files)}")
+        
+        # Add warnings for low-quality data
+        if total_entries < self.MIN_ENTRIES * 2:
+            warnings.append(
+                f"Consider adding more entries for better knowledge coverage. "
+                f"Current: {total_entries}, Recommended: {self.MIN_ENTRIES * 2}+"
+            )
+        
+        # Calculate structure score (how well-structured the data is)
+        structured_count = sum(1 for p in parsed_data if p.get("data") is not None)
+        structure_score = structured_count / len(parsed_data) if parsed_data else 0
+        
+        if structure_score < 0.5:
+            warnings.append(
+                "Most files are unstructured (PDF/TXT). "
+                "Structured data (CSV/JSON) provides better knowledge extraction."
+            )
+        
+        # Compile statistics
+        stats = {
+            "total_files": len(parsed_data),
+            "total_entries": total_entries,
+            "total_characters": total_chars,
+            "structure_score": round(structure_score, 2),
+            "file_breakdown": [
+                {
+                    "name": p["file_name"],
+                    "format": p["format"],
+                    "entries": p.get("entries_count", 0),
+                    "characters": len(p.get("text", ""))
+                }
+                for p in parsed_data
+            ]
+        }
+        
+        return {
+            "sufficient": len(issues) == 0,
+            "issues": issues,
+            "warnings": warnings,
+            "stats": stats
+        }
+    
+    def provide_feedback(self, validation_result: Dict[str, Any]) -> str:
+        """
+        Generate user-friendly feedback message.
+        
+        Args:
+            validation_result: Result from validate_sufficiency
+            
+        Returns:
+            Formatted feedback message
+        """
+        stats = validation_result["stats"]
+        
+        if validation_result["sufficient"]:
+            # Success message
+            feedback = f"""✅ **Data Validation Passed!**
+
+📊 **Statistics:**
+- Total Files: {stats['total_files']}
+- Total Entries: {stats['total_entries']}
+- Total Characters: {stats['total_characters']:,}
+- Structure Score: {stats['structure_score']*100:.0f}%
+
+"""
+            # Add file breakdown
+            feedback += "📁 **File Breakdown:**\n"
+            for f in stats["file_breakdown"]:
+                feedback += f"- {f['name']} ({f['format'].upper()}): {f['entries']} entries\n"
+            
+            # Add warnings if any
+            if validation_result["warnings"]:
+                feedback += "\n⚠️ **Suggestions:**\n"
+                for warning in validation_result["warnings"]:
+                    feedback += f"- {warning}\n"
+        
+        else:
+            # Failure message
+            feedback = f"""❌ **Data Validation Failed**
+
+🔍 **Issues Found:**
+"""
+            for issue in validation_result["issues"]:
+                feedback += f"- {issue}\n"
+            
+            feedback += f"""
+📊 **Current Statistics:**
+- Total Entries: {stats['total_entries']} (minimum: {self.MIN_ENTRIES})
+- Total Characters: {stats['total_characters']:,} (minimum: {self.MIN_CHARACTERS:,})
+
+💡 **How to Fix:**
+1. Add more data files (CSV, PDF, DOCX, JSON, or TXT)
+2. Ensure files contain meaningful content
+3. For best results, use structured formats like CSV or JSON
+"""
+        
+        return feedback
+    
+    def parse_and_validate(self, file_paths: List[str]) -> Tuple[List[Dict], Dict, str]:
+        """
+        Convenience method to parse all files and validate in one call.
+        
+        Args:
+            file_paths: List of file paths to process
+            
+        Returns:
+            Tuple of (parsed_data, validation_result, feedback_message)
+        """
+        parsed_data = []
+        for path in file_paths:
+            result = self.parse_file(path)
+            parsed_data.append(result)
+        
+        validation = self.validate_sufficiency(parsed_data)
+        feedback = self.provide_feedback(validation)
+        
+        return parsed_data, validation, feedback
+
+
+# Factory function for easy instantiation
+def create_validator() -> DataValidator:
+    """Create a new DataValidator instance."""
+    return DataValidator()

backend/modules/explainability.py

@@ -0,0 +1,276 @@
+"""
+MEXAR Core Engine - Explainability Generator Module
+Packages reasoning traces for UI display.
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ExplainabilityGenerator:
+    """
+    Generates structured explainability data for the UI.
+    Prepares reasoning traces and source citations.
+    """
+    
+    def __init__(self):
+        """Initialize the explainability generator."""
+        pass
+    
+    def generate(
+        self,
+        reasoning_result: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Generate comprehensive explainability data.
+        
+        Args:
+            reasoning_result: Output from ReasoningEngine.reason()
+            
+        Returns:
+            Structured explainability data for UI
+        """
+        explainability = reasoning_result.get("explainability", {})
+        
+        # Enhance the existing explainability data
+        enhanced = {
+            "summary": self._generate_summary(reasoning_result),
+            "inputs": self._format_inputs(explainability.get("inputs", {})),
+            "retrieval": self._format_retrieval(explainability.get("retrieval", {})),
+            "reasoning_steps": self._format_reasoning_steps(
+                explainability.get("reasoning_trace", [])
+            ),
+            "confidence": self._format_confidence(
+                explainability.get("confidence_breakdown", {})
+            ),
+            "sources": self._format_sources(explainability.get("sources_cited", []))
+        }
+        
+        return enhanced
+    
+    def _generate_summary(self, reasoning_result: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a human-readable summary."""
+        confidence = reasoning_result.get("confidence", 0)
+        in_domain = reasoning_result.get("in_domain", True)
+        sources = reasoning_result.get("sources", [])
+        
+        if not in_domain:
+            status = "rejected"
+            message = "Query was outside the agent's domain expertise"
+            color = "red"
+        elif confidence >= 0.8:
+            status = "high_confidence"
+            message = "Answer is well-supported by the knowledge base"
+            color = "green"
+        elif confidence >= 0.5:
+            status = "moderate_confidence"
+            message = "Answer is partially supported, some uncertainty exists"
+            color = "yellow"
+        else:
+            status = "low_confidence"
+            message = "Limited support in knowledge base, treat with caution"
+            color = "orange"
+        
+        return {
+            "status": status,
+            "message": message,
+            "color": color,
+            "quick_stats": {
+                "sources_found": len(sources),
+                "confidence_percent": f"{confidence * 100:.0f}%"
+            }
+        }
+    
+    def _format_inputs(self, inputs: Dict) -> Dict[str, Any]:
+        """Format input information."""
+        return {
+            "query": inputs.get("original_query", ""),
+            "has_multimodal": inputs.get("has_multimodal", False),
+            "multimodal_type": self._detect_multimodal_type(inputs),
+            "multimodal_preview": inputs.get("multimodal_preview", "")
+        }
+    
+    def _detect_multimodal_type(self, inputs: Dict) -> Optional[str]:
+        """Detect the type of multimodal input."""
+        preview = inputs.get("multimodal_preview", "")
+        if not preview:
+            return None
+        
+        if "[AUDIO" in preview:
+            return "audio"
+        elif "[IMAGE" in preview:
+            return "image"
+        elif "[VIDEO" in preview:
+            return "video"
+        return "text"
+    
+    def _format_retrieval(self, retrieval: Dict) -> Dict[str, Any]:
+        """Format retrieval information."""
+        return {
+            "chunks_retrieved": retrieval.get("chunks_retrieved", 0),
+            "previews": retrieval.get("chunk_previews", [])
+        }
+    
+    def _format_reasoning_steps(self, trace: List[Dict]) -> List[Dict[str, Any]]:
+        """Format reasoning trace into displayable steps."""
+        steps = []
+        
+        for item in trace:
+            step = {
+                "step_number": item.get("step", len(steps) + 1),
+                "action": item.get("action", "unknown"),
+                "action_display": self._get_action_display(item.get("action", "unknown")),
+                "explanation": item.get("explanation", ""),
+                "icon": self._get_action_icon(item.get("action", "unknown"))
+            }
+            steps.append(step)
+        
+        return steps
+    
+    def _get_action_display(self, action: str) -> str:
+        """Get display-friendly action name."""
+        action_map = {
+            "domain_check": "Domain Relevance Check",
+            "vector_retrieval": "Semantic Search",
+            "llm_generation": "Answer Generation",
+            "guardrail_rejection": "Domain Guardrail"
+        }
+        return action_map.get(action, action.replace("_", " ").title())
+    
+    def _get_action_icon(self, action: str) -> str:
+        """Get icon for reasoning action."""
+        icon_map = {
+            "domain_check": "✅",
+            "vector_retrieval": "🔍",
+            "llm_generation": "💬",
+            "guardrail_rejection": "🚫"
+        }
+        return icon_map.get(action, "▶️")
+    
+    def _format_confidence(self, breakdown: Dict) -> Dict[str, Any]:
+        """Format confidence breakdown for display."""
+        overall = breakdown.get("overall", 0)
+        
+        # Determine confidence level
+        if overall >= 0.8:
+            level = "high"
+            color = "#22c55e"  # Green
+            message = "High confidence answer"
+        elif overall >= 0.5:
+            level = "moderate"
+            color = "#eab308"  # Yellow
+            message = "Moderate confidence"
+        else:
+            level = "low"
+            color = "#f97316"  # Orange
+            message = "Low confidence - verify independently"
+        
+        return {
+            "overall_score": overall,
+            "overall_percent": f"{overall * 100:.0f}%",
+            "level": level,
+            "color": color,
+            "message": message,
+            "factors": [
+                {
+                    "name": "Domain Relevance",
+                    "score": breakdown.get("domain_relevance", 0),
+                    "percent": f"{breakdown.get('domain_relevance', 0) * 100:.0f}%",
+                    "description": "How well the query matches the agent's domain"
+                },
+                {
+                    "name": "Retrieval Quality",
+                    "score": breakdown.get("retrieval_quality", 0),
+                    "percent": f"{breakdown.get('retrieval_quality', 0) * 100:.0f}%",
+                    "description": "Quality of retrieved context chunks"
+                }
+            ]
+        }
+    
+    def _format_sources(self, sources: List[str]) -> List[Dict[str, str]]:
+        """Format source citations."""
+        formatted = []
+        
+        for source in sources:
+            source_type = self._detect_source_type(source)
+            formatted.append({
+                "citation": source,
+                "type": source_type,
+                "icon": self._get_source_icon(source_type)
+            })
+        
+        return formatted
+    
+    def _detect_source_type(self, source: str) -> str:
+        """Detect the type of source citation."""
+        source_lower = source.lower()
+        
+        if ".csv" in source_lower:
+            return "csv"
+        elif ".pdf" in source_lower:
+            return "pdf"
+        elif ".json" in source_lower:
+            return "json"
+        elif ".docx" in source_lower or ".doc" in source_lower:
+            return "docx"
+        elif "entry" in source_lower or "row" in source_lower:
+            return "entry"
+        else:
+            return "text"
+    
+    def _get_source_icon(self, source_type: str) -> str:
+        """Get icon for source type."""
+        icon_map = {
+            "csv": "📊",
+            "pdf": "📄",
+            "json": "📋",
+            "docx": "📝",
+            "txt": "📃",
+            "entry": "📌"
+        }
+        return icon_map.get(source_type, "📎")
+    
+    def format_for_display(
+        self,
+        explainability_data: Dict[str, Any],
+        format_type: str = "full"
+    ) -> Dict[str, Any]:
+        """
+        Format explainability data for specific display contexts.
+        
+        Args:
+            explainability_data: Generated explainability data
+            format_type: 'full', 'compact', or 'minimal'
+            
+        Returns:
+            Formatted data appropriate for the display context
+        """
+        if format_type == "minimal":
+            return {
+                "summary": explainability_data.get("summary", {}),
+                "confidence": {
+                    "score": explainability_data.get("confidence", {}).get("overall_percent", "0%"),
+                    "level": explainability_data.get("confidence", {}).get("level", "unknown")
+                }
+            }
+        
+        elif format_type == "compact":
+            return {
+                "summary": explainability_data.get("summary", {}),
+                "retrieval": explainability_data.get("retrieval", {}),
+                "confidence": explainability_data.get("confidence", {}),
+                "sources": explainability_data.get("sources", [])[:3]
+            }
+        
+        # Full format
+        return explainability_data
+
+
+# Factory function
+def create_explainability_generator() -> ExplainabilityGenerator:
+    """Create a new ExplainabilityGenerator instance."""
+    return ExplainabilityGenerator()

backend/modules/knowledge_compiler.py

@@ -0,0 +1,408 @@
+"""
+MEXAR Core Engine - Knowledge Compilation Module
+Builds Vector embeddings from parsed data for semantic retrieval.
+"""
+
+import os
+import json
+import logging
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+
+from utils.groq_client import get_groq_client, GroqClient
+from fastembed import TextEmbedding
+from core.database import SessionLocal
+from models.agent import Agent
+from models.chunk import DocumentChunk
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class KnowledgeCompiler:
+    """
+    Compiles knowledge from parsed data into Vector embeddings.
+    Uses semantic similarity for retrieval-based reasoning.
+    """
+    
+    def __init__(self, groq_client: Optional[GroqClient] = None, data_dir: str = "data/agents"):
+        """
+        Initialize the knowledge compiler.
+        
+        Args:
+            groq_client: Optional pre-configured Groq client
+            data_dir: Directory to store agent data
+        """
+        self.client = groq_client or get_groq_client()
+        self.data_dir = Path(data_dir)
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Compilation progress tracking
+        self.progress = {
+            "status": "idle",
+            "percentage": 0,
+            "current_step": "",
+            "details": {}
+        }
+        
+        # Initialize embedding model (384 dim default)
+        try:
+            # Force cache to /tmp for HF Spaces or use env var
+            cache_dir = os.getenv("FASTEMBED_CACHE_PATH", "/tmp/.cache/fastembed")
+            self.embedding_model = TextEmbedding(
+                model_name="BAAI/bge-small-en-v1.5", 
+                cache_dir=cache_dir
+            )
+            logger.info(f"FastEmbed model loaded (cache: {cache_dir})")
+        except Exception as e:
+            logger.warning(f"Failed to load embedding model: {e}")
+            self.embedding_model = None
+    
+    def compile(
+        self,
+        agent_name: str,
+        parsed_data: List[Dict[str, Any]],
+        system_prompt: str,
+        prompt_analysis: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Main compilation function.
+        
+        Args:
+            agent_name: Name of the agent being created
+            parsed_data: List of parsed file results from DataValidator
+            system_prompt: User's system prompt
+            prompt_analysis: Analysis from PromptAnalyzer
+            
+        Returns:
+            Dict containing:
+                - domain_signature: Keywords for domain matching
+                - stats: Compilation statistics
+        """
+        self._update_progress("starting", 0, "Initializing compilation...")
+        
+        try:
+            # Step 1: Build text context (30%)
+            self._update_progress("building_context", 10, "Building text context...")
+            text_context = self._build_text_context(parsed_data)
+            self._update_progress("building_context", 30, f"Text context built: {len(text_context):,} characters")
+            
+            # Step 2: Extract domain signature (50%)
+            self._update_progress("extracting_signature", 35, "Extracting domain signature...")
+            domain_signature = self._extract_domain_signature(parsed_data, prompt_analysis)
+            self._update_progress("extracting_signature", 50, f"Domain signature: {len(domain_signature)} keywords")
+            
+            # Step 3: Calculate stats (60%)
+            self._update_progress("calculating_stats", 55, "Calculating statistics...")
+            stats = self._calculate_stats(text_context, parsed_data)
+            
+            # Step 4: Save metadata (70%)
+            self._update_progress("saving", 65, "Saving agent metadata...")
+            self._save_agent(
+                agent_name=agent_name,
+                text_context=text_context,
+                domain_signature=domain_signature,
+                system_prompt=system_prompt,
+                prompt_analysis=prompt_analysis,
+                stats=stats
+            )
+            
+            # Step 5: Save to Vector DB (95%)
+            if self.embedding_model:
+                self._update_progress("saving_vector", 75, "Saving to Vector Store...")
+                self._save_to_vector_db(agent_name, text_context)
+            
+            self._update_progress("complete", 100, "Compilation complete!")
+            
+            return {
+                "domain_signature": domain_signature,
+                "stats": stats,
+                "agent_path": str(self.data_dir / agent_name)
+            }
+            
+        except Exception as e:
+            logger.error(f"Compilation failed: {e}")
+            self._update_progress("error", self.progress["percentage"], f"Error: {str(e)}")
+            raise
+    
+    def _update_progress(self, status: str, percentage: int, step: str, details: Dict = None):
+        """Update compilation progress."""
+        self.progress = {
+            "status": status,
+            "percentage": percentage,
+            "current_step": step,
+            "details": details or {}
+        }
+        logger.info(f"[{percentage}%] {step}")
+    
+    def get_progress(self) -> Dict[str, Any]:
+        """Get current compilation progress."""
+        return self.progress.copy()
+    
+    def _build_text_context(self, parsed_data: List[Dict[str, Any]]) -> str:
+        """
+        Build text context from parsed data.
+        
+        Args:
+            parsed_data: Parsed file data
+            
+        Returns:
+            Formatted text context
+        """
+        context_parts = []
+        
+        for i, file_data in enumerate(parsed_data):
+            file_name = file_data.get("file_name", file_data.get("source", f"Source_{i+1}"))
+            file_format = file_data.get("format", file_data.get("type", "unknown"))
+            
+            context_parts.append(f"\n{'='*60}")
+            context_parts.append(f"SOURCE: {file_name} ({file_format.upper()})")
+            context_parts.append(f"{'='*60}\n")
+            
+            # Handle structured data (CSV, JSON)
+            if file_data.get("data"):
+                for j, entry in enumerate(file_data["data"]):
+                    if isinstance(entry, dict):
+                        entry_lines = [f"[Entry {j+1}]"]
+                        for key, value in entry.items():
+                            if value is not None and str(value).strip():
+                                entry_lines.append(f"  {key}: {value}")
+                        context_parts.append("\n".join(entry_lines))
+                    else:
+                        context_parts.append(f"[Entry {j+1}] {entry}")
+            
+            # Handle unstructured text (PDF, DOCX, TXT)
+            elif file_data.get("text"):
+                context_parts.append(file_data["text"])
+            
+            # Handle content field
+            elif file_data.get("content"):
+                context_parts.append(file_data["content"])
+            
+            # Handle records field
+            elif file_data.get("records"):
+                for j, record in enumerate(file_data["records"]):
+                    if record and record.strip():
+                        context_parts.append(f"[Line {j+1}] {record}")
+        
+        text_context = "\n".join(context_parts)
+        
+        # Limit to prevent token overflow (approximately 128K tokens = 500K chars)
+        max_chars = 500000
+        if len(text_context) > max_chars:
+            logger.warning(f"Text context truncated from {len(text_context)} to {max_chars} characters")
+            text_context = text_context[:max_chars] + "\n\n[CONTEXT TRUNCATED DUE TO SIZE LIMITS]"
+        
+        return text_context
+    
+    def _extract_domain_signature(
+        self,
+        parsed_data: List[Dict[str, Any]],
+        prompt_analysis: Dict[str, Any]
+    ) -> List[str]:
+        """
+        Extract domain signature keywords for guardrail checking.
+        """
+        # Start with analyzed keywords (highest priority)
+        domain_keywords = prompt_analysis.get("domain_keywords", [])
+        signature = list(domain_keywords)
+        
+        # Add domain and sub-domains
+        domain = prompt_analysis.get("domain", "")
+        if domain and domain not in signature:
+            signature.insert(0, domain)
+        
+        for sub_domain in prompt_analysis.get("sub_domains", []):
+            if sub_domain and sub_domain.lower() not in [s.lower() for s in signature]:
+                signature.append(sub_domain)
+        
+        # Extract column headers from structured data
+        for file_data in parsed_data:
+            if file_data.get("data") and isinstance(file_data["data"], list):
+                if file_data["data"] and isinstance(file_data["data"][0], dict):
+                    for key in file_data["data"][0].keys():
+                        clean_key = key.lower().strip().replace("_", " ")
+                        if clean_key and clean_key not in [s.lower() for s in signature]:
+                            signature.append(clean_key)
+        
+        return signature[:80]  # Limit for efficiency
+    
+    def _calculate_stats(
+        self,
+        text_context: str,
+        parsed_data: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """Calculate compilation statistics."""
+        return {
+            "context_length": len(text_context),
+            "context_tokens": len(text_context) // 4,  # Rough estimate
+            "source_files": len(parsed_data),
+            "total_entries": sum(
+                len(p.get("data", [])) or len(p.get("records", []))
+                for p in parsed_data
+            )
+        }
+    
+    def _save_agent(
+        self,
+        agent_name: str,
+        text_context: str,
+        domain_signature: List[str],
+        system_prompt: str,
+        prompt_analysis: Dict[str, Any],
+        stats: Dict[str, Any]
+    ):
+        """Save agent artifacts to filesystem."""
+        agent_dir = self.data_dir / agent_name
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Save text context (for backup/debugging)
+        with open(agent_dir / "context.txt", "w", encoding="utf-8") as f:
+            f.write(text_context)
+        
+        # Save metadata
+        metadata = {
+            "agent_name": agent_name,
+            "system_prompt": system_prompt,
+            "prompt_analysis": prompt_analysis,
+            "domain_signature": domain_signature,
+            "stats": stats,
+            "created_at": self._get_timestamp()
+        }
+        with open(agent_dir / "metadata.json", "w", encoding="utf-8") as f:
+            json.dump(metadata, f, indent=2, ensure_ascii=False)
+        
+        logger.info(f"Agent saved to: {agent_dir}")
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+    
+    def load_agent(self, agent_name: str) -> Dict[str, Any]:
+        """
+        Load a previously compiled agent.
+        
+        Args:
+            agent_name: Name of the agent to load
+            
+        Returns:
+            Dict with agent artifacts
+        """
+        agent_dir = self.data_dir / agent_name
+        
+        if not agent_dir.exists():
+            raise FileNotFoundError(f"Agent '{agent_name}' not found")
+        
+        # Load metadata
+        with open(agent_dir / "metadata.json", "r", encoding="utf-8") as f:
+            metadata = json.load(f)
+        
+        return {
+            "metadata": metadata,
+            "domain_signature": metadata.get("domain_signature", []),
+            "system_prompt": metadata.get("system_prompt", ""),
+            "prompt_analysis": metadata.get("prompt_analysis", {})
+        }
+    
+    def _save_to_vector_db(self, agent_name: str, context: str):
+        """Chunk and save context to vector database."""
+        try:
+            chunks = self._chunk_text(context)
+            if not chunks:
+                logger.warning(f"No chunks generated for {agent_name}")
+                return
+
+            logger.info(f"Generating embeddings for {len(chunks)} chunks...")
+            
+            # Generate embeddings with error handling
+            try:
+                embeddings = list(self.embedding_model.embed(chunks))
+                logger.info(f"Successfully generated {len(embeddings)} embeddings")
+            except Exception as embed_error:
+                logger.error(f"Embedding generation failed: {embed_error}")
+                # Don't fail the entire compilation if embeddings fail
+                return
+            
+            with SessionLocal() as db:
+                agent = db.query(Agent).filter(Agent.name == agent_name).first()
+                if not agent:
+                    logger.error(f"Agent {agent_name} not found in DB")
+                    return
+                
+                # Clear old chunks
+                try:
+                    deleted_count = db.query(DocumentChunk).filter(DocumentChunk.agent_id == agent.id).delete()
+                    logger.info(f"Deleted {deleted_count} old chunks for agent {agent_name}")
+                except Exception as delete_error:
+                    logger.warning(f"Failed to delete old chunks: {delete_error}")
+                    # Continue anyway
+                
+                # Insert new chunks
+                try:
+                    new_chunks = [
+                        DocumentChunk(
+                            agent_id=agent.id,
+                            content=chunk,
+                            embedding=embedding.tolist(),
+                            source="context"
+                        )
+                        for chunk, embedding in zip(chunks, embeddings)
+                    ]
+                    db.add_all(new_chunks)
+                    
+                    # Update agent's chunk_count
+                    agent.chunk_count = len(new_chunks)
+                    
+                    db.commit()
+                    logger.info(f"Saved {len(new_chunks)} chunks to vector store for {agent_name}")
+                except Exception as insert_error:
+                    logger.error(f"Failed to insert chunks: {insert_error}")
+                    db.rollback()
+                    raise
+                
+        except Exception as e:
+            logger.error(f"Vector save failed: {e}", exc_info=True)
+            # Don't raise - allow compilation to continue even if vector save fails
+
+
+    def _chunk_text(self, text: str, chunk_size: int = 1000, overlap: int = 100) -> List[str]:
+        """Simple text chunker."""
+        chunks = []
+        if not text:
+            return []
+        
+        start = 0
+        while start < len(text):
+            end = min(start + chunk_size, len(text))
+            chunks.append(text[start:end])
+            if end == len(text):
+                break
+            start += (chunk_size - overlap)
+        return chunks
+
+    def list_agents(self) -> List[Dict[str, Any]]:
+        """List all compiled agents."""
+        agents = []
+        
+        for agent_dir in self.data_dir.iterdir():
+            if agent_dir.is_dir():
+                metadata_path = agent_dir / "metadata.json"
+                if metadata_path.exists():
+                    with open(metadata_path, "r", encoding="utf-8") as f:
+                        metadata = json.load(f)
+                    agents.append({
+                        "name": agent_dir.name,
+                        "domain": metadata.get("prompt_analysis", {}).get("domain", "unknown"),
+                        "created_at": metadata.get("created_at"),
+                        "stats": metadata.get("stats", {})
+                    })
+        
+        return agents
+
+
+# Factory function
+def create_knowledge_compiler(data_dir: str = "data/agents") -> KnowledgeCompiler:
+    """Create a new KnowledgeCompiler instance."""
+    return KnowledgeCompiler(data_dir=data_dir)

backend/modules/multimodal_processor.py

@@ -0,0 +1,415 @@
+"""
+MEXAR Core Engine - Multimodal Input Processing Module
+Handles audio, image, and video input conversion to text.
+"""
+
+import os
+import base64
+import logging
+import tempfile
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+
+from utils.groq_client import get_groq_client, GroqClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class MultimodalProcessor:
+    """
+    Processes multimodal inputs (audio, image, video) and converts them to text.
+    Uses Groq Whisper for audio and Groq Vision for images.
+    """
+    
+    # Supported file types
+    AUDIO_EXTENSIONS = {'.mp3', '.wav', '.m4a', '.ogg', '.flac', '.webm'}
+    IMAGE_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'}
+    VIDEO_EXTENSIONS = {'.mp4', '.avi', '.mov', '.mkv', '.webm'}
+    
+    def __init__(self, groq_client: Optional[GroqClient] = None):
+        """
+        Initialize the multimodal processor.
+        
+        Args:
+            groq_client: Optional pre-configured Groq client
+        """
+        self.client = groq_client or get_groq_client()
+    
+    def process_audio(self, audio_path: str, language: str = "en") -> Dict[str, Any]:
+        """
+        Transcribe audio file using Groq Whisper.
+        
+        Args:
+            audio_path: Path to audio file
+            language: Language code for transcription
+            
+        Returns:
+            Dict with transcription results
+        """
+        path = Path(audio_path)
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_path}")
+        
+        if path.suffix.lower() not in self.AUDIO_EXTENSIONS:
+            raise ValueError(f"Unsupported audio format: {path.suffix}")
+        
+        try:
+            logger.info(f"Transcribing audio: {path.name}")
+            
+            transcript = self.client.transcribe_audio(audio_path, language)
+            
+            return {
+                "success": True,
+                "type": "audio",
+                "file_name": path.name,
+                "transcript": transcript,
+                "language": language,
+                "word_count": len(transcript.split())
+            }
+            
+        except Exception as e:
+            logger.error(f"Audio transcription failed: {e}")
+            return {
+                "success": False,
+                "type": "audio",
+                "file_name": path.name,
+                "error": str(e)
+            }
+    
+    def process_image(
+        self,
+        image_path: str,
+        prompt: str = "Describe this image in detail, including all visible text, objects, and relevant information."
+    ) -> Dict[str, Any]:
+        """
+        Describe image using Groq Vision.
+        
+        Args:
+            image_path: Path to image file
+            prompt: Question or instruction for the vision model
+            
+        Returns:
+            Dict with image description
+        """
+        path = Path(image_path)
+        
+        if not path.exists():
+            logger.error(f"Image file not found: {image_path}")
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+        
+        if path.suffix.lower() not in self.IMAGE_EXTENSIONS:
+            logger.error(f"Unsupported image format: {path.suffix}")
+            raise ValueError(f"Unsupported image format: {path.suffix}")
+        
+        try:
+            logger.info(f"Analyzing image: {path.name} (size: {path.stat().st_size} bytes)")
+            
+            # Call Groq Vision API
+            description = self.client.describe_image(image_path, prompt)
+            
+            logger.info(f"Image analysis successful: {len(description)} chars returned")
+            
+            return {
+                "success": True,
+                "type": "image",
+                "file_name": path.name,
+                "description": description,
+                "prompt_used": prompt
+            }
+            
+        except Exception as e:
+            logger.error(f"Image analysis failed for {path.name}: {type(e).__name__}: {e}")
+            return {
+                "success": False,
+                "type": "image",
+                "file_name": path.name,
+                "error": str(e),
+                "error_type": type(e).__name__
+            }
+    
+    def process_video(
+        self,
+        video_path: str,
+        max_frames: int = 5,
+        extract_audio: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Process video by extracting keyframes and audio.
+        
+        Args:
+            video_path: Path to video file
+            max_frames: Maximum number of keyframes to extract
+            extract_audio: Whether to extract and transcribe audio
+            
+        Returns:
+            Dict with video analysis results
+        """
+        path = Path(video_path)
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        
+        if path.suffix.lower() not in self.VIDEO_EXTENSIONS:
+            raise ValueError(f"Unsupported video format: {path.suffix}")
+        
+        result = {
+            "success": True,
+            "type": "video",
+            "file_name": path.name,
+            "frames": [],
+            "audio_transcript": None
+        }
+        
+        try:
+            # Try to import OpenCV
+            try:
+                import cv2
+                has_opencv = True
+            except ImportError:
+                logger.warning("OpenCV not available, skipping video frame extraction")
+                has_opencv = False
+            
+            if has_opencv:
+                # Extract keyframes
+                frames = self._extract_keyframes(video_path, max_frames)
+                
+                # Analyze each frame
+                for i, frame_path in enumerate(frames):
+                    frame_result = self.process_image(
+                        frame_path,
+                        f"This is frame {i+1} from a video. Describe what you see, focusing on actions, objects, and any text visible."
+                    )
+                    result["frames"].append(frame_result)
+                    
+                    # Clean up temp frame
+                    try:
+                        os.remove(frame_path)
+                    except:
+                        pass
+            
+            # Extract and transcribe audio
+            if extract_audio:
+                audio_path = self._extract_audio(video_path)
+                if audio_path:
+                    audio_result = self.process_audio(audio_path)
+                    result["audio_transcript"] = audio_result.get("transcript", "")
+                    
+                    # Clean up temp audio
+                    try:
+                        os.remove(audio_path)
+                    except:
+                        pass
+            
+            logger.info(f"Video processed: {len(result['frames'])} frames, audio: {result['audio_transcript'] is not None}")
+            
+        except Exception as e:
+            logger.error(f"Video processing failed: {e}")
+            result["success"] = False
+            result["error"] = str(e)
+        
+        return result
+    
+    def _extract_keyframes(self, video_path: str, max_frames: int = 5) -> List[str]:
+        """Extract keyframes from video using OpenCV."""
+        import cv2
+        
+        cap = cv2.VideoCapture(video_path)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        if total_frames == 0:
+            cap.release()
+            return []
+        
+        # Calculate frame intervals
+        interval = max(1, total_frames // max_frames)
+        
+        frame_paths = []
+        frame_count = 0
+        
+        while cap.isOpened() and len(frame_paths) < max_frames:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            if frame_count % interval == 0:
+                # Save frame to temp file
+                temp_path = tempfile.mktemp(suffix=".jpg")
+                cv2.imwrite(temp_path, frame)
+                frame_paths.append(temp_path)
+            
+            frame_count += 1
+        
+        cap.release()
+        return frame_paths
+    
+    def _extract_audio(self, video_path: str) -> Optional[str]:
+        """Extract audio track from video."""
+        try:
+            # Try using ffmpeg via subprocess
+            import subprocess
+            
+            temp_audio = tempfile.mktemp(suffix=".mp3")
+            
+            cmd = [
+                "ffmpeg",
+                "-i", video_path,
+                "-vn",  # No video
+                "-acodec", "libmp3lame",
+                "-q:a", "2",
+                "-y",  # Overwrite
+                temp_audio
+            ]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=120
+            )
+            
+            if os.path.exists(temp_audio) and os.path.getsize(temp_audio) > 0:
+                return temp_audio
+            
+            return None
+            
+        except Exception as e:
+            logger.warning(f"Audio extraction failed: {e}")
+            return None
+    
+    def fuse_inputs(
+        self,
+        text: str = "",
+        audio_result: Optional[Dict] = None,
+        image_result: Optional[Dict] = None,
+        video_result: Optional[Dict] = None
+    ) -> str:
+        """
+        Fuse all multimodal inputs into a unified text context.
+        
+        Args:
+            text: Direct text input
+            audio_result: Result from process_audio
+            image_result: Result from process_image
+            video_result: Result from process_video
+            
+        Returns:
+            Unified text context
+        """
+        context_parts = []
+        
+        # Add text input
+        if text and text.strip():
+            context_parts.append(f"[USER TEXT]\n{text.strip()}")
+        
+        # Add audio transcript
+        if audio_result and audio_result.get("success"):
+            transcript = audio_result.get("transcript", "")
+            if transcript:
+                context_parts.append(f"[AUDIO TRANSCRIPT]\n{transcript}")
+        
+        # Add image description
+        if image_result and image_result.get("success"):
+            description = image_result.get("description", "")
+            if description:
+                context_parts.append(f"[IMAGE DESCRIPTION]\n{description}")
+        
+        # Add video content
+        if video_result and video_result.get("success"):
+            video_context = []
+            
+            # Add frame descriptions
+            for i, frame in enumerate(video_result.get("frames", [])):
+                if frame.get("success"):
+                    video_context.append(f"Frame {i+1}: {frame.get('description', '')}")
+            
+            # Add audio transcript
+            if video_result.get("audio_transcript"):
+                video_context.append(f"Audio: {video_result['audio_transcript']}")
+            
+            if video_context:
+                context_parts.append(f"[VIDEO ANALYSIS]\n" + "\n".join(video_context))
+        
+        # Combine all parts
+        fused_context = "\n\n".join(context_parts)
+        
+        logger.info(f"Fused context: {len(fused_context)} characters from {len(context_parts)} sources")
+        
+        return fused_context
+    
+    def process_upload(
+        self,
+        file_path: str,
+        additional_text: str = ""
+    ) -> Dict[str, Any]:
+        """
+        Automatically detect file type and process accordingly.
+        
+        Args:
+            file_path: Path to uploaded file
+            additional_text: Additional text context
+            
+        Returns:
+            Processing result with fused context
+        """
+        path = Path(file_path)
+        ext = path.suffix.lower()
+        
+        result = {
+            "success": True,
+            "file_type": "unknown",
+            "processing_result": None,
+            "fused_context": ""
+        }
+        
+        try:
+            if ext in self.AUDIO_EXTENSIONS:
+                result["file_type"] = "audio"
+                audio_result = self.process_audio(file_path)
+                result["processing_result"] = audio_result
+                result["fused_context"] = self.fuse_inputs(
+                    text=additional_text,
+                    audio_result=audio_result
+                )
+            
+            elif ext in self.IMAGE_EXTENSIONS:
+                result["file_type"] = "image"
+                image_result = self.process_image(file_path)
+                result["processing_result"] = image_result
+                result["fused_context"] = self.fuse_inputs(
+                    text=additional_text,
+                    image_result=image_result
+                )
+            
+            elif ext in self.VIDEO_EXTENSIONS:
+                result["file_type"] = "video"
+                video_result = self.process_video(file_path)
+                result["processing_result"] = video_result
+                result["fused_context"] = self.fuse_inputs(
+                    text=additional_text,
+                    video_result=video_result
+                )
+            
+            else:
+                # Treat as text file
+                result["file_type"] = "text"
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                    file_text = f.read()
+                result["fused_context"] = self.fuse_inputs(
+                    text=f"{additional_text}\n\n[FILE CONTENT]\n{file_text}"
+                )
+            
+        except Exception as e:
+            result["success"] = False
+            result["error"] = str(e)
+            logger.error(f"Upload processing failed: {e}")
+        
+        return result
+
+
+# Factory function
+def create_multimodal_processor() -> MultimodalProcessor:
+    """Create a new MultimodalProcessor instance."""
+    return MultimodalProcessor()

backend/modules/prompt_analyzer.py

@@ -0,0 +1,336 @@
+"""
+MEXAR Core Engine - System Prompt Configuration Module
+Analyzes system prompts to extract domain, personality, and constraints.
+"""
+
+import json
+import logging
+from typing import Dict, List, Optional, Any
+from utils.groq_client import get_groq_client, GroqClient
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class PromptAnalyzer:
+    """
+    Analyzes system prompts to extract metadata for agent configuration.
+    Uses Groq LLM for intelligent prompt understanding.
+    """
+    
+    def __init__(self, groq_client: Optional[GroqClient] = None):
+        """
+        Initialize the prompt analyzer.
+        
+        Args:
+            groq_client: Optional pre-configured Groq client
+        """
+        self.client = groq_client or get_groq_client()
+    
+    def analyze_prompt(self, system_prompt: str) -> Dict[str, Any]:
+        """
+        Analyze a system prompt to extract metadata.
+        
+        Args:
+            system_prompt: The user's system prompt for the agent
+            
+        Returns:
+            Dict containing:
+                - domain: Primary domain (e.g., 'medical', 'legal', 'cooking')
+                - sub_domains: Related sub-domains
+                - personality: Agent personality traits
+                - constraints: Behavioral constraints
+                - suggested_name: Auto-generated agent name
+                - domain_keywords: Keywords for domain detection
+                - tone: Communication tone
+                - capabilities: What the agent can do
+        """
+        analysis_prompt = """You are a prompt analysis expert. Analyze the following system prompt and extract structured metadata.
+
+SYSTEM PROMPT TO ANALYZE:
+\"\"\"
+{prompt}
+\"\"\"
+
+Respond with a JSON object containing:
+{{
+    "domain": "primary domain (e.g., medical, legal, cooking, technology, finance, education)",
+    "sub_domains": ["list", "of", "related", "sub-domains"],
+    "personality": "brief personality description (e.g., friendly, professional, empathetic)",
+    "constraints": ["list", "of", "behavioral", "constraints"],
+    "suggested_name": "creative agent name based on domain and personality",
+    "domain_keywords": ["20", "keywords", "that", "define", "this", "domain"],
+    "tone": "communication tone (formal/casual/empathetic/technical)",
+    "capabilities": ["list", "of", "what", "agent", "can", "do"]
+}}
+
+Be thorough with domain_keywords - these are crucial for query filtering.
+Make the suggested_name memorable and relevant.
+"""
+        
+        try:
+            response = self.client.analyze_with_system_prompt(
+                system_prompt="You are a JSON extraction assistant. Return only valid JSON, no markdown or explanation.",
+                user_message=analysis_prompt.format(prompt=system_prompt),
+                model="chat",
+                json_mode=True
+            )
+            
+            result = json.loads(response)
+            
+            # Validate and ensure all fields exist
+            result = self._ensure_fields(result)
+            
+            logger.info(f"Prompt analyzed: domain={result['domain']}, name={result['suggested_name']}")
+            return result
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse LLM response as JSON: {e}")
+            return self._create_fallback_analysis(system_prompt)
+        except Exception as e:
+            logger.error(f"Error analyzing prompt: {e}")
+            return self._create_fallback_analysis(system_prompt)
+    
+    def _ensure_fields(self, result: Dict) -> Dict:
+        """Ensure all required fields exist in the result."""
+        defaults = {
+            "domain": "general",
+            "sub_domains": [],
+            "personality": "helpful and professional",
+            "constraints": [],
+            "suggested_name": "MEXAR Agent",
+            "domain_keywords": [],
+            "tone": "professional",
+            "capabilities": []
+        }
+        
+        for key, default in defaults.items():
+            if key not in result or result[key] is None:
+                result[key] = default
+        
+        # Ensure domain_keywords has at least 10 items
+        if len(result.get("domain_keywords", [])) < 10:
+            result["domain_keywords"] = self._expand_keywords(
+                result.get("domain_keywords", []),
+                result.get("domain", "general")
+            )
+        
+        return result
+    
+    def _expand_keywords(self, existing: List[str], domain: str) -> List[str]:
+        """Expand keywords list if too short."""
+        # Common domain-specific keywords
+        domain_defaults = {
+            "medical": ["health", "patient", "doctor", "treatment", "diagnosis", "symptoms", 
+                       "medicine", "hospital", "disease", "therapy", "prescription", "clinic",
+                       "medical", "healthcare", "wellness", "condition", "care", "physician",
+                       "nurse", "medication"],
+            "legal": ["law", "court", "legal", "attorney", "lawyer", "case", "contract",
+                     "rights", "litigation", "judge", "verdict", "lawsuit", "compliance",
+                     "regulation", "statute", "defendant", "plaintiff", "trial", "evidence",
+                     "testimony"],
+            "cooking": ["recipe", "cook", "ingredient", "food", "kitchen", "meal", "dish",
+                       "flavor", "cuisine", "bake", "chef", "cooking", "taste", "serve",
+                       "prepare", "dinner", "lunch", "breakfast", "snack", "dessert"],
+            "technology": ["software", "code", "programming", "computer", "system", "data",
+                          "network", "security", "cloud", "application", "development",
+                          "algorithm", "database", "API", "server", "hardware", "digital",
+                          "technology", "tech", "IT"],
+            "finance": ["money", "investment", "bank", "finance", "budget", "tax", "stock",
+                       "credit", "loan", "savings", "financial", "accounting", "capital",
+                       "asset", "portfolio", "market", "trading", "insurance", "wealth",
+                       "income"]
+        }
+        
+        # Start with existing keywords
+        keywords = list(existing)
+        
+        # Add domain defaults if available
+        if domain.lower() in domain_defaults:
+            for kw in domain_defaults[domain.lower()]:
+                if kw not in keywords and len(keywords) < 20:
+                    keywords.append(kw)
+        
+        # Add the domain itself if not present
+        if domain.lower() not in [k.lower() for k in keywords]:
+            keywords.append(domain)
+        
+        return keywords[:20]
+    
+    def _create_fallback_analysis(self, system_prompt: str) -> Dict[str, Any]:
+        """Create a fallback analysis when LLM fails."""
+        # Simple keyword extraction
+        words = system_prompt.lower().split()
+        
+        # Try to detect domain from common words
+        domain_indicators = {
+            "medical": ["medical", "doctor", "patient", "health", "hospital", "treatment"],
+            "legal": ["legal", "law", "attorney", "court", "contract", "rights"],
+            "cooking": ["cook", "recipe", "food", "chef", "kitchen", "ingredient"],
+            "technology": ["tech", "software", "code", "programming", "computer"],
+            "finance": ["finance", "money", "bank", "investment", "budget"]
+        }
+        
+        detected_domain = "general"
+        for domain, indicators in domain_indicators.items():
+            if any(ind in words for ind in indicators):
+                detected_domain = domain
+                break
+        
+        return {
+            "domain": detected_domain,
+            "sub_domains": [],
+            "personality": "helpful assistant",
+            "constraints": ["Stay within knowledge base", "Be accurate"],
+            "suggested_name": f"MEXAR {detected_domain.title()} Agent",
+            "domain_keywords": self._expand_keywords([], detected_domain),
+            "tone": "professional",
+            "capabilities": ["Answer questions", "Provide information"]
+        }
+    
+    def generate_enhanced_system_prompt(
+        self,
+        original_prompt: str,
+        analysis: Dict[str, Any],
+        cag_context: str
+    ) -> str:
+        """
+        Generate an enhanced system prompt with CAG context.
+        
+        Args:
+            original_prompt: User's original system prompt
+            analysis: Analysis result from analyze_prompt
+            cag_context: Compiled knowledge context
+            
+        Returns:
+            Enhanced system prompt for the agent
+        """
+        enhanced_prompt = f"""{original_prompt}
+
+---
+KNOWLEDGE BASE CONTEXT:
+You have been provided with a comprehensive knowledge base containing domain-specific information.
+Use this knowledge to answer questions accurately and cite sources when possible.
+
+DOMAIN: {analysis['domain']}
+DOMAIN KEYWORDS: {', '.join(analysis['domain_keywords'][:10])}
+
+BEHAVIORAL GUIDELINES:
+1. Only answer questions related to your domain and knowledge base
+2. If a question is outside your domain, politely decline and explain your specialization
+3. Always be {analysis['tone']} in your responses
+4. When uncertain, acknowledge limitations rather than guessing
+
+KNOWLEDGE CONTEXT:
+{cag_context[:50000]}  # Limit to prevent token overflow
+"""
+        
+        return enhanced_prompt
+    
+    def get_system_prompt_templates(self) -> List[Dict[str, str]]:
+        """
+        Return a list of system prompt templates for common domains.
+        
+        Returns:
+            List of template dictionaries with name and content
+        """
+        return [
+            {
+                "name": "Medical Assistant",
+                "domain": "medical",
+                "template": """You are a knowledgeable medical information assistant. 
+Your role is to provide accurate health information based on your knowledge base.
+You should be empathetic, professional, and always recommend consulting healthcare professionals for personal medical advice.
+Never provide diagnoses - only educational information."""
+            },
+            {
+                "name": "Legal Advisor",
+                "domain": "legal",
+                "template": """You are a legal information assistant providing general legal knowledge.
+Be professional and precise in your explanations.
+Always clarify that you provide educational information, not legal advice.
+Recommend consulting a licensed attorney for specific legal matters."""
+            },
+            {
+                "name": "Recipe Chef",
+                "domain": "cooking",
+                "template": """You are a friendly culinary assistant with expertise in cooking and recipes.
+Help users with cooking techniques, ingredient substitutions, and recipe adaptations.
+Be enthusiastic about food and encourage culinary exploration.
+Provide clear, step-by-step instructions when explaining recipes."""
+            },
+            {
+                "name": "Tech Support",
+                "domain": "technology",
+                "template": """You are a technical support specialist helping users with technology questions.
+Explain complex concepts in simple terms.
+Provide step-by-step troubleshooting guidance.
+Be patient and thorough in your explanations."""
+            },
+            {
+                "name": "Financial Guide",
+                "domain": "finance",
+                "template": """You are a financial information assistant providing educational content about personal finance.
+Be clear and professional when explaining financial concepts.
+Always remind users that this is educational information, not financial advice.
+Recommend consulting certified financial professionals for personal financial decisions."""
+            }
+        ]
+
+
+# Factory function
+def create_prompt_analyzer() -> PromptAnalyzer:
+    """Create a new PromptAnalyzer instance."""
+    return PromptAnalyzer()
+
+
+def get_prompt_templates() -> List[Dict[str, str]]:
+    """
+    Get system prompt templates without initializing Groq client.
+    
+    Returns:
+        List of template dictionaries with name and content
+    """
+    return [
+        {
+            "name": "Medical Assistant",
+            "domain": "medical",
+            "template": """You are a knowledgeable medical information assistant. 
+Your role is to provide accurate health information based on your knowledge base.
+You should be empathetic, professional, and always recommend consulting healthcare professionals for personal medical advice.
+Never provide diagnoses - only educational information."""
+        },
+        {
+            "name": "Legal Advisor",
+            "domain": "legal",
+            "template": """You are a legal information assistant providing general legal knowledge.
+Be professional and precise in your explanations.
+Always clarify that you provide educational information, not legal advice.
+Recommend consulting a licensed attorney for specific legal matters."""
+        },
+        {
+            "name": "Recipe Chef",
+            "domain": "cooking",
+            "template": """You are a friendly culinary assistant with expertise in cooking and recipes.
+Help users with cooking techniques, ingredient substitutions, and recipe adaptations.
+Be enthusiastic about food and encourage culinary exploration.
+Provide clear, step-by-step instructions when explaining recipes."""
+        },
+        {
+            "name": "Tech Support",
+            "domain": "technology",
+            "template": """You are a technical support specialist helping users with technology questions.
+Explain complex concepts in simple terms.
+Provide step-by-step troubleshooting guidance.
+Be patient and thorough in your explanations."""
+        },
+        {
+            "name": "Financial Guide",
+            "domain": "finance",
+            "template": """You are a financial information assistant providing educational content about personal finance.
+Be clear and professional when explaining financial concepts.
+Always remind users that this is educational information, not financial advice.
+Recommend consulting certified financial professionals for personal financial decisions."""
+        }
+    ]

backend/modules/reasoning_engine.py

@@ -0,0 +1,538 @@
+"""
+MEXAR Core Engine - Hybrid Reasoning Engine (RAG Version)
+Pure RAG with Source Attribution + Faithfulness scoring.
+No CAG preloading - dynamic retrieval per query.
+"""
+
+import json
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from pathlib import Path
+import networkx as nx
+from difflib import SequenceMatcher
+import numpy as np
+
+from utils.groq_client import get_groq_client, GroqClient
+from utils.hybrid_search import HybridSearcher
+from utils.reranker import Reranker
+from utils.source_attribution import SourceAttributor
+from utils.faithfulness import FaithfulnessScorer, BartNLIScorer
+from fastembed import TextEmbedding
+from core.database import SessionLocal
+from models.agent import Agent
+from models.chunk import DocumentChunk
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class ReasoningEngine:
+    """
+    Pure RAG reasoning engine with:
+    1. Hybrid search (semantic + keyword)
+    2. Cross-encoder reranking
+    3. Source attribution (inline citations)
+    4. Faithfulness scoring
+    """
+    
+    # Domain guardrail threshold (lowered for better general question handling)
+    DOMAIN_SIMILARITY_THRESHOLD = 0.05
+    MCNEMAR_BINARIZATION_THRESHOLD = 0.6  # Threshold at which a response is labeled "correct" for McNemar's test binarisation
+    
+    
+    def __init__(
+        self,
+        groq_client: Optional[GroqClient] = None,
+        data_dir: str = "data/agents"
+    ):
+        """
+        Initialize the reasoning engine.
+        
+        Args:
+            groq_client: Optional pre-configured Groq client
+            data_dir: Legacy parameter, kept for compatibility
+        """
+        self.client = groq_client or get_groq_client()
+        self.data_dir = Path(data_dir)
+        
+        # Initialize embedding model (384 dim - matches compiler)
+        try:
+            self.embedding_model = TextEmbedding(model_name="BAAI/bge-small-en-v1.5")
+            logger.info("FastEmbed bge-small-en-v1.5 loaded (384 dim)")
+        except Exception as e:
+            logger.error(f"Failed to load embedding model: {e}")
+            self.embedding_model = None
+        
+        # Initialize RAG components
+        self.searcher = HybridSearcher(self.embedding_model) if self.embedding_model else None
+        self.reranker = Reranker()
+        self.attributor = SourceAttributor(self.embedding_model)
+        self.faithfulness_scorer = FaithfulnessScorer()
+        self.bart_nli_scorer = BartNLIScorer()
+        
+        # Cache for loaded agents
+        self._agent_cache: Dict[str, Dict] = {}
+    
+    def reason(
+        self,
+        agent_name: str,
+        query: str,
+        multimodal_context: str = ""
+    ) -> Dict[str, Any]:
+        """
+        Main reasoning function - Pure RAG with Attribution.
+        
+        Args:
+            agent_name: Name of the agent to use
+            query: User's question
+            multimodal_context: Additional context from audio/image/video
+            
+        Returns:
+            Dict containing:
+                - answer: Generated answer with citations
+                - confidence: Confidence score (0-1)
+                - in_domain: Whether query is in domain
+                - explainability: Full explainability data
+        """
+        # Load agent from Supabase
+        agent = self._load_agent(agent_name)
+        
+        # Combine query with multimodal context
+        full_query = query
+        if multimodal_context:
+            full_query = f"{query}\n\n[ADDITIONAL CONTEXT]\n{multimodal_context}"
+        
+        # Step 1: Check domain guardrail
+        in_domain, domain_score = self._check_guardrail(
+            full_query,
+            agent["domain_signature"],
+            agent["prompt_analysis"]
+        )
+        
+        if not in_domain:
+            return self._create_out_of_domain_response(
+                query=query,
+                domain=agent["prompt_analysis"].get("domain", "unknown"),
+                domain_score=domain_score
+            )
+        
+        # Step 2: Hybrid Search (semantic + keyword)
+        search_results = []
+        if self.searcher:
+            search_results = self.searcher.search(full_query, agent["id"], top_k=20)
+        
+        if not search_results:
+            # Fallback to simple query
+            return self._create_no_results_response(query, agent)
+        
+        # Step 3: Rerank with cross-encoder
+        chunks = [r[0] for r in search_results]
+        rrf_scores = [r[1] for r in search_results]
+        
+        reranked = self.reranker.rerank(full_query, chunks, top_k=5)
+        top_chunks = [r[0] for r in reranked]
+        rerank_scores = [r[1] for r in reranked]
+        
+        # Step 4: Generate answer with focused context
+        context = "\n\n---\n\n".join([c.content for c in top_chunks])
+        answer = self._generate_answer(
+            query=query,  # Use original query, not full_query
+            context=context,
+            system_prompt=agent["system_prompt"],
+            multimodal_context=multimodal_context  # Pass multimodal context separately
+        )
+        
+        # Step 5: Source Attribution
+        chunk_embeddings = None
+        if self.embedding_model:
+            try:
+                chunk_embeddings = list(self.embedding_model.embed([c.content for c in top_chunks]))
+            except:
+                pass
+        
+        attribution = self.attributor.attribute(answer, top_chunks, chunk_embeddings)
+        
+        # Step 6: Faithfulness Scoring
+        faithfulness_result = self.faithfulness_scorer.score(answer, context)
+        
+        # Independent NLI Baseline Scoring (for reviewer feedback)
+        bart_nli_result = self.bart_nli_scorer.score(answer, context)
+        
+        # Step 7: Calculate Confidence
+        top_similarity = rrf_scores[0] if rrf_scores else 0
+        top_rerank = rerank_scores[0] if rerank_scores else 0
+        
+        confidence = self._calculate_confidence(
+            top_similarity=top_similarity,
+            rerank_score=top_rerank,
+            faithfulness=faithfulness_result.score
+        )
+        
+        # Step 8: Build Explainability
+        explainability = self._build_explainability(
+            query=query,
+            multimodal_context=multimodal_context,
+            chunks=top_chunks,
+            rrf_scores=rrf_scores[:5],
+            rerank_scores=rerank_scores,
+            attribution=attribution,
+            faithfulness=faithfulness_result,
+            bart_nli_result=bart_nli_result,
+            confidence=confidence,
+            domain_score=domain_score
+        )
+        
+        logger.info(f"Reasoning complete: confidence={confidence:.2f}, chunks={len(top_chunks)}, faithfulness={faithfulness_result.score:.2f}")
+        
+        return {
+            "answer": attribution.answer_with_citations,
+            "confidence": confidence,
+            "in_domain": True,
+            "reasoning_paths": [],  # Legacy, kept for compatibility
+            "entities_found": [],  # Legacy, kept for compatibility
+            "explainability": explainability
+        }
+    
+    def _load_agent(self, agent_name: str) -> Dict[str, Any]:
+        """Load agent from Supabase (with caching)."""
+        if agent_name in self._agent_cache:
+            return self._agent_cache[agent_name]
+        
+        db = SessionLocal()
+        try:
+            agent = db.query(Agent).filter(Agent.name == agent_name).first()
+            
+            if not agent:
+                raise ValueError(f"Agent '{agent_name}' not found")
+            
+            agent_data = {
+                "id": agent.id,
+                "name": agent.name,
+                "system_prompt": agent.system_prompt,
+                "domain": agent.domain,
+                "domain_signature": agent.domain_signature or [],
+                "prompt_analysis": agent.prompt_analysis or {},
+                "knowledge_graph": agent.knowledge_graph_json or {},
+                "chunk_count": agent.chunk_count or 0
+            }
+            
+            self._agent_cache[agent_name] = agent_data
+            return agent_data
+        finally:
+            db.close()
+    
+    def _check_guardrail(
+        self,
+        query: str,
+        domain_signature: List[str],
+        prompt_analysis: Dict[str, Any]
+    ) -> Tuple[bool, float]:
+        """Check if query matches the domain."""
+        query_lower = query.lower()
+        query_words = set(query_lower.split())
+        
+        matches = 0
+        bonus_matches = 0
+        
+        # Check domain match
+        domain = prompt_analysis.get("domain", "")
+        if domain.lower() in query_lower:
+            bonus_matches += 3
+        
+        # Check sub-domains
+        for sub_domain in prompt_analysis.get("sub_domains", []):
+            if sub_domain.lower() in query_lower:
+                bonus_matches += 2
+        
+        # Check domain keywords
+        for keyword in prompt_analysis.get("domain_keywords", []):
+            if keyword.lower() in query_lower:
+                bonus_matches += 1.5
+        
+        # Check signature keywords with fuzzy matching
+        signature_lower = [kw.lower() for kw in (domain_signature or [])]
+        
+        for word in query_words:
+            if len(word) < 3:
+                continue
+            for kw in signature_lower[:100]:
+                if self._fuzzy_match(word, kw) > 0.75:
+                    matches += 1
+                    break
+                if word in kw or kw in word:
+                    matches += 0.5
+                    break
+        
+        # Calculate score
+        max_possible = max(1, min(len(query_words), 10))
+        base_score = matches / max_possible
+        bonus_score = min(0.5, bonus_matches * 0.1)
+        score = min(1.0, base_score + bonus_score)
+        
+        if bonus_matches >= 1:
+            score = max(score, 0.2)
+        
+        is_in_domain = score >= self.DOMAIN_SIMILARITY_THRESHOLD
+        
+        # Analyze guardrail false-accept rate: Log boundary queries (close to threshold)
+        if 0.05 <= score < 0.15:
+            logger.info(f"GUARDRAIL_BOUNDARY_ACCEPT: score={score:.2f}, query='{query}' - Check for false positive")
+        
+        logger.info(f"Guardrail: score={score:.2f}, matches={matches}, bonus={bonus_matches}, in_domain={is_in_domain}")
+        
+        return is_in_domain, score
+    
+    def _fuzzy_match(self, s1: str, s2: str) -> float:
+        """Calculate fuzzy match ratio."""
+        return SequenceMatcher(None, s1, s2).ratio()
+    
+    def _generate_answer(
+        self,
+        query: str,
+        context: str,
+        system_prompt: str,
+        multimodal_context: str = ""
+    ) -> str:
+        """Generate answer using LLM with retrieved context and multimodal data."""
+        
+        # Build multimodal section if present
+        multimodal_section = ""
+        if multimodal_context:
+            multimodal_section = f"""\n\nMULTIMODAL INPUT (User uploaded media):
+{multimodal_context}
+
+IMPORTANT: When the user asks about images, audio, or other uploaded media, 
+use the descriptions above to answer their questions. The multimodal input 
+contains AI-generated descriptions of what the user has uploaded."""
+        
+        full_system_prompt = f"""{system_prompt}
+
+RETRIEVED KNOWLEDGE BASE CONTEXT:
+{context[:80000]}
+{multimodal_section}
+
+IMPORTANT INSTRUCTIONS:
+1. Answer using the retrieved context AND any multimodal input provided
+2. If the user asks about uploaded images/audio, use the MULTIMODAL INPUT section
+3. If asking about knowledge base topics, use the RETRIEVED CONTEXT
+4. If information is not available in any source, say "I don't have information about that"
+5. Be specific and cite sources when possible
+6. Be concise but comprehensive
+7. If you quote directly, use quotation marks
+"""
+        
+        try:
+            answer = self.client.analyze_with_system_prompt(
+                system_prompt=full_system_prompt,
+                user_message=query,
+                model="chat"
+            )
+            return answer
+        except Exception as e:
+            logger.error(f"Answer generation failed: {e}")
+            return "I apologize, but I encountered an error processing your query. Please try again."
+    
+    def _calculate_confidence(
+        self,
+        top_similarity: float,
+        rerank_score: float,
+        faithfulness: float
+    ) -> float:
+        """
+        Calculate confidence score based on RAG metrics.
+        
+        Calibrated to provide meaningful scores:
+        - High retrieval + high faithfulness = high confidence
+        - Low retrieval = capped confidence
+        """
+        # Normalize rerank score (cross-encoder outputs vary)
+        # Typical range is -10 to +10, normalize to 0-1
+        norm_rerank = min(1.0, max(0, (rerank_score + 10) / 20))
+        
+        # Normalize RRF score (typically 0 to 0.03)
+        norm_similarity = min(1.0, top_similarity * 30)
+        
+        # Weighted combination
+        confidence = (
+            norm_similarity * 0.35 +      # Retrieval quality
+            norm_rerank * 0.30 +           # Rerank confidence
+            faithfulness * 0.25 +          # Grounding quality
+            0.10                           # Base floor for in-domain
+        )
+        
+        # Apply thresholds
+        if norm_similarity > 0.7 and faithfulness > 0.8:
+            confidence = max(confidence, 0.75)
+        elif norm_similarity < 0.3:
+            confidence = min(confidence, 0.45)
+        
+        return round(min(0.95, max(0.15, confidence)), 2)
+    
+    def _build_explainability(
+        self,
+        query: str,
+        multimodal_context: str,
+        chunks: List,
+        rrf_scores: List[float],
+        rerank_scores: List[float],
+        attribution,
+        faithfulness,
+        bart_nli_result,
+        confidence: float,
+        domain_score: float
+    ) -> Dict[str, Any]:
+        """Build comprehensive explainability output."""
+        return {
+            "why_this_answer": {
+                "summary": f"Answer derived from {len(chunks)} retrieved sources with {faithfulness.score*100:.0f}% faithfulness",
+                "sources": [
+                    {
+                        "citation": src["citation"],
+                        "source_file": src["source"],
+                        "content_preview": src["preview"][:150] if src.get("preview") else "",
+                        "relevance_score": f"{src.get('similarity', 0)*100:.0f}%"
+                    }
+                    for src in attribution.sources
+                ]
+            },
+            "confidence_breakdown": {
+                "overall": f"{confidence*100:.0f}%",
+                "domain_relevance": f"{domain_score*100:.0f}%",
+                "retrieval_quality": f"{rrf_scores[0]*100:.1f}%" if rrf_scores else "N/A",
+                "rerank_score": f"{rerank_scores[0]:.2f}" if rerank_scores else "N/A",
+                "faithfulness": f"{faithfulness.score*100:.0f}%",
+                "bart_nli_score": f"{bart_nli_result.score*100:.0f}%" if bart_nli_result else "N/A",
+                "claims_supported": f"{faithfulness.supported_claims}/{faithfulness.total_claims}"
+            },
+            "unsupported_claims": faithfulness.unsupported_claims[:3],
+            "inputs": {
+                "original_query": query,
+                "has_multimodal": bool(multimodal_context),
+                "chunks_retrieved": len(chunks)
+            },
+            "knowledge_graph": None  # Optional, can be populated for visualization
+        }
+    
+    def _create_out_of_domain_response(
+        self,
+        query: str,
+        domain: str,
+        domain_score: float
+    ) -> Dict[str, Any]:
+        """Create response for out-of-domain queries."""
+        return {
+            "answer": f"""I apologize, but your question appears to be outside my area of expertise.
+
+I am a specialized **{domain.title()}** assistant and can only answer questions related to that domain based on my knowledge base.
+
+Your query doesn't seem to match the topics I'm trained on (relevance score: {domain_score*100:.0f}%).
+
+**How I can help:**
+- Ask questions related to {domain}
+- Query information from my knowledge base
+- Get explanations about {domain}-related topics
+
+Would you like to rephrase your question to focus on {domain}?""",
+            "confidence": 0.1,
+            "in_domain": False,
+            "reasoning_paths": [],
+            "entities_found": [],
+            "explainability": {
+                "why_this_answer": {
+                    "summary": "Query rejected - outside domain expertise",
+                    "sources": []
+                },
+                "confidence_breakdown": {
+                    "overall": "10%",
+                    "domain_relevance": f"{domain_score*100:.0f}%",
+                    "rejection_reason": "out_of_domain"
+                },
+                "inputs": {"original_query": query}
+            }
+        }
+    
+    def _create_no_results_response(
+        self,
+        query: str,
+        agent: Dict
+    ) -> Dict[str, Any]:
+        """Create response when no relevant chunks found."""
+        return {
+            "answer": f"""I couldn't find relevant information in my knowledge base to answer your question.
+
+This could mean:
+- The topic isn't covered in my training data
+- Try rephrasing your question with different keywords
+- Ask about a more specific aspect of {agent.get('domain', 'the domain')}""",
+            "confidence": 0.2,
+            "in_domain": True,
+            "reasoning_paths": [],
+            "entities_found": [],
+            "explainability": {
+                "why_this_answer": {
+                    "summary": "No relevant chunks found in knowledge base",
+                    "sources": []
+                },
+                "confidence_breakdown": {
+                    "overall": "20%",
+                    "issue": "no_relevant_retrieval"
+                },
+                "inputs": {"original_query": query}
+            }
+        }
+
+    # ==========================================
+    # Baselines for Paper Table II Comparison
+    # ==========================================
+
+    def reason_crag_baseline(self, agent_name: str, query: str) -> Dict[str, Any]:
+        """
+        CRAG (Corrective RAG) baseline.
+        Retrieves documents, evaluates their relevance to the query.
+        Returns a slightly different output simulating CRAG flow.
+        """
+        logger.info(f"Running CRAG baseline for query: {query}")
+        return self._run_baseline("CRAG", agent_name, query)
+
+    def reason_raptor_baseline(self, agent_name: str, query: str) -> Dict[str, Any]:
+        """
+        RAPTOR baseline.
+        Simulates recursive summarization trees. We retrieve larger context windows.
+        """
+        logger.info(f"Running RAPTOR baseline for query: {query}")
+        return self._run_baseline("RAPTOR", agent_name, query)
+
+    def _run_baseline(self, baseline: str, agent_name: str, query: str) -> Dict[str, Any]:
+        """Generic baseline runner for comparative evaluations."""
+        agent = self._load_agent(agent_name)
+        search_results = self.searcher.search(query, agent["id"], top_k=5) if self.searcher else []
+        chunks = [r[0] for r in search_results]
+        context = "\n".join([c.content for c in chunks])
+        
+        if baseline == "CRAG":
+            sys_prompt = f"You are a Corrective-RAG system. You must answer ONLY using the context. If context cannot answer it, literally respond with 'Context insufficient'.\n\nContext: {context[:4000]}"
+        else: # RAPTOR
+            sys_prompt = f"You are a RAPTOR baseline model. Synthesize information from the provided tree of context summaries below to answer the query.\n\nContext: {context[:8000]}"
+
+        answer = self._generate_answer(query, context, sys_prompt)
+        faithfulness = self.faithfulness_scorer.score(answer, context)
+        
+        return {
+            "answer": answer,
+            "confidence": faithfulness.score,
+            "in_domain": True,
+            "reasoning_paths": [],
+            "entities_found": [],
+            "explainability": {
+                "baseline": baseline,
+                "faithfulness": faithfulness.score,
+                "chunks_used": len(chunks)
+            }
+        }
+
+
+# Factory function
+def create_reasoning_engine(data_dir: str = "data/agents") -> ReasoningEngine:
+    """Create a new ReasoningEngine instance."""
+    return ReasoningEngine(data_dir=data_dir)

backend/quick_test.py

@@ -0,0 +1,32 @@
+"""
+Quick test to see the full multimodal response
+"""
+import requests
+from pathlib import Path
+
+BASE_URL = 'http://127.0.0.1:8000'
+
+# Login
+login_resp = requests.post(f'{BASE_URL}/api/auth/login', json={'email': 'dev@gmail.com', 'password': '123456'})
+token = login_resp.json().get('access_token')
+headers = {'Authorization': f'Bearer {token}'}
+
+# Get agent
+agents_resp = requests.get(f'{BASE_URL}/api/agents/', headers=headers)
+agent_name = agents_resp.json()[0]['name']
+print(f"Using agent: {agent_name}")
+
+# Test with image
+test_image = Path('data/temp/test_multimodal.png')
+with open(test_image, 'rb') as f:
+    files = {'image': (test_image.name, f, 'image/png')}
+    data = {'agent_name': agent_name, 'message': 'What color is this image?', 'include_explainability': 'true'}
+    response = requests.post(f'{BASE_URL}/api/chat/multimodal', files=files, data=data, headers=headers, timeout=120)
+
+result = response.json()
+print('=== FULL RESPONSE ===')
+print(f"Success: {result.get('success')}")
+print(f"Answer: {result.get('answer')}")
+print(f"Confidence: {result.get('confidence')}")
+print(f"Image URL: {result.get('image_url')}")
+print(f"In Domain: {result.get('in_domain')}")

backend/requirements.txt

@@ -0,0 +1,55 @@
+# MEXAR Phase 1 - Backend Dependencies
+
+# Web Framework
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+
+# Groq API
+groq==0.4.2
+httpx==0.27.0  # Pin to compatible version for groq SDK
+
+# Knowledge Graph
+networkx==3.2.1
+
+# Data Processing
+pandas==2.1.4
+PyPDF2==3.0.1
+python-docx==1.1.0
+
+# File Upload
+python-multipart==0.0.6
+
+# Video Processing
+opencv-python==4.9.0.80
+
+# Environment
+python-dotenv==1.0.0
+
+# JSON handling
+orjson==3.9.10
+
+# Async support
+aiofiles==23.2.1
+
+# Database (Supabase/PostgreSQL)
+SQLAlchemy==2.0.25
+psycopg2-binary==2.9.9
+
+# Authentication & Security
+passlib[bcrypt]==1.7.4
+python-jose[cryptography]==3.3.0
+bcrypt==4.1.2
+email-validator==2.1.0
+
+# Supabase Client
+supabase==2.24.0
+
+# Vector Support
+fastembed>=0.7.0  # Updated from 0.2.0 (was yanked)
+pgvector==0.2.4
+
+# RAG Components (NEW)
+sentence-transformers>=2.2.0  # Cross-encoder reranking
+numpy>=1.24.0  # Vector operations
+transformers>=4.38.0
+torch>=2.0.0

backend/services/agent_service.py

@@ -0,0 +1,84 @@
+
+import shutil
+import json
+from pathlib import Path
+from typing import List, Optional
+from sqlalchemy.orm import Session
+from models.agent import Agent
+from models.user import User
+from core.config import settings
+
+class AgentService:
+    def __init__(self):
+        self.storage_path = Path(settings.STORAGE_PATH)
+        self.storage_path.mkdir(parents=True, exist_ok=True)
+
+    def create_agent(self, db: Session, user: User, name: str, system_prompt: str) -> Agent:
+        """Create a new agent entry in database."""
+        # Sanitize name
+        clean_name = name.strip().replace(" ", "_").lower()
+        
+        # Check if agent already exists for this user
+        existing = db.query(Agent).filter(
+            Agent.user_id == user.id,
+            Agent.name == clean_name
+        ).first()
+        
+        if existing:
+            raise ValueError(f"You already have an agent named '{clean_name}'")
+
+        # Create agent storage directory
+        agent_dir = self.storage_path / str(user.id) / clean_name
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create DB record
+        new_agent = Agent(
+            user_id=user.id,
+            name=clean_name,
+            system_prompt=system_prompt,
+            storage_path=str(agent_dir),
+            status="initializing"
+        )
+        
+        db.add(new_agent)
+        db.commit()
+        db.refresh(new_agent)
+        
+        return new_agent
+
+    def get_agent(self, db: Session, user: User, agent_name: str) -> Optional[Agent]:
+        """Get a specific agent owned by the user."""
+        return db.query(Agent).filter(
+            Agent.user_id == user.id,
+            Agent.name == agent_name
+        ).first()
+
+    def get_agent_by_id(self, db: Session, agent_id: int, user_id: int) -> Optional[Agent]:
+        """Get agent by ID with ownership check."""
+        return db.query(Agent).filter(
+            Agent.id == agent_id,
+            Agent.user_id == user_id
+        ).first()
+
+    def list_agents(self, db: Session, user: User) -> List[Agent]:
+        """List all agents owned by the user."""
+        return db.query(Agent).filter(Agent.user_id == user.id).all()
+
+    def delete_agent(self, db: Session, user: User, agent_name: str):
+        """Delete an agent and its files."""
+        agent = self.get_agent(db, user, agent_name)
+        if not agent:
+            raise ValueError("Agent not found")
+            
+        # Delete files
+        try:
+            if agent.storage_path and Path(agent.storage_path).exists():
+                shutil.rmtree(agent.storage_path)
+        except Exception as e:
+            print(f"Error deleting files for agent {agent.name}: {e}")
+            # Continue to delete DB record even if file deletion fails
+            
+        db.delete(agent)
+        db.commit()
+
+agent_service = AgentService()

backend/services/auth_service.py

@@ -0,0 +1,60 @@
+
+from sqlalchemy.orm import Session
+from datetime import datetime
+from models.user import User
+from core.security import get_password_hash, verify_password, create_access_token
+
+class AuthService:
+    def register_user(self, db: Session, email: str, password: str) -> User:
+        """Register a new user."""
+        # Check if user exists
+        existing_user = db.query(User).filter(User.email == email).first()
+        if existing_user:
+            raise ValueError("Email already registered")
+        
+        # Create user
+        hashed_pw = get_password_hash(password)
+        new_user = User(email=email, password=hashed_pw)
+        
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+        return new_user
+
+    def authenticate_user(self, db: Session, email: str, password: str) -> dict:
+        """Authenticate user and return token."""
+        user = db.query(User).filter(User.email == email).first()
+        if not user or not verify_password(password, user.password):
+            return None
+        
+        # Update login time
+        user.last_login = datetime.utcnow()
+        db.commit()
+        
+        # Create token
+        access_token = create_access_token(data={"sub": user.email, "user_id": user.id})
+        
+        return {
+            "access_token": access_token,
+            "token_type": "bearer",
+            "user": {
+                "id": user.id,
+                "email": user.email,
+                "created_at": user.created_at
+            }
+        }
+
+    def change_password(self, db: Session, user_email: str, old_password: str, new_password: str):
+        """Change user password."""
+        user = db.query(User).filter(User.email == user_email).first()
+        if not user:
+            raise ValueError("User not found")
+        
+        if not verify_password(old_password, user.password):
+            raise ValueError("Incorrect current password")
+            
+        user.password = get_password_hash(new_password)
+        db.commit()
+        return True
+
+auth_service = AuthService()

backend/services/conversation_service.py

@@ -0,0 +1,150 @@
+
+from typing import List, Optional
+from sqlalchemy.orm import Session
+from datetime import datetime
+
+from models.conversation import Conversation, Message
+from models.agent import Agent
+from models.user import User
+
+class ConversationService:
+    """
+    Service for managing conversations and messages.
+    Handles auto-creation of conversations and message persistence.
+    """
+    
+    def get_or_create_conversation(
+        self, 
+        db: Session, 
+        agent_id: int, 
+        user_id: int
+    ) -> Conversation:
+        """Get existing conversation or create a new one."""
+        conversation = db.query(Conversation).filter(
+            Conversation.agent_id == agent_id,
+            Conversation.user_id == user_id
+        ).first()
+        
+        if not conversation:
+            conversation = Conversation(
+                agent_id=agent_id,
+                user_id=user_id
+            )
+            db.add(conversation)
+            db.commit()
+            db.refresh(conversation)
+        
+        return conversation
+    
+    def add_message(
+        self,
+        db: Session,
+        conversation_id: int,
+        role: str,
+        content: str,
+        multimodal_data: dict = None,
+        explainability_data: dict = None,
+        confidence: float = None
+    ) -> Message:
+        """Add a message to a conversation."""
+        message = Message(
+            conversation_id=conversation_id,
+            role=role,
+            content=content,
+            multimodal_data=multimodal_data,
+            explainability_data=explainability_data,
+            confidence=confidence
+        )
+        
+        db.add(message)
+        
+        # Update conversation timestamp
+        conversation = db.query(Conversation).filter(
+            Conversation.id == conversation_id
+        ).first()
+        if conversation:
+            conversation.updated_at = datetime.utcnow()
+        
+        db.commit()
+        db.refresh(message)
+        
+        return message
+    
+    def get_messages(
+        self,
+        db: Session,
+        conversation_id: int,
+        limit: int = 50
+    ) -> List[Message]:
+        """Get messages from a conversation."""
+        return db.query(Message).filter(
+            Message.conversation_id == conversation_id
+        ).order_by(Message.timestamp.asc()).limit(limit).all()
+    
+    def get_conversation_history(
+        self,
+        db: Session,
+        agent_id: int,
+        user_id: int,
+        limit: int = 50
+    ) -> List[dict]:
+        """Get conversation history for an agent-user pair."""
+        conversation = db.query(Conversation).filter(
+            Conversation.agent_id == agent_id,
+            Conversation.user_id == user_id
+        ).first()
+        
+        if not conversation:
+            return []
+        
+        messages = self.get_messages(db, conversation.id, limit)
+        
+        return [
+            {
+                "id": msg.id,
+                "role": msg.role,
+                "content": msg.content,
+                "timestamp": msg.timestamp,
+                "confidence": msg.confidence,
+                "explainability": msg.explainability_data
+            }
+            for msg in messages
+        ]
+    
+    def list_conversations(
+        self,
+        db: Session,
+        user_id: int
+    ) -> List[dict]:
+        """List all conversations for a user."""
+        conversations = db.query(Conversation).filter(
+            Conversation.user_id == user_id
+        ).order_by(Conversation.updated_at.desc()).all()
+        
+        return [
+            {
+                "id": conv.id,
+                "agent_id": conv.agent_id,
+                "created_at": conv.created_at,
+                "updated_at": conv.updated_at,
+                "message_count": len(conv.messages)
+            }
+            for conv in conversations
+        ]
+    
+    def delete_conversation(self, db: Session, conversation_id: int, user_id: int) -> bool:
+        """Delete a conversation (with ownership check)."""
+        conversation = db.query(Conversation).filter(
+            Conversation.id == conversation_id,
+            Conversation.user_id == user_id
+        ).first()
+        
+        if not conversation:
+            return False
+        
+        db.delete(conversation)
+        db.commit()
+        return True
+
+# Singleton instance
+conversation_service = ConversationService()

backend/services/inference_service.py

@@ -0,0 +1,130 @@
+
+from typing import Optional
+from pathlib import Path
+from sqlalchemy.orm import Session
+
+from models.agent import Agent
+from models.user import User
+from services.conversation_service import conversation_service
+from modules.reasoning_engine import ReasoningEngine, create_reasoning_engine
+
+class InferenceService:
+    """
+    Service for running inference with AI agents.
+    Wraps the Phase 1 ReasoningEngine with multi-tenancy support.
+    """
+    
+    def __init__(self):
+        self.engine_cache = {}  # agent_id -> ReasoningEngine
+    
+    def get_engine(self, agent: Agent) -> ReasoningEngine:
+        """Get or create a reasoning engine for an agent."""
+        if agent.id in self.engine_cache:
+            return self.engine_cache[agent.id]
+        
+        # Create new engine
+        engine = create_reasoning_engine(agent.storage_path)
+        self.engine_cache[agent.id] = engine
+        return engine
+    
+    def clear_cache(self, agent_id: int = None):
+        """Clear engine cache."""
+        if agent_id:
+            if agent_id in self.engine_cache:
+                del self.engine_cache[agent_id]
+        else:
+            self.engine_cache.clear()
+    
+    def chat(
+        self,
+        db: Session,
+        agent: Agent,
+        user: User,
+        message: str,
+        image_path: Optional[str] = None,
+        audio_path: Optional[str] = None
+    ) -> dict:
+        """
+        Process a chat message with the agent.
+        
+        Returns:
+            dict with answer, confidence, explainability, etc.
+        """
+        # Check agent status
+        if agent.status != "ready":
+            return {
+                "answer": f"Agent is not ready. Current status: {agent.status}",
+                "confidence": 0.0,
+                "in_domain": False,
+                "explainability": None
+            }
+        
+        # Get or create conversation
+        conversation = conversation_service.get_or_create_conversation(
+            db, agent.id, user.id
+        )
+        
+        # Save user message
+        conversation_service.add_message(
+            db, conversation.id, "user", message,
+            multimodal_data={"image": image_path, "audio": audio_path} if image_path or audio_path else None
+        )
+        
+        # Get reasoning engine
+        engine = self.get_engine(agent)
+        
+        # Run inference
+        try:
+            # Build multimodal context
+            multimodal_context = ""
+            if image_path:
+                multimodal_context += f"[IMAGE: {image_path}]\n"
+            if audio_path:
+                multimodal_context += f"[AUDIO: {audio_path}]\n"
+            
+            result = engine.reason(
+                agent_name=agent.name,
+                query=message,
+                multimodal_context=multimodal_context
+            )
+            
+            # Save assistant response
+            conversation_service.add_message(
+                db, conversation.id, "assistant", result.get("answer", ""),
+                explainability_data=result.get("explainability"),
+                confidence=result.get("confidence", 0.0)
+            )
+            
+            return result
+            
+        except Exception as e:
+            error_response = {
+                "answer": f"Error processing query: {str(e)}",
+                "confidence": 0.0,
+                "in_domain": False,
+                "explainability": None
+            }
+            
+            # Save error response
+            conversation_service.add_message(
+                db, conversation.id, "assistant", error_response["answer"],
+                confidence=0.0
+            )
+            
+            return error_response
+    
+    def get_history(
+        self,
+        db: Session,
+        agent: Agent,
+        user: User,
+        limit: int = 50
+    ) -> list:
+        """Get conversation history for agent-user pair."""
+        return conversation_service.get_conversation_history(
+            db, agent.id, user.id, limit
+        )
+
+
+# Singleton instance
+inference_service = InferenceService()

backend/services/storage_service.py

@@ -0,0 +1,144 @@
+"""
+MEXAR Core Engine - Storage Service
+Handles file uploads to Supabase Storage.
+"""
+
+import os
+import logging
+from typing import Optional
+from pathlib import Path
+import uuid
+from fastapi import UploadFile, HTTPException
+from supabase import create_client, Client
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class StorageService:
+    """Service for managing file uploads to Supabase Storage."""
+    
+    def __init__(self):
+        """Initialize Supabase client."""
+        supabase_url = os.getenv("SUPABASE_URL")
+        supabase_key = os.getenv("SUPABASE_KEY")
+        
+        if not supabase_url or not supabase_key:
+            raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables")
+        
+        self.client: Client = create_client(supabase_url, supabase_key)
+        logger.info("Supabase Storage client initialized")
+    
+    async def upload_file(
+        self, 
+        file: UploadFile, 
+        bucket: str, 
+        folder: str = ""
+    ) -> dict:
+        """
+        Upload file to Supabase Storage and return file info.
+        
+        Args:
+            file: FastAPI UploadFile object
+            bucket: Bucket name (e.g., 'agent-uploads', 'chat-media')
+            folder: Optional folder path within bucket
+            
+        Returns:
+            Dict containing:
+                - path: File path in storage
+                - url: Public URL (if bucket is public)
+                - size: File size in bytes
+        """
+        try:
+            # Generate unique filename
+            ext = Path(file.filename).suffix
+            filename = f"{uuid.uuid4()}{ext}"
+            path = f"{folder}/{filename}" if folder else filename
+            
+            # Read file content
+            content = await file.read()
+            file_size = len(content)
+            
+            # Upload to Supabase
+            logger.info(f"Uploading file to {bucket}/{path}")
+            response = self.client.storage.from_(bucket).upload(
+                path=path,
+                file=content,
+                file_options={"content-type": file.content_type or "application/octet-stream"}
+            )
+            
+            # Get public URL (works for public buckets)
+            public_url = self.client.storage.from_(bucket).get_public_url(path)
+            
+            logger.info(f"File uploaded successfully: {path}")
+            
+            return {
+                "path": path,
+                "url": public_url,
+                "size": file_size,
+                "bucket": bucket,
+                "original_filename": file.filename
+            }
+            
+        except Exception as e:
+            logger.error(f"Error uploading file to Supabase Storage: {str(e)}")
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Failed to upload file: {str(e)}"
+            )
+    
+    def delete_file(self, bucket: str, path: str) -> bool:
+        """
+        Delete file from storage.
+        
+        Args:
+            bucket: Bucket name
+            path: File path in bucket
+            
+        Returns:
+            True if successful
+        """
+        try:
+            logger.info(f"Deleting file from {bucket}/{path}")
+            self.client.storage.from_(bucket).remove([path])
+            logger.info(f"File deleted successfully: {path}")
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting file: {str(e)}")
+            return False
+    
+    def get_signed_url(self, bucket: str, path: str, expires_in: int = 3600) -> str:
+        """
+        Generate a signed URL for private files.
+        
+        Args:
+            bucket: Bucket name
+            path: File path
+            expires_in: URL expiration time in seconds (default: 1 hour)
+            
+        Returns:
+            Signed URL string
+        """
+        try:
+            response = self.client.storage.from_(bucket).create_signed_url(
+                path=path,
+                expires_in=expires_in
+            )
+            return response.get("signedURL", "")
+        except Exception as e:
+            logger.error(f"Error generating signed URL: {str(e)}")
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to generate signed URL: {str(e)}"
+            )
+
+
+# Factory function for easy instantiation
+def create_storage_service() -> StorageService:
+    """Create a new StorageService instance."""
+    return StorageService()
+
+
+# Global instance
+storage_service = create_storage_service()