feat: add admin rules ingestion UI and persistent backend storage

LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 IntegraChat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

README.md

@@ -1,683 +1,134 @@
-<div align="center">
-
-# 🚀 IntegraChat
-
-### Multi-Tenant Autonomous MCP Platform
-
-**Enterprise-grade AI with autonomous agents, secure multi-tenant RAG, real-time web search, red-flag governance, and analytics.**
-
-[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
-[![React](https://img.shields.io/badge/React-18-blue.svg)](https://reactjs.org/)
-[![FastAPI](https://img.shields.io/badge/FastAPI-Latest-green.svg)](https://fastapi.tiangolo.com/)
-[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![MCP](https://img.shields.io/badge/MCP-In%20Action-purple.svg)](https://modelcontextprotocol.io/)
-
-</div>
-
----
-
-## 📑 Table of Contents
-
-- [Overview](#-overview)
-- [Purpose](#-purpose)
-- [Key Features](#-key-features)
-- [Technology Stack](#-technology-stack)
-- [System Architecture](#-system-architecture)
-- [Project Structure](#-project-structure)
-- [Getting Started](#-getting-started)
-- [Why IntegraChat Stands Out](#-why-integrachat-stands-out)
-- [Submission Metadata](#-submission-metadata)
-- [License](#-license)
+# IntegraChat — MCP Autonomous Agent
 
----
-
-## 📌 Overview
-
-**IntegraChat** is an enterprise-ready, multi-tenant AI platform built to demonstrate the full capabilities of the **Model Context Protocol (MCP)** in a real production-style environment.
-
-It combines **autonomous tool-using agents**, **RAG retrieval**, **live web search**, and **admin governance** under strict **tenant isolation**, powered by **Ollama** (local) or **Groq** (cloud) LLM inference.
-
-IntegraChat is a complete **"MCP in Action"** ecosystem — ideal for enterprise demos, research, production scaffolds, and governance-focused AI deployments.
+**Track:** MCP in Action  
+**Category:** Enterprise  
+**Tag:** `mcp-in-action-track-enterprise`
 
 ---
 
-## 🎯 Purpose
+## Overview
 
-IntegraChat showcases how MCP can power **intelligent, governed, multi-tenant AI systems** with real-world requirements:
+IntegraChat is an enterprise-ready, multi-tenant AI platform that demonstrates the full capabilities of the **Model Context Protocol (MCP)** in a production-style environment. It combines autonomous tool-using agents, RAG retrieval, live web search, and admin governance under strict tenant isolation.
 
-- 🔒 **Isolation & Access Control** - Strict tenant separation
-- 🛡️ **Compliance & Red-Flag Detection** - Automated safety monitoring
-- 🤖 **Tool-Aware Autonomous Reasoning** - Dynamic tool selection
-- 🔍 **RAG + Web Search Hybrid AI** - Best of both worlds
-- 📊 **Analytics & Observability** - Full system insights
-- ⚙️ **Admin Governance Workflows** - Enterprise-ready controls
+This Hugging Face Space provides a Gradio interface to interact with the IntegraChat MCP backend, showcasing how MCP can power intelligent, governed, multi-tenant AI systems.
 
 ---
 
-## 🧩 Key Features
-
-### 1. 🤖 Autonomous MCP Agents
-
-Agents can intelligently:
-
-- ✅ Analyze user intent and context
-- ✅ Detect sensitive or unsafe content
-- ✅ **Dynamically select multiple tools in sequence** (RAG + Web + LLM, Web + LLM, RAG + LLM, etc.)
-- ✅ **Multi-step tool execution** - Execute tools sequentially and synthesize results
-- ✅ Retrieve tenant-private knowledge
-- ✅ Pull real-time data from the internet
-- ✅ Trigger admin alerts when needed
-- ✅ Respond using **Ollama** (local) or **Groq** (cloud) LLM
-
-### 2. 📚 Enterprise RAG System
-
-- **MiniLM embeddings** (384-dim) for semantic search
-- **Supabase + pgvector** for vector storage
-- **Automatic database schema initialization** on server startup
-- **Strict multi-tenant isolation** with tenant_id filtering
-- **Intelligent text chunking** (~300 words per chunk)
-- **Vector similarity search** using cosine distance
-- **Multi-format document ingestion**:
-  - **PDF files** - Server-side parsing with PyPDF2
-  - **DOCX files** - Server-side parsing with python-docx
-  - **TXT/Markdown files** - Direct text ingestion
-  - **URLs** - Automatic content fetching and extraction
-  - **Raw text** - Direct paste and ingest
-- **File upload endpoint** (`/rag/ingest-file`) for binary file processing
-- **Enhanced ingestion API** (`/rag/ingest-document`) with metadata support
-- **Document listing** (`/rag/list`) with pagination and filtering
-- **Knowledge base management UI**:
-  - Search interface with semantic search
-  - File upload with drag-and-drop support
-  - Source type selection (PDF, DOCX, TXT, URL, raw text)
-  - Document library page showing all ingested content
-  - Filter by document type (PDF, FAQ, Link, Text)
-- **Async document ingestion** via Celery workers (optional)
-
-### 3. 🌐 Live Web Search Tool
-
-- Real-time news and information
-- General web search capabilities
-- **English language results** - Forces English content via region parameters
-- Fact-checking & fresh data retrieval
-- Multiple provider support (DuckDuckGo, SerpAPI, Bing)
-
-### 4. 🔄 Multi-Tool Selection & Execution
-
-The intelligent tool selector can:
-
-- **Pattern-based detection** - Recognizes fact queries, freshness keywords, internal docs
-- **LLM-enhanced planning** - Uses LLM to determine optimal tool combinations
-- **Sequential execution** - Executes tools in order (RAG → Web → LLM)
-- **Result synthesis** - Combines all tool outputs into comprehensive responses
-
-**Supported combinations:**
-- `RAG + LLM` - Internal knowledge questions
-- `Web + LLM` - Public fact questions  
-- `RAG + Web + LLM` - Comprehensive queries needing both sources
-- `LLM only` - Simple conversational queries
-
-### 5. 🚨 Red-Flag Governance Engine
-
-Admins configure rules to:
-
-- ⛔ Block unsafe queries automatically
-- 📝 Log violations for audit trails
-- 🔔 Trigger admin alerts in real-time
-
-**Example rules**: `salary`, `delete all data`, `confidential client info`
-
-### 6. 📊 Analytics Dashboard
-
-Comprehensive insights for:
-
-- 📈 Query volume and trends
-- 🔧 Tool usage statistics
-- 🎯 RAG performance metrics
-- 🚨 Red-flag violation tracking
-- 🧠 Agent reasoning traces
-- 👥 Tenant activity monitoring
-- **Real-time analytics panel** in the frontend UI
-- **Async analytics processing** via Celery workers
-
-### 7. 📄 Document Ingestion System
-
-Complete document management workflow:
-
-- **Multiple ingestion methods**:
-  - File upload (PDF, DOCX, TXT, MD)
-  - URL fetching with HTML extraction
-  - Raw text pasting
-  - Programmatic API ingestion
-- **Automatic type detection** from filename or content
-- **Metadata support** (filename, URL, doc_id, custom fields)
-- **Server-side parsing** for binary files (PDF/DOCX)
-- **Text normalization** and sanitization
-- **Knowledge base library** page with:
-  - Document grid view
-  - Type-based filtering (PDF, FAQ, Link, Text)
-  - Search functionality
-  - Document metadata display
-  - Creation date tracking
-
-### 8. 🏢 Multi-Tenant Isolation
-
-Each tenant gets:
-
-- 🔐 Private agents
-- 📦 Private knowledge base
-- ⚙️ Private admin rules
-- 📊 Private analytics
-
-Isolation is guaranteed via **Supabase Row-Level Security (RLS)**.
+## Features
 
----
-
-## 🛠 Technology Stack
-
-### Backend
-
-| Technology | Purpose |
-|------------|---------|
-| **FastAPI** | High-performance API framework |
-| **MCP Client + Servers** | Model Context Protocol implementation |
-| **Supabase** | Auth + Storage + pgvector database |
-| **PostgreSQL + pgvector** | Vector database for embeddings |
-| **MiniLM Embeddings** | Semantic search embeddings (384-dim) |
-| **Ollama / Groq** | LLM inference engine (configurable) |
-| **DuckDuckGo Search** | Web search provider |
-| **Slack / Email** | Alerting system |
-| **Celery** | Async task queue for document ingestion and analytics |
-| **Redis / RabbitMQ** | Message broker for Celery workers |
-| **PyPDF2** | PDF text extraction |
-| **python-docx** | DOCX text extraction |
-| **python-multipart** | File upload handling |
-
-### Frontend
-
-| Technology | Purpose |
-|------------|---------|
-| **Next.js 16** | React framework with App Router |
-| **React 19** | Modern UI framework |
-| **TailwindCSS** | Utility-first styling |
-| **TypeScript** | Type-safe development |
-| **WebSocket** | Real-time streaming |
-| **Admin Dashboard** | Analytics & governance UI |
-| **Knowledge Base UI** | Document management interface |
+- 🤖 **Autonomous MCP Agents** - Intelligent tool selection and execution
+- 📚 **Enterprise RAG System** - Multi-tenant knowledge base with semantic search
+- 🌐 **Live Web Search** - Real-time information retrieval
+- 🛡️ **Red-Flag Governance** - Automated safety monitoring and compliance
+- 🏢 **Multi-Tenant Isolation** - Strict tenant separation with secure access control
+- 📊 **Analytics Dashboard** - Comprehensive system insights and observability
+- 🔄 **Multi-Tool Selection** - Dynamic tool combinations (RAG + Web + LLM)
 
 ---
 
-## 🧱 System Architecture
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    Frontend (React)                         │
-│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
-│  │ Chat UI  │  │  Admin   │  │Analytics │  │WebSocket │  │
-│  │          │  │  Panel   │  │ Dashboard│  │Streaming │  │
-│  └──────────┘  └──────────┘  └──────────┘  └──────────┘  │
-└─────────────────────────────────────────────────────────────┘
-                            ↕ HTTP/WebSocket
-┌─────────────────────────────────────────────────────────────┐
-��              MCP Client (FastAPI)                           │
-│  • Intent handling                                          │
-│  • Red-flag scanning                                        │
-│  • Multi-tool selection logic                               │
-│  • Sequential tool execution                                │
-│  • Groq Llama-3.1 integration                              │
-│  • Event logging                                            │
-└─────────────────────────────────────────────────────────────┘
-                            ↕ MCP Protocol
-┌─────────────────────────────────────────────────────────────┐
-│                    MCP Servers                              │
-│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
-│  │ RAG Server   │  │ Web Search   │  │ Admin Server │     │
-│  │ (Knowledge)  │  │ (Live/EN)    │  │ (Governance) │     │
-│  └──────────────┘  └──────────────┘  └──────────────┘     │
-└─────────────────────────────────────────────────────────────┘
-                            ↕
-┌─────────────────────────────────────────────────────────────┐
-│              Supabase Database                              │
-│  • Authentication                                           │
-│  • pgvector (embeddings)                                    │
-│  • Row-Level Security (RLS)                                 │
-│  • Storage                                                  │
-└─────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 📁 Project Structure
-
-```
-IntegraChat/
-├── backend/
-│   ├── api/
-│   │   ├── main.py
-│   │   ├── routes/
-│   │   │   ├── agent.py
-│   │   │   ├── rag.py
-│   │   │   ├── web.py
-│   │   │   ├── admin.py
-│   │   │   └── analytics.py
-│   │   ├── services/
-│   │   │   ├── agent_orchestrator.py
-│   │   │   ├── intent_classifier.py
-│   │   │   ├── redflag_detector.py
-│   │   │   ├── tool_selector.py
-│   │   │   ├── tool_scoring.py
-│   │   │   ├── semantic_encoder.py
-│   │   │   ├── prompt_builder.py
-│   │   │   ├── llm_client.py
-│   │   │   └── document_ingestion.py
-│   │   ├── mcp_clients/
-│   │   │   ├── rag_client.py
-│   │   │   ├── web_client.py
-│   │   │   └── admin_client.py
-│   │   ├── models/
-│   │   │   ├── agent.py
-│   │   │   └── redflag.py
-│   │   ├── utils/
-│   │   │   └── text_extractor.py   
-│   │   └── config.py
-│   │
-│   ├── mcp_servers/
-│   │   ├── main.py              # RAG MCP Server (FastAPI)
-│   │   ├── rag_server.py        # Alternative RAG server implementation
-│   │   ├── web_server.py        # Web search MCP server
-│   │   ├── admin_server.py      # Admin governance MCP server
-│   │   ├── database.py          # Supabase/PostgreSQL connection + pgvector
-│   │   ├── embeddings.py       # Sentence transformers embeddings
-│   │   └── models/
-│   │       ├── rag.py
-│   │       ├── web.py
-│   │       └── admin.py
-│   │
-│   ├── workers/
-│   │   ├── ingestion_worker.py    # Celery tasks for document ingestion
-│   │   ├── analytics_worker.py     # Celery tasks for analytics processing
-│   │   ├── scheduler.py           # Scheduled task definitions
-│   │   └── celeryconfig.py        # Celery app configuration
-│   │
-│   ├── tests/
-│   │   ├── test_agent.py
-│   │   ├── test_rag.py
-│   │   ├── test_admin.py
-│   │   ├── test_web.py
-│   │   └── test_end_to_end.py
-│   │
-│   └── Dockerfile
-│
-├── frontend/
-│   ├── app/
-│   │   ├── page.tsx               # Main landing page
-│   │   ├── layout.tsx              # Root layout
-│   │   ├── globals.css            # Global styles
-│   │   └── knowledge-base/
-│   │       └── page.tsx           # Knowledge base library page
-│   ├── components/
-│   │   ├── chat-panel.tsx         # Chat interface component
-│   │   ├── analytics-panel.tsx    # Analytics dashboard component
-│   │   ├── knowledge-base-panel.tsx # Knowledge base search/ingest UI
-│   │   ├── hero.tsx               # Hero section
-│   │   ├── feature-grid.tsx       # Feature showcase grid
-│   │   └── footer.tsx             # Footer component
-│   ├── public/
-│   └── package.json
-│
-├── supabase/
-│   ├── migrations/
-│   │   ├── 001_init.sql
-│   │   ├── 002_embeddings.sql
-│   │   ├── 003_redflag_rules.sql
-│   │   └── 004_analytics_tables.sql
-│   ├── seed/
-│   │   ├── default_redflags.sql
-│   │   └── demo_tenants.sql
-│   ├── policies/
-│   │   ├── rls_tenant_documents.sql
-│   │   ├── rls_tenant_embeddings.sql
-│   │   └── rls_admin_rules.sql
-│   ├── functions/
-│   │   └── vector_search.sql
-│   └── README.md
-│
-├── docs/
-│   ├── architecture-diagram.png
-│   ├── sequence-mcp-agent.png
-│   ├── api-spec.md
-│   ├── mcp-server-protocol.md
-│   └── rag-pipeline.md
-│
-├── scripts/
-│   ├── run_dev.sh
-│   ├── build_all.sh
-│   ├── reset_db.sh
-│   └── run_workers.sh
-│
-├── docker-compose.yml
-├── README.md
-└── LICENSE
-```
-
----
-
-## 🚀 Getting Started
+## How to Run the Space
 
 ### Prerequisites
 
-Before you begin, ensure you have the following installed:
-
-- ✅ **Python 3.10+**
-- ✅ **Node.js 20+ (64-bit)** (for frontend - required for Next.js)
-- ✅ **Supabase project** (with pgvector extension enabled)
-- ✅ **PostgreSQL connection string** (from Supabase)
-- ✅ **Ollama** (for local LLM) - [Installation Guide](#llm-setup)
-- ✅ **DuckDuckGo Search** (built-in, no key required)
-- ✅ **Slack/Email webhook** for alerts (optional)
-- ✅ **Redis/RabbitMQ** (for Celery workers, optional)
+1. **Backend Server Running**: The IntegraChat FastAPI backend must be running at `http://localhost:8000`
+   - See the [backend README](backend/README.md) for setup instructions
+   - The backend provides the MCP agent endpoint at `/agent/chat`
 
-### Backend Setup
+2. **Python 3.10+** installed
 
-1. **Navigate to backend directory**
-   ```bash
-   cd backend
-   ```
+### Installation
 
-2. **Install dependencies**
+1. **Install dependencies**:
    ```bash
    pip install -r requirements.txt
    ```
 
-3. **Configure environment variables**
-   
-   Create a `.env` file in the project root with the following:
-   ```env
-   # Database Configurationa
-   POSTGRESQL_URL=postgresql://user:password@host:port/database
-   SUPABASE_URL=https://your-project.supabase.co
-   SUPABASE_SERVICE_KEY=your_service_role_key
-   
-   # MCP Server URLs
-   RAG_MCP_URL=http://localhost:8001
-   WEB_MCP_URL=http://localhost:8002
-   ADMIN_MCP_URL=http://localhost:8003
-   
-   # LLM Configuration
-   OLLAMA_URL=http://localhost:11434
-   OLLAMA_MODEL=llama3.1:latest
-   LLM_BACKEND=ollama
-   # Note: Install Ollama from https://ollama.ai and run: ollama pull llama3.1:latest
-   
-   # Celery Configuration (for async workers)
-   CELERY_BROKER_URL=redis://localhost:6379/0
-   CELERY_RESULT_BACKEND=redis://localhost:6379/0
-   ```
-
-4. **Start the MCP Servers** (in separate terminals or use start.bat)
-   
-   **RAG MCP Server:**
-   ```bash
-   cd backend/mcp_servers
-   python main.py
-   # Or: uvicorn main:app --reload --port 8001
-   ```
-   - Server runs on `http://localhost:8001`
-   - Automatically initializes database schema on startup
-   - API docs: `http://localhost:8001/docs`
-   
-   **Web MCP Server:**
-   ```bash
-   cd backend/mcp_servers
-   uvicorn web_server:web_app --reload --port 8002
-   ```
-   
-   **Admin MCP Server:**
-   ```bash
-   cd backend/mcp_servers
-   uvicorn admin_server:admin_app --reload --port 8003
-   ```
-   
-   **Or use the start script:**
-   ```bash
-   ./start.bat  # Windows
-   # or
-   ./start.sh   # Linux/Mac
-   ```
-
-5. **Start Celery workers** (for async document ingestion and analytics)
-   ```bash
-   # Start Celery worker
-   celery -A backend.workers.celeryconfig worker --loglevel=info
-   
-   # In another terminal, start Celery beat (for scheduled tasks)
-   celery -A backend.workers.celeryconfig beat --loglevel=info
-   ```
-
-6. **Run the main API server**
+2. **Start the Gradio app**:
    ```bash
-   cd backend
-   uvicorn backend.api.main:app --reload --port 8000
+   python app.py
    ```
-   - Server runs on `http://localhost:8000`
-   - API docs: `http://localhost:8000/docs`
-
-### RAG API Endpoints
-
-The RAG system provides multiple endpoints:
-
-**1. Enhanced Document Ingestion (with metadata):**
-```bash
-curl -X POST http://localhost:8000/rag/ingest-document \
-  -H "Content-Type: application/json" \
-  -H "x-tenant-id: tenant123" \
-  -d '{
-    "action": "ingest_document",
-    "source_type": "raw_text",
-    "content": "Your document text here...",
-    "metadata": {
-      "filename": "policy.txt",
-      "doc_id": "policy-001"
-    }
-  }'
-```
-
-**2. File Upload (PDF, DOCX, TXT, MD):**
-```bash
-curl -X POST http://localhost:8000/rag/ingest-file \
-  -H "x-tenant-id: tenant123" \
-  -F "file=@document.pdf"
-```
-
-**3. Semantic Search:**
-```bash
-curl -X POST http://localhost:8000/rag/search \
-  -H "Content-Type: application/json" \
-  -H "x-tenant-id: tenant123" \
-  -d '{
-    "query": "What are the HR policies?"
-  }'
-```
-
-**4. List All Documents:**
-```bash
-curl -X GET "http://localhost:8000/rag/list?limit=100&offset=0" \
-  -H "x-tenant-id: tenant123"
-```
 
-**5. Legacy Simple Ingestion:**
-```bash
-curl -X POST http://localhost:8000/rag/ingest \
-  -H "Content-Type: application/json" \
-  -H "x-tenant-id: tenant123" \
-  -d '{
-    "content": "Your document text here..."
-  }'
-```
-
-### Document Ingestion System
-
-Documents can be ingested through multiple methods:
-
-**Supported formats:**
-- **PDF files** - Server-side parsing with PyPDF2
-- **DOCX files** - Server-side parsing with python-docx  
-- **TXT/Markdown files** - Direct text ingestion
-- **URLs** - Automatic content fetching and HTML extraction
-- **Raw text** - Direct paste and ingest
-
-**Ingestion methods:**
-
-1. **File Upload** (recommended for PDF/DOCX):
-   - Use the frontend UI or `/rag/ingest-file` endpoint
-   - Files are parsed server-side automatically
+3. **Access the interface**:
+   - Local: `http://localhost:7860`
+   - The app will automatically connect to the backend at `http://localhost:8000`
 
-2. **Enhanced API** (with metadata):
-   - Use `/rag/ingest-document` for structured ingestion
-   - Supports filename, URL, doc_id, and custom metadata
+### Usage
 
-3. **Simple API** (legacy):
-   - Use `/rag/ingest` for quick text ingestion
+1. Enter your **Tenant ID** in the textbox (e.g., `tenant123`)
+2. Type your message in the chat interface
+3. Click **Send** or press Enter
+4. The agent will process your message using MCP tools and respond
 
-**The ingestion process automatically:**
-- Detects document type from filename or content
-- Extracts text (PDF/DOCX parsed server-side)
-- Normalizes and sanitizes text
-- Chunks text with configurable overlap (~300 words)
-- Generates embeddings using Sentence-Transformers (MiniLM)
-- Stores chunks and embeddings in pgvector
-- Preserves metadata (filename, URL, doc_id)
-
-**Optional: Async Processing via Celery**
-- For large-scale ingestion, use Celery workers
-- Configure `CELERY_BROKER_URL` in `.env`
-- Workers process ingestion tasks asynchronously
-
-### Frontend Setup
-
-1. **Navigate to frontend directory**
-   ```bash
-   cd frontend
-   ```
-
-2. **Install dependencies**
-   ```bash
-   npm install
-   ```
-
-3. **Configure environment variables** (optional)
-   
-   Create a `.env.local` file in the frontend directory:
-   ```env
-   NEXT_PUBLIC_API_URL=http://localhost:8000
-   ```
-
-4. **Start the development server**
-   ```bash
-   npm run dev
-   ```
-   
-   The app will be available at `http://localhost:3000` with:
-   - **Main landing page** (`/`) with:
-     - Hero section and feature overview
-     - **Knowledge Base Panel** - Search and ingest documents
-     - **Chat Panel** - Interact with the AI agent
-     - **Analytics Panel** - View metrics and tool usage
-   - **Knowledge Base Library** (`/knowledge-base`) - Browse all ingested documents with filtering
+---
 
-### LLM Setup
+## API Endpoint
 
-**Ollama (Recommended for Local Development):**
+The Gradio interface communicates with the backend MCP agent via:
 
-1. **Install Ollama:**
-   - Download from https://ollama.ai
-   - Install and start the service
+**Endpoint:** `POST http://localhost:8000/agent/chat`
 
-2. **Pull a model:**
-   ```bash
-   ollama pull llama3.1:latest
-   ```
+**Headers:**
+- `Content-Type: application/json`
+- `x-tenant-id: <your-tenant-id>`
 
-3. **Verify it's running:**
-   ```bash
-   curl http://localhost:11434/api/tags
-   ```
+**Request Body:**
+```json
+{
+  "message": "Your message here"
+}
+```
 
-4. **Configure in `.env`:**
-   ```env
-   OLLAMA_URL=http://localhost:11434
-   OLLAMA_MODEL=llama3.1:latest
-   LLM_BACKEND=ollama
-   ```
+**Response:**
+```json
+{
+  "response": "Agent's response text"
+}
+```
 
-**Note:** If Ollama is not running, the system will show helpful error messages with setup instructions.
+**Note:** The backend MCP system must be running separately. This Space provides only the frontend interface. See the [backend documentation](backend/README.md) for full setup instructions.
 
-### Quick Start with Docker
+---
 
-```bash
-docker-compose up -d
-```
+## Demo Video
 
----
+🎥 **[Demo Video Placeholder]** - Coming soon!
 
-## ✨ Why IntegraChat Stands Out
-
-| Feature | Description |
-|---------|-------------|
-| 🤖 **True MCP-Native** | Autonomous agents (not static prompts) |
-| 🛡️ **Enterprise Governance** | Regex-based red-flag rules system |
-| 🔍 **Hybrid Intelligence** | Multi-tool selection (RAG + Web + LLM combinations) |
-| 🔄 **Sequential Execution** | Execute multiple tools in sequence and synthesize results |
-| 🌐 **English Web Search** | Forces English language results for better accuracy |
-| 🏢 **Production-Grade** | Multi-tenant design with strict Supabase RLS |
-| 📊 **Full Observability** | Logs, analytics, tool events, violations |
-| 📚 **Knowledge Base UI** | Complete document management with search, ingestion, and library view |
-| 📄 **Multi-Format Ingestion** | PDF, DOCX, TXT, URL, and raw text support with server-side parsing |
-| 🔍 **Document Library** | Browse, filter, and search all ingested documents |
-| ⚡ **Async Processing** | Celery workers for scalable document ingestion and analytics |
-| 🎯 **Demo-Ready** | Perfect for enterprise presentations |
+Watch how IntegraChat uses MCP to power autonomous agents with multi-tool selection, RAG retrieval, and governance.
 
 ---
 
-## 🏷 Submission Metadata
+## Social Media
 
-| Field | Value |
-|-------|-------|
-| **Track** | MCP in Action |
-| **Category** | Enterprise |
-| **Tag** | `mcp-in-action-track-enterprise` |
-| **Project Name** | **IntegraChat** |
-  
-### Short Summary
+📱 **[Social Media Post Placeholder]** - Coming soon!
 
-> IntegraChat is a multi-tenant AI platform where autonomous MCP-powered agents intelligently select and execute multiple tools in sequence (RAG + Web + LLM combinations), retrieve private knowledge using RAG, access live web information in English, and enforce admin-defined safety rules via a red-flag compliance system. It includes an analytics dashboard, advanced multi-tool selection engine, and strict tenant isolation.
+Follow us for updates and demos of IntegraChat in action!
 
 ---
 
-## 📄 License
+## Team Member(s)
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+- **Your Name Here** - Developer & MCP Enthusiast
 
 ---
 
-## 📬 Contributing
+## License
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 ---
 
-## 🙏 Acknowledgments
+## Acknowledgments
 
 - Built with [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
-- Powered by [Ollama](https://ollama.ai/) or [Groq](https://groq.com/) for LLM inference
-- Database powered by [Supabase](https://supabase.com/)
+- Powered by [Gradio](https://gradio.app/) for the interface
+- Backend built with [FastAPI](https://fastapi.tiangolo.com/)
 
 ---
 
 <div align="center">
 
-**Made with ❤️ for the MCP community**
+**Made with ❤️ for the MCP Hackathon**
 
-[⬆ Back to Top](#-integrachat)
+[⬆ Back to Top](#integrachat--mcp-autonomous-agent)
 
 </div>

app.py

@@ -0,0 +1,627 @@
+import gradio as gr
+import requests
+import json
+import os
+from pathlib import Path
+
+BACKEND_BASE_URL = os.getenv("BACKEND_BASE_URL", "http://localhost:8000")
+
+
+def chat_with_agent(message, tenant_id, history):
+    """
+    Send a message to the backend MCP agent and return the response.
+    
+    Args:
+        message: User's message text
+        tenant_id: Tenant ID for multi-tenant isolation
+        history: Chat history (Gradio messages format)
+    
+    Returns:
+        Updated chat history with agent response
+    """
+    if not message or not message.strip():
+        return history
+    
+    if not tenant_id or not tenant_id.strip():
+        error_msg = "Please enter a Tenant ID before sending a message."
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": error_msg})
+        return history
+    
+    # Backend API endpoint
+    backend_url = f"{BACKEND_BASE_URL}/agent/message"
+    
+    # Prepare request payload (matching backend API format)
+    payload = {
+        "tenant_id": tenant_id.strip(),
+        "message": message,
+        "user_id": None,
+        "conversation_history": [],
+        "temperature": 0.0
+    }
+    
+    # Prepare headers
+    headers = {
+        "Content-Type": "application/json"
+    }
+    
+    try:
+        # Send POST request to backend
+        # Increased timeout to 120 seconds for complex agent operations
+        # (RAG search, web search, LLM calls can take time)
+        response = requests.post(
+            backend_url,
+            json=payload,
+            headers=headers,
+            timeout=120
+        )
+        
+        # Check if request was successful
+        if response.status_code == 200:
+            response_data = response.json()
+            # Backend returns response in "text" field
+            agent_response = response_data.get("text", "No response received from agent.")
+            history.append({"role": "user", "content": message})
+            history.append({"role": "assistant", "content": agent_response})
+        else:
+            error_msg = f"Error {response.status_code}: {response.text}"
+            history.append({"role": "user", "content": message})
+            history.append({"role": "assistant", "content": error_msg})
+    
+    except requests.exceptions.ConnectionError:
+        error_msg = "❌ Connection Error: Could not connect to backend. Please ensure the FastAPI server is running at http://localhost:8000"
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": error_msg})
+    
+    except requests.exceptions.Timeout:
+        error_msg = "⏱️ Request Timeout: The backend took longer than 2 minutes to respond. This may happen if:\n- The LLM is processing a complex query\n- Multiple tools (RAG, Web Search) are being used\n- The backend is under heavy load\n\nPlease try again with a simpler query, or check if the backend services (Ollama, MCP servers) are running properly."
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": error_msg})
+    
+    except requests.exceptions.RequestException as e:
+        error_msg = f"❌ Request Error: {str(e)}"
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": error_msg})
+    
+    except Exception as e:
+        error_msg = f"❌ Unexpected Error: {str(e)}"
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": error_msg})
+    
+    return history
+
+
+def ingest_document(
+    tenant_id: str,
+    source_type: str,
+    content: str,
+    document_url: str,
+    filename: str,
+    doc_id: str,
+    metadata_json: str
+):
+    if not tenant_id or not tenant_id.strip():
+        return "❗ Tenant ID is required to ingest documents."
+
+    tenant_id = tenant_id.strip()
+
+    payload_content = content or ""
+    if source_type == "url" and document_url:
+        payload_content = document_url.strip()
+
+    metadata = {}
+    if filename:
+        metadata["filename"] = filename.strip()
+    if document_url:
+        metadata["url"] = document_url.strip()
+    if doc_id:
+        metadata["doc_id"] = doc_id.strip()
+
+    if metadata_json:
+        try:
+            extra_metadata = json.loads(metadata_json)
+            if isinstance(extra_metadata, dict):
+                metadata.update(extra_metadata)
+            else:
+                return "❗ Metadata JSON must represent an object (key/value pairs)."
+        except json.JSONDecodeError as exc:
+            return f"❗ Invalid metadata JSON: {exc}"
+
+    payload = {
+        "action": "ingest_document",
+        "tenant_id": tenant_id,
+        "source_type": source_type,
+        "content": payload_content,
+        "metadata": metadata
+    }
+
+    try:
+        response = requests.post(
+            f"{BACKEND_BASE_URL}/rag/ingest-document",
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=60
+        )
+        if response.status_code == 200:
+            data = response.json()
+            return f"✅ Document ingested successfully.\n\n{data.get('message', '')}"
+        return f"❌ Ingestion failed ({response.status_code}): {response.text}"
+    except requests.exceptions.ConnectionError:
+        return "❌ Could not reach the backend. Make sure the FastAPI server is running."
+    except requests.exceptions.Timeout:
+        return "⏱️ The ingestion request timed out. Please try again."
+    except Exception as exc:
+        return f"❌ Unexpected error during ingestion: {exc}"
+
+
+def ingest_file(tenant_id: str, file_obj):
+    if not tenant_id or not tenant_id.strip():
+        return "❗ Tenant ID is required to ingest files."
+    if file_obj is None:
+        return "❗ Please select a file to upload."
+
+    tenant_id = tenant_id.strip()
+
+    try:
+        file_path = Path(file_obj.name)
+        with open(file_path, "rb") as f:
+            file_bytes = f.read()
+
+        files = {
+            "file": (file_path.name, file_bytes, "application/octet-stream")
+        }
+        response = requests.post(
+            f"{BACKEND_BASE_URL}/rag/ingest-file",
+            files=files,
+            headers={"x-tenant-id": tenant_id},
+            timeout=120
+        )
+        if response.status_code == 200:
+            data = response.json()
+            return f"✅ File ingested successfully.\n\n{data.get('message', '')}"
+        return f"❌ File ingestion failed ({response.status_code}): {response.text}"
+    except FileNotFoundError:
+        return "❌ Could not read the uploaded file."
+    except requests.exceptions.ConnectionError:
+        return "❌ Could not reach the backend. Make sure the FastAPI server is running."
+    except requests.exceptions.Timeout:
+        return "⏱️ File ingestion timed out. Please try again."
+    except Exception as exc:
+        return f"❌ Unexpected error during file ingestion: {exc}"
+
+
+def _format_rules_table(rules: list[str]) -> list[list]:
+    return [[idx + 1, rule] for idx, rule in enumerate(rules)]
+
+
+def fetch_admin_rules(tenant_id: str) -> tuple[str, list[list]]:
+    if not tenant_id or not tenant_id.strip():
+        return "❗ Tenant ID is required.", []
+
+    tenant_id = tenant_id.strip()
+    try:
+        response = requests.get(
+            f"{BACKEND_BASE_URL}/admin/rules",
+            headers={"x-tenant-id": tenant_id},
+            timeout=30
+        )
+        if response.status_code == 200:
+            rules = response.json().get("rules", [])
+            if not rules:
+                return "✅ No admin rules have been configured yet.", []
+            summary = f"### Current Rules ({len(rules)})"
+            return summary, _format_rules_table(rules)
+        return f"❌ Error {response.status_code}: {response.text}", []
+    except requests.exceptions.ConnectionError:
+        return "❌ Could not reach backend. Ensure the FastAPI server is running.", []
+    except requests.exceptions.Timeout:
+        return "⏱️ Request timed out. Please try again.", []
+    except Exception as exc:
+        return f"❌ Unexpected error: {exc}", []
+
+
+def add_admin_rules(tenant_id: str, rules_text: str) -> str:
+    if not tenant_id or not tenant_id.strip():
+        return "❗ Tenant ID is required."
+    if not rules_text or not rules_text.strip():
+        return "❗ Provide at least one rule to upload."
+
+    tenant_id = tenant_id.strip()
+    rules = [rule.strip() for rule in rules_text.splitlines() if rule.strip()]
+    if not rules:
+        return "❗ No valid rules detected."
+
+    added = []
+    errors = []
+    for rule in rules:
+        try:
+            resp = requests.post(
+                f"{BACKEND_BASE_URL}/admin/rules",
+                params={"rule": rule},
+                headers={"x-tenant-id": tenant_id},
+                timeout=15
+            )
+            if resp.status_code == 200:
+                added.append(rule)
+            else:
+                errors.append(f"{rule} -> {resp.status_code}: {resp.text}")
+        except Exception as exc:
+            errors.append(f"{rule} -> {exc}")
+
+    summary = []
+    if added:
+        summary.append(f"✅ Added {len(added)} rule(s):\n" + "\n".join([f"- {r}" for r in added]))
+    if errors:
+        summary.append("⚠️ Errors:\n" + "\n".join(errors))
+
+    return "\n\n".join(summary) if summary else "No rules were added."
+
+
+def delete_admin_rule(tenant_id: str, rule: str) -> str:
+    if not tenant_id or not tenant_id.strip():
+        return "❗ Tenant ID is required."
+    if not rule or not rule.strip():
+        return "❗ Provide the exact rule text to delete."
+
+    tenant_id = tenant_id.strip()
+    rule = rule.strip()
+
+    try:
+        resp = requests.delete(
+            f"{BACKEND_BASE_URL}/admin/rules/{rule}",
+            headers={"x-tenant-id": tenant_id},
+            timeout=15
+        )
+        if resp.status_code == 200:
+            return f"🗑️ Deleted rule: {rule}"
+        return f"❌ Error {resp.status_code}: {resp.text}"
+    except requests.exceptions.ConnectionError:
+        return "❌ Could not reach backend. Ensure the FastAPI server is running."
+    except requests.exceptions.Timeout:
+        return "⏱️ Delete request timed out. Please try again."
+    except Exception as exc:
+        return f"❌ Unexpected error: {exc}"
+
+
+def add_rules_and_refresh(tenant_id: str, rules_text: str):
+    status = add_admin_rules(tenant_id, rules_text)
+    summary, rows = fetch_admin_rules(tenant_id)
+    return status, summary, rows
+
+
+def delete_rule_and_refresh(tenant_id: str, rule: str):
+    status = delete_admin_rule(tenant_id, rule)
+    summary, rows = fetch_admin_rules(tenant_id)
+    return status, summary, rows
+
+
+def fetch_admin_analytics(tenant_id: str) -> str:
+    if not tenant_id or not tenant_id.strip():
+        return "❗ Tenant ID is required to view analytics."
+
+    tenant_id = tenant_id.strip()
+    headers = {"x-tenant-id": tenant_id}
+    sections = []
+
+    endpoints = [
+        ("Overview", "/analytics/overview"),
+        ("Tool Usage", "/analytics/tool-usage"),
+        ("Red Flags", "/analytics/redflags"),
+        ("Activity", "/analytics/activity"),
+    ]
+
+    for label, path in endpoints:
+        try:
+            resp = requests.get(
+                f"{BACKEND_BASE_URL}{path}",
+                headers=headers,
+                timeout=30
+            )
+            if resp.status_code == 200:
+                data = resp.json()
+                pretty = json.dumps(data, indent=2)
+                sections.append(f"### {label}\n```json\n{pretty}\n```")
+            else:
+                sections.append(f"### {label}\n❌ Error {resp.status_code}: {resp.text}")
+        except requests.exceptions.ConnectionError:
+            sections.append(f"### {label}\n❌ Could not reach backend. Is the FastAPI server running?")
+        except requests.exceptions.Timeout:
+            sections.append(f"### {label}\n⏱️ Request timed out. Please try again.")
+        except Exception as exc:
+            sections.append(f"### {label}\n❌ Unexpected error: {exc}")
+
+    return "\n\n".join(sections) if sections else "No analytics available."
+
+
+# Create Gradio interface
+with gr.Blocks(title="IntegraChat — MCP Autonomous Agent", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🤖 IntegraChat — MCP Autonomous Agent
+        
+        **Enterprise-grade AI with autonomous agents, secure multi-tenant RAG, real-time web search, and governance.**
+        
+        Enter your Tenant ID to chat with the MCP-powered agent or ingest documents into the enterprise knowledge base.
+        """
+    )
+    
+    tenant_id_input = gr.Textbox(
+        label="Tenant ID",
+        placeholder="Enter your tenant ID (e.g., tenant123)",
+        value="",
+        interactive=True
+    )
+    
+    with gr.Tabs():
+        with gr.Tab("Chat"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    chatbot = gr.Chatbot(
+                        label="Chat with Agent",
+                        height=500,
+                        show_label=True,
+                        container=True,
+                        type="messages"
+                    )
+                    
+                    with gr.Row():
+                        message_input = gr.Textbox(
+                            label="Message",
+                            placeholder="Type your message here...",
+                            scale=4,
+                            show_label=False,
+                            container=False
+                        )
+                        send_button = gr.Button("Send", variant="primary", scale=1)
+                
+                with gr.Column(scale=1):
+                    gr.Markdown(
+                        """
+                        ### 📝 Chat Instructions
+                        1. Enter your **Tenant ID** above
+                        2. Ask a question or give a task to the agent
+                        3. The MCP agent will automatically select tools (RAG, Web, etc.)
+                        
+                        ### ⚙️ Backend Configuration
+                        The agent connects to the FastAPI backend at `http://localhost:8000/agent/message`
+                        """
+                    )
+            
+            # Event handlers for chat tab
+            def send_message(message, tenant_id, history):
+                updated_history = chat_with_agent(message, tenant_id, history)
+                return updated_history, ""  # Clear message input after sending
+            
+            send_button.click(
+                fn=send_message,
+                inputs=[message_input, tenant_id_input, chatbot],
+                outputs=[chatbot, message_input]
+            )
+            
+            message_input.submit(
+                fn=send_message,
+                inputs=[message_input, tenant_id_input, chatbot],
+                outputs=[chatbot, message_input]
+            )
+        
+        with gr.Tab("Document Ingestion"):
+            gr.Markdown(
+                """
+                ### 📚 Knowledge Base Ingestion
+                Ingest documents so the MCP agent can reference tenant-private knowledge.
+                
+                - **Raw text / URLs:** Use the fields below.
+                - **Files (PDF, DOCX, TXT, MD):** Use the file upload section.
+                """
+            )
+            
+            ingestion_mode = gr.Radio(
+                ["Raw Text", "URL", "File Upload"],
+                value="Raw Text",
+                label="Select Ingestion Mode"
+            )
+            
+            with gr.Row():
+                doc_filename = gr.Textbox(label="Filename (optional)")
+                doc_id = gr.Textbox(label="Document ID (optional)")
+            
+            document_url = gr.Textbox(
+                label="Document URL (for URL ingestion)",
+                placeholder="https://example.com/policy",
+                visible=False
+            )
+            
+            doc_content = gr.Textbox(
+                label="Content / Notes",
+                placeholder="Paste the document text here...",
+                lines=8,
+                visible=True
+            )
+            
+            metadata_json = gr.Textbox(
+                label="Additional Metadata (JSON)",
+                placeholder='{"department": "HR", "tags": ["policy", "benefits"]}'
+            )
+            
+            ingest_doc_button = gr.Button("Ingest Text / URL Document", variant="primary")
+            
+            document_status = gr.Markdown("")
+            
+            def handle_ingest_document(
+                tenant_id,
+                mode,
+                content,
+                doc_url,
+                filename,
+                doc_id_value,
+                metadata
+            ):
+                source_type = "raw_text" if mode == "Raw Text" else "url"
+                return ingest_document(
+                    tenant_id=tenant_id,
+                    source_type=source_type,
+                    content=content,
+                    document_url=doc_url,
+                    filename=filename,
+                    doc_id=doc_id_value,
+                    metadata_json=metadata
+                )
+            
+            ingest_doc_button.click(
+                fn=handle_ingest_document,
+                inputs=[
+                    tenant_id_input,
+                    ingestion_mode,
+                    doc_content,
+                    document_url,
+                    doc_filename,
+                    doc_id,
+                    metadata_json
+                ],
+                outputs=document_status
+            )
+            
+            file_section = gr.Markdown("#### 📁 File Upload (PDF, DOCX, TXT, Markdown)", visible=False)
+            file_upload = gr.File(
+                label="Upload File",
+                file_types=[".pdf", ".docx", ".txt", ".md", ".markdown"],
+                visible=False
+            )
+            ingest_file_button = gr.Button("Upload & Ingest File", visible=False)
+            
+            def handle_file_ingestion(tenant_id, file_obj):
+                return ingest_file(tenant_id, file_obj)
+            
+            ingest_file_button.click(
+                fn=handle_file_ingestion,
+                inputs=[tenant_id_input, file_upload],
+                outputs=document_status
+            )
+
+            def toggle_source_fields(mode):
+                show_text = mode == "Raw Text"
+                show_url = mode == "URL"
+                show_file = mode == "File Upload"
+                return (
+                    gr.update(visible=show_text),
+                    gr.update(visible=show_url),
+                    gr.update(visible=not show_file),
+                    gr.update(visible=not show_file),
+                    gr.update(visible=not show_file),
+                    gr.update(visible=show_file),
+                    gr.update(visible=show_file),
+                    gr.update(visible=show_file),
+                )
+
+            ingestion_mode.change(
+                fn=toggle_source_fields,
+                inputs=[ingestion_mode],
+                outputs=[
+                    doc_content,
+                    document_url,
+                    doc_filename,
+                    doc_id,
+                    ingest_doc_button,
+                    file_section,
+                    file_upload,
+                    ingest_file_button,
+                ]
+            )
+        
+        with gr.Tab("Admin Analytics"):
+            gr.Markdown(
+                """
+                ### 📊 Admin Analytics
+                Review tenant-level analytics generated by the IntegraChat backend.
+                
+                - **Overview:** Total queries, active users, red-flag count.
+                - **Tool Usage:** How often RAG, Web, and Admin tools are invoked.
+                - **Red Flags:** Recent governance events for this tenant.
+                - **Activity:** Summary of tenant activity metrics.
+                """
+            )
+            
+            analytics_refresh = gr.Button("Fetch Analytics Snapshot", variant="primary")
+            analytics_output = gr.Markdown("👉 Click the button to load analytics for the current tenant.")
+            
+            analytics_refresh.click(
+                fn=fetch_admin_analytics,
+                inputs=[tenant_id_input],
+                outputs=analytics_output
+            )
+        
+        with gr.Tab("Admin Rules & Compliance"):
+            gr.Markdown(
+                """
+                ### 🛡️ Admin Rules & Regulations
+                Upload or manage tenant-specific governance rules (red-flag patterns, compliance policies, etc.).
+                
+                - Enter one rule per line to upload multiple at once.
+                - Use the delete box to remove an exact rule.
+                - Refresh anytime to view the latest rule set.
+                """
+            )
+            
+            rules_summary = gr.Markdown("👉 Click **Refresh Rules** to see existing entries.")
+            rules_table = gr.Dataframe(
+                headers=["#", "Rule"],
+                datatype=["number", "str"],
+                interactive=False,
+                value=[]
+            )
+            rules_status = gr.Markdown("")
+            
+            with gr.Row():
+                refresh_rules_button = gr.Button("Refresh Rules", variant="secondary")
+                gr.Markdown("")
+            
+            rules_input = gr.Textbox(
+                label="Rules / Regulations",
+                placeholder="Enter one rule per line...",
+                lines=6
+            )
+            upload_rules_button = gr.Button("Upload / Append Rules", variant="primary")
+            
+            delete_rule_input = gr.Textbox(
+                label="Delete Rule",
+                placeholder="Enter the exact rule text to remove..."
+            )
+            delete_rule_button = gr.Button("Delete Rule", variant="stop")
+            
+            refresh_rules_button.click(
+                fn=fetch_admin_rules,
+                inputs=[tenant_id_input],
+                outputs=[rules_summary, rules_table]
+            )
+            
+            upload_rules_button.click(
+                fn=add_rules_and_refresh,
+                inputs=[tenant_id_input, rules_input],
+                outputs=[rules_status, rules_summary, rules_table]
+            )
+            
+            delete_rule_button.click(
+                fn=delete_rule_and_refresh,
+                inputs=[tenant_id_input, delete_rule_input],
+                outputs=[rules_status, rules_summary, rules_table]
+            )
+    
+    gr.Markdown(
+        """
+        ---
+        **Built with [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) for the MCP Hackathon**
+        """
+    )
+
+if __name__ == "__main__":
+    import os
+    # For Hugging Face Spaces, bind to 0.0.0.0; for local dev, use 127.0.0.1
+    # HF Spaces sets SPACE_ID environment variable
+    server_name = "0.0.0.0" if os.getenv("SPACE_ID") else "127.0.0.1"
+    
+    demo.launch(
+        server_name=server_name,
+        server_port=7860,
+        share=False
+    )
+

backend/README.md

@@ -0,0 +1,28 @@
+# Backend Documentation
+
+This directory contains the IntegraChat backend implementation.
+
+## Structure
+
+- `api/` - FastAPI application with routes and services
+- `mcp_servers/` - MCP server implementations (RAG, Web Search, Admin)
+- `workers/` - Celery workers for async task processing
+
+## Setup
+
+For full backend setup instructions, refer to the main project README.md in the root directory.
+
+## API Endpoints
+
+The main API endpoint used by the Gradio interface:
+
+- `POST /agent/chat` - Chat with the MCP agent
+  - Headers: `x-tenant-id: <tenant-id>`
+  - Body: `{ "message": "<text>" }`
+  - Response: `{ "response": "<agent-response>" }`
+
+## Note
+
+This Hugging Face Space submission includes only placeholder files for the backend structure.
+The full backend codebase exists in the main IntegraChat repository.
+

backend/api/placeholder.txt

@@ -0,0 +1,4 @@
+This directory contains the FastAPI backend API code.
+For the Hugging Face Space submission, only placeholder files are included.
+The full backend implementation exists separately.
+

backend/api/routes/admin.py

@@ -1,17 +1,27 @@
 from fastapi import APIRouter, Header, HTTPException
-from typing import List
+from pydantic import BaseModel
+from typing import List, Optional
+
+from backend.api.storage.rules_store import RulesStore
 
 router = APIRouter()
 
-# Temporary in-memory store (replace with Supabase later)
-TENANT_RULES = {}
+rules_store = RulesStore()
+
+
+class RulePayload(BaseModel):
+    rule: str
+
+
+class BulkRulePayload(BaseModel):
+    rules: List[str]
 
 
 def get_rules_for_tenant(tenant_id: str) -> List[str]:
-    return TENANT_RULES.get(tenant_id, [])
+    return rules_store.get_rules(tenant_id)
 
 
-@router.get("/admin/rules")
+@router.get("/rules")
 async def get_redflag_rules(
     x_tenant_id: str = Header(None)
 ):
@@ -28,33 +38,64 @@ async def get_redflag_rules(
     }
 
 
-@router.post("/admin/rules")
+@router.post("/rules")
 async def add_redflag_rule(
-    rule: str,
+    payload: Optional[RulePayload] = None,
+    rule: Optional[str] = None,
     x_tenant_id: str = Header(None)
 ):
     """
     Adds a new red-flag rule to this tenant.
+    Accepts either JSON body {"rule": "..."} or query parameter ?rule=...
     """
 
     if not x_tenant_id:
         raise HTTPException(status_code=400, detail="Missing tenant ID")
 
+    rule_value = payload.rule if payload else rule
+    if not rule_value:
+        raise HTTPException(status_code=400, detail="Missing rule text")
+
+    rule_value = rule_value.strip()
+    if not rule_value:
+        raise HTTPException(status_code=400, detail="Rule cannot be empty")
+
+    rules_store.add_rule(x_tenant_id, rule_value)
     rules = get_rules_for_tenant(x_tenant_id)
 
-    if rule not in rules:
-        rules.append(rule)
+    return {
+        "tenant_id": x_tenant_id,
+        "added_rule": rule_value,
+        "rules": rules
+    }
 
-    TENANT_RULES[x_tenant_id] = rules
+
+@router.post("/rules/bulk")
+async def add_redflag_rules_bulk(
+    payload: BulkRulePayload,
+    x_tenant_id: str = Header(None)
+):
+    """
+    Adds multiple rules in one call.
+    """
+    if not x_tenant_id:
+        raise HTTPException(status_code=400, detail="Missing tenant ID")
+
+    if not payload.rules:
+        raise HTTPException(status_code=400, detail="No rules provided")
+
+    cleaned = [rule.strip() for rule in payload.rules if rule.strip()]
+    added = rules_store.add_rules_bulk(x_tenant_id, cleaned)
+    rules = get_rules_for_tenant(x_tenant_id)
 
     return {
         "tenant_id": x_tenant_id,
-        "added_rule": rule,
+        "added_rules": added,
         "rules": rules
     }
 
 
-@router.delete("/admin/rules/{rule}")
+@router.delete("/rules/{rule}")
 async def delete_redflag_rule(
     rule: str,
     x_tenant_id: str = Header(None)
@@ -66,13 +107,11 @@ async def delete_redflag_rule(
     if not x_tenant_id:
         raise HTTPException(status_code=400, detail="Missing tenant ID")
 
-    rules = get_rules_for_tenant(x_tenant_id)
-
-    if rule not in rules:
+    deleted = rules_store.delete_rule(x_tenant_id, rule)
+    if not deleted:
         raise HTTPException(status_code=404, detail="Rule not found")
 
-    rules.remove(rule)
-    TENANT_RULES[x_tenant_id] = rules
+    rules = get_rules_for_tenant(x_tenant_id)
 
     return {
         "tenant_id": x_tenant_id,

backend/api/services/prompt_builder.py

@@ -1,66 +0,0 @@
-class PromptBuilder:
-    """
-    Builds the final prompt sent to the LLM.
-    """
-
-    def __init__(self):
-        pass
-
-    def build(
-        self,
-        user_message: str,
-        tool: str,
-        rag_results: list[str] = None,
-        web_results: list[dict] = None,
-        redflag_info: dict = None,
-        tenant_id: str = None
-    ) -> str:
-
-        # 1. Base system prompt
-        system_prompt = (
-            "You are VariaAI, an enterprise-grade MCP agent. "
-            "Always follow tenant isolation: only use data belonging to the tenant. "
-            "Be concise, correct, and safe.\n\n"
-        )
-
-        # 2. Insert admin red-flag context (if triggered)
-        if tool == "admin":
-            system_prompt += (
-                "⚠️ SECURITY NOTICE:\n"
-                "The user request appears sensitive or unsafe.\n"
-                "Provide a safe response, avoid executing harmful instructions.\n\n"
-            )
-
-        # 3. Insert RAG context
-        if tool == "rag" and rag_results:
-            system_prompt += "📄 Relevant Knowledge Base Documents:\n"
-            for i, chunk in enumerate(rag_results, start=1):
-                system_prompt += f"({i}) {chunk}\n"
-            system_prompt += "\n"
-
-        # 4. Insert Web Search results
-        if tool == "web" and web_results:
-            system_prompt += "🌐 Web Search Results:\n"
-            for i, item in enumerate(web_results, start=1):
-                title = item.get("title")
-                snippet = item.get("snippet")
-                system_prompt += f"({i}) {title}\n  {snippet}\n"
-            system_prompt += "\n"
-
-        # 5. Add tenant metadata (optional)
-        if tenant_id:
-            system_prompt += f"Tenant ID: {tenant_id}\n\n"
-
-        # 6. Insert user query
-        system_prompt += "🗣️ User Message:\n"
-        system_prompt += user_message + "\n\n"
-
-        # 7. Instructions for the model
-        system_prompt += (
-            "🎯 Your Task:\n"
-            "- Answer using the context above.\n"
-            "- If context is missing, say so.\n"
-            "- Do not hallucinate facts.\n"
-        )
-
-        return system_prompt

backend/api/storage/rules_store.py

@@ -0,0 +1,76 @@
+import sqlite3
+from pathlib import Path
+from typing import List
+
+
+class RulesStore:
+    """
+    Lightweight SQLite-backed store for admin rules.
+    Ensures data persists across restarts without requiring external DB setup.
+    """
+
+    def __init__(self):
+        root_dir = Path(__file__).resolve().parents[3]  # points to project root
+        data_dir = root_dir / "data"
+        data_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = data_dir / "admin_rules.db"
+        self._init_db()
+
+    def _init_db(self):
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS admin_rules (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    tenant_id TEXT NOT NULL,
+                    rule TEXT NOT NULL,
+                    UNIQUE(tenant_id, rule)
+                )
+                """
+            )
+            conn.commit()
+
+    def get_rules(self, tenant_id: str) -> List[str]:
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT rule FROM admin_rules WHERE tenant_id = ? ORDER BY id ASC",
+                (tenant_id,),
+            )
+            return [row[0] for row in cursor.fetchall()]
+
+    def add_rule(self, tenant_id: str, rule: str) -> bool:
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute(
+                    "INSERT OR IGNORE INTO admin_rules (tenant_id, rule) VALUES (?, ?)",
+                    (tenant_id, rule),
+                )
+                conn.commit()
+            return True
+        except sqlite3.Error:
+            return False
+
+    def add_rules_bulk(self, tenant_id: str, rules: List[str]) -> List[str]:
+        added = []
+        with sqlite3.connect(self.db_path) as conn:
+            for rule in rules:
+                try:
+                    conn.execute(
+                        "INSERT OR IGNORE INTO admin_rules (tenant_id, rule) VALUES (?, ?)",
+                        (tenant_id, rule),
+                    )
+                    added.append(rule)
+                except sqlite3.Error:
+                    continue
+            conn.commit()
+        return added
+
+    def delete_rule(self, tenant_id: str, rule: str) -> bool:
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "DELETE FROM admin_rules WHERE tenant_id = ? AND rule = ?",
+                (tenant_id, rule),
+            )
+            conn.commit()
+            return cursor.rowcount > 0
+

backend/mcp_servers/placeholder.txt

@@ -0,0 +1,4 @@
+This directory contains the MCP server implementations.
+For the Hugging Face Space submission, only placeholder files are included.
+The full MCP server code exists separately.
+

backend/workers/placeholder.txt

@@ -0,0 +1,4 @@
+This directory contains Celery worker tasks for async processing.
+For the Hugging Face Space submission, only placeholder files are included.
+The full worker implementation exists separately.
+

requirements.txt

@@ -11,4 +11,6 @@ pytest-asyncio
 duckduckgo-search
 PyPDF2
 python-docx
-python-multipart
+python-multipart
+gradio>=4.0.0
+requests>=2.31.0