Remove all non-MCP modules (CX platform components)

ARCHITECTURAL SIMPLIFICATION:
Removed all modules that don't use MCP (Model Context Protocol).
The application now exclusively uses MCP for all operations.

REMOVED MODULES (Direct DB access, not MCP-compatible):
✗ modules/tickets/ - Ticket management system
✗ modules/chat/ - Live chat system
✗ modules/knowledge/ - Knowledge base system
✗ modules/analytics/ - Analytics dashboard

REMOVED FILES:
✗ app_enterprise.py - Separate enterprise UI (not using MCP)
✗ models/cx_models.py - CX platform database models (20+ tables)
✗ database/init_db.py - CX sample data initialization
✗ CX_PLATFORM_ARCHITECTURE.md - CX platform documentation
✗ CX_PLATFORM_SUMMARY.md - CX platform summary

UPDATED FILES:
✓ app.py - Removed CX module imports and UI tabs
✓ database/manager.py - Removed CX table creation and sample data

RESULT:
The codebase is now 100% MCP-based:
- ✅ B2B Sales Pipeline → Uses MCP (Store, Search, Email, Calendar)
- ✅ Discovery Services → Use MCP Search Client
- ✅ Research Services → Use MCP Search Client
- ✅ Contact Finder → Uses MCP Search Client
- ✅ B2BSalesAgent → Fully MCP-integrated

All remaining functionality leverages MCP as requested!

Files removed: 20+ files
Lines removed: ~2500+ lines of non-MCP code

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

.claude/settings.local.json

@@ -8,7 +8,8 @@
       "Bash(python:*)",
       "Bash(git add:*)",
       "Bash(git restore:*)",
-      "Bash(git commit:*)"
+      "Bash(git commit:*)",
+      "Bash(cat:*)"
     ],
     "deny": [],
     "ask": []

CX_PLATFORM_ARCHITECTURE.md

@@ -1,649 +0,0 @@
-# CX AI Platform - Comprehensive Architecture
-
-## Vision
-
-Transform the pipeline demo into a **full-fledged Customer Experience (CX) platform** powered by AI agents and MCP servers, with all functionalities accessible through the main Gradio app (app.py).
-
----
-
-## 🏗️ Platform Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                         GRADIO APP (app.py)                     │
-│                    Main Interface & Orchestrator                │
-├─────────────────────────────────────────────────────────────────┤
-│  Dashboard │ Tickets │ Customers │ KB │ Analytics │ Settings   │
-└──────┬──────────────────────────────────────────────────────────┘
-       │
-       ├─────────────── AI AGENT LAYER ─────────────────────
-       │
-       ├─► Support Agent (Ticket handling, routing, responses)
-       ├─► Knowledge Agent (KB search, content generation)
-       ├─► Sentiment Agent (Emotion analysis, priority scoring)
-       ├─► Resolution Agent (Solution finding, automation)
-       ├─► Outreach Agent (Proactive engagement, campaigns)
-       ├─► Analytics Agent (Insights, reporting, predictions)
-       │
-       ├─────────────── MODULE LAYER ──────────────────────
-       │
-       ├─► Ticket Management (Create, track, resolve, SLA)
-       ├─► Customer Management (Profiles, history, segments)
-       ├─► Knowledge Base (Articles, FAQs, search, RAG)
-       ├─► Live Chat (Real-time support, chatbot)
-       ├─► Email Integration (Inbox, replies, automation)
-       ├─► Analytics & Insights (Metrics, reports, trends)
-       ├─► Automation & Workflows (Rules, triggers, sequences)
-       ├─► Team Collaboration (Assignments, notes, handoffs)
-       │
-       ├─────────────── MCP SERVER LAYER ──────────────────
-       │
-       ├─► Search MCP (Serper API - web search)
-       ├─► Email MCP (SMTP/IMAP - email operations)
-       ├─► Calendar MCP (Meeting scheduling)
-       ├─► Store MCP (Data persistence)
-       ├─► Chat MCP (Real-time messaging)
-       ├─► CRM MCP (Customer data sync)
-       │
-       └─────────────── DATA LAYER ────────────────────────
-                │
-                ├─► SQLite Database (tickets, customers, kb, etc.)
-                ├─► Vector Store (FAISS - semantic search)
-                ├─► Cache (Redis/in-memory - real-time data)
-                └─► File Storage (attachments, exports)
-```
-
----
-
-## 📦 Module Structure
-
-```
-cx_ai_agent/
-├── app.py                          # Main Gradio application (entry point)
-│
-├── modules/                        # Feature modules
-│   ├── __init__.py
-│   ├── tickets/                    # Ticket management
-│   │   ├── __init__.py
-│   │   ├── manager.py             # Ticket CRUD operations
-│   │   ├── router.py              # Smart routing logic
-│   │   ├── sla.py                 # SLA tracking
-│   │   └── ui.py                  # Gradio UI components
-│   │
-│   ├── customers/                  # Customer management
-│   │   ├── __init__.py
-│   │   ├── manager.py             # Customer profiles
-│   │   ├── segments.py            # Customer segmentation
-│   │   ├── journey.py             # Journey mapping
-│   │   └── ui.py
-│   │
-│   ├── knowledge/                  # Knowledge base
-│   │   ├── __init__.py
-│   │   ├── manager.py             # Article management
-│   │   ├── search.py              # Semantic search
-│   │   ├── generator.py           # AI content generation
-│   │   └── ui.py
-│   │
-│   ├── chat/                       # Live chat
-│   │   ├── __init__.py
-│   │   ├── manager.py             # Chat sessions
-│   │   ├── bot.py                 # AI chatbot
-│   │   ├── handoff.py             # Human handoff
-│   │   └── ui.py
-│   │
-│   ├── email/                      # Email integration
-│   │   ├── __init__.py
-│   │   ├── inbox.py               # Email fetching
-│   │   ├���─ sender.py              # Email sending
-│   │   ├── templates.py           # Email templates
-│   │   └── ui.py
-│   │
-│   ├── analytics/                  # Analytics & insights
-│   │   ├── __init__.py
-│   │   ├── metrics.py             # KPI calculations
-│   │   ├── reports.py             # Report generation
-│   │   ├── forecasting.py         # Predictive analytics
-│   │   └── ui.py
-│   │
-│   ├── automation/                 # Workflows & automation
-│   │   ├── __init__.py
-│   │   ├── rules.py               # Business rules
-│   │   ├── triggers.py            # Event triggers
-│   │   ├── workflows.py           # Workflow engine
-│   │   └── ui.py
-│   │
-│   └── settings/                   # Platform settings
-│       ├── __init__.py
-│       ├── config.py              # Configuration
-│       ├── users.py               # User management
-│       └── ui.py
-│
-├── agents/                         # AI agents (existing + new)
-│   ├── support_agent.py           # NEW: Ticket handling
-│   ├── knowledge_agent.py         # NEW: KB operations
-│   ├── sentiment_agent.py         # NEW: Emotion analysis
-│   ├── resolution_agent.py        # NEW: Problem solving
-│   ├── hunter.py                  # Existing: Prospect discovery
-│   ├── enricher.py                # Existing: Data enrichment
-│   ├── writer.py                  # Existing: Content generation
-│   └── ... (other existing agents)
-│
-├── mcp/                            # MCP servers
-│   ├── servers/
-│   │   ├── search_server.py       # Existing: Web search
-│   │   ├── email_server.py        # Existing: Email
-│   │   ├── chat_server.py         # NEW: Live chat
-│   │   ├── crm_server.py          # NEW: CRM integration
-│   │   └── notification_server.py # NEW: Notifications
-│   └── ... (other MCP components)
-│
-├── database/                       # Data layer
-│   ├── schema.sql                 # Existing + extended
-│   ├── manager.py                 # Existing
-│   └── migrations/                # Database migrations
-│
-├── models/                         # Data models
-│   ├── database.py                # Existing + extended
-│   ├── ticket.py                  # NEW: Ticket models
-│   ├── customer.py                # NEW: Customer models
-│   └── knowledge.py               # NEW: KB models
-│
-├── ui/                             # UI components
-│   ├── theme.py                   # Existing
-│   ├── components.py              # NEW: Reusable components
-│   └── layouts.py                 # NEW: Page layouts
-│
-└── api/                            # API layer
-    ├── __init__.py
-    ├── routes.py                  # FastAPI routes
-    └── webhooks.py                # Webhook handlers
-```
-
----
-
-## 🤖 AI Agents (Expanded)
-
-### 1. Support Agent
-**Purpose:** Handle customer support tickets
-**Capabilities:**
-- Auto-categorize tickets
-- Route to appropriate team
-- Suggest responses
-- Escalate urgent issues
-- Track SLA compliance
-
-**MCP Tools:**
-- Store MCP (ticket data)
-- Search MCP (find solutions)
-- Email MCP (send updates)
-
-### 2. Knowledge Agent
-**Purpose:** Manage knowledge base
-**Capabilities:**
-- Search KB articles (semantic)
-- Generate new articles
-- Update existing content
-- Suggest related articles
-- Answer questions from KB
-
-**MCP Tools:**
-- Store MCP (KB data)
-- Search MCP (research)
-- Vector Store (RAG)
-
-### 3. Sentiment Agent
-**Purpose:** Analyze customer emotions
-**Capabilities:**
-- Detect sentiment (positive/negative/neutral)
-- Identify urgency
-- Score priority
-- Flag escalations
-- Track satisfaction trends
-
-**MCP Tools:**
-- Store MCP (conversation history)
-- Analytics (trending emotions)
-
-### 4. Resolution Agent
-**Purpose:** Find and apply solutions
-**Capabilities:**
-- Diagnose issues
-- Find KB solutions
-- Generate step-by-step guides
-- Auto-resolve common issues
-- Learn from resolutions
-
-**MCP Tools:**
-- Search MCP (find solutions)
-- Store MCP (save resolutions)
-- Vector Store (similar issues)
-
-### 5. Outreach Agent (Existing - Enhanced)
-**Purpose:** Proactive customer engagement
-**Capabilities:**
-- Discover opportunities
-- Run campaigns
-- Personalize messages
-- Track engagement
-- Measure ROI
-
-### 6. Analytics Agent
-**Purpose:** Generate insights
-**Capabilities:**
-- Calculate KPIs
-- Identify trends
-- Predict issues
-- Recommend actions
-- Generate reports
-
----
-
-## 📊 Core Modules
-
-### 1. Ticket Management Module
-
-**Features:**
-- Create tickets (manual, email, chat, API)
-- Smart categorization (AI-powered)
-- Priority scoring
-- SLA tracking & alerts
-- Assignment & routing
-- Status workflow (New → Open → Pending → Resolved → Closed)
-- Attachments support
-- Internal notes
-- Customer notifications
-
-**UI Components:**
-```
-Ticket List View:
-┌─────────────────────────────────────────────────────┐
-│ [+ New Ticket]  [Filter ▼]  [Search...]            │
-├─────────────────────────────────────────────────────┤
-│ ID    Subject           Customer    Status   Agent  │
-│ #123  Login issue      John Doe    🔴 Open  Sarah  │
-│ #122  Billing question Jane Smith  ⏳ Pending Alice │
-│ #121  Feature request  Mike Chen   ✅ Resolved Bob  │
-└─────────────────────────────────────────────────────┘
-
-Ticket Detail View:
-┌─────────────────────────────────────────────────────┐
-│ #123 - Login issue                    🔴 Open      │
-├─────────────────────────────────────────────────────┤
-│ Customer: John Doe ([email protected])              │
-│ Priority: High  |  SLA: 2h remaining               │
-│ Agent: Sarah    |  Category: Technical             │
-├─────────────────────────────────────────────────────┤
-│ Conversation:                                       │
-│ [Customer message thread...]                        │
-│ [Agent replies...]                                  │
-│ [AI suggested responses...]                         │
-├─────────────────────────────────────────────────────┤
-│ [💬 Reply]  [📎 Attach]  [✅ Resolve]  [↗ Escalate]│
-└─────────────────────────────────────────────────────┘
-```
-
-**Database Tables:**
-```sql
-tickets (id, customer_id, subject, description, status, priority,
-         category, assigned_to, sla_due_at, created_at, resolved_at)
-
-ticket_messages (id, ticket_id, sender_type, sender_id, message,
-                 is_internal, created_at)
-
-ticket_attachments (id, ticket_id, filename, file_path, file_size)
-```
-
-### 2. Customer Management Module
-
-**Features:**
-- Customer profiles (360° view)
-- Contact history (all interactions)
-- Sentiment tracking
-- Segmentation (VIP, at-risk, etc.)
-- Custom fields
-- Tags and labels
-- Journey mapping
-- Satisfaction scores (CSAT, NPS)
-
-**UI Components:**
-```
-Customer Profile:
-┌─────────────────────────────────────────────────────┐
-│ 👤 John Doe                           VIP Customer │
-│ [email protected]  |  +1-555-0123                   │
-│ Customer since: Jan 2023  |  LTV: $12,450          │
-├─────────────────────────────────────────────────────┤
-│ 📊 Metrics:                                        │
-│ • Tickets: 23 (2 open)                             │
-│ • CSAT: 4.5/5 ⭐                                   │
-│ • Sentiment: 😊 Positive                           │
-│ • Last contact: 2 days ago                         │
-├─────────────────────────────────────────────────────┤
-│ 🕒 Recent Activity:                                │
-│ • Yesterday: Opened ticket #123                    │
-│ • 3 days ago: Purchased Premium plan               │
-│ • 1 week ago: Rated support 5/5                    │
-├─────────────────────────────────────────────────────┤
-│ [📧 Email]  [💬 Chat]  [🎫 New Ticket]  [📝 Note] │
-└─────────────────────────────────────────────────────┘
-```
-
-**Database Tables:**
-```sql
-customers (id, name, email, phone, company, segment,
-           lifetime_value, satisfaction_score, created_at)
-
-customer_attributes (customer_id, key, value)
-
-customer_segments (id, name, criteria, color)
-
-interaction_history (id, customer_id, type, channel,
-                     summary, sentiment, created_at)
-```
-
-### 3. Knowledge Base Module
-
-**Features:**
-- Article management (CRUD)
-- Categories & tags
-- Semantic search (RAG)
-- AI content generation
-- Version control
-- View analytics
-- Related articles
-- Multi-language support
-- Public/internal articles
-
-**UI Components:**
-```
-Knowledge Base:
-┌─────────────────────────────────────────────────────┐
-│ [+ New Article]  [Categories ▼]  [🔍 Search KB...] │
-├─────────────────────────────────────────────────────┤
-│ Categories:                                         │
-│ • Getting Started (12 articles)                    │
-│ • Billing & Payments (8 articles)                  │
-│ • Technical Issues (15 articles)                   │
-│ • Account Management (10 articles)                 │
-├─────────────────────────────────────────────────────┤
-│ Popular Articles:                                   │
-│ 1. How to reset your password       👁 1,234 views │
-│ 2. Setting up two-factor auth       👁 892 views   │
-│ 3. Understanding your bill          👁 756 views   │
-├─────────────────────────────────────────────────────┤
-│ [AI-Generated Draft Articles: 3]                   │
-└─────────────────────────────────────────────────────┘
-
-Article Editor:
-┌─────────────────────────────────────────────────────┐
-│ Title: [How to reset your password_____________]   │
-│ Category: [Getting Started ▼]                      │
-│ Tags: [password, security, account___________]     │
-├─────────────────────────────────────────────────────┤
-│ Content: [Rich text editor...]                     │
-│ [AI: Generate content]  [AI: Improve clarity]      │
-├─────────────────────────────────────────────────────┤
-│ Status: ● Published  |  Views: 1,234  |  Rating: 4.5│
-│ [💾 Save]  [👁 Preview]  [🗑 Delete]                │
-└─────────────────────────────────────────────────────┘
-```
-
-**Database Tables:**
-```sql
-kb_articles (id, title, content, category_id, status,
-             views, rating, created_at, updated_at)
-
-kb_categories (id, name, parent_id, order)
-
-kb_article_tags (article_id, tag)
-
-kb_article_versions (id, article_id, content, version, created_at)
-```
-
-### 4. Live Chat Module
-
-**Features:**
-- Real-time chat widget
-- AI chatbot (first response)
-- Human handoff
-- Canned responses
-- Typing indicators
-- File sharing
-- Chat history
-- Proactive chat triggers
-- Chat routing
-
-**UI Components:**
-```
-Live Chat Dashboard:
-┌─────────────────────────────────────────────────────┐
-│ Active Chats (3)  |  Waiting (1)  |  Bot Only (5)  │
-├─────────────────────────────────────────────────────┤
-│ 💬 Jane Smith                          ⏱ 00:03:45 │
-│ "Having trouble with payment..."                   │
-│ [Take over from bot]                               │
-├─────────────────────────────────────────────────────┤
-│ 💬 Mike Chen                           ⏱ 00:01:20 │
-│ "Need help with setup"                             │
-│ [View conversation]                                │
-└─────────────────────────────────────────────────────┘
-
-Chat Window:
-┌─────────────────────────────────────────────────────┐
-│ 💬 Chat with Jane Smith                            │
-├─────────────────────────────────────────────────────┤
-│ [10:30] Jane: Having trouble with payment          │
-│ [10:31] Bot: I can help! What issue are you having?│
-│ [10:32] Jane: Card declined                        │
-│ [10:33] Bot: Let me get a human agent...           │
-│ [10:34] Sarah: Hi Jane! I'll help you with this.   │
-├─────────────────────────────────────────────────────┤
-│ [Type message...]                    [📎] [😊] [▶]│
-│ 💡 Suggested: "Let me check your payment method"   │
-└─────────────────────────────────────────────────────┘
-```
-
-### 5. Analytics & Insights Module
-
-**Features:**
-- Real-time dashboard
-- Custom reports
-- KPI tracking (CSAT, NPS, FCR, AHT)
-- Trend analysis
-- Agent performance
-- Channel analytics
-- Predictive insights
-- Export (CSV, PDF)
-
-**UI Components:**
-```
-Analytics Dashboard:
-┌─────────────────────────────────────────────────────┐
-│ Overview (Last 30 days)                            │
-├─────────────────────────────────────────────────────┤
-│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌─────────┐│
-│ │ Tickets  │ │   CSAT   │ │   FCR    │ │  AHT   ││
-│ │   342    │ │  4.5/5   │ │   78%    │ │ 12min  ││
-│ │  ↑ 12%   │ │  ↑ 0.3   │ │  ↓ 5%    │ │ ↓ 2min ││
-│ └──────────┘ └──────────┘ └──────────┘ └─────────┘│
-├─────────────────────────────────────────────────────┤
-│ Ticket Volume Trend:                               │
-│ [Line chart showing daily ticket count...]         │
-├─────────────────────────────────────────────────────┤
-│ Top Issues:                                         │
-│ 1. Login problems           42 tickets (12%)       │
-│ 2. Billing questions        38 tickets (11%)       │
-│ 3. Feature requests         32 tickets (9%)        │
-└─────────────────────────────────────────────────────┘
-```
-
-### 6. Automation & Workflows Module
-
-**Features:**
-- Rule builder (if-then)
-- Triggers (time, event, condition)
-- Actions (assign, tag, email, escalate)
-- Templates & macros
-- Auto-responses
-- Scheduled tasks
-- Workflow analytics
-
-**UI Components:**
-```
-Automation Rules:
-┌─────────────────────────────────────────────────────┐
-│ [+ New Rule]                                       │
-├─────────────────────────────────────────────────────┤
-│ Rule: Auto-escalate high priority                  │
-│ ● Active                                            │
-│                                                     │
-│ IF:                                                 │
-│   • Ticket priority = High                         │
-│   • No response in 2 hours                         │
-│                                                     │
-│ THEN:                                               │
-│   • Assign to: Manager                             │
-│   • Send notification: Email + Slack               │
-│   • Add tag: "escalated"                           │
-│                                                     │
-│ [✏️ Edit]  [▶ Test]  [📊 Stats]  [🗑 Delete]       │
-└─────────────────────────────────────────────────────┘
-```
-
----
-
-## 🔌 MCP Servers (Extended)
-
-### Existing:
-1. **Search MCP** - Serper API for web search
-2. **Email MCP** - Email sending/receiving
-3. **Calendar MCP** - Meeting scheduling
-4. **Store MCP** - Data persistence
-
-### New:
-5. **Chat MCP** - Real-time messaging
-6. **CRM MCP** - Customer data sync
-7. **Notification MCP** - Multi-channel notifications
-8. **Analytics MCP** - Data aggregation
-9. **AI MCP** - LLM operations
-
----
-
-## 🎯 Main App (app.py) - Unified Interface
-
-```python
-# app.py - Main entry point
-import gradio as gr
-
-# Import all modules
-from modules.tickets import ui as tickets_ui
-from modules.customers import ui as customers_ui
-from modules.knowledge import ui as knowledge_ui
-from modules.chat import ui as chat_ui
-from modules.email import ui as email_ui
-from modules.analytics import ui as analytics_ui
-from modules.automation import ui as automation_ui
-from modules.settings import ui as settings_ui
-
-# Import agents
-from agents.support_agent import SupportAgent
-from agents.knowledge_agent import KnowledgeAgent
-from agents.sentiment_agent import SentimentAgent
-
-# Main application
-with gr.Blocks(theme=enterprise_theme()) as demo:
-    gr.Markdown("# 🤖 CX AI Platform - Complete Customer Experience Suite")
-
-    with gr.Tabs():
-        with gr.Tab("📊 Dashboard"):
-            dashboard_ui.render()
-
-        with gr.Tab("🎫 Tickets"):
-            tickets_ui.render()
-
-        with gr.Tab("👥 Customers"):
-            customers_ui.render()
-
-        with gr.Tab("📚 Knowledge Base"):
-            knowledge_ui.render()
-
-        with gr.Tab("💬 Live Chat"):
-            chat_ui.render()
-
-        with gr.Tab("📧 Email"):
-            email_ui.render()
-
-        with gr.Tab("📈 Analytics"):
-            analytics_ui.render()
-
-        with gr.Tab("⚙️ Automation"):
-            automation_ui.render()
-
-        with gr.Tab("🔧 Settings"):
-            settings_ui.render()
-
-if __name__ == "__main__":
-    demo.launch()
-```
-
----
-
-## 📈 Implementation Phases
-
-### Phase 1: Core Foundation (Week 1-2)
-- [x] Ticket management module
-- [x] Customer management module
-- [x] Basic UI integration in app.py
-
-### Phase 2: Knowledge & Support (Week 3-4)
-- [ ] Knowledge base module
-- [ ] Support agent (AI)
-- [ ] Sentiment agent (AI)
-- [ ] Resolution agent (AI)
-
-### Phase 3: Communication (Week 5-6)
-- [ ] Live chat module
-- [ ] Email integration module
-- [ ] Chat MCP server
-- [ ] Notification system
-
-### Phase 4: Intelligence (Week 7-8)
-- [ ] Analytics module
-- [ ] Analytics agent (AI)
-- [ ] Predictive insights
-- [ ] Reporting engine
-
-### Phase 5: Automation (Week 9-10)
-- [ ] Automation module
-- [ ] Workflow engine
-- [ ] Rule builder UI
-- [ ] Scheduled tasks
-
-### Phase 6: Integrations (Week 11-12)
-- [ ] CRM MCP server
-- [ ] API layer (FastAPI)
-- [ ] Webhooks
-- [ ] Third-party integrations
-
----
-
-## 🎯 Success Metrics
-
-**Customer Satisfaction:**
-- CSAT > 4.5/5
-- NPS > 50
-- FCR > 75%
-
-**Efficiency:**
-- AHT < 10 minutes
-- Response time < 1 hour
-- Resolution time < 24 hours
-
-**Automation:**
-- 40% tickets auto-resolved
-- 60% queries answered by KB
-- 80% sentiment detection accuracy
-
----
-
-This is the **complete architecture** for a production-ready CX platform. Ready to start building?

CX_PLATFORM_SUMMARY.md

@@ -1,439 +0,0 @@
-# CX AI Agent - Full Platform Edition
-
-## 🎉 Build Complete!
-
-I've successfully transformed your CX AI Agent from a pipeline demo into a **full-featured enterprise customer experience platform** with 4 major modules, all integrated into app.py.
-
----
-
-## 📦 What Was Built
-
-### Core Modules (4 Total)
-
-#### 1. 🎫 Ticket Management System
-**Location**: `modules/tickets/`
-
-**Files Created**:
-- `manager.py` (470+ lines) - Full CRUD operations, SLA tracking, routing
-- `ui.py` (450+ lines) - Gradio interface with 4 tabs
-- `__init__.py` - Module exports
-
-**Features**:
-- Create, read, update, delete tickets
-- Multi-threaded conversations with customer/agent/system/AI messages
-- SLA calculation and breach tracking
-- Smart assignment and routing
-- AI sentiment analysis and categorization
-- Priority-based SLA rules (urgent: 15min, high: 1hr, medium: 4hr, low: 8hr)
-- Overdue ticket detection
-- Response and resolution time tracking
-- Full ticket lifecycle management
-
-**Database Tables**:
-- `cx_tickets` - Main ticket data
-- `cx_ticket_messages` - Conversation threads
-- `cx_ticket_attachments` - File uploads
-
-#### 2. 📚 Knowledge Base with RAG
-**Location**: `modules/knowledge/`
-
-**Files Created**:
-- `manager.py` (440+ lines) - Article CRUD, versioning, analytics
-- `search.py` (340+ lines) - Semantic search engine with FAISS
-- `ui.py` (490+ lines) - Gradio interface with 5 tabs
-- `__init__.py` - Module exports
-
-**Features**:
-- Full article management with categories
-- **RAG-Powered Semantic Search**:
-  - FAISS vector index with sentence-transformers
-  - Hybrid search (semantic + keyword)
-  - Article recommendations for tickets
-  - Context retrieval for AI agents
-- Article versioning with change tracking
-- Helpfulness voting system
-- View count analytics
-- Auto-generated slugs for SEO
-- Markdown content support
-- Draft/Published/Archived workflow
-
-**Database Tables**:
-- `cx_kb_categories` - Article categories
-- `cx_kb_articles` - Articles with metrics
-- `cx_kb_article_versions` - Version history
-
-#### 3. 💬 Live Chat with AI Bot
-**Location**: `modules/chat/`
-
-**Files Created**:
-- `manager.py` (370+ lines) - Session and message management
-- `bot.py` (350+ lines) - AI chatbot with RAG integration
-- `ui.py` (400+ lines) - Gradio interface with 4 tabs
-- `__init__.py` - Module exports
-
-**Features**:
-- **AI-Powered Chatbot**:
-  - RAG-based responses using knowledge base
-  - Intent detection (greeting, question, complaint, escalation)
-  - Sentiment analysis (positive, neutral, negative)
-  - Automatic escalation triggers
-  - Confidence scoring
-- Session management with customer tracking
-- Bot-to-human handoff workflow
-- Chat rating and feedback collection
-- Wait time and response time metrics
-- Anonymous chat support
-- Real-time conversation history
-
-**Database Tables**:
-- `cx_chat_sessions` - Chat sessions with bot/agent tracking
-- `cx_chat_messages` - Message history with intent/sentiment
-
-#### 4. 📊 Analytics Dashboard
-**Location**: `modules/analytics/`
-
-**Files Created**:
-- `manager.py` (330+ lines) - Metrics aggregation and reporting
-- `ui.py` (280+ lines) - Gradio dashboard with 5 tabs
-- `__init__.py` - Module exports
-
-**Features**:
-- **Real-Time Metrics**:
-  - Customer stats (total, active, CSAT)
-  - Ticket stats (open, resolved, avg resolution time)
-  - Chat stats (active, completed, ratings)
-  - KB stats (articles, views)
-- **Ticket Analytics**:
-  - Distribution by status, priority, category
-  - SLA performance tracking
-  - Breach/at-risk/on-track categorization
-- **Customer Analytics**:
-  - Segmentation (VIP, standard, at-risk, churned)
-  - Sentiment distribution
-- **Trends & Forecasting**:
-  - Weekly performance trends
-  - Date range custom reports
-- **Daily Snapshots**:
-  - Automated daily metric collection
-
-**Database Tables**:
-- `cx_analytics_daily` - Daily metric snapshots
-- `cx_agent_stats` - Agent performance tracking
-
----
-
-## 🗄️ Database Architecture
-
-### Extended Schema Created
-
-**File**: `database/schema_extended.sql` (470+ lines)
-
-**Tables Created** (15 total):
-1. `cx_customers` - Customer master data with segmentation
-2. `cx_tickets` - Support tickets with SLA
-3. `cx_ticket_messages` - Conversation threads
-4. `cx_ticket_attachments` - File attachments
-5. `cx_kb_categories` - KB categories
-6. `cx_kb_articles` - Articles with metrics
-7. `cx_kb_article_versions` - Version control
-8. `cx_chat_sessions` - Live chat sessions
-9. `cx_chat_messages` - Chat messages
-10. `cx_automation_rules` - Workflow automation
-11. `cx_interactions` - Customer journey tracking
-12. `cx_analytics_daily` - Daily snapshots
-13. `cx_canned_responses` - Quick reply templates
-14. `cx_agent_stats` - Agent performance
-15. Additional indexes and relationships
-
-### SQLAlchemy Models
-
-**File**: `models/cx_models.py` (780+ lines)
-
-**Models Created**:
-- `CXCustomer` - With segmentation, lifecycle, satisfaction scores
-- `CXTicket` - With SLA, sentiment, AI categorization
-- `CXTicketMessage` - Multi-sender support
-- `CXTicketAttachment` - File metadata
-- `CXKBCategory` - Hierarchical categories
-- `CXKBArticle` - Full article model with metrics
-- `CXKBArticleVersion` - Version snapshots
-- `CXChatSession` - Bot handoff tracking
-- `CXChatMessage` - Intent/sentiment
-- `CXAutomationRule` - Trigger-based actions
-- `CXInteraction` - Journey tracking
-- `CXAnalyticsDaily` - Metric snapshots
-- `CXCannedResponse` - Templates
-- `CXAgentStats` - Performance metrics
-
-**Features**:
-- Full relationships with foreign keys
-- Helper methods (`to_dict()`, property accessors)
-- JSON field handling
-- Automatic timestamps
-- Cascade deletes
-
-### Database Manager Updates
-
-**File**: `database/manager.py` (updated)
-
-**Enhancements**:
-- Auto-initialization of CX tables
-- Sample data loading (demo customer, KB articles, canned responses)
-- Support for both enterprise and CX schemas
-- Session management with context managers
-- Error handling and rollback
-
----
-
-## 🎨 Main Application Integration
-
-**File**: `app.py` (updated)
-
-**Changes Made**:
-- Imported all 4 CX modules
-- Added 4 new tabs to Gradio interface:
-  - 🎫 Tickets tab
-  - 📚 Knowledge Base tab
-  - 💬 Live Chat tab
-  - 📊 Analytics tab
-- Updated header to describe full platform
-- Updated About tab with complete documentation
-- Database auto-initialization on startup
-- Preserved original Pipeline, System, and About tabs
-
-**Navigation Structure**:
-```
-┌─────────────────────────────────────────────┐
-│  🤖 CX AI Agent - Full Platform Edition     │
-├─────────────────────────────────────────────┤
-│ 🚀 Pipeline │ 🎫 Tickets │ 📚 KB │ 💬 Chat │
-│ 📊 Analytics │ ⚙️ System │ ℹ️ About          │
-└─────────────────────────────────────────────┘
-```
-
----
-
-## 📊 Statistics
-
-### Code Volume
-- **Total Lines of Code**: ~15,000+
-- **New Files Created**: 20+
-- **Modules**: 4 major modules
-- **Database Tables**: 15 tables
-- **SQLAlchemy Models**: 14 model classes
-- **UI Components**: 18 tabs across all modules
-
-### Breakdown by Module
-1. **Database Layer**: ~1,250 lines (schema + models + manager)
-2. **Tickets Module**: ~1,000 lines (manager + UI)
-3. **Knowledge Base Module**: ~1,270 lines (manager + search + UI)
-4. **Chat Module**: ~1,120 lines (manager + bot + UI)
-5. **Analytics Module**: ~610 lines (manager + UI)
-6. **Integration**: ~150 lines (app.py updates)
-
----
-
-## 🚀 How to Use
-
-### Quick Start
-
-1. **Install Dependencies**:
-   ```bash
-   pip install -r requirements_gradio.txt
-   ```
-
-2. **Set Environment Variables**:
-   ```bash
-   # .env file
-   HF_API_TOKEN=your_hf_token
-   SERPER_API_KEY=your_serper_key
-   DATABASE_PATH=./data/cx_agent.db  # Optional
-   ```
-
-3. **Run Application**:
-   ```bash
-   python app.py
-   ```
-
-4. **Database Auto-Initializes**:
-   - Creates SQLite database at `./data/cx_agent.db`
-   - Creates all 15+ tables
-   - Loads sample data (demo customer, KB articles)
-
-### Using Each Module
-
-#### 🎫 Tickets
-1. Go to "🎫 Tickets" tab
-2. Create a test ticket with [email protected]
-3. View ticket list with SLA indicators
-4. Open ticket details, add messages
-5. Check SLA Dashboard for overdue tickets
-
-#### 📚 Knowledge Base
-1. Go to "📚 Knowledge Base" tab
-2. Browse sample articles (2 pre-loaded)
-3. Create new article with markdown
-4. Go to "Index Management" tab
-5. Click "Build Index" to enable semantic search
-6. Test semantic search with queries like "reset password"
-
-#### 💬 Live Chat
-1. Go to "💬 Live Chat" tab
-2. Go to "Test Bot" tab
-3. Enter customer message: "How do I reset my password?"
-4. See AI bot response with RAG context from KB
-5. View bot metadata (intent, sentiment, confidence)
-
-#### 📊 Analytics
-1. Go to "📊 Analytics" tab
-2. View overview metrics (customers, tickets, chats)
-3. Check ticket analytics (status, priority, SLA)
-4. View trends over time
-5. Generate custom date range reports
-
-#### 🚀 Pipeline
-1. Go to "🚀 Pipeline" tab (original feature)
-2. Enter company names: "Shopify, Stripe"
-3. Watch 8-agent pipeline discover and process companies
-4. See LLM streaming in real-time
-
----
-
-## 🔧 Configuration
-
-### Database Path
-```python
-# Default: ./data/cx_agent.db
-export DATABASE_PATH=/custom/path/database.db
-```
-
-### SLA Configuration
-Edit in `modules/tickets/manager.py`:
-```python
-self.sla_config = {
-    'urgent': {'first_response': 15, 'resolution': 120},
-    'high': {'first_response': 60, 'resolution': 480},
-    'medium': {'first_response': 240, 'resolution': 1440},
-    'low': {'first_response': 480, 'resolution': 2880}
-}
-```
-
-### Semantic Search Model
-Edit in `modules/knowledge/search.py`:
-```python
-# Default: all-MiniLM-L6-v2
-self.model = SentenceTransformer('all-MiniLM-L6-v2')
-```
-
----
-
-## 🎯 Key Features Demonstrated
-
-### ✅ RAG Implementation
-- FAISS vector store for KB articles
-- Sentence-transformers embeddings
-- Hybrid search (semantic + keyword)
-- Context retrieval for chatbot responses
-- Article recommendations for tickets
-
-### ✅ AI Agent Integration
-- Chatbot with intent/sentiment detection
-- Auto-escalation based on sentiment
-- KB-powered responses
-- Confidence scoring
-- Smart handoff to humans
-
-### ✅ Full-Stack Implementation
-- SQLite database with 15+ tables
-- SQLAlchemy ORM with relationships
-- Gradio multi-tab UI
-- Real-time metrics
-- CRUD operations across all modules
-
-### ✅ Enterprise Features
-- SLA tracking and enforcement
-- Customer segmentation
-- Lifecycle management
-- Multi-channel support (tickets, chat, email)
-- Analytics and reporting
-- Automation framework
-
----
-
-## 🏆 Achievements
-
-✅ **Complete CX Platform** - All 4 modules fully functional
-✅ **RAG-Powered Search** - Semantic search with FAISS
-✅ **AI Chatbot** - Intent detection, sentiment analysis, KB integration
-✅ **SLA Management** - Real-time tracking with breach detection
-✅ **Analytics Dashboard** - Real-time metrics across all modules
-✅ **Database Design** - 15+ tables with proper relationships
-✅ **Modular Architecture** - Clean separation of concerns
-✅ **Sample Data** - Pre-loaded for immediate testing
-✅ **Single Entry Point** - Everything in app.py as requested
-✅ **Production Ready** - Error handling, logging, session management
-
----
-
-## 📝 Next Steps (Future Enhancements)
-
-### Phase 1: Enhanced AI Features
-- [ ] Sentiment-based ticket auto-prioritization
-- [ ] AI-generated KB articles from ticket patterns
-- [ ] Smart response suggestions for agents
-- [ ] Conversation summarization
-
-### Phase 2: Advanced Search
-- [ ] Multi-language support
-- [ ] Search result ranking tuning
-- [ ] Article recommendations based on customer history
-- [ ] Federated search across tickets + KB + chat
-
-### Phase 3: Automation
-- [ ] Workflow automation engine
-- [ ] Trigger-based actions (new ticket → assign, tag → email)
-- [ ] Scheduled reports
-- [ ] Auto-escalation rules
-
-### Phase 4: Integrations
-- [ ] Email inbox integration
-- [ ] Slack/Teams notifications
-- [ ] CRM sync (Salesforce, HubSpot)
-- [ ] Calendar integration for meetings
-
-### Phase 5: Advanced Analytics
-- [ ] Plotly charts for visualizations
-- [ ] Predictive analytics (ticket volume forecasting)
-- [ ] Customer churn prediction
-- [ ] Agent performance dashboards
-
----
-
-## 🤖 Built With
-
-- **Framework**: Gradio 5.x
-- **Database**: SQLite + SQLAlchemy
-- **Vector Store**: FAISS
-- **Embeddings**: sentence-transformers
-- **LLM**: Hugging Face Inference API
-- **Search**: Serper API (Google Search)
-- **MCP**: Model Context Protocol
-
----
-
-## 📞 Support
-
-All features are fully documented in:
-- `CX_PLATFORM_ARCHITECTURE.md` - Original design document
-- `ENTERPRISE_DEPLOYMENT.md` - Enterprise features guide
-- `WHATS_NEW_ENTERPRISE.md` - Enterprise edition features
-- This file - Full platform summary
-
----
-
-**Version**: 3.0.0-full-platform
-**Status**: ✅ Production Ready
-**Total Build Time**: Single continuous session
-**Lines of Code**: ~15,000+
-
-🎉 **The full CX platform is now ready to use!**

app.py

@@ -61,23 +61,17 @@ else:
 
 print("="*80 + "\n")
 
-# Initialize CX database FIRST (before importing modules that use it)
+# Initialize database (for client profiles and B2B data)
 from database.manager import get_db_manager
 
 try:
     db_manager = get_db_manager()
-    print("✅ CX Platform database initialized")
+    print("✅ Database initialized")
 except Exception as e:
-    print(f"⚠️  CX Platform database initialization error: {e}")
+    print(f"⚠️  Database initialization error: {e}")
     import traceback
     traceback.print_exc()
 
-# NOW import CX Platform modules (they need database to be ready)
-from modules.tickets import render_ticket_ui
-from modules.knowledge import render_kb_ui
-from modules.chat import render_chat_ui
-from modules.analytics import render_analytics_ui
-
 # Initialize core components
 orchestrator = Orchestrator()
 mcp_registry = MCPRegistry()
@@ -1820,22 +1814,6 @@ with gr.Blocks(
                 outputs=[chat_output, status_text, workflow_output]
             )
 
-        # Tickets Tab
-        with gr.Tab("🎫 Tickets"):
-            ticket_interface = render_ticket_ui()
-
-        # Knowledge Base Tab
-        with gr.Tab("📚 Knowledge Base"):
-            kb_interface = render_kb_ui()
-
-        # Live Chat Tab
-        with gr.Tab("💬 Live Chat"):
-            chat_interface = render_chat_ui()
-
-        # Analytics Tab
-        with gr.Tab("📊 Analytics"):
-            analytics_interface = render_analytics_ui()
-
         # System Tab
         with gr.Tab("⚙️ System"):
             gr.Markdown("### System Status & Controls")

app_enterprise.py

@@ -1,533 +0,0 @@
-"""
-CX AI Agent - Enterprise Edition
-Full-featured customer experience automation platform with campaign management,
-contact tracking, email sequences, and analytics
-"""
-import gradio as gr
-import json
-from datetime import datetime, timedelta
-from typing import List, Dict, Optional
-import logging
-
-# Database and models
-from database.manager import get_db_manager
-from models.database import (
-    Campaign, Contact, Company, Sequence, SequenceEmail,
-    EmailActivity, Meeting, Activity, CampaignContact
-)
-
-# UI components
-from ui.theme import (
-    get_enterprise_theme, get_custom_css, create_header,
-    create_metric_card, create_status_badge, create_empty_state
-)
-
-# Core orchestrator
-from app.orchestrator import Orchestrator
-from mcp.registry import MCPRegistry
-
-logger = logging.getLogger(__name__)
-
-# Initialize core components
-db_manager = get_db_manager()
-orchestrator = Orchestrator()
-mcp_registry = MCPRegistry()
-
-
-# =============================================================================
-# DASHBOARD VIEW
-# =============================================================================
-
-def show_dashboard():
-    """Render main dashboard with metrics and activity feed"""
-    with db_manager.get_session() as session:
-        # Get metrics
-        total_campaigns = session.query(Campaign).count()
-        active_campaigns = session.query(Campaign).filter(Campaign.status == 'active').count()
-        total_contacts = session.query(Contact).count()
-        total_meetings = session.query(Meeting).filter(Meeting.status == 'scheduled').count()
-
-        # Get recent activities (last 10)
-        recent_activities = session.query(Activity).order_by(
-            Activity.occurred_at.desc()
-        ).limit(10).all()
-
-    # Create metrics HTML
-    metrics_html = f"""
-        <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; margin-bottom: 2rem;">
-            {create_metric_card("Total Campaigns", str(total_campaigns), "5 this month", True)}
-            {create_metric_card("Active Campaigns", str(active_campaigns))}
-            {create_metric_card("Total Contacts", f"{total_contacts:,}")}
-            {create_metric_card("Upcoming Meetings", str(total_meetings))}
-        </div>
-    """
-
-    # Create activity feed
-    activity_items = []
-    for activity in recent_activities:
-        time_ago = format_time_ago(activity.occurred_at)
-        icon = get_activity_icon(activity.type)
-        activity_items.append(f"""
-            <div class="activity-item">
-                <div class="activity-icon" style="background: #eff6ff; color: #3b82f6;">
-                    {icon}
-                </div>
-                <div class="activity-content">
-                    <div class="activity-title">{activity.description or activity.type}</div>
-                    <div class="activity-meta">{time_ago}</div>
-                </div>
-            </div>
-        """)
-
-    activity_html = f"""
-        <div class="activity-feed">
-            <h3 style="margin: 0 0 1rem 0; font-size: 1.125rem; font-weight: 600;">Recent Activity</h3>
-            {''.join(activity_items) if activity_items else create_empty_state("📭", "No activity yet", "Activity will appear here as your campaigns run")}
-        </div>
-    """
-
-    return gr.HTML(metrics_html + activity_html)
-
-
-def format_time_ago(dt: datetime) -> str:
-    """Format datetime as relative time (e.g., '2 hours ago')"""
-    if not dt:
-        return "Unknown"
-
-    now = datetime.utcnow()
-    diff = now - dt
-
-    if diff.total_seconds() < 60:
-        return "Just now"
-    elif diff.total_seconds() < 3600:
-        minutes = int(diff.total_seconds() / 60)
-        return f"{minutes} minute{'s' if minutes != 1 else ''} ago"
-    elif diff.total_seconds() < 86400:
-        hours = int(diff.total_seconds() / 3600)
-        return f"{hours} hour{'s' if hours != 1 else ''} ago"
-    elif diff.days < 30:
-        return f"{diff.days} day{'s' if diff.days != 1 else ''} ago"
-    else:
-        return dt.strftime("%b %d, %Y")
-
-
-def get_activity_icon(activity_type: str) -> str:
-    """Get icon for activity type"""
-    icons = {
-        'discovery': '🔍',
-        'enrichment': '📊',
-        'email_sent': '📧',
-        'email_opened': '👀',
-        'reply_received': '💬',
-        'meeting_scheduled': '📅',
-        'meeting_completed': '✅',
-    }
-    return icons.get(activity_type, '•')
-
-
-# =============================================================================
-# CAMPAIGNS VIEW
-# =============================================================================
-
-def show_campaigns():
-    """Render campaigns management interface"""
-    with db_manager.get_session() as session:
-        campaigns = session.query(Campaign).order_by(Campaign.created_at.desc()).all()
-
-    if not campaigns:
-        return gr.HTML(create_empty_state(
-            "📋",
-            "No campaigns yet",
-            "Create your first campaign to start discovering and engaging prospects",
-            "Create Campaign"
-        ))
-
-    # Create campaigns table
-    rows = []
-    for campaign in campaigns:
-        status_badge = create_status_badge(campaign.status)
-        progress = (campaign.contacts_contacted / campaign.goal_contacts * 100) if campaign.goal_contacts else 0
-
-        rows.append(f"""
-            <tr>
-                <td><strong>{campaign.name}</strong><br/><span class="text-sm" style="color: #6b7280;">{campaign.description or ''}</span></td>
-                <td>{status_badge}</td>
-                <td>{campaign.contacts_discovered or 0}</td>
-                <td>{campaign.contacts_contacted or 0} / {campaign.goal_contacts or 0}</td>
-                <td>{campaign.contacts_responded or 0}</td>
-                <td>{campaign.meetings_booked or 0}</td>
-                <td>
-                    <div style="width: 100px;">
-                        {create_progress_bar(min(progress, 100))}
-                        <div class="text-xs text-center mt-2">{int(progress)}%</div>
-                    </div>
-                </td>
-                <td>{format_time_ago(campaign.created_at)}</td>
-            </tr>
-        """)
-
-    table_html = f"""
-        <table class="data-table">
-            <thead>
-                <tr>
-                    <th>Campaign</th>
-                    <th>Status</th>
-                    <th>Discovered</th>
-                    <th>Contacted</th>
-                    <th>Responded</th>
-                    <th>Meetings</th>
-                    <th>Progress</th>
-                    <th>Created</th>
-                </tr>
-            </thead>
-            <tbody>
-                {''.join(rows)}
-            </tbody>
-        </table>
-    """
-
-    return gr.HTML(table_html)
-
-
-def create_progress_bar(percentage: float):
-    """Create a progress bar"""
-    return f"""
-        <div style="width: 100%; height: 0.5rem; background: #e5e7eb; border-radius: 9999px; overflow: hidden;">
-            <div style="height: 100%; width: {percentage}%; background: linear-gradient(90deg, #3b82f6 0%, #8b5cf6 100%); border-radius: 9999px; transition: width 0.3s ease;"></div>
-        </div>
-    """
-
-
-async def create_campaign_from_ui(
-    name: str,
-    description: str,
-    company_names: str,
-    sequence_id: int = 1
-):
-    """Create a new campaign and run discovery"""
-    if not name:
-        return "❌ Please provide a campaign name"
-
-    try:
-        # Parse company names
-        companies = [c.strip() for c in company_names.split(',') if c.strip()]
-
-        if not companies:
-            return "❌ Please provide at least one company name"
-
-        # Create campaign in database
-        with db_manager.get_session() as session:
-            campaign = Campaign(
-                name=name,
-                description=description,
-                status='active',
-                sequence_id=sequence_id,
-                goal_contacts=len(companies) * 10  # Estimate
-            )
-            session.add(campaign)
-            session.commit()
-            campaign_id = campaign.id
-
-        # Run pipeline for this campaign
-        results = []
-        async for event in orchestrator.run_pipeline(
-            company_names=companies,
-            use_seed_file=False
-        ):
-            event_type = event.get('type')
-            message = event.get('message', '')
-
-            results.append(f"{event_type}: {message}")
-
-            # Store discovered contacts in campaign
-            if event_type == 'agent_end' and event.get('agent') == 'hunter':
-                prospects = event.get('payload', {}).get('prospects', [])
-
-                with db_manager.get_session() as session:
-                    for prospect in prospects:
-                        # Create or get company
-                        company = session.query(Company).filter_by(
-                            name=prospect.get('company_name')
-                        ).first()
-
-                        if not company:
-                            company = Company(
-                                name=prospect.get('company_name'),
-                                domain=prospect.get('domain'),
-                                industry=prospect.get('industry'),
-                                size=str(prospect.get('size', ''))
-                            )
-                            session.add(company)
-                            session.flush()
-
-                        # Create contact
-                        contact = Contact(
-                            company_id=company.id,
-                            email=prospect.get('email', f"contact@{prospect.get('domain', 'example.com')}"),
-                            job_title=prospect.get('title', 'Unknown'),
-                            fit_score=prospect.get('fit_score', 0.5),
-                            source='discovery_agent'
-                        )
-                        session.add(contact)
-                        session.flush()
-
-                        # Link to campaign
-                        campaign_contact = CampaignContact(
-                            campaign_id=campaign_id,
-                            contact_id=contact.id,
-                            stage='discovery'
-                        )
-                        session.add(campaign_contact)
-
-                    # Update campaign counts
-                    campaign_obj = session.query(Campaign).get(campaign_id)
-                    campaign_obj.contacts_discovered = len(prospects)
-                    session.commit()
-
-        return f"✅ Campaign '{name}' created successfully with {len(results)} events"
-
-    except Exception as e:
-        logger.error(f"Failed to create campaign: {str(e)}")
-        return f"❌ Error creating campaign: {str(e)}"
-
-
-# =============================================================================
-# CONTACTS VIEW
-# =============================================================================
-
-def show_contacts(search_query: str = "", status_filter: str = "all"):
-    """Render contacts list with filtering"""
-    with db_manager.get_session() as session:
-        query = session.query(Contact).join(Contact.company, isouter=True)
-
-        # Apply filters
-        if search_query:
-            search = f"%{search_query}%"
-            query = query.filter(
-                (Contact.first_name.like(search)) |
-                (Contact.last_name.like(search)) |
-                (Contact.email.like(search)) |
-                (Company.name.like(search))
-            )
-
-        if status_filter != "all":
-            query = query.filter(Contact.status == status_filter)
-
-        contacts = query.order_by(Contact.created_at.desc()).limit(50).all()
-
-    if not contacts:
-        return gr.HTML(create_empty_state(
-            "👥",
-            "No contacts found",
-            "Contacts will appear here as you discover them through campaigns"
-        ))
-
-    # Create contacts table
-    rows = []
-    for contact in contacts:
-        status_badge = create_status_badge(contact.status)
-        score_color = "#10b981" if contact.overall_score > 0.7 else "#f59e0b" if contact.overall_score > 0.4 else "#ef4444"
-
-        rows.append(f"""
-            <tr>
-                <td>
-                    <strong>{contact.full_name or 'Unknown'}</strong><br/>
-                    <span class="text-sm" style="color: #6b7280;">{contact.email}</span>
-                </td>
-                <td>{contact.company.name if contact.company else 'N/A'}</td>
-                <td>{contact.job_title or 'N/A'}</td>
-                <td>{status_badge}</td>
-                <td>
-                    <div style="display: flex; align-items: center; gap: 0.5rem;">
-                        <div style="width: 60px; height: 6px; background: #e5e7eb; border-radius: 9999px;">
-                            <div style="width: {contact.overall_score * 100}%; height: 100%; background: {score_color}; border-radius: 9999px;"></div>
-                        </div>
-                        <span style="font-weight: 600; color: {score_color};">{contact.overall_score:.2f}</span>
-                    </div>
-                </td>
-                <td>{format_time_ago(contact.created_at)}</td>
-            </tr>
-        """)
-
-    table_html = f"""
-        <table class="data-table">
-            <thead>
-                <tr>
-                    <th>Contact</th>
-                    <th>Company</th>
-                    <th>Title</th>
-                    <th>Status</th>
-                    <th>Score</th>
-                    <th>Added</th>
-                </tr>
-            </thead>
-            <tbody>
-                {''.join(rows)}
-            </tbody>
-        </table>
-    """
-
-    return gr.HTML(table_html)
-
-
-# =============================================================================
-# MAIN APPLICATION
-# =============================================================================
-
-async def initialize_system():
-    """Initialize MCP connections"""
-    try:
-        await mcp_registry.connect()
-        return "System initialized successfully"
-    except Exception as e:
-        return f"System initialization error: {str(e)}"
-
-
-# Create Gradio interface
-with gr.Blocks(
-    theme=get_enterprise_theme(),
-    css=get_custom_css(),
-    title="CX AI Agent - Enterprise Edition"
-) as demo:
-    # Header
-    create_header()
-
-    # Main navigation
-    with gr.Row(elem_classes="nav-tabs"):
-        nav_dashboard = gr.Button("📊 Dashboard", elem_classes="nav-tab active")
-        nav_campaigns = gr.Button("📋 Campaigns", elem_classes="nav-tab")
-        nav_contacts = gr.Button("👥 Contacts", elem_classes="nav-tab")
-        nav_sequences = gr.Button("📧 Sequences", elem_classes="nav-tab")
-        nav_analytics = gr.Button("📈 Analytics", elem_classes="nav-tab")
-
-    # Content area
-    with gr.Column() as content_area:
-        # Dashboard View
-        with gr.Column(visible=True) as dashboard_view:
-            dashboard_content = gr.HTML()
-
-        # Campaigns View
-        with gr.Column(visible=False) as campaigns_view:
-            with gr.Row():
-                gr.Markdown("### 📋 Campaigns")
-                create_campaign_btn = gr.Button("+ New Campaign", variant="primary")
-
-            campaigns_list = gr.HTML()
-
-            # Campaign creation form (initially hidden)
-            with gr.Column(visible=False) as campaign_form:
-                gr.Markdown("### Create New Campaign")
-
-                campaign_name = gr.Textbox(
-                    label="Campaign Name",
-                    placeholder="Q1 Enterprise Outreach"
-                )
-                campaign_description = gr.Textbox(
-                    label="Description",
-                    placeholder="Target enterprise SaaS companies...",
-                    lines=2
-                )
-                campaign_companies = gr.Textbox(
-                    label="Target Companies (comma-separated)",
-                    placeholder="Shopify, Stripe, Zendesk",
-                    lines=3
-                )
-
-                with gr.Row():
-                    cancel_campaign_btn = gr.Button("Cancel")
-                    save_campaign_btn = gr.Button("Create & Launch Campaign", variant="primary")
-
-                campaign_result = gr.Textbox(label="Result", interactive=False)
-
-        # Contacts View
-        with gr.Column(visible=False) as contacts_view:
-            gr.Markdown("### 👥 Contacts")
-
-            with gr.Row():
-                contact_search = gr.Textbox(
-                    placeholder="Search contacts...",
-                    show_label=False,
-                    scale=3
-                )
-                contact_status_filter = gr.Dropdown(
-                    choices=["all", "new", "contacted", "responded", "meeting_scheduled"],
-                    value="all",
-                    label="Filter by status",
-                    scale=1
-                )
-
-            contacts_list = gr.HTML()
-
-        # Sequences View (Placeholder)
-        with gr.Column(visible=False) as sequences_view:
-            gr.Markdown("### 📧 Email Sequences")
-            gr.HTML(create_empty_state(
-                "📧",
-                "Sequences coming soon",
-                "Email sequence builder will be available in the next update"
-            ))
-
-        # Analytics View (Placeholder)
-        with gr.Column(visible=False) as analytics_view:
-            gr.Markdown("### 📈 Analytics")
-            gr.HTML(create_empty_state(
-                "📊",
-                "Analytics dashboard coming soon",
-                "Comprehensive analytics and reporting will be available soon"
-            ))
-
-    # Navigation logic
-    def switch_view(view_name):
-        return {
-            dashboard_view: gr.update(visible=view_name == "dashboard"),
-            campaigns_view: gr.update(visible=view_name == "campaigns"),
-            contacts_view: gr.update(visible=view_name == "contacts"),
-            sequences_view: gr.update(visible=view_name == "sequences"),
-            analytics_view: gr.update(visible=view_name == "analytics"),
-        }
-
-    nav_dashboard.click(lambda: switch_view("dashboard"), outputs=[dashboard_view, campaigns_view, contacts_view, sequences_view, analytics_view])
-    nav_campaigns.click(lambda: switch_view("campaigns"), outputs=[dashboard_view, campaigns_view, contacts_view, sequences_view, analytics_view])
-    nav_contacts.click(lambda: switch_view("contacts"), outputs=[dashboard_view, campaigns_view, contacts_view, sequences_view, analytics_view])
-    nav_sequences.click(lambda: switch_view("sequences"), outputs=[dashboard_view, campaigns_view, contacts_view, sequences_view, analytics_view])
-    nav_analytics.click(lambda: switch_view("analytics"), outputs=[dashboard_view, campaigns_view, contacts_view, sequences_view, analytics_view])
-
-    # Campaign creation logic
-    create_campaign_btn.click(
-        lambda: gr.update(visible=True),
-        outputs=[campaign_form]
-    )
-
-    cancel_campaign_btn.click(
-        lambda: gr.update(visible=False),
-        outputs=[campaign_form]
-    )
-
-    save_campaign_btn.click(
-        create_campaign_from_ui,
-        inputs=[campaign_name, campaign_description, campaign_companies],
-        outputs=[campaign_result]
-    )
-
-    # Contacts filtering
-    contact_search.change(
-        show_contacts,
-        inputs=[contact_search, contact_status_filter],
-        outputs=[contacts_list]
-    )
-
-    contact_status_filter.change(
-        show_contacts,
-        inputs=[contact_search, contact_status_filter],
-        outputs=[contacts_list]
-    )
-
-    # Initialize on load
-    demo.load(fn=initialize_system, outputs=[])
-    demo.load(fn=show_dashboard, outputs=[dashboard_content])
-    demo.load(fn=show_campaigns, outputs=[campaigns_list])
-    demo.load(fn=show_contacts, outputs=[contacts_list])
-
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)

database/init_db.py

@@ -1,230 +0,0 @@
-"""
-Database Initialization Script
-Creates all tables and loads sample data for the CX platform
-"""
-
-import os
-from pathlib import Path
-from sqlalchemy import create_engine, text
-from models.cx_models import Base
-from database.manager import get_db_manager
-
-
-def init_database(db_path: str = None):
-    """
-    Initialize database with all tables
-
-    Args:
-        db_path: Optional path to database file
-    """
-    if db_path is None:
-        db_path = os.getenv('DATABASE_PATH', './data/cx_agent.db')
-
-    # Ensure data directory exists
-    data_dir = Path(db_path).parent
-    data_dir.mkdir(parents=True, exist_ok=True)
-
-    print(f"Initializing database at: {db_path}")
-
-    # Create engine
-    engine = create_engine(f'sqlite:///{db_path}')
-
-    # Create all tables
-    Base.metadata.create_all(engine)
-
-    print("✅ All tables created successfully!")
-
-    # Load sample data
-    load_sample_data(db_path)
-
-    print("✅ Database initialization complete!")
-
-
-def load_sample_data(db_path: str):
-    """Load sample data for testing"""
-    db = get_db_manager(db_path)
-
-    with db.get_session() as session:
-        from models.cx_models import (
-            CXCustomer, CXKBCategory, CXKBArticle, CXCannedResponse
-        )
-
-        # Check if data already exists
-        existing_customers = session.query(CXCustomer).count()
-        if existing_customers > 0:
-            print("Sample data already exists, skipping...")
-            return
-
-        # Create sample customer
-        customer = CXCustomer(
-            email="[email protected]",
-            first_name="Demo",
-            last_name="Customer",
-            company="Demo Company",
-            segment="standard",
-            lifecycle_stage="active"
-        )
-        session.add(customer)
-
-        # Create KB categories
-        cat_general = CXKBCategory(name="General", description="General information", icon="📘")
-        cat_technical = CXKBCategory(name="Technical", description="Technical guides", icon="⚙️")
-        cat_billing = CXKBCategory(name="Billing", description="Billing and payments", icon="💳")
-
-        session.add_all([cat_general, cat_technical, cat_billing])
-        session.flush()
-
-        # Create sample KB articles
-        articles = [
-            CXKBArticle(
-                category_id=cat_general.id,
-                title="Getting Started Guide",
-                summary="Learn how to get started with our platform",
-                content="""# Getting Started
-
-Welcome to our platform! This guide will help you get up and running quickly.
-
-## Step 1: Create Your Account
-
-Visit our signup page and create an account using your email address.
-
-## Step 2: Set Up Your Profile
-
-Complete your profile with your company information and preferences.
-
-## Step 3: Explore Features
-
-Take a tour of our main features:
-- Dashboard for overview
-- Projects for collaboration
-- Reports for insights
-
-## Need Help?
-
-Contact our support team at [email protected] or use the live chat feature.
-""",
-                slug="getting-started-guide",
-                status="published",
-                visibility="public",
-                author="Support Team"
-            ),
-            CXKBArticle(
-                category_id=cat_technical.id,
-                title="How to Reset Your Password",
-                summary="Step-by-step guide to reset your password",
-                content="""# Password Reset Guide
-
-Forgot your password? No problem! Follow these steps:
-
-## Steps:
-
-1. Go to the login page
-2. Click "Forgot Password"
-3. Enter your email address
-4. Check your email for reset link
-5. Click the link and create a new password
-
-## Password Requirements:
-
-- At least 8 characters
-- Include uppercase and lowercase letters
-- Include at least one number
-- Include a special character
-
-## Still Having Issues?
-
-Contact support if you don't receive the reset email within 5 minutes.
-""",
-                slug="reset-password",
-                status="published",
-                visibility="public",
-                author="Support Team"
-            ),
-            CXKBArticle(
-                category_id=cat_billing.id,
-                title="Understanding Your Invoice",
-                summary="Explanation of invoice charges and billing cycles",
-                content="""# Invoice Guide
-
-This guide explains the charges on your invoice.
-
-## Billing Cycle
-
-Your billing cycle runs from the 1st to the last day of each month.
-
-## Common Charges:
-
-### Base Subscription
-- Your plan tier (Basic, Pro, Enterprise)
-- Billed monthly or annually
-
-### Usage Charges
-- Additional users beyond plan limit
-- Extra storage
-- API calls above quota
-
-### One-Time Charges
-- Setup fees
-- Custom integrations
-- Professional services
-
-## Payment Methods
-
-We accept:
-- Credit cards (Visa, MasterCard, Amex)
-- ACH/Bank transfer (Enterprise only)
-- PayPal
-
-## Questions?
-
-Email [email protected] for invoice questions.
-""",
-                slug="invoice-guide",
-                status="published",
-                visibility="public",
-                author="Billing Team"
-            )
-        ]
-
-        session.add_all(articles)
-
-        # Create canned responses
-        responses = [
-            CXCannedResponse(
-                name="Greeting",
-                shortcut="/hello",
-                category="general",
-                content="Hello! Thank you for contacting us. How can I help you today?"
-            ),
-            CXCannedResponse(
-                name="Password Reset",
-                shortcut="/resetpw",
-                category="technical",
-                subject="Password Reset Instructions",
-                content="""I can help you reset your password. Please follow these steps:
-
-1. Go to the login page
-2. Click "Forgot Password"
-3. Enter your email address
-4. Check your email for a reset link
-
-If you don't receive the email within 5 minutes, please let me know and I'll escalate this to our technical team.
-"""
-            ),
-            CXCannedResponse(
-                name="Escalation",
-                shortcut="/escalate",
-                category="general",
-                content="I'm escalating your case to our specialist team. They will contact you within 24 hours. Is there anything else I can help with in the meantime?"
-            )
-        ]
-
-        session.add_all(responses)
-
-        session.commit()
-
-        print("✅ Sample data loaded successfully!")
-
-
-if __name__ == "__main__":
-    init_database()

database/manager.py

@@ -1,5 +1,5 @@
 """
-Database Manager for Enterprise CX AI Agent
+Database Manager for B2B Sales AI Agent
 Handles database initialization, migrations, and session management
 """
 from sqlalchemy import create_engine, event
@@ -86,23 +86,10 @@ class DatabaseManager:
                 print(f"⚠️  Could not import enterprise models: {e}")
                 logger.warning(f"Could not import enterprise models: {e}")
 
-            # Import CX models and create tables
-            try:
-                print("🔨 Creating CX platform tables...")
-                from models.cx_models import Base as CXBase
-                CXBase.metadata.create_all(self.engine)
-                print("✅ CX platform tables created successfully!")
-                logger.info("CX platform tables created")
-            except Exception as e:
-                print(f"❌ Failed to create CX tables: {e}")
-                logger.error(f"Failed to create CX tables: {e}")
-                raise
-
             logger.info(f"Database initialized at {self.db_path}")
 
             # Initialize with default data
             self._initialize_default_data()
-            self._initialize_cx_sample_data()
 
             return True
 
@@ -260,96 +247,6 @@ Best regards,
                 session.rollback()
                 session.close()
 
-    def _initialize_cx_sample_data(self):
-        """Initialize sample data for CX platform tables"""
-        try:
-            from models.cx_models import CXCustomer, CXKBCategory, CXKBArticle, CXCannedResponse
-            from datetime import datetime
-
-            session = self.Session()
-
-            # Check if already initialized
-            existing_customers = session.query(CXCustomer).first()
-            if existing_customers:
-                session.close()
-                logger.info("CX sample data already exists, skipping...")
-                return
-
-            # Create sample customer
-            customer = CXCustomer(
-                email="[email protected]",
-                first_name="Demo",
-                last_name="Customer",
-                company="Demo Company",
-                segment="standard",
-                lifecycle_stage="active",
-                first_interaction_at=datetime.utcnow()
-            )
-            session.add(customer)
-
-            # Create KB categories
-            cat_general = CXKBCategory(name="General", description="General information", icon="📘")
-            cat_technical = CXKBCategory(name="Technical", description="Technical guides", icon="⚙️")
-            cat_billing = CXKBCategory(name="Billing", description="Billing and payments", icon="💳")
-
-            session.add_all([cat_general, cat_technical, cat_billing])
-            session.flush()
-
-            # Create sample KB articles
-            articles = [
-                CXKBArticle(
-                    category_id=cat_general.id,
-                    title="Getting Started Guide",
-                    summary="Learn how to get started with our platform",
-                    content="# Getting Started\n\nWelcome to our platform!...",
-                    slug="getting-started-guide",
-                    status="published",
-                    visibility="public",
-                    author="Support Team",
-                    published_at=datetime.utcnow()
-                ),
-                CXKBArticle(
-                    category_id=cat_technical.id,
-                    title="How to Reset Your Password",
-                    summary="Step-by-step guide to reset your password",
-                    content="# Password Reset Guide\n\nForgot your password?...",
-                    slug="reset-password",
-                    status="published",
-                    visibility="public",
-                    author="Support Team",
-                    published_at=datetime.utcnow()
-                )
-            ]
-            session.add_all(articles)
-
-            # Create canned responses
-            responses = [
-                CXCannedResponse(
-                    name="Greeting",
-                    shortcut="/hello",
-                    category="general",
-                    content="Hello! Thank you for contacting us. How can I help you today?"
-                ),
-                CXCannedResponse(
-                    name="Password Reset",
-                    shortcut="/resetpw",
-                    category="technical",
-                    subject="Password Reset Instructions",
-                    content="I can help you reset your password. Please follow these steps..."
-                )
-            ]
-            session.add_all(responses)
-
-            session.commit()
-            session.close()
-
-            logger.info("CX sample data initialized successfully")
-
-        except Exception as e:
-            logger.error(f"Failed to initialize CX sample data: {str(e)}")
-            if session:
-                session.rollback()
-                session.close()
 
     @contextmanager
     def get_session(self):

models/cx_models.py

@@ -1,598 +0,0 @@
-"""
-CX Platform - SQLAlchemy Models for Extended Schema
-Maps to schema_extended.sql tables
-"""
-
-from sqlalchemy import Column, Integer, String, Float, Boolean, Text, ForeignKey, DateTime, Date, TIMESTAMP
-from sqlalchemy.orm import relationship, declarative_base
-from sqlalchemy.sql import func
-from datetime import datetime
-from typing import Optional, Dict, Any
-import json
-
-Base = declarative_base()
-
-
-# =============================================================================
-# CUSTOMERS
-# =============================================================================
-class CXCustomer(Base):
-    __tablename__ = 'cx_customers'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    email = Column(String, unique=True, nullable=False)
-    first_name = Column(String)
-    last_name = Column(String)
-    company = Column(String)
-    phone = Column(String)
-
-    # Segmentation
-    segment = Column(String, default='standard')  # vip, standard, at_risk, churned
-    lifecycle_stage = Column(String, default='active')  # new, active, at_risk, churned
-
-    # Metrics
-    lifetime_value = Column(Float, default=0.0)
-    satisfaction_score = Column(Float, default=0.0)  # CSAT average
-    nps_score = Column(Integer)  # Net Promoter Score
-    sentiment = Column(String, default='neutral')  # positive, neutral, negative
-
-    # Tracking
-    first_interaction_at = Column(TIMESTAMP)
-    last_interaction_at = Column(TIMESTAMP)
-    total_interactions = Column(Integer, default=0)
-    total_tickets = Column(Integer, default=0)
-
-    # Metadata
-    tags = Column(Text)  # JSON array
-    custom_fields = Column(Text)  # JSON object
-    notes = Column(Text)
-
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-    updated_at = Column(TIMESTAMP, default=func.current_timestamp(), onupdate=func.current_timestamp())
-
-    # Relationships
-    tickets = relationship("CXTicket", back_populates="customer", cascade="all, delete-orphan")
-    chat_sessions = relationship("CXChatSession", back_populates="customer")
-    interactions = relationship("CXInteraction", back_populates="customer", cascade="all, delete-orphan")
-
-    @property
-    def full_name(self) -> str:
-        if self.first_name and self.last_name:
-            return f"{self.first_name} {self.last_name}"
-        return self.first_name or self.last_name or self.email
-
-    def get_tags(self) -> list:
-        return json.loads(self.tags) if self.tags else []
-
-    def set_tags(self, tags: list):
-        self.tags = json.dumps(tags)
-
-    def get_custom_fields(self) -> dict:
-        return json.loads(self.custom_fields) if self.custom_fields else {}
-
-    def set_custom_fields(self, fields: dict):
-        self.custom_fields = json.dumps(fields)
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'email': self.email,
-            'full_name': self.full_name,
-            'company': self.company,
-            'phone': self.phone,
-            'segment': self.segment,
-            'lifecycle_stage': self.lifecycle_stage,
-            'lifetime_value': self.lifetime_value,
-            'satisfaction_score': self.satisfaction_score,
-            'nps_score': self.nps_score,
-            'sentiment': self.sentiment,
-            'total_interactions': self.total_interactions,
-            'total_tickets': self.total_tickets,
-            'tags': self.get_tags(),
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-
-# =============================================================================
-# TICKETS
-# =============================================================================
-class CXTicket(Base):
-    __tablename__ = 'cx_tickets'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    customer_id = Column(Integer, ForeignKey('cx_customers.id', ondelete='CASCADE'), nullable=False)
-
-    # Core fields
-    subject = Column(String, nullable=False)
-    description = Column(Text)
-    status = Column(String, default='new')  # new, open, pending, resolved, closed
-    priority = Column(String, default='medium')  # low, medium, high, urgent
-    category = Column(String)  # technical, billing, feature_request, etc.
-
-    # Assignment
-    assigned_to = Column(String)  # agent name/id
-    assigned_team = Column(String)
-
-    # SLA
-    sla_due_at = Column(TIMESTAMP)
-    first_response_at = Column(TIMESTAMP)
-    resolved_at = Column(TIMESTAMP)
-    closed_at = Column(TIMESTAMP)
-
-    # Metrics
-    response_time_minutes = Column(Integer)
-    resolution_time_minutes = Column(Integer)
-    reopened_count = Column(Integer, default=0)
-
-    # AI fields
-    sentiment = Column(String)  # detected from description
-    ai_suggested_category = Column(String)
-    ai_confidence = Column(Float)
-    auto_resolved = Column(Boolean, default=False)
-
-    # Metadata
-    source = Column(String, default='manual')  # manual, email, chat, api, web_form
-    tags = Column(Text)  # JSON array
-    custom_fields = Column(Text)  # JSON
-
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-    updated_at = Column(TIMESTAMP, default=func.current_timestamp(), onupdate=func.current_timestamp())
-
-    # Relationships
-    customer = relationship("CXCustomer", back_populates="tickets")
-    messages = relationship("CXTicketMessage", back_populates="ticket", cascade="all, delete-orphan")
-    attachments = relationship("CXTicketAttachment", back_populates="ticket", cascade="all, delete-orphan")
-
-    def get_tags(self) -> list:
-        return json.loads(self.tags) if self.tags else []
-
-    def set_tags(self, tags: list):
-        self.tags = json.dumps(tags)
-
-    def is_overdue(self) -> bool:
-        if not self.sla_due_at:
-            return False
-        return datetime.utcnow() > self.sla_due_at and self.status not in ['resolved', 'closed']
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'customer_id': self.customer_id,
-            'customer_name': self.customer.full_name if self.customer else None,
-            'subject': self.subject,
-            'description': self.description,
-            'status': self.status,
-            'priority': self.priority,
-            'category': self.category,
-            'assigned_to': self.assigned_to,
-            'sentiment': self.sentiment,
-            'is_overdue': self.is_overdue(),
-            'message_count': len(self.messages) if self.messages else 0,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-
-class CXTicketMessage(Base):
-    __tablename__ = 'cx_ticket_messages'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    ticket_id = Column(Integer, ForeignKey('cx_tickets.id', ondelete='CASCADE'), nullable=False)
-
-    # Sender
-    sender_type = Column(String, nullable=False)  # customer, agent, system, ai_bot
-    sender_id = Column(String)  # customer_id, agent_id, or 'system'
-    sender_name = Column(String)
-
-    # Message
-    message = Column(Text, nullable=False)
-    message_html = Column(Text)
-    is_internal = Column(Boolean, default=False)  # internal note vs customer-visible
-
-    # AI fields
-    sentiment = Column(String)
-    intent = Column(String)  # question, complaint, praise, feedback
-
-    # Metadata
-    meta_data = Column(Text)  # JSON
-
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-    # Relationships
-    ticket = relationship("CXTicket", back_populates="messages")
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'ticket_id': self.ticket_id,
-            'sender_type': self.sender_type,
-            'sender_name': self.sender_name,
-            'message': self.message,
-            'is_internal': self.is_internal,
-            'sentiment': self.sentiment,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-
-class CXTicketAttachment(Base):
-    __tablename__ = 'cx_ticket_attachments'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    ticket_id = Column(Integer, ForeignKey('cx_tickets.id', ondelete='CASCADE'), nullable=False)
-    message_id = Column(Integer, ForeignKey('cx_ticket_messages.id', ondelete='SET NULL'))
-
-    filename = Column(String, nullable=False)
-    file_path = Column(String, nullable=False)
-    file_size = Column(Integer)
-    mime_type = Column(String)
-
-    uploaded_by = Column(String)
-    uploaded_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-    # Relationships
-    ticket = relationship("CXTicket", back_populates="attachments")
-
-
-# =============================================================================
-# KNOWLEDGE BASE
-# =============================================================================
-class CXKBCategory(Base):
-    __tablename__ = 'cx_kb_categories'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    name = Column(String, nullable=False)
-    description = Column(Text)
-    parent_id = Column(Integer, ForeignKey('cx_kb_categories.id', ondelete='SET NULL'))
-    display_order = Column(Integer, default=0)
-    icon = Column(String)
-
-    is_active = Column(Boolean, default=True)
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-    # Relationships
-    articles = relationship("CXKBArticle", back_populates="category")
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'name': self.name,
-            'description': self.description,
-            'parent_id': self.parent_id,
-            'article_count': len(self.articles) if self.articles else 0
-        }
-
-
-class CXKBArticle(Base):
-    __tablename__ = 'cx_kb_articles'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    category_id = Column(Integer, ForeignKey('cx_kb_categories.id', ondelete='SET NULL'))
-
-    # Content
-    title = Column(String, nullable=False)
-    summary = Column(Text)
-    content = Column(Text, nullable=False)
-    content_html = Column(Text)
-
-    # Status
-    status = Column(String, default='draft')  # draft, published, archived
-    visibility = Column(String, default='public')  # public, internal, private
-
-    # SEO
-    slug = Column(String, unique=True)
-    meta_description = Column(Text)
-
-    # Metrics
-    view_count = Column(Integer, default=0)
-    helpful_count = Column(Integer, default=0)
-    not_helpful_count = Column(Integer, default=0)
-    average_rating = Column(Float, default=0.0)
-
-    # AI fields
-    ai_generated = Column(Boolean, default=False)
-    ai_confidence = Column(Float)
-    keywords = Column(Text)  # JSON array for semantic search
-
-    # Versioning
-    version = Column(Integer, default=1)
-
-    # Metadata
-    tags = Column(Text)  # JSON array
-    related_articles = Column(Text)  # JSON array of article IDs
-
-    # Authoring
-    author = Column(String)
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-    updated_at = Column(TIMESTAMP, default=func.current_timestamp(), onupdate=func.current_timestamp())
-    published_at = Column(TIMESTAMP)
-
-    # Relationships
-    category = relationship("CXKBCategory", back_populates="articles")
-    versions = relationship("CXKBArticleVersion", back_populates="article", cascade="all, delete-orphan")
-
-    def get_keywords(self) -> list:
-        return json.loads(self.keywords) if self.keywords else []
-
-    def helpfulness_score(self) -> float:
-        total = self.helpful_count + self.not_helpful_count
-        if total == 0:
-            return 0.0
-        return self.helpful_count / total
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'title': self.title,
-            'summary': self.summary,
-            'status': self.status,
-            'view_count': self.view_count,
-            'helpful_count': self.helpful_count,
-            'helpfulness': self.helpfulness_score(),
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-
-class CXKBArticleVersion(Base):
-    __tablename__ = 'cx_kb_article_versions'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    article_id = Column(Integer, ForeignKey('cx_kb_articles.id', ondelete='CASCADE'), nullable=False)
-
-    version = Column(Integer, nullable=False)
-    title = Column(String, nullable=False)
-    content = Column(Text, nullable=False)
-
-    changed_by = Column(String)
-    change_note = Column(Text)
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-    # Relationships
-    article = relationship("CXKBArticle", back_populates="versions")
-
-
-# =============================================================================
-# LIVE CHAT
-# =============================================================================
-class CXChatSession(Base):
-    __tablename__ = 'cx_chat_sessions'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    customer_id = Column(Integer, ForeignKey('cx_customers.id', ondelete='SET NULL'))
-
-    # Session info
-    session_id = Column(String, unique=True, nullable=False)
-    status = Column(String, default='active')  # active, waiting, assigned, closed
-
-    # Routing
-    assigned_to = Column(String)  # agent name/id
-    assigned_at = Column(TIMESTAMP)
-
-    # AI bot
-    bot_active = Column(Boolean, default=True)
-    bot_handed_off = Column(Boolean, default=False)
-    bot_handoff_reason = Column(String)
-
-    # Metrics
-    wait_time_seconds = Column(Integer, default=0)
-    response_time_seconds = Column(Integer, default=0)
-    message_count = Column(Integer, default=0)
-
-    # Metadata
-    page_url = Column(String)
-    referrer = Column(String)
-    user_agent = Column(String)
-    ip_address = Column(String)
-
-    # Satisfaction
-    rated = Column(Boolean, default=False)
-    rating = Column(Integer)
-    feedback = Column(Text)
-
-    started_at = Column(TIMESTAMP, default=func.current_timestamp())
-    ended_at = Column(TIMESTAMP)
-
-    # Relationships
-    customer = relationship("CXCustomer", back_populates="chat_sessions")
-    messages = relationship("CXChatMessage", back_populates="session", cascade="all, delete-orphan")
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'session_id': self.session_id,
-            'customer_name': self.customer.full_name if self.customer else 'Anonymous',
-            'status': self.status,
-            'assigned_to': self.assigned_to,
-            'bot_active': self.bot_active,
-            'message_count': self.message_count,
-            'rating': self.rating,
-            'started_at': self.started_at.isoformat() if self.started_at else None
-        }
-
-
-class CXChatMessage(Base):
-    __tablename__ = 'cx_chat_messages'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    session_id = Column(Integer, ForeignKey('cx_chat_sessions.id', ondelete='CASCADE'), nullable=False)
-
-    # Sender
-    sender_type = Column(String, nullable=False)  # customer, agent, bot, system
-    sender_id = Column(String)
-    sender_name = Column(String)
-
-    # Message
-    message = Column(Text, nullable=False)
-    message_type = Column(String, default='text')  # text, image, file, system_message
-
-    # AI fields
-    is_bot_response = Column(Boolean, default=False)
-    bot_confidence = Column(Float)
-    intent = Column(String)
-
-    # Status
-    is_read = Column(Boolean, default=False)
-    read_at = Column(TIMESTAMP)
-
-    # Metadata
-    meta_data = Column(Text)  # JSON
-
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-    # Relationships
-    session = relationship("CXChatSession", back_populates="messages")
-
-    def to_dict(self) -> dict:
-        return {
-            'id': self.id,
-            'sender_type': self.sender_type,
-            'sender_name': self.sender_name,
-            'message': self.message,
-            'is_bot_response': self.is_bot_response,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }
-
-
-# =============================================================================
-# AUTOMATION & ANALYTICS
-# =============================================================================
-class CXAutomationRule(Base):
-    __tablename__ = 'cx_automation_rules'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-
-    name = Column(String, nullable=False)
-    description = Column(Text)
-    is_active = Column(Boolean, default=True)
-
-    # Trigger
-    trigger_type = Column(String, nullable=False)  # ticket_created, ticket_updated, time_based, etc.
-    trigger_conditions = Column(Text, nullable=False)  # JSON
-
-    # Actions
-    actions = Column(Text, nullable=False)  # JSON array of actions
-
-    # Execution
-    execution_count = Column(Integer, default=0)
-    last_executed_at = Column(TIMESTAMP)
-
-    # Priority
-    priority = Column(Integer, default=0)
-
-    created_by = Column(String)
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-    updated_at = Column(TIMESTAMP, default=func.current_timestamp(), onupdate=func.current_timestamp())
-
-
-class CXInteraction(Base):
-    __tablename__ = 'cx_interactions'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    customer_id = Column(Integer, ForeignKey('cx_customers.id', ondelete='CASCADE'), nullable=False)
-
-    type = Column(String, nullable=False)  # ticket, chat, email, call, meeting
-    channel = Column(String)  # web, email, phone, chat, api
-
-    summary = Column(Text)
-    sentiment = Column(String)
-    intent = Column(String)
-
-    # References
-    reference_type = Column(String)  # ticket, chat_session, email, etc.
-    reference_id = Column(Integer)
-
-    # Metrics
-    duration_seconds = Column(Integer)
-    satisfaction_rating = Column(Integer)
-
-    # Agent
-    handled_by = Column(String)
-
-    occurred_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-    # Relationships
-    customer = relationship("CXCustomer", back_populates="interactions")
-
-
-class CXAnalyticsDaily(Base):
-    __tablename__ = 'cx_analytics_daily'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    date = Column(Date, nullable=False, unique=True)
-
-    # Ticket metrics
-    tickets_created = Column(Integer, default=0)
-    tickets_resolved = Column(Integer, default=0)
-    tickets_reopened = Column(Integer, default=0)
-    avg_resolution_time_minutes = Column(Float, default=0.0)
-    avg_first_response_minutes = Column(Float, default=0.0)
-
-    # Chat metrics
-    chats_started = Column(Integer, default=0)
-    chats_completed = Column(Integer, default=0)
-    avg_wait_time_seconds = Column(Float, default=0.0)
-    bot_resolution_rate = Column(Float, default=0.0)
-
-    # Satisfaction
-    avg_csat = Column(Float, default=0.0)
-    avg_nps = Column(Integer, default=0)
-
-    # KB metrics
-    kb_views = Column(Integer, default=0)
-    kb_helpful_votes = Column(Integer, default=0)
-    kb_searches = Column(Integer, default=0)
-
-    # Sentiment
-    positive_interactions = Column(Integer, default=0)
-    neutral_interactions = Column(Integer, default=0)
-    negative_interactions = Column(Integer, default=0)
-
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-
-
-class CXCannedResponse(Base):
-    __tablename__ = 'cx_canned_responses'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-
-    name = Column(String, nullable=False)
-    shortcut = Column(String, unique=True)  # e.g., "/greeting"
-    category = Column(String)
-
-    subject = Column(String)
-    content = Column(Text, nullable=False)
-
-    # Usage
-    use_count = Column(Integer, default=0)
-    last_used_at = Column(TIMESTAMP)
-
-    is_active = Column(Boolean, default=True)
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())
-    updated_at = Column(TIMESTAMP, default=func.current_timestamp(), onupdate=func.current_timestamp())
-
-
-class CXAgentStats(Base):
-    __tablename__ = 'cx_agent_stats'
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    agent_id = Column(String, nullable=False)
-    agent_name = Column(String, nullable=False)
-    date = Column(Date, nullable=False)
-
-    # Tickets
-    tickets_handled = Column(Integer, default=0)
-    tickets_resolved = Column(Integer, default=0)
-    avg_resolution_time_minutes = Column(Float, default=0.0)
-
-    # Chats
-    chats_handled = Column(Integer, default=0)
-    avg_chat_duration_minutes = Column(Float, default=0.0)
-
-    # Quality
-    avg_csat = Column(Float, default=0.0)
-    positive_feedbacks = Column(Integer, default=0)
-    negative_feedbacks = Column(Integer, default=0)
-
-    # Efficiency
-    avg_response_time_minutes = Column(Float, default=0.0)
-    first_contact_resolutions = Column(Integer, default=0)
-
-    created_at = Column(TIMESTAMP, default=func.current_timestamp())

modules/analytics/__init__.py

@@ -1,9 +0,0 @@
-"""
-Analytics Module
-Provides metrics, dashboards, and reporting for CX platform
-"""
-
-from .manager import AnalyticsManager
-from .ui import render_analytics_ui
-
-__all__ = ['AnalyticsManager', 'render_analytics_ui']

modules/analytics/manager.py

@@ -1,346 +0,0 @@
-"""
-Analytics Manager - Aggregate metrics and generate reports
-"""
-
-from typing import Dict, Any, List, Optional
-from datetime import datetime, timedelta, date
-from sqlalchemy import func
-from database.manager import get_db_manager
-from models.cx_models import (
-    CXTicket, CXChatSession, CXCustomer, CXKBArticle,
-    CXInteraction, CXAnalyticsDaily
-)
-
-
-class AnalyticsManager:
-    """Manages analytics and reporting across all modules"""
-
-    def __init__(self):
-        self.db = get_db_manager()
-
-    # =============================================================================
-    # OVERVIEW METRICS
-    # =============================================================================
-
-    def get_overview_metrics(self) -> Dict[str, Any]:
-        """
-        Get high-level overview metrics for dashboard
-
-        Returns:
-            Dict with key metrics across all modules
-        """
-        with self.db.get_session() as session:
-            # Customer metrics
-            total_customers = session.query(func.count(CXCustomer.id)).scalar()
-            active_customers = session.query(func.count(CXCustomer.id)).filter(
-                CXCustomer.lifecycle_stage == 'active'
-            ).scalar()
-            avg_satisfaction = session.query(func.avg(CXCustomer.satisfaction_score)).scalar() or 0
-
-            # Ticket metrics
-            total_tickets = session.query(func.count(CXTicket.id)).scalar()
-            open_tickets = session.query(func.count(CXTicket.id)).filter(
-                CXTicket.status.in_(['new', 'open', 'pending'])
-            ).scalar()
-            resolved_tickets = session.query(func.count(CXTicket.id)).filter(
-                CXTicket.status == 'resolved'
-            ).scalar()
-
-            # Calculate avg resolution time
-            avg_resolution_time = session.query(func.avg(CXTicket.resolution_time_minutes)).filter(
-                CXTicket.resolution_time_minutes.isnot(None)
-            ).scalar() or 0
-
-            # Chat metrics
-            total_chats = session.query(func.count(CXChatSession.id)).scalar()
-            active_chats = session.query(func.count(CXChatSession.id)).filter(
-                CXChatSession.status.in_(['active', 'waiting', 'assigned'])
-            ).scalar()
-            avg_chat_rating = session.query(func.avg(CXChatSession.rating)).filter(
-                CXChatSession.rated == True
-            ).scalar() or 0
-
-            # KB metrics
-            total_articles = session.query(func.count(CXKBArticle.id)).filter(
-                CXKBArticle.status == 'published'
-            ).scalar()
-            total_kb_views = session.query(func.sum(CXKBArticle.view_count)).scalar() or 0
-
-            return {
-                'customers': {
-                    'total': total_customers or 0,
-                    'active': active_customers or 0,
-                    'avg_satisfaction': round(avg_satisfaction, 2)
-                },
-                'tickets': {
-                    'total': total_tickets or 0,
-                    'open': open_tickets or 0,
-                    'resolved': resolved_tickets or 0,
-                    'avg_resolution_time_minutes': round(avg_resolution_time, 1),
-                    'resolution_rate': round((resolved_tickets / total_tickets * 100) if total_tickets > 0 else 0, 1)
-                },
-                'chats': {
-                    'total': total_chats or 0,
-                    'active': active_chats or 0,
-                    'avg_rating': round(avg_chat_rating, 2)
-                },
-                'knowledge_base': {
-                    'total_articles': total_articles or 0,
-                    'total_views': total_kb_views or 0
-                }
-            }
-
-    # =============================================================================
-    # TIME-SERIES METRICS
-    # =============================================================================
-
-    def get_metrics_by_date_range(
-        self,
-        start_date: datetime,
-        end_date: datetime
-    ) -> Dict[str, Any]:
-        """Get metrics for a specific date range"""
-        with self.db.get_session() as session:
-            # Tickets created in range
-            tickets_in_range = session.query(CXTicket).filter(
-                CXTicket.created_at >= start_date,
-                CXTicket.created_at <= end_date
-            ).all()
-
-            # Chats in range
-            chats_in_range = session.query(CXChatSession).filter(
-                CXChatSession.started_at >= start_date,
-                CXChatSession.started_at <= end_date
-            ).all()
-
-            # Calculate ticket metrics
-            tickets_created = len(tickets_in_range)
-            tickets_resolved = sum(1 for t in tickets_in_range if t.status == 'resolved')
-            resolution_times = [t.resolution_time_minutes for t in tickets_in_range if t.resolution_time_minutes]
-
-            # Calculate chat metrics
-            chats_started = len(chats_in_range)
-            chats_completed = sum(1 for c in chats_in_range if c.status == 'closed')
-            chat_ratings = [c.rating for c in chats_in_range if c.rated and c.rating]
-
-            return {
-                'period': {
-                    'start': start_date.isoformat(),
-                    'end': end_date.isoformat(),
-                    'days': (end_date - start_date).days
-                },
-                'tickets': {
-                    'created': tickets_created,
-                    'resolved': tickets_resolved,
-                    'avg_resolution_time': round(sum(resolution_times) / len(resolution_times), 1) if resolution_times else 0,
-                    'resolution_rate': round((tickets_resolved / tickets_created * 100) if tickets_created > 0 else 0, 1)
-                },
-                'chats': {
-                    'started': chats_started,
-                    'completed': chats_completed,
-                    'avg_rating': round(sum(chat_ratings) / len(chat_ratings), 2) if chat_ratings else 0
-                }
-            }
-
-    # =============================================================================
-    # CUSTOMER ANALYTICS
-    # =============================================================================
-
-    def get_customer_segmentation(self) -> Dict[str, int]:
-        """Get customer count by segment"""
-        with self.db.get_session() as session:
-            results = session.query(
-                CXCustomer.segment,
-                func.count(CXCustomer.id)
-            ).group_by(CXCustomer.segment).all()
-
-            return {segment: count for segment, count in results}
-
-    def get_customer_sentiment_distribution(self) -> Dict[str, int]:
-        """Get customer count by sentiment"""
-        with self.db.get_session() as session:
-            results = session.query(
-                CXCustomer.sentiment,
-                func.count(CXCustomer.id)
-            ).group_by(CXCustomer.sentiment).all()
-
-            return {sentiment: count for sentiment, count in results}
-
-    # =============================================================================
-    # TICKET ANALYTICS
-    # =============================================================================
-
-    def get_tickets_by_status(self) -> Dict[str, int]:
-        """Get ticket count by status"""
-        with self.db.get_session() as session:
-            results = session.query(
-                CXTicket.status,
-                func.count(CXTicket.id)
-            ).group_by(CXTicket.status).all()
-
-            return {status: count for status, count in results}
-
-    def get_tickets_by_priority(self) -> Dict[str, int]:
-        """Get ticket count by priority"""
-        with self.db.get_session() as session:
-            results = session.query(
-                CXTicket.priority,
-                func.count(CXTicket.id)
-            ).group_by(CXTicket.priority).all()
-
-            return {priority: count for priority, count in results}
-
-    def get_tickets_by_category(self) -> Dict[str, int]:
-        """Get ticket count by category"""
-        with self.db.get_session() as session:
-            results = session.query(
-                CXTicket.category,
-                func.count(CXTicket.id)
-            ).filter(
-                CXTicket.category.isnot(None)
-            ).group_by(CXTicket.category).all()
-
-            return {category: count for category, count in results}
-
-    # =============================================================================
-    # SLA PERFORMANCE
-    # =============================================================================
-
-    def get_sla_performance(self) -> Dict[str, Any]:
-        """Get SLA performance metrics"""
-        with self.db.get_session() as session:
-            now = datetime.utcnow()
-
-            # All open tickets
-            open_tickets = session.query(CXTicket).filter(
-                CXTicket.status.in_(['new', 'open', 'pending'])
-            ).all()
-
-            breached = 0
-            at_risk = 0
-            on_track = 0
-
-            for ticket in open_tickets:
-                if ticket.sla_due_at:
-                    if ticket.sla_due_at < now:
-                        breached += 1
-                    elif ticket.sla_due_at < now + timedelta(hours=2):
-                        at_risk += 1
-                    else:
-                        on_track += 1
-                else:
-                    on_track += 1
-
-            total = len(open_tickets)
-
-            return {
-                'breached': breached,
-                'at_risk': at_risk,
-                'on_track': on_track,
-                'total': total,
-                'sla_compliance_rate': round((on_track / total * 100) if total > 0 else 0, 1)
-            }
-
-    # =============================================================================
-    # TRENDING & FORECASTING
-    # =============================================================================
-
-    def get_weekly_trend(self, weeks: int = 4) -> List[Dict[str, Any]]:
-        """Get weekly metrics trend"""
-        trends = []
-        end_date = datetime.utcnow()
-
-        for i in range(weeks):
-            week_start = end_date - timedelta(weeks=i+1)
-            week_end = end_date - timedelta(weeks=i)
-
-            metrics = self.get_metrics_by_date_range(week_start, week_end)
-
-            trends.append({
-                'week': f"Week {weeks - i}",
-                'start_date': week_start.strftime("%Y-%m-%d"),
-                'tickets_created': metrics['tickets']['created'],
-                'tickets_resolved': metrics['tickets']['resolved'],
-                'chats_started': metrics['chats']['started']
-            })
-
-        return list(reversed(trends))
-
-    # =============================================================================
-    # AGENT PERFORMANCE
-    # =============================================================================
-
-    def get_agent_performance_summary(self) -> List[Dict[str, Any]]:
-        """Get agent performance summary (placeholder for future agent tracking)"""
-        # TODO: Implement when agent tracking is added
-        return [
-            {
-                'agent_name': 'Agent 1',
-                'tickets_handled': 0,
-                'tickets_resolved': 0,
-                'avg_resolution_time': 0,
-                'avg_csat': 0
-            }
-        ]
-
-    # =============================================================================
-    # DAILY SNAPSHOTS
-    # =============================================================================
-
-    def create_daily_snapshot(self, target_date: Optional[date] = None) -> CXAnalyticsDaily:
-        """
-        Create daily analytics snapshot
-
-        Args:
-            target_date: Date to create snapshot for (defaults to today)
-        """
-        if target_date is None:
-            target_date = date.today()
-
-        with self.db.get_session() as session:
-            # Check if snapshot already exists
-            existing = session.query(CXAnalyticsDaily).filter_by(date=target_date).first()
-            if existing:
-                # Update existing
-                snapshot = existing
-            else:
-                # Create new
-                snapshot = CXAnalyticsDaily(date=target_date)
-                session.add(snapshot)
-
-            # Calculate ticket metrics for the day
-            day_start = datetime.combine(target_date, datetime.min.time())
-            day_end = datetime.combine(target_date, datetime.max.time())
-
-            tickets_created = session.query(func.count(CXTicket.id)).filter(
-                CXTicket.created_at >= day_start,
-                CXTicket.created_at <= day_end
-            ).scalar() or 0
-
-            tickets_resolved = session.query(func.count(CXTicket.id)).filter(
-                CXTicket.resolved_at >= day_start,
-                CXTicket.resolved_at <= day_end
-            ).scalar() or 0
-
-            # Chat metrics
-            chats_started = session.query(func.count(CXChatSession.id)).filter(
-                CXChatSession.started_at >= day_start,
-                CXChatSession.started_at <= day_end
-            ).scalar() or 0
-
-            chats_completed = session.query(func.count(CXChatSession.id)).filter(
-                CXChatSession.ended_at >= day_start,
-                CXChatSession.ended_at <= day_end,
-                CXChatSession.status == 'closed'
-            ).scalar() or 0
-
-            # Update snapshot
-            snapshot.tickets_created = tickets_created
-            snapshot.tickets_resolved = tickets_resolved
-            snapshot.chats_started = chats_started
-            snapshot.chats_completed = chats_completed
-
-            session.commit()
-            session.refresh(snapshot)
-
-            return snapshot

modules/analytics/ui.py

@@ -1,248 +0,0 @@
-"""
-Analytics UI - Dashboard and reporting interface
-"""
-
-import gradio as gr
-from datetime import datetime, timedelta
-
-from .manager import AnalyticsManager
-
-
-class AnalyticsUI:
-    """Gradio UI for analytics dashboard"""
-
-    def __init__(self):
-        self.manager = AnalyticsManager()
-
-    def render(self) -> gr.Blocks:
-        """Render analytics dashboard"""
-
-        with gr.Blocks() as analytics_interface:
-            gr.Markdown("# 📊 Analytics Dashboard")
-
-            with gr.Tabs():
-                # TAB 1: Overview
-                with gr.Tab("📈 Overview"):
-                    refresh_overview_btn = gr.Button("🔄 Refresh", variant="secondary")
-
-                    gr.Markdown("## Key Metrics")
-
-                    with gr.Row():
-                        total_customers_display = gr.Number(label="Total Customers", value=0)
-                        active_customers_display = gr.Number(label="Active Customers", value=0)
-                        avg_satisfaction_display = gr.Number(label="Avg CSAT", value=0)
-
-                    with gr.Row():
-                        total_tickets_display = gr.Number(label="Total Tickets", value=0)
-                        open_tickets_display = gr.Number(label="Open Tickets", value=0)
-                        resolved_tickets_display = gr.Number(label="Resolved Tickets", value=0)
-
-                    with gr.Row():
-                        avg_resolution_time_display = gr.Number(label="Avg Resolution Time (min)", value=0)
-                        resolution_rate_display = gr.Number(label="Resolution Rate (%)", value=0)
-                        total_chats_display = gr.Number(label="Total Chats", value=0)
-
-                    gr.Markdown("## Full Metrics")
-                    overview_metrics_json = gr.JSON(label="All Metrics")
-
-                # TAB 2: Tickets
-                with gr.Tab("🎫 Ticket Analytics"):
-                    refresh_tickets_btn = gr.Button("🔄 Refresh", variant="secondary")
-
-                    gr.Markdown("### Ticket Distribution")
-
-                    with gr.Row():
-                        with gr.Column():
-                            tickets_by_status = gr.JSON(label="By Status")
-                        with gr.Column():
-                            tickets_by_priority = gr.JSON(label="By Priority")
-                        with gr.Column():
-                            tickets_by_category = gr.JSON(label="By Category")
-
-                    gr.Markdown("### SLA Performance")
-                    sla_performance = gr.JSON(label="SLA Metrics")
-
-                # TAB 3: Customers
-                with gr.Tab("👥 Customer Analytics"):
-                    refresh_customers_btn = gr.Button("🔄 Refresh", variant="secondary")
-
-                    gr.Markdown("### Customer Segmentation")
-
-                    with gr.Row():
-                        customer_segmentation = gr.JSON(label="By Segment")
-                        sentiment_distribution = gr.JSON(label="By Sentiment")
-
-                # TAB 4: Trends
-                with gr.Tab("📉 Trends"):
-                    gr.Markdown("### Weekly Trends")
-
-                    weeks_selector = gr.Slider(
-                        minimum=2,
-                        maximum=12,
-                        value=4,
-                        step=1,
-                        label="Number of Weeks"
-                    )
-
-                    load_trends_btn = gr.Button("Load Trends", variant="primary")
-
-                    trends_table = gr.Dataframe(
-                        headers=["Week", "Start Date", "Tickets Created", "Tickets Resolved", "Chats Started"],
-                        label="Weekly Performance",
-                        interactive=False
-                    )
-
-                # TAB 5: Reports
-                with gr.Tab("📄 Reports"):
-                    gr.Markdown("### Generate Custom Report")
-
-                    with gr.Row():
-                        start_date_input = gr.Textbox(
-                            label="Start Date (YYYY-MM-DD)",
-                            value=(datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
-                        )
-                        end_date_input = gr.Textbox(
-                            label="End Date (YYYY-MM-DD)",
-                            value=datetime.now().strftime("%Y-%m-%d")
-                        )
-
-                    generate_report_btn = gr.Button("Generate Report", variant="primary")
-
-                    report_output = gr.JSON(label="Report Data")
-
-            # =============================================================================
-            # EVENT HANDLERS
-            # =============================================================================
-
-            def load_overview():
-                """Load overview metrics"""
-                try:
-                    metrics = self.manager.get_overview_metrics()
-
-                    return (
-                        metrics['customers']['total'],
-                        metrics['customers']['active'],
-                        metrics['customers']['avg_satisfaction'],
-                        metrics['tickets']['total'],
-                        metrics['tickets']['open'],
-                        metrics['tickets']['resolved'],
-                        metrics['tickets']['avg_resolution_time_minutes'],
-                        metrics['tickets']['resolution_rate'],
-                        metrics['chats']['total'],
-                        metrics
-                    )
-                except Exception as e:
-                    error_metrics = {"error": str(e)}
-                    return (0, 0, 0, 0, 0, 0, 0, 0, 0, error_metrics)
-
-            def load_ticket_analytics():
-                """Load ticket analytics"""
-                try:
-                    by_status = self.manager.get_tickets_by_status()
-                    by_priority = self.manager.get_tickets_by_priority()
-                    by_category = self.manager.get_tickets_by_category()
-                    sla = self.manager.get_sla_performance()
-
-                    return by_status, by_priority, by_category, sla
-
-                except Exception as e:
-                    error = {"error": str(e)}
-                    return error, error, error, error
-
-            def load_customer_analytics():
-                """Load customer analytics"""
-                try:
-                    segmentation = self.manager.get_customer_segmentation()
-                    sentiment = self.manager.get_customer_sentiment_distribution()
-
-                    return segmentation, sentiment
-
-                except Exception as e:
-                    error = {"error": str(e)}
-                    return error, error
-
-            def load_weekly_trends(weeks):
-                """Load weekly trends"""
-                try:
-                    trends = self.manager.get_weekly_trend(weeks=int(weeks))
-
-                    # Convert to table format
-                    rows = []
-                    for trend in trends:
-                        rows.append([
-                            trend['week'],
-                            trend['start_date'],
-                            trend['tickets_created'],
-                            trend['tickets_resolved'],
-                            trend['chats_started']
-                        ])
-
-                    return rows
-
-                except Exception as e:
-                    return [[f"Error: {str(e)}", "", "", "", ""]]
-
-            def generate_custom_report(start_date_str, end_date_str):
-                """Generate custom date range report"""
-                try:
-                    start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
-                    end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
-
-                    report = self.manager.get_metrics_by_date_range(start_date, end_date)
-
-                    return report
-
-                except Exception as e:
-                    return {"error": str(e)}
-
-            # Wire up events
-            refresh_overview_btn.click(
-                fn=load_overview,
-                outputs=[
-                    total_customers_display, active_customers_display, avg_satisfaction_display,
-                    total_tickets_display, open_tickets_display, resolved_tickets_display,
-                    avg_resolution_time_display, resolution_rate_display, total_chats_display,
-                    overview_metrics_json
-                ]
-            )
-
-            refresh_tickets_btn.click(
-                fn=load_ticket_analytics,
-                outputs=[tickets_by_status, tickets_by_priority, tickets_by_category, sla_performance]
-            )
-
-            refresh_customers_btn.click(
-                fn=load_customer_analytics,
-                outputs=[customer_segmentation, sentiment_distribution]
-            )
-
-            load_trends_btn.click(
-                fn=load_weekly_trends,
-                inputs=[weeks_selector],
-                outputs=[trends_table]
-            )
-
-            generate_report_btn.click(
-                fn=generate_custom_report,
-                inputs=[start_date_input, end_date_input],
-                outputs=[report_output]
-            )
-
-            # Load initial data
-            analytics_interface.load(
-                fn=load_overview,
-                outputs=[
-                    total_customers_display, active_customers_display, avg_satisfaction_display,
-                    total_tickets_display, open_tickets_display, resolved_tickets_display,
-                    avg_resolution_time_display, resolution_rate_display, total_chats_display,
-                    overview_metrics_json
-                ]
-            )
-
-        return analytics_interface
-
-
-def render_analytics_ui() -> gr.Blocks:
-    """Convenience function to render analytics UI"""
-    ui = AnalyticsUI()
-    return ui.render()

modules/chat/__init__.py

@@ -1,10 +0,0 @@
-"""
-Live Chat Module
-Handles real-time customer chat with AI bot and human handoff
-"""
-
-from .manager import ChatManager
-from .bot import ChatBot
-from .ui import render_chat_ui
-
-__all__ = ['ChatManager', 'ChatBot', 'render_chat_ui']

modules/chat/bot.py

@@ -1,360 +0,0 @@
-"""
-ChatBot - AI-powered chat bot with RAG
-Uses knowledge base for context-aware responses
-"""
-
-from typing import Optional, Dict, Any, Tuple
-import os
-import re
-
-# Import knowledge base for RAG
-from modules.knowledge.search import SemanticSearchEngine
-from modules.knowledge.manager import KnowledgeBaseManager
-
-
-class ChatBot:
-    """
-    AI-powered chatbot for customer support
-
-    Features:
-    - RAG-powered responses using knowledge base
-    - Intent detection
-    - Sentiment analysis
-    - Automatic escalation to human agent
-    - Context-aware conversations
-    """
-
-    def __init__(self):
-        self.kb_search = SemanticSearchEngine()
-        self.kb_manager = KnowledgeBaseManager()
-
-        # Escalation triggers
-        self.escalation_keywords = [
-            'speak to human', 'talk to agent', 'real person',
-            'not helping', 'frustrated', 'angry', 'manager',
-            'cancel', 'refund', 'complaint'
-        ]
-
-        # Greeting patterns
-        self.greeting_patterns = [
-            r'\b(hi|hello|hey|greetings)\b',
-            r'\bgood (morning|afternoon|evening)\b'
-        ]
-
-    # =============================================================================
-    # MAIN RESPONSE GENERATION
-    # =============================================================================
-
-    def generate_response(
-        self,
-        message: str,
-        session_context: Optional[Dict[str, Any]] = None
-    ) -> Tuple[str, Dict[str, Any]]:
-        """
-        Generate AI response to customer message
-
-        Args:
-            message: Customer message
-            session_context: Optional session context (previous messages, customer info)
-
-        Returns:
-            Tuple of (response_text, metadata)
-            metadata includes: intent, sentiment, confidence, should_escalate, suggested_articles
-        """
-        # Detect intent
-        intent = self.detect_intent(message)
-
-        # Detect sentiment
-        sentiment = self.detect_sentiment(message)
-
-        # Check if should escalate to human
-        should_escalate = self.should_escalate_to_human(message, sentiment, intent)
-
-        # Handle different intents
-        if intent == 'greeting':
-            response = self._handle_greeting(message)
-            confidence = 0.95
-            suggested_articles = []
-
-        elif intent == 'farewell':
-            response = self._handle_farewell(message)
-            confidence = 0.95
-            suggested_articles = []
-
-        elif should_escalate:
-            response = self._handle_escalation(message)
-            confidence = 0.90
-            suggested_articles = []
-
-        else:
-            # Use RAG to generate response
-            response, confidence, suggested_articles = self._generate_rag_response(message)
-
-        # Build metadata
-        metadata = {
-            'intent': intent,
-            'sentiment': sentiment,
-            'confidence': confidence,
-            'should_escalate': should_escalate,
-            'suggested_articles': [article.id for article, _ in suggested_articles] if suggested_articles else []
-        }
-
-        return response, metadata
-
-    # =============================================================================
-    # RAG-POWERED RESPONSE
-    # =============================================================================
-
-    def _generate_rag_response(
-        self,
-        message: str
-    ) -> Tuple[str, float, list]:
-        """
-        Generate response using RAG from knowledge base
-
-        Returns:
-            Tuple of (response, confidence, suggested_articles)
-        """
-        # Search knowledge base for relevant articles
-        relevant_articles = self.kb_search.suggest_articles_for_ticket(
-            message,
-            top_k=3
-        )
-
-        if not relevant_articles:
-            # No relevant articles found
-            return self._handle_unknown_query(), 0.3, []
-
-        # Get best match
-        best_article, best_score = relevant_articles[0]
-
-        # If confidence is too low, escalate
-        if best_score < 0.4:
-            return self._handle_unknown_query(), best_score, relevant_articles
-
-        # Build response from article
-        response = self._build_response_from_article(best_article, message)
-
-        # Add suggestions for other articles
-        if len(relevant_articles) > 1:
-            response += "\n\nYou might also find these helpful:\n"
-            for article, score in relevant_articles[1:]:
-                response += f"• {article.title}\n"
-
-        return response, best_score, relevant_articles
-
-    def _build_response_from_article(
-        self,
-        article,
-        query: str
-    ) -> str:
-        """Build a conversational response from KB article"""
-        # Extract relevant portion of article
-        content = article.content
-
-        # Try to find the most relevant paragraph
-        paragraphs = content.split('\n\n')
-
-        # Simple relevance: paragraph containing query keywords
-        query_words = set(query.lower().split())
-        relevant_para = None
-        max_overlap = 0
-
-        for para in paragraphs:
-            para_words = set(para.lower().split())
-            overlap = len(query_words & para_words)
-            if overlap > max_overlap:
-                max_overlap = overlap
-                relevant_para = para
-
-        if relevant_para:
-            response = f"Based on our knowledge base, here's what I found:\n\n{relevant_para}\n\n"
-        else:
-            # Use summary or first paragraph
-            response = f"{article.summary or paragraphs[0] if paragraphs else content[:300]}\n\n"
-
-        response += f"For more details, check out: **{article.title}**"
-
-        return response
-
-    def _handle_unknown_query(self) -> str:
-        """Handle queries with no good KB match"""
-        return (
-            "I'm not entirely sure about that. Let me connect you with one of our support agents "
-            "who can help you better. Would you like me to do that?"
-        )
-
-    # =============================================================================
-    # INTENT & SENTIMENT DETECTION
-    # =============================================================================
-
-    def detect_intent(self, message: str) -> str:
-        """
-        Detect user intent
-
-        Returns:
-            greeting, farewell, question, complaint, escalation_request, general
-        """
-        message_lower = message.lower()
-
-        # Greeting
-        if any(re.search(pattern, message_lower) for pattern in self.greeting_patterns):
-            return 'greeting'
-
-        # Farewell
-        if any(word in message_lower for word in ['bye', 'goodbye', 'thanks', 'thank you']):
-            return 'farewell'
-
-        # Escalation request
-        if any(keyword in message_lower for keyword in self.escalation_keywords):
-            return 'escalation_request'
-
-        # Question (contains question words or ?)
-        if '?' in message or any(word in message_lower for word in ['how', 'what', 'why', 'when', 'where', 'can', 'could', 'would']):
-            return 'question'
-
-        # Complaint
-        complaint_words = ['problem', 'issue', 'error', 'broken', 'not working', 'wrong']
-        if any(word in message_lower for word in complaint_words):
-            return 'complaint'
-
-        return 'general'
-
-    def detect_sentiment(self, message: str) -> str:
-        """
-        Detect sentiment
-
-        Returns:
-            positive, neutral, negative
-        """
-        message_lower = message.lower()
-
-        # Negative keywords
-        negative_keywords = [
-            'angry', 'frustrated', 'terrible', 'awful', 'worst', 'hate',
-            'disappointed', 'useless', 'horrible', 'bad', 'problem', 'issue'
-        ]
-
-        # Positive keywords
-        positive_keywords = [
-            'great', 'excellent', 'awesome', 'wonderful', 'love', 'perfect',
-            'thanks', 'thank you', 'appreciate', 'helpful', 'good'
-        ]
-
-        neg_count = sum(1 for word in negative_keywords if word in message_lower)
-        pos_count = sum(1 for word in positive_keywords if word in message_lower)
-
-        if neg_count > pos_count:
-            return 'negative'
-        elif pos_count > neg_count:
-            return 'positive'
-        else:
-            return 'neutral'
-
-    def should_escalate_to_human(
-        self,
-        message: str,
-        sentiment: str,
-        intent: str
-    ) -> bool:
-        """
-        Determine if conversation should be escalated to human
-
-        Returns:
-            True if should escalate
-        """
-        message_lower = message.lower()
-
-        # Explicit escalation request
-        if intent == 'escalation_request':
-            return True
-
-        # Very negative sentiment
-        if sentiment == 'negative':
-            angry_words = ['angry', 'furious', 'hate', 'worst']
-            if any(word in message_lower for word in angry_words):
-                return True
-
-        # Billing/payment issues
-        if any(word in message_lower for word in ['refund', 'charge', 'billing', 'payment']):
-            return True
-
-        # Account security
-        if any(word in message_lower for word in ['hacked', 'unauthorized', 'fraud', 'security']):
-            return True
-
-        return False
-
-    # =============================================================================
-    # PREDEFINED RESPONSES
-    # =============================================================================
-
-    def _handle_greeting(self, message: str) -> str:
-        """Handle greeting"""
-        return (
-            "Hello! 👋 I'm your AI support assistant. "
-            "I'm here to help you with any questions you have. "
-            "What can I assist you with today?"
-        )
-
-    def _handle_farewell(self, message: str) -> str:
-        """Handle goodbye"""
-        if 'thank' in message.lower():
-            return (
-                "You're very welcome! 😊 If you need any more help, feel free to start a new chat. "
-                "Have a great day!"
-            )
-        else:
-            return "Goodbye! Feel free to reach out if you need anything else. Take care! 👋"
-
-    def _handle_escalation(self, message: str) -> str:
-        """Handle escalation request"""
-        return (
-            "I understand. Let me connect you with one of our support specialists "
-            "who can assist you further. Please hold on for just a moment..."
-        )
-
-    # =============================================================================
-    # UTILITIES
-    # =============================================================================
-
-    def get_suggested_responses(
-        self,
-        message: str
-    ) -> list:
-        """
-        Get suggested quick responses for agents
-
-        Returns:
-            List of suggested response texts
-        """
-        intent = self.detect_intent(message)
-
-        suggestions = {
-            'greeting': [
-                "Hello! How can I help you today?",
-                "Hi there! What brings you here today?",
-                "Welcome! How may I assist you?"
-            ],
-            'farewell': [
-                "Thank you for contacting us! Have a great day!",
-                "You're welcome! Feel free to reach out anytime.",
-                "Glad I could help! Take care!"
-            ],
-            'question': [
-                "Let me look that up for you...",
-                "I can help you with that. Here's what I found...",
-                "Great question! Let me explain..."
-            ],
-            'complaint': [
-                "I'm sorry to hear you're experiencing this issue. Let me help...",
-                "I understand your frustration. Let's resolve this...",
-                "Thank you for bringing this to our attention. Let me assist..."
-            ]
-        }
-
-        return suggestions.get(intent, [
-            "How can I assist you with that?",
-            "Let me help you with that.",
-            "I'm here to help!"
-        ])

modules/chat/manager.py

@@ -1,427 +0,0 @@
-"""
-Chat Manager - Session and message handling for live chat
-"""
-
-from typing import Optional, List, Dict, Any, Tuple
-from datetime import datetime, timedelta
-from sqlalchemy.orm import Session
-from sqlalchemy import desc, and_
-import uuid
-import json
-
-from models.cx_models import CXChatSession, CXChatMessage, CXCustomer, CXInteraction
-from database.manager import get_db_manager
-
-
-class ChatManager:
-    """Manages live chat sessions and messages"""
-
-    def __init__(self):
-        self.db = get_db_manager()
-
-    # =============================================================================
-    # SESSION MANAGEMENT
-    # =============================================================================
-
-    def create_session(
-        self,
-        customer_id: Optional[int] = None,
-        page_url: Optional[str] = None,
-        referrer: Optional[str] = None,
-        user_agent: Optional[str] = None,
-        ip_address: Optional[str] = None
-    ) -> CXChatSession:
-        """
-        Create a new chat session
-
-        Args:
-            customer_id: Optional customer ID if identified
-            page_url: Page where chat was initiated
-            referrer: Referrer URL
-            user_agent: Browser user agent
-            ip_address: Client IP address
-
-        Returns:
-            Created session
-        """
-        with self.db.get_session() as session:
-            # Generate unique session ID
-            session_id = str(uuid.uuid4())
-
-            chat_session = CXChatSession(
-                customer_id=customer_id,
-                session_id=session_id,
-                status='active',
-                bot_active=True,
-                page_url=page_url,
-                referrer=referrer,
-                user_agent=user_agent,
-                ip_address=ip_address
-            )
-
-            session.add(chat_session)
-            session.commit()
-            session.refresh(chat_session)
-
-            return chat_session
-
-    def get_session(self, session_id: str) -> Optional[CXChatSession]:
-        """Get session by session_id"""
-        with self.db.get_session() as session:
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if chat_session:
-                _ = chat_session.customer  # Eager load
-                _ = chat_session.messages
-
-            return chat_session
-
-    def get_session_by_id(self, id: int) -> Optional[CXChatSession]:
-        """Get session by database ID"""
-        with self.db.get_session() as session:
-            return session.query(CXChatSession).filter_by(id=id).first()
-
-    def get_all_sessions(
-        self,
-        status: Optional[str] = None,
-        assigned_to: Optional[str] = None,
-        limit: int = 100,
-        offset: int = 0
-    ) -> Tuple[List[CXChatSession], int]:
-        """
-        Get all sessions with filters
-
-        Returns:
-            Tuple of (sessions list, total count)
-        """
-        with self.db.get_session() as session:
-            query = session.query(CXChatSession)
-
-            if status:
-                query = query.filter(CXChatSession.status == status)
-            if assigned_to:
-                query = query.filter(CXChatSession.assigned_to == assigned_to)
-
-            total = query.count()
-
-            sessions = query.order_by(desc(CXChatSession.started_at)).limit(limit).offset(offset).all()
-
-            # Eager load customers
-            for chat_session in sessions:
-                _ = chat_session.customer
-
-            return sessions, total
-
-    def update_session(self, session_id: str, **updates) -> CXChatSession:
-        """Update session fields"""
-        with self.db.get_session() as session:
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if not chat_session:
-                raise ValueError(f"Session {session_id} not found")
-
-            for key, value in updates.items():
-                if hasattr(chat_session, key):
-                    setattr(chat_session, key, value)
-
-            # Handle status changes
-            if 'status' in updates and updates['status'] == 'closed':
-                chat_session.ended_at = datetime.utcnow()
-
-            session.commit()
-            session.refresh(chat_session)
-
-            return chat_session
-
-    def close_session(
-        self,
-        session_id: str,
-        rating: Optional[int] = None,
-        feedback: Optional[str] = None
-    ) -> CXChatSession:
-        """Close a chat session"""
-        with self.db.get_session() as session:
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if not chat_session:
-                raise ValueError(f"Session {session_id} not found")
-
-            chat_session.status = 'closed'
-            chat_session.ended_at = datetime.utcnow()
-
-            if rating is not None:
-                chat_session.rated = True
-                chat_session.rating = rating
-                chat_session.feedback = feedback
-
-            # Create interaction record
-            if chat_session.customer_id:
-                interaction = CXInteraction(
-                    customer_id=chat_session.customer_id,
-                    type='chat',
-                    channel='web',
-                    summary=f"Chat session - {chat_session.message_count} messages",
-                    reference_type='chat_session',
-                    reference_id=chat_session.id,
-                    satisfaction_rating=rating,
-                    occurred_at=chat_session.started_at
-                )
-                session.add(interaction)
-
-            session.commit()
-            session.refresh(chat_session)
-
-            return chat_session
-
-    # =============================================================================
-    # MESSAGE MANAGEMENT
-    # =============================================================================
-
-    def add_message(
-        self,
-        session_id: str,
-        sender_type: str,
-        message: str,
-        sender_id: Optional[str] = None,
-        sender_name: Optional[str] = None,
-        message_type: str = 'text',
-        is_bot_response: bool = False,
-        bot_confidence: Optional[float] = None,
-        intent: Optional[str] = None
-    ) -> CXChatMessage:
-        """
-        Add a message to a chat session
-
-        Args:
-            session_id: Session ID
-            sender_type: customer, agent, bot, system
-            message: Message content
-            sender_id: Optional sender ID
-            sender_name: Display name
-            message_type: text, image, file, system_message
-            is_bot_response: Whether this is from AI bot
-            bot_confidence: Bot confidence score (0-1)
-            intent: Detected intent
-
-        Returns:
-            Created message
-        """
-        with self.db.get_session() as session:
-            # Get chat session
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if not chat_session:
-                raise ValueError(f"Session {session_id} not found")
-
-            # Create message
-            chat_message = CXChatMessage(
-                session_id=chat_session.id,
-                sender_type=sender_type,
-                sender_id=sender_id,
-                sender_name=sender_name,
-                message=message,
-                message_type=message_type,
-                is_bot_response=is_bot_response,
-                bot_confidence=bot_confidence,
-                intent=intent
-            )
-
-            session.add(chat_message)
-
-            # Update session
-            chat_session.message_count += 1
-
-            # Update wait time if first agent response
-            if sender_type == 'agent' and chat_session.wait_time_seconds == 0:
-                delta = datetime.utcnow() - chat_session.started_at
-                chat_session.wait_time_seconds = int(delta.total_seconds())
-
-            session.commit()
-            session.refresh(chat_message)
-
-            return chat_message
-
-    def get_session_messages(
-        self,
-        session_id: str,
-        limit: Optional[int] = None
-    ) -> List[CXChatMessage]:
-        """Get all messages for a session"""
-        with self.db.get_session() as session:
-            # Get session by session_id
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if not chat_session:
-                return []
-
-            query = session.query(CXChatMessage).filter(
-                CXChatMessage.session_id == chat_session.id
-            ).order_by(CXChatMessage.created_at)
-
-            if limit:
-                query = query.limit(limit)
-
-            return query.all()
-
-    def mark_message_read(self, message_id: int):
-        """Mark a message as read"""
-        with self.db.get_session() as session:
-            message = session.query(CXChatMessage).filter_by(id=message_id).first()
-            if message:
-                message.is_read = True
-                message.read_at = datetime.utcnow()
-                session.commit()
-
-    # =============================================================================
-    # ASSIGNMENT & ROUTING
-    # =============================================================================
-
-    def assign_to_agent(
-        self,
-        session_id: str,
-        agent_id: str,
-        agent_name: Optional[str] = None
-    ) -> CXChatSession:
-        """Assign chat session to an agent"""
-        with self.db.get_session() as session:
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if not chat_session:
-                raise ValueError(f"Session {session_id} not found")
-
-            chat_session.assigned_to = agent_id
-            chat_session.assigned_at = datetime.utcnow()
-            chat_session.status = 'assigned'
-
-            # Add system message
-            system_msg = CXChatMessage(
-                session_id=chat_session.id,
-                sender_type='system',
-                sender_name='System',
-                message=f"Chat assigned to {agent_name or agent_id}",
-                message_type='system_message'
-            )
-            session.add(system_msg)
-
-            session.commit()
-            session.refresh(chat_session)
-
-            return chat_session
-
-    def handoff_to_human(
-        self,
-        session_id: str,
-        reason: Optional[str] = None
-    ) -> CXChatSession:
-        """
-        Handoff from bot to human agent
-
-        Args:
-            session_id: Session ID
-            reason: Reason for handoff (escalation, unable_to_help, customer_request)
-        """
-        with self.db.get_session() as session:
-            chat_session = session.query(CXChatSession).filter_by(
-                session_id=session_id
-            ).first()
-
-            if not chat_session:
-                raise ValueError(f"Session {session_id} not found")
-
-            chat_session.bot_handed_off = True
-            chat_session.bot_handoff_reason = reason
-            chat_session.bot_active = False
-            chat_session.status = 'waiting'  # Waiting for agent
-
-            # Add system message
-            system_msg = CXChatMessage(
-                session_id=chat_session.id,
-                sender_type='system',
-                sender_name='System',
-                message="Transferring you to a human agent...",
-                message_type='system_message'
-            )
-            session.add(system_msg)
-
-            session.commit()
-            session.refresh(chat_session)
-
-            return chat_session
-
-    # =============================================================================
-    # ANALYTICS
-    # =============================================================================
-
-    def get_chat_stats(
-        self,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None
-    ) -> Dict[str, Any]:
-        """Get chat statistics"""
-        with self.db.get_session() as session:
-            query = session.query(CXChatSession)
-
-            if start_date:
-                query = query.filter(CXChatSession.started_at >= start_date)
-            if end_date:
-                query = query.filter(CXChatSession.started_at <= end_date)
-
-            sessions = query.all()
-
-            total = len(sessions)
-            by_status = {}
-            wait_times = []
-            ratings = []
-            bot_handoffs = 0
-
-            for chat_session in sessions:
-                # Count by status
-                by_status[chat_session.status] = by_status.get(chat_session.status, 0) + 1
-
-                # Collect wait times
-                if chat_session.wait_time_seconds:
-                    wait_times.append(chat_session.wait_time_seconds)
-
-                # Collect ratings
-                if chat_session.rated and chat_session.rating:
-                    ratings.append(chat_session.rating)
-
-                # Count bot handoffs
-                if chat_session.bot_handed_off:
-                    bot_handoffs += 1
-
-            return {
-                'total_sessions': total,
-                'by_status': by_status,
-                'avg_wait_time_seconds': sum(wait_times) / len(wait_times) if wait_times else 0,
-                'avg_rating': sum(ratings) / len(ratings) if ratings else 0,
-                'bot_handoff_rate': bot_handoffs / total if total > 0 else 0
-            }
-
-    def get_active_sessions_count(self) -> int:
-        """Get count of active sessions"""
-        with self.db.get_session() as session:
-            return session.query(CXChatSession).filter(
-                CXChatSession.status.in_(['active', 'waiting', 'assigned'])
-            ).count()
-
-    def get_waiting_sessions(self) -> List[CXChatSession]:
-        """Get sessions waiting for agent assignment"""
-        with self.db.get_session() as session:
-            sessions = session.query(CXChatSession).filter(
-                CXChatSession.status == 'waiting'
-            ).order_by(CXChatSession.started_at).all()
-
-            return sessions

modules/chat/ui.py

@@ -1,331 +0,0 @@
-"""
-Chat UI - Gradio interface for managing chat sessions
-Note: Real-time chat would require WebSockets; this is a management interface
-"""
-
-import gradio as gr
-from typing import List
-from datetime import datetime
-
-from .manager import ChatManager
-from .bot import ChatBot
-
-
-class ChatUI:
-    """Gradio UI for chat management"""
-
-    def __init__(self):
-        self.manager = ChatManager()
-        self.bot = ChatBot()
-
-    def render(self) -> gr.Blocks:
-        """Render chat management interface"""
-
-        with gr.Blocks() as chat_interface:
-            gr.Markdown("# 💬 Live Chat Management")
-            gr.Markdown("Monitor and manage customer chat sessions")
-
-            with gr.Tabs():
-                # TAB 1: Active Sessions
-                with gr.Tab("🟢 Active Sessions"):
-                    refresh_active_btn = gr.Button("🔄 Refresh", variant="secondary")
-
-                    active_sessions_table = gr.Dataframe(
-                        headers=["ID", "Customer", "Status", "Bot Active", "Messages", "Wait Time", "Started", "Assigned To"],
-                        label="Active Chat Sessions",
-                        interactive=False
-                    )
-
-                    with gr.Row():
-                        active_count = gr.Textbox(label="Active Sessions", value="0")
-                        waiting_count = gr.Textbox(label="Waiting for Agent", value="0")
-                        avg_wait_time = gr.Textbox(label="Avg Wait Time", value="0s")
-
-                # TAB 2: Session Details
-                with gr.Tab("🔍 Session Details"):
-                    with gr.Row():
-                        session_id_input = gr.Textbox(label="Session ID")
-                        load_session_btn = gr.Button("Load Session", variant="secondary")
-
-                    session_info = gr.Markdown("Enter a session ID to view details")
-
-                    gr.Markdown("### 💬 Conversation")
-                    conversation_display = gr.Chatbot(
-                        label="Messages",
-                        height=400
-                    )
-
-                    with gr.Row():
-                        with gr.Column(scale=3):
-                            agent_message_input = gr.Textbox(
-                                label="Send Message as Agent",
-                                placeholder="Type your response...",
-                                lines=2
-                            )
-                        with gr.Column(scale=1):
-                            send_message_btn = gr.Button("Send", variant="primary")
-                            handoff_btn = gr.Button("🤖→👤 Handoff to Human")
-                            close_session_btn = gr.Button("🔒 Close Session")
-
-                    action_output = gr.Textbox(label="Action Result", lines=2)
-
-                # TAB 3: Bot Testing
-                with gr.Tab("🤖 Test Bot"):
-                    gr.Markdown("### Test AI Bot Responses")
-                    gr.Markdown("See how the bot would respond to customer messages")
-
-                    test_message_input = gr.Textbox(
-                        label="Test Message",
-                        placeholder="How do I reset my password?",
-                        lines=2
-                    )
-
-                    test_bot_btn = gr.Button("Test Bot Response", variant="primary")
-
-                    bot_response_output = gr.Markdown("Bot response will appear here")
-
-                    bot_metadata_output = gr.JSON(label="Response Metadata")
-
-                # TAB 4: Chat Analytics
-                with gr.Tab("📊 Analytics"):
-                    gr.Markdown("### Chat Performance Metrics")
-
-                    refresh_stats_btn = gr.Button("🔄 Refresh Stats", variant="secondary")
-
-                    with gr.Row():
-                        total_sessions_metric = gr.Textbox(label="Total Sessions", value="0")
-                        avg_rating_metric = gr.Textbox(label="Avg Rating", value="0.0")
-                        handoff_rate_metric = gr.Textbox(label="Bot Handoff Rate", value="0%")
-
-                    chat_stats_json = gr.JSON(label="Detailed Statistics")
-
-            # =============================================================================
-            # EVENT HANDLERS
-            # =============================================================================
-
-            def load_active_sessions():
-                """Load active chat sessions"""
-                try:
-                    sessions, total = self.manager.get_all_sessions(limit=100)
-
-                    rows = []
-                    active_cnt = 0
-                    waiting_cnt = 0
-                    wait_times = []
-
-                    for session in sessions:
-                        if session.status in ['active', 'waiting', 'assigned']:
-                            active_cnt += 1
-
-                        if session.status == 'waiting':
-                            waiting_cnt += 1
-
-                        if session.wait_time_seconds:
-                            wait_times.append(session.wait_time_seconds)
-
-                        # Format wait time
-                        wait_str = f"{session.wait_time_seconds}s" if session.wait_time_seconds else "N/A"
-
-                        rows.append([
-                            session.id,
-                            session.customer.full_name if session.customer else "Anonymous",
-                            session.status,
-                            "Yes" if session.bot_active else "No",
-                            session.message_count,
-                            wait_str,
-                            session.started_at.strftime("%Y-%m-%d %H:%M") if session.started_at else "",
-                            session.assigned_to or "Unassigned"
-                        ])
-
-                    avg_wait = int(sum(wait_times) / len(wait_times)) if wait_times else 0
-
-                    return (
-                        rows,
-                        str(active_cnt),
-                        str(waiting_cnt),
-                        f"{avg_wait}s"
-                    )
-
-                except Exception as e:
-                    return [], f"Error: {e}", "0", "0s"
-
-            def load_session_details(session_id):
-                """Load session and conversation"""
-                if not session_id:
-                    return "Please enter a session ID", []
-
-                try:
-                    session = self.manager.get_session(session_id)
-                    if not session:
-                        return "❌ Session not found", []
-
-                    # Build session info
-                    info = f"""
-### Session: {session.session_id}
-
-**Customer:** {session.customer.full_name if session.customer else 'Anonymous'}
-**Status:** {session.status}
-**Started:** {session.started_at.strftime("%Y-%m-%d %H:%M:%S") if session.started_at else 'N/A'}
-**Messages:** {session.message_count}
-**Bot Active:** {'Yes' if session.bot_active else 'No'}
-**Assigned To:** {session.assigned_to or 'Unassigned'}
-**Rating:** {session.rating if session.rated else 'Not rated'}
-                    """
-
-                    # Load messages
-                    messages = self.manager.get_session_messages(session_id)
-
-                    # Format for chatbot display
-                    conversation = []
-                    for msg in messages:
-                        # Determine role
-                        if msg.sender_type in ['customer']:
-                            role = "user"
-                        else:
-                            role = "assistant"
-
-                        # Add message
-                        conversation.append([msg.message, None] if role == "user" else [None, msg.message])
-
-                    return info, conversation
-
-                except Exception as e:
-                    return f"❌ Error: {str(e)}", []
-
-            def send_agent_message(session_id, message):
-                """Send message as agent"""
-                if not session_id or not message:
-                    return "Please provide session ID and message"
-
-                try:
-                    self.manager.add_message(
-                        session_id=session_id,
-                        sender_type='agent',
-                        sender_id='agent_1',
-                        sender_name='Support Agent',
-                        message=message
-                    )
-                    return f"✅ Message sent successfully"
-                except Exception as e:
-                    return f"❌ Error: {str(e)}"
-
-            def handoff_to_human(session_id):
-                """Handoff session from bot to human"""
-                if not session_id:
-                    return "Please provide session ID"
-
-                try:
-                    self.manager.handoff_to_human(
-                        session_id=session_id,
-                        reason='manual_handoff'
-                    )
-                    return "✅ Session handed off to human agent queue"
-                except Exception as e:
-                    return f"❌ Error: {str(e)}"
-
-            def close_chat_session(session_id):
-                """Close a session"""
-                if not session_id:
-                    return "Please provide session ID"
-
-                try:
-                    self.manager.close_session(session_id)
-                    return "✅ Session closed successfully"
-                except Exception as e:
-                    return f"❌ Error: {str(e)}"
-
-            def test_bot_response(message):
-                """Test bot response generation"""
-                if not message:
-                    return "Please enter a test message", {}
-
-                try:
-                    response, metadata = self.bot.generate_response(message)
-
-                    # Format response
-                    output = f"## Bot Response:\n\n{response}\n\n"
-
-                    # Add suggestions if available
-                    if metadata.get('suggested_articles'):
-                        output += "\n### Suggested Articles (IDs):\n"
-                        for article_id in metadata['suggested_articles']:
-                            output += f"- Article #{article_id}\n"
-
-                    return output, metadata
-
-                except Exception as e:
-                    return f"❌ Error: {str(e)}", {}
-
-            def load_chat_stats():
-                """Load chat statistics"""
-                try:
-                    stats = self.manager.get_chat_stats()
-
-                    total = stats.get('total_sessions', 0)
-                    avg_rating = stats.get('avg_rating', 0)
-                    handoff_rate = stats.get('bot_handoff_rate', 0)
-
-                    return (
-                        str(total),
-                        f"{avg_rating:.1f}",
-                        f"{int(handoff_rate * 100)}%",
-                        stats
-                    )
-
-                except Exception as e:
-                    return "Error", "Error", "Error", {"error": str(e)}
-
-            # Wire up events
-            refresh_active_btn.click(
-                fn=load_active_sessions,
-                outputs=[active_sessions_table, active_count, waiting_count, avg_wait_time]
-            )
-
-            load_session_btn.click(
-                fn=load_session_details,
-                inputs=[session_id_input],
-                outputs=[session_info, conversation_display]
-            )
-
-            send_message_btn.click(
-                fn=send_agent_message,
-                inputs=[session_id_input, agent_message_input],
-                outputs=[action_output]
-            )
-
-            handoff_btn.click(
-                fn=handoff_to_human,
-                inputs=[session_id_input],
-                outputs=[action_output]
-            )
-
-            close_session_btn.click(
-                fn=close_chat_session,
-                inputs=[session_id_input],
-                outputs=[action_output]
-            )
-
-            test_bot_btn.click(
-                fn=test_bot_response,
-                inputs=[test_message_input],
-                outputs=[bot_response_output, bot_metadata_output]
-            )
-
-            refresh_stats_btn.click(
-                fn=load_chat_stats,
-                outputs=[total_sessions_metric, avg_rating_metric, handoff_rate_metric, chat_stats_json]
-            )
-
-            # Load initial data
-            chat_interface.load(
-                fn=load_active_sessions,
-                outputs=[active_sessions_table, active_count, waiting_count, avg_wait_time]
-            )
-
-        return chat_interface
-
-
-def render_chat_ui() -> gr.Blocks:
-    """Convenience function to render chat UI"""
-    ui = ChatUI()
-    return ui.render()

modules/knowledge/__init__.py

@@ -1,10 +0,0 @@
-"""
-Knowledge Base Module
-Handles articles, semantic search with RAG, and AI content generation
-"""
-
-from .manager import KnowledgeBaseManager
-from .search import SemanticSearchEngine
-from .ui import render_kb_ui
-
-__all__ = ['KnowledgeBaseManager', 'SemanticSearchEngine', 'render_kb_ui']

modules/knowledge/manager.py

@@ -1,475 +0,0 @@
-"""
-Knowledge Base Manager - CRUD operations for articles and categories
-"""
-
-from typing import Optional, List, Dict, Any, Tuple
-from datetime import datetime
-from sqlalchemy.orm import Session
-from sqlalchemy import desc, or_, func
-import json
-import re
-
-from models.cx_models import CXKBArticle, CXKBCategory, CXKBArticleVersion
-from database.manager import get_db_manager
-
-
-class KnowledgeBaseManager:
-    """Manages knowledge base articles and categories"""
-
-    def __init__(self):
-        self.db = get_db_manager()
-
-    # =============================================================================
-    # CATEGORY MANAGEMENT
-    # =============================================================================
-
-    def create_category(
-        self,
-        name: str,
-        description: Optional[str] = None,
-        parent_id: Optional[int] = None,
-        icon: Optional[str] = None
-    ) -> CXKBCategory:
-        """Create a new KB category"""
-        with self.db.get_session() as session:
-            category = CXKBCategory(
-                name=name,
-                description=description,
-                parent_id=parent_id,
-                icon=icon
-            )
-            session.add(category)
-            session.commit()
-            session.refresh(category)
-            return category
-
-    def get_all_categories(self, active_only: bool = True) -> List[CXKBCategory]:
-        """Get all categories"""
-        with self.db.get_session() as session:
-            query = session.query(CXKBCategory)
-            if active_only:
-                query = query.filter(CXKBCategory.is_active == True)
-
-            categories = query.order_by(CXKBCategory.display_order).all()
-            return categories
-
-    def get_category(self, category_id: int) -> Optional[CXKBCategory]:
-        """Get category by ID"""
-        with self.db.get_session() as session:
-            return session.query(CXKBCategory).filter_by(id=category_id).first()
-
-    # =============================================================================
-    # ARTICLE CRUD
-    # =============================================================================
-
-    def create_article(
-        self,
-        title: str,
-        content: str,
-        category_id: Optional[int] = None,
-        summary: Optional[str] = None,
-        author: Optional[str] = None,
-        tags: Optional[List[str]] = None,
-        status: str = 'draft',
-        visibility: str = 'public',
-        ai_generated: bool = False
-    ) -> CXKBArticle:
-        """
-        Create a new KB article
-
-        Args:
-            title: Article title
-            content: Article content (markdown)
-            category_id: Optional category ID
-            summary: Brief summary
-            author: Author name
-            tags: List of tags
-            status: draft, published, archived
-            visibility: public, internal, private
-            ai_generated: Whether content was AI-generated
-        """
-        with self.db.get_session() as session:
-            # Generate slug from title
-            slug = self._generate_slug(title)
-
-            # Check for duplicate slug
-            existing = session.query(CXKBArticle).filter_by(slug=slug).first()
-            if existing:
-                slug = f"{slug}-{datetime.utcnow().timestamp()}"
-
-            article = CXKBArticle(
-                title=title,
-                content=content,
-                category_id=category_id,
-                summary=summary,
-                author=author,
-                slug=slug,
-                status=status,
-                visibility=visibility,
-                ai_generated=ai_generated
-            )
-
-            if tags:
-                article.tags = json.dumps(tags)
-
-            session.add(article)
-            session.flush()
-
-            # Create initial version
-            self._create_version(session, article, author, "Initial version")
-
-            # Auto-publish if requested
-            if status == 'published':
-                article.published_at = datetime.utcnow()
-
-            session.commit()
-            session.refresh(article)
-
-            return article
-
-    def get_article(self, article_id: int) -> Optional[CXKBArticle]:
-        """Get article by ID"""
-        with self.db.get_session() as session:
-            article = session.query(CXKBArticle).filter_by(id=article_id).first()
-            if article:
-                _ = article.category  # Eager load
-            return article
-
-    def get_article_by_slug(self, slug: str) -> Optional[CXKBArticle]:
-        """Get article by slug"""
-        with self.db.get_session() as session:
-            return session.query(CXKBArticle).filter_by(slug=slug).first()
-
-    def get_all_articles(
-        self,
-        status: Optional[str] = None,
-        category_id: Optional[int] = None,
-        visibility: Optional[str] = None,
-        limit: int = 100,
-        offset: int = 0
-    ) -> Tuple[List[CXKBArticle], int]:
-        """
-        Get articles with filters
-
-        Returns:
-            Tuple of (articles list, total count)
-        """
-        with self.db.get_session() as session:
-            query = session.query(CXKBArticle)
-
-            # Apply filters
-            if status:
-                query = query.filter(CXKBArticle.status == status)
-            if category_id:
-                query = query.filter(CXKBArticle.category_id == category_id)
-            if visibility:
-                query = query.filter(CXKBArticle.visibility == visibility)
-
-            # Get total count
-            total = query.count()
-
-            # Apply pagination
-            articles = query.order_by(desc(CXKBArticle.created_at)).limit(limit).offset(offset).all()
-
-            # Eager load categories
-            for article in articles:
-                _ = article.category
-
-            return articles, total
-
-    def update_article(
-        self,
-        article_id: int,
-        changed_by: Optional[str] = None,
-        change_note: Optional[str] = None,
-        **updates
-    ) -> CXKBArticle:
-        """
-        Update article
-
-        Args:
-            article_id: Article ID
-            changed_by: Who made the change
-            change_note: Reason for change
-            **updates: Fields to update
-        """
-        with self.db.get_session() as session:
-            article = session.query(CXKBArticle).filter_by(id=article_id).first()
-            if not article:
-                raise ValueError(f"Article {article_id} not found")
-
-            # Track if content changed (triggers new version)
-            content_changed = 'content' in updates or 'title' in updates
-
-            # Update fields
-            for key, value in updates.items():
-                if hasattr(article, key):
-                    setattr(article, key, value)
-
-            # Handle status changes
-            if 'status' in updates:
-                if updates['status'] == 'published' and not article.published_at:
-                    article.published_at = datetime.utcnow()
-
-            # Create new version if content changed
-            if content_changed:
-                article.version += 1
-                self._create_version(session, article, changed_by, change_note)
-
-            session.commit()
-            session.refresh(article)
-
-            return article
-
-    def delete_article(self, article_id: int) -> bool:
-        """Delete article (soft delete - set to archived)"""
-        with self.db.get_session() as session:
-            article = session.query(CXKBArticle).filter_by(id=article_id).first()
-            if not article:
-                return False
-
-            article.status = 'archived'
-            session.commit()
-            return True
-
-    # =============================================================================
-    # ARTICLE VERSIONING
-    # =============================================================================
-
-    def _create_version(
-        self,
-        session: Session,
-        article: CXKBArticle,
-        changed_by: Optional[str],
-        change_note: Optional[str]
-    ) -> CXKBArticleVersion:
-        """Create a version snapshot"""
-        version = CXKBArticleVersion(
-            article_id=article.id,
-            version=article.version,
-            title=article.title,
-            content=article.content,
-            changed_by=changed_by,
-            change_note=change_note
-        )
-        session.add(version)
-        return version
-
-    def get_article_versions(self, article_id: int) -> List[CXKBArticleVersion]:
-        """Get all versions of an article"""
-        with self.db.get_session() as session:
-            versions = session.query(CXKBArticleVersion).filter(
-                CXKBArticleVersion.article_id == article_id
-            ).order_by(desc(CXKBArticleVersion.version)).all()
-            return versions
-
-    def restore_version(
-        self,
-        article_id: int,
-        version_number: int,
-        restored_by: Optional[str] = None
-    ) -> CXKBArticle:
-        """Restore article to a previous version"""
-        with self.db.get_session() as session:
-            article = session.query(CXKBArticle).filter_by(id=article_id).first()
-            if not article:
-                raise ValueError(f"Article {article_id} not found")
-
-            version = session.query(CXKBArticleVersion).filter_by(
-                article_id=article_id,
-                version=version_number
-            ).first()
-
-            if not version:
-                raise ValueError(f"Version {version_number} not found")
-
-            # Restore content
-            article.title = version.title
-            article.content = version.content
-            article.version += 1
-
-            # Create new version record
-            self._create_version(
-                session,
-                article,
-                restored_by,
-                f"Restored from version {version_number}"
-            )
-
-            session.commit()
-            session.refresh(article)
-
-            return article
-
-    # =============================================================================
-    # SEARCH & DISCOVERY
-    # =============================================================================
-
-    def search_articles(
-        self,
-        query: str,
-        status: str = 'published',
-        limit: int = 20
-    ) -> List[CXKBArticle]:
-        """
-        Simple keyword search in articles
-
-        For semantic search, use SemanticSearchEngine
-        """
-        with self.db.get_session() as session:
-            search_term = f"%{query}%"
-
-            articles = session.query(CXKBArticle).filter(
-                CXKBArticle.status == status,
-                or_(
-                    CXKBArticle.title.like(search_term),
-                    CXKBArticle.content.like(search_term),
-                    CXKBArticle.summary.like(search_term)
-                )
-            ).limit(limit).all()
-
-            return articles
-
-    def get_popular_articles(
-        self,
-        limit: int = 10,
-        days: int = 30
-    ) -> List[CXKBArticle]:
-        """Get most viewed articles"""
-        with self.db.get_session() as session:
-            articles = session.query(CXKBArticle).filter(
-                CXKBArticle.status == 'published'
-            ).order_by(desc(CXKBArticle.view_count)).limit(limit).all()
-
-            return articles
-
-    def get_helpful_articles(self, limit: int = 10) -> List[CXKBArticle]:
-        """Get most helpful articles (by vote ratio)"""
-        with self.db.get_session() as session:
-            articles = session.query(CXKBArticle).filter(
-                CXKBArticle.status == 'published',
-                CXKBArticle.helpful_count > 0
-            ).all()
-
-            # Calculate helpfulness ratio
-            scored_articles = []
-            for article in articles:
-                total = article.helpful_count + article.not_helpful_count
-                if total > 0:
-                    ratio = article.helpful_count / total
-                    scored_articles.append((article, ratio))
-
-            # Sort by ratio
-            scored_articles.sort(key=lambda x: x[1], reverse=True)
-
-            return [article for article, _ in scored_articles[:limit]]
-
-    # =============================================================================
-    # ARTICLE METRICS
-    # =============================================================================
-
-    def track_view(self, article_id: int):
-        """Increment article view count"""
-        with self.db.get_session() as session:
-            article = session.query(CXKBArticle).filter_by(id=article_id).first()
-            if article:
-                article.view_count += 1
-                session.commit()
-
-    def vote_helpful(self, article_id: int, is_helpful: bool):
-        """Record helpfulness vote"""
-        with self.db.get_session() as session:
-            article = session.query(CXKBArticle).filter_by(id=article_id).first()
-            if not article:
-                return
-
-            if is_helpful:
-                article.helpful_count += 1
-            else:
-                article.not_helpful_count += 1
-
-            # Recalculate average rating
-            total = article.helpful_count + article.not_helpful_count
-            if total > 0:
-                article.average_rating = article.helpful_count / total
-
-            session.commit()
-
-    # =============================================================================
-    # AI CONTENT GENERATION
-    # =============================================================================
-
-    def generate_article_from_tickets(
-        self,
-        ticket_ids: List[int],
-        author: str = "AI Assistant"
-    ) -> CXKBArticle:
-        """
-        Generate a KB article from common ticket patterns
-
-        TODO: Implement with AI agent
-        """
-        # Placeholder for AI generation
-        title = "Auto-Generated Article"
-        content = "Content generated from ticket analysis..."
-
-        return self.create_article(
-            title=title,
-            content=content,
-            author=author,
-            ai_generated=True,
-            status='draft'
-        )
-
-    def suggest_improvements(self, article_id: int) -> Dict[str, Any]:
-        """
-        Suggest improvements for an article using AI
-
-        TODO: Implement with AI agent
-
-        Returns:
-            Dict with suggestions
-        """
-        return {
-            'clarity_score': 0.85,
-            'completeness_score': 0.75,
-            'suggestions': [
-                "Add more examples",
-                "Improve formatting",
-                "Add troubleshooting section"
-            ]
-        }
-
-    # =============================================================================
-    # UTILITIES
-    # =============================================================================
-
-    def _generate_slug(self, title: str) -> str:
-        """Generate URL-friendly slug from title"""
-        # Convert to lowercase
-        slug = title.lower()
-
-        # Replace spaces and special chars with hyphens
-        slug = re.sub(r'[^\w\s-]', '', slug)
-        slug = re.sub(r'[\s_]+', '-', slug)
-        slug = slug.strip('-')
-
-        return slug[:100]  # Limit length
-
-    def get_kb_stats(self) -> Dict[str, Any]:
-        """Get overall KB statistics"""
-        with self.db.get_session() as session:
-            total_articles = session.query(func.count(CXKBArticle.id)).scalar()
-            published_articles = session.query(func.count(CXKBArticle.id)).filter(
-                CXKBArticle.status == 'published'
-            ).scalar()
-            total_views = session.query(func.sum(CXKBArticle.view_count)).scalar() or 0
-            total_categories = session.query(func.count(CXKBCategory.id)).scalar()
-
-            return {
-                'total_articles': total_articles,
-                'published_articles': published_articles,
-                'draft_articles': total_articles - published_articles,
-                'total_views': total_views,
-                'total_categories': total_categories
-            }

modules/knowledge/search.py

@@ -1,361 +0,0 @@
-"""
-Semantic Search Engine - RAG-powered knowledge base search
-Uses sentence transformers and FAISS for vector similarity search
-"""
-
-from typing import List, Dict, Any, Tuple, Optional
-import os
-import pickle
-import numpy as np
-from pathlib import Path
-
-try:
-    import faiss
-    from sentence_transformers import SentenceTransformer
-    SEMANTIC_SEARCH_AVAILABLE = True
-except ImportError:
-    SEMANTIC_SEARCH_AVAILABLE = False
-
-from models.cx_models import CXKBArticle
-from .manager import KnowledgeBaseManager
-
-
-class SemanticSearchEngine:
-    """
-    Semantic search engine for KB articles using RAG
-
-    Features:
-    - Vector embeddings with sentence-transformers
-    - FAISS vector similarity search
-    - Automatic index building and updates
-    - Hybrid search (keyword + semantic)
-    """
-
-    def __init__(
-        self,
-        model_name: str = 'all-MiniLM-L6-v2',
-        index_path: str = './data/kb_index'
-    ):
-        """
-        Initialize semantic search engine
-
-        Args:
-            model_name: HuggingFace sentence-transformer model
-            index_path: Path to store FAISS index
-        """
-        self.kb_manager = KnowledgeBaseManager()
-        self.index_path = Path(index_path)
-        self.index_path.mkdir(parents=True, exist_ok=True)
-
-        # Check if dependencies available
-        if not SEMANTIC_SEARCH_AVAILABLE:
-            print("⚠️  Warning: sentence-transformers or faiss-cpu not installed. Semantic search disabled.")
-            self.enabled = False
-            return
-
-        self.enabled = True
-
-        # Load embedding model
-        print(f"Loading embedding model: {model_name}...")
-        self.model = SentenceTransformer(model_name)
-        self.embedding_dim = self.model.get_sentence_embedding_dimension()
-
-        # Load or create FAISS index
-        self.index = None
-        self.article_ids = []
-        self.load_index()
-
-    # =============================================================================
-    # INDEX MANAGEMENT
-    # =============================================================================
-
-    def build_index(self, force_rebuild: bool = False):
-        """
-        Build FAISS index from all published articles
-
-        Args:
-            force_rebuild: Rebuild even if index exists
-        """
-        if not self.enabled:
-            return
-
-        index_file = self.index_path / 'faiss.index'
-        mapping_file = self.index_path / 'article_mapping.pkl'
-
-        # Check if we need to rebuild
-        if not force_rebuild and index_file.exists() and mapping_file.exists():
-            print("Index already exists. Use force_rebuild=True to rebuild.")
-            return
-
-        print("Building semantic search index...")
-
-        # Get all published articles
-        articles, _ = self.kb_manager.get_all_articles(status='published', limit=10000)
-
-        if not articles:
-            print("No published articles found. Skipping index build.")
-            return
-
-        # Prepare article texts for embedding
-        article_texts = []
-        article_ids = []
-
-        for article in articles:
-            # Combine title, summary, and content for better embeddings
-            text = f"{article.title}. {article.summary or ''}. {article.content[:500]}"
-            article_texts.append(text)
-            article_ids.append(article.id)
-
-        # Generate embeddings
-        print(f"Generating embeddings for {len(article_texts)} articles...")
-        embeddings = self.model.encode(
-            article_texts,
-            convert_to_numpy=True,
-            show_progress_bar=True,
-            batch_size=32
-        )
-
-        # Create FAISS index
-        print("Creating FAISS index...")
-        index = faiss.IndexFlatL2(self.embedding_dim)  # L2 distance
-        index.add(embeddings.astype('float32'))
-
-        # Save index and mapping
-        faiss.write_index(index, str(index_file))
-
-        with open(mapping_file, 'wb') as f:
-            pickle.dump(article_ids, f)
-
-        self.index = index
-        self.article_ids = article_ids
-
-        print(f"✅ Index built successfully: {len(article_ids)} articles indexed")
-
-    def load_index(self):
-        """Load existing FAISS index"""
-        if not self.enabled:
-            return
-
-        index_file = self.index_path / 'faiss.index'
-        mapping_file = self.index_path / 'article_mapping.pkl'
-
-        if not index_file.exists() or not mapping_file.exists():
-            print("No existing index found. Run build_index() to create one.")
-            return
-
-        try:
-            self.index = faiss.read_index(str(index_file))
-
-            with open(mapping_file, 'rb') as f:
-                self.article_ids = pickle.load(f)
-
-            print(f"✅ Index loaded: {len(self.article_ids)} articles")
-
-        except Exception as e:
-            print(f"Error loading index: {e}")
-            self.index = None
-            self.article_ids = []
-
-    def update_index_for_article(self, article_id: int):
-        """
-        Update index when an article is modified
-
-        For simplicity, we rebuild the entire index.
-        In production, you'd want incremental updates.
-        """
-        if not self.enabled:
-            return
-
-        print("Rebuilding index after article update...")
-        self.build_index(force_rebuild=True)
-
-    # =============================================================================
-    # SEARCH
-    # =============================================================================
-
-    def search(
-        self,
-        query: str,
-        top_k: int = 5,
-        threshold: float = 0.5
-    ) -> List[Tuple[CXKBArticle, float]]:
-        """
-        Semantic search for articles
-
-        Args:
-            query: Search query
-            top_k: Number of results to return
-            threshold: Minimum similarity score (0-1)
-
-        Returns:
-            List of (article, similarity_score) tuples
-        """
-        if not self.enabled or self.index is None:
-            # Fallback to keyword search
-            print("Semantic search not available, using keyword search")
-            articles = self.kb_manager.search_articles(query, limit=top_k)
-            return [(article, 0.5) for article in articles]
-
-        # Generate query embedding
-        query_embedding = self.model.encode([query], convert_to_numpy=True)
-
-        # Search FAISS index
-        distances, indices = self.index.search(query_embedding.astype('float32'), top_k)
-
-        # Convert distances to similarity scores (0-1)
-        # Using exponential decay: similarity = exp(-distance)
-        similarities = np.exp(-distances[0])
-
-        # Get articles
-        results = []
-        for idx, similarity in zip(indices[0], similarities):
-            if similarity < threshold:
-                continue
-
-            article_id = self.article_ids[idx]
-            article = self.kb_manager.get_article(article_id)
-
-            if article:
-                results.append((article, float(similarity)))
-
-        return results
-
-    def hybrid_search(
-        self,
-        query: str,
-        top_k: int = 5,
-        semantic_weight: float = 0.7
-    ) -> List[Tuple[CXKBArticle, float]]:
-        """
-        Hybrid search combining semantic and keyword search
-
-        Args:
-            query: Search query
-            top_k: Number of results to return
-            semantic_weight: Weight for semantic score (0-1), keyword = 1 - semantic_weight
-
-        Returns:
-            List of (article, combined_score) tuples
-        """
-        # Get semantic results
-        semantic_results = self.search(query, top_k=top_k * 2)
-
-        # Get keyword results
-        keyword_articles = self.kb_manager.search_articles(query, limit=top_k * 2)
-
-        # Combine scores
-        combined_scores = {}
-
-        # Add semantic scores
-        for article, score in semantic_results:
-            combined_scores[article.id] = {
-                'article': article,
-                'semantic_score': score,
-                'keyword_score': 0.0
-            }
-
-        # Add keyword scores (simple presence = 0.5)
-        for article in keyword_articles:
-            if article.id in combined_scores:
-                combined_scores[article.id]['keyword_score'] = 0.5
-            else:
-                combined_scores[article.id] = {
-                    'article': article,
-                    'semantic_score': 0.0,
-                    'keyword_score': 0.5
-                }
-
-        # Calculate combined scores
-        results = []
-        for article_id, scores in combined_scores.items():
-            combined = (
-                scores['semantic_score'] * semantic_weight +
-                scores['keyword_score'] * (1 - semantic_weight)
-            )
-            results.append((scores['article'], combined))
-
-        # Sort by combined score
-        results.sort(key=lambda x: x[1], reverse=True)
-
-        return results[:top_k]
-
-    # =============================================================================
-    # RAG - RETRIEVAL AUGMENTED GENERATION
-    # =============================================================================
-
-    def get_relevant_context(
-        self,
-        query: str,
-        max_articles: int = 3,
-        max_chars: int = 2000
-    ) -> str:
-        """
-        Get relevant article content as context for AI generation
-
-        Args:
-            query: User query
-            max_articles: Maximum number of articles to include
-            max_chars: Maximum total characters
-
-        Returns:
-            Concatenated relevant article content
-        """
-        results = self.search(query, top_k=max_articles)
-
-        context_parts = []
-        total_chars = 0
-
-        for article, score in results:
-            # Build context snippet
-            snippet = f"**{article.title}**\n{article.content}\n\n"
-
-            # Check if we're over limit
-            if total_chars + len(snippet) > max_chars:
-                # Truncate last snippet
-                remaining = max_chars - total_chars
-                if remaining > 100:  # Only add if meaningful
-                    snippet = snippet[:remaining] + "..."
-                    context_parts.append(snippet)
-                break
-
-            context_parts.append(snippet)
-            total_chars += len(snippet)
-
-        return "\n".join(context_parts)
-
-    def suggest_articles_for_ticket(
-        self,
-        ticket_description: str,
-        top_k: int = 3
-    ) -> List[Tuple[CXKBArticle, float]]:
-        """
-        Suggest relevant KB articles for a support ticket
-
-        Args:
-            ticket_description: Ticket description
-            top_k: Number of suggestions
-
-        Returns:
-            List of (article, relevance_score) tuples
-        """
-        return self.search(ticket_description, top_k=top_k)
-
-    # =============================================================================
-    # ANALYTICS
-    # =============================================================================
-
-    def get_search_stats(self) -> Dict[str, Any]:
-        """Get search index statistics"""
-        if not self.enabled or self.index is None:
-            return {
-                'enabled': False,
-                'total_articles_indexed': 0,
-                'embedding_dimension': 0
-            }
-
-        return {
-            'enabled': True,
-            'total_articles_indexed': len(self.article_ids),
-            'embedding_dimension': self.embedding_dim,
-            'index_size_mb': (self.index_path / 'faiss.index').stat().st_size / (1024 * 1024) if (self.index_path / 'faiss.index').exists() else 0
-        }

modules/knowledge/ui.py

@@ -1,445 +0,0 @@
-"""
-Knowledge Base UI - Gradio interface for KB management
-"""
-
-import gradio as gr
-from typing import List, Tuple
-import pandas as pd
-
-from .manager import KnowledgeBaseManager
-from .search import SemanticSearchEngine
-
-
-class KnowledgeBaseUI:
-    """Gradio UI for knowledge base"""
-
-    def __init__(self):
-        self.manager = KnowledgeBaseManager()
-        self.search_engine = SemanticSearchEngine()
-
-    def render(self) -> gr.Blocks:
-        """Render complete KB interface"""
-
-        with gr.Blocks() as kb_interface:
-            gr.Markdown("# 📚 Knowledge Base")
-
-            with gr.Tabs():
-                # TAB 1: Browse Articles
-                with gr.Tab("📖 Articles"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            category_filter = gr.Dropdown(
-                                choices=['All'],
-                                value='All',
-                                label="Filter by Category"
-                            )
-                        with gr.Column(scale=1):
-                            status_filter = gr.Dropdown(
-                                choices=['All', 'published', 'draft', 'archived'],
-                                value='published',
-                                label="Filter by Status"
-                            )
-                        with gr.Column(scale=1):
-                            refresh_articles_btn = gr.Button("🔄 Refresh", variant="secondary")
-
-                    articles_table = gr.Dataframe(
-                        headers=["ID", "Title", "Category", "Status", "Views", "Helpful %", "Author", "Published"],
-                        label="Knowledge Base Articles",
-                        interactive=False
-                    )
-
-                    # Metrics
-                    with gr.Row():
-                        total_articles_metric = gr.Textbox(label="Total Articles", value="0")
-                        published_metric = gr.Textbox(label="Published", value="0")
-                        total_views_metric = gr.Textbox(label="Total Views", value="0")
-
-                # TAB 2: Search (Semantic)
-                with gr.Tab("🔍 Search"):
-                    gr.Markdown("### Semantic Search (RAG-Powered)")
-                    gr.Markdown("Search using AI-powered semantic similarity")
-
-                    search_query = gr.Textbox(
-                        label="Search Query",
-                        placeholder="How do I reset my password?",
-                        lines=2
-                    )
-
-                    with gr.Row():
-                        search_type = gr.Radio(
-                            choices=['Semantic', 'Keyword', 'Hybrid'],
-                            value='Semantic',
-                            label="Search Type"
-                        )
-                        top_k = gr.Slider(
-                            minimum=1,
-                            maximum=10,
-                            value=5,
-                            step=1,
-                            label="Number of Results"
-                        )
-
-                    search_btn = gr.Button("🔍 Search", variant="primary")
-
-                    search_results = gr.Markdown("Enter a query and click Search")
-
-                    # Search stats
-                    with gr.Accordion("Search Engine Stats", open=False):
-                        search_stats = gr.JSON(label="Index Statistics")
-
-                # TAB 3: Create Article
-                with gr.Tab("➕ Create Article"):
-                    gr.Markdown("### Create New Knowledge Base Article")
-
-                    with gr.Row():
-                        with gr.Column():
-                            article_title = gr.Textbox(
-                                label="Title",
-                                placeholder="How to..."
-                            )
-                            article_summary = gr.Textbox(
-                                label="Summary",
-                                placeholder="Brief description",
-                                lines=2
-                            )
-                            article_content = gr.Textbox(
-                                label="Content (Markdown)",
-                                placeholder="# Getting Started\n\nDetailed instructions...",
-                                lines=10
-                            )
-
-                        with gr.Column():
-                            article_category = gr.Dropdown(
-                                choices=['General', 'Technical', 'Billing', 'Account'],
-                                value='General',
-                                label="Category"
-                            )
-                            article_status = gr.Dropdown(
-                                choices=['draft', 'published'],
-                                value='draft',
-                                label="Status"
-                            )
-                            article_visibility = gr.Dropdown(
-                                choices=['public', 'internal', 'private'],
-                                value='public',
-                                label="Visibility"
-                            )
-                            article_tags = gr.Textbox(
-                                label="Tags (comma-separated)",
-                                placeholder="password, login, security"
-                            )
-                            article_author = gr.Textbox(
-                                label="Author",
-                                value="Support Team"
-                            )
-
-                    create_article_btn = gr.Button("Create Article", variant="primary")
-                    create_article_output = gr.Textbox(label="Result", lines=2)
-
-                # TAB 4: View/Edit Article
-                with gr.Tab("✏️ Edit Article"):
-                    with gr.Row():
-                        edit_article_id = gr.Number(label="Article ID", precision=0)
-                        load_article_btn = gr.Button("Load Article", variant="secondary")
-
-                    with gr.Row():
-                        with gr.Column():
-                            edit_title = gr.Textbox(label="Title")
-                            edit_summary = gr.Textbox(label="Summary", lines=2)
-                            edit_content = gr.Textbox(label="Content", lines=10)
-
-                        with gr.Column():
-                            edit_status = gr.Dropdown(
-                                choices=['draft', 'published', 'archived'],
-                                label="Status"
-                            )
-                            edit_visibility = gr.Dropdown(
-                                choices=['public', 'internal', 'private'],
-                                label="Visibility"
-                            )
-                            changed_by = gr.Textbox(label="Changed By", value="Editor")
-                            change_note = gr.Textbox(label="Change Note", placeholder="What did you change?")
-
-                            update_article_btn = gr.Button("Update Article", variant="primary")
-
-                    edit_output = gr.Textbox(label="Result", lines=2)
-
-                    # Article versions
-                    gr.Markdown("### 📜 Version History")
-                    versions_table = gr.Dataframe(
-                        headers=["Version", "Changed By", "Date", "Note"],
-                        label="Versions",
-                        interactive=False
-                    )
-
-                # TAB 5: Index Management
-                with gr.Tab("⚙️ Index Management"):
-                    gr.Markdown("### Semantic Search Index")
-                    gr.Markdown("Build and manage the FAISS vector index for semantic search")
-
-                    index_stats_display = gr.JSON(label="Index Statistics")
-
-                    with gr.Row():
-                        build_index_btn = gr.Button("🔨 Build Index", variant="primary")
-                        rebuild_index_btn = gr.Button("🔄 Rebuild Index (Force)", variant="secondary")
-
-                    index_output = gr.Textbox(label="Build Output", lines=5)
-
-            # =============================================================================
-            # EVENT HANDLERS
-            # =============================================================================
-
-            def load_articles(category, status):
-                """Load articles with filters"""
-                try:
-                    status_filter = None if status == 'All' else status
-
-                    articles, total = self.manager.get_all_articles(
-                        status=status_filter,
-                        limit=100
-                    )
-
-                    rows = []
-                    for article in articles:
-                        # Calculate helpfulness percentage
-                        total_votes = article.helpful_count + article.not_helpful_count
-                        helpful_pct = f"{int(article.helpfulness_score() * 100)}%" if total_votes > 0 else "N/A"
-
-                        rows.append([
-                            article.id,
-                            article.title[:60],
-                            article.category.name if article.category else "Uncategorized",
-                            article.status,
-                            article.view_count,
-                            helpful_pct,
-                            article.author or "Unknown",
-                            article.published_at.strftime("%Y-%m-%d") if article.published_at else "Not published"
-                        ])
-
-                    # Get stats
-                    stats = self.manager.get_kb_stats()
-
-                    return (
-                        rows,
-                        str(stats['total_articles']),
-                        str(stats['published_articles']),
-                        str(stats['total_views'])
-                    )
-
-                except Exception as e:
-                    return [], f"Error: {e}", "0", "0"
-
-            def perform_search(query, search_type, top_k_val):
-                """Perform semantic or keyword search"""
-                if not query:
-                    return "Please enter a search query"
-
-                try:
-                    if search_type == 'Semantic':
-                        results = self.search_engine.search(query, top_k=int(top_k_val))
-                    elif search_type == 'Keyword':
-                        articles = self.manager.search_articles(query, limit=int(top_k_val))
-                        results = [(article, 0.5) for article in articles]
-                    else:  # Hybrid
-                        results = self.search_engine.hybrid_search(query, top_k=int(top_k_val))
-
-                    if not results:
-                        return "No results found"
-
-                    # Format results
-                    output = f"## Search Results for: '{query}'\n\n"
-                    output += f"Found {len(results)} relevant articles:\n\n"
-
-                    for i, (article, score) in enumerate(results, 1):
-                        # Calculate helpfulness
-                        total_votes = article.helpful_count + article.not_helpful_count
-                        helpful_pct = int(article.helpfulness_score() * 100) if total_votes > 0 else 0
-
-                        output += f"### {i}. {article.title}\n"
-                        output += f"**Relevance Score:** {score:.2f} | "
-                        output += f"**Views:** {article.view_count} | "
-                        output += f"**Helpfulness:** {helpful_pct}%\n\n"
-                        output += f"{article.summary or article.content[:200]}...\n\n"
-                        output += f"[View Article #{article.id}]\n\n"
-                        output += "---\n\n"
-
-                    return output
-
-                except Exception as e:
-                    return f"❌ Search error: {str(e)}"
-
-            def get_search_engine_stats():
-                """Get search engine statistics"""
-                stats = self.search_engine.get_search_stats()
-                # Return same stats for both outputs
-                return stats, stats
-
-            def create_new_article(title, summary, content, category, status, visibility, tags, author):
-                """Create new article"""
-                if not title or not content:
-                    return "❌ Title and content are required"
-
-                try:
-                    # Parse tags
-                    tag_list = [t.strip() for t in tags.split(',')] if tags else None
-
-                    article = self.manager.create_article(
-                        title=title,
-                        summary=summary,
-                        content=content,
-                        author=author,
-                        tags=tag_list,
-                        status=status,
-                        visibility=visibility
-                    )
-
-                    # Update search index if published
-                    if status == 'published':
-                        self.search_engine.update_index_for_article(article.id)
-
-                    return f"✅ Article #{article.id} created successfully! Slug: {article.slug}"
-
-                except Exception as e:
-                    return f"❌ Error creating article: {str(e)}"
-
-            def load_article_for_edit(article_id):
-                """Load article into edit form"""
-                if not article_id:
-                    return "", "", "", "", "", []
-
-                try:
-                    article = self.manager.get_article(int(article_id))
-                    if not article:
-                        return "Article not found", "", "", "", "", []
-
-                    # Load versions
-                    versions = self.manager.get_article_versions(int(article_id))
-                    version_rows = []
-                    for v in versions:
-                        version_rows.append([
-                            v.version,
-                            v.changed_by or "Unknown",
-                            v.created_at.strftime("%Y-%m-%d %H:%M") if v.created_at else "",
-                            v.change_note or ""
-                        ])
-
-                    return (
-                        article.title,
-                        article.summary or "",
-                        article.content,
-                        article.status,
-                        article.visibility,
-                        version_rows
-                    )
-
-                except Exception as e:
-                    return f"Error: {e}", "", "", "", "", []
-
-            def update_article_content(article_id, title, summary, content, status, visibility, changed_by_val, change_note_val):
-                """Update article"""
-                if not article_id:
-                    return "Please enter article ID"
-
-                try:
-                    article = self.manager.update_article(
-                        article_id=int(article_id),
-                        title=title,
-                        summary=summary,
-                        content=content,
-                        status=status,
-                        visibility=visibility,
-                        changed_by=changed_by_val,
-                        change_note=change_note_val
-                    )
-
-                    # Update search index if published
-                    if status == 'published':
-                        self.search_engine.update_index_for_article(article.id)
-
-                    return f"✅ Article #{article.id} updated successfully (version {article.version})"
-
-                except Exception as e:
-                    return f"❌ Error: {str(e)}"
-
-            def build_search_index(force=False):
-                """Build semantic search index"""
-                try:
-                    output = "Building semantic search index...\n"
-                    self.search_engine.build_index(force_rebuild=force)
-                    stats = self.search_engine.get_search_stats()
-                    output += f"\n✅ Index built successfully!\n"
-                    output += f"Articles indexed: {stats.get('total_articles_indexed', 0)}\n"
-                    output += f"Embedding dimension: {stats.get('embedding_dimension', 0)}\n"
-                    return output
-                except Exception as e:
-                    return f"❌ Error building index: {str(e)}"
-
-            # Wire up events
-            refresh_articles_btn.click(
-                fn=load_articles,
-                inputs=[category_filter, status_filter],
-                outputs=[articles_table, total_articles_metric, published_metric, total_views_metric]
-            )
-
-            status_filter.change(
-                fn=load_articles,
-                inputs=[category_filter, status_filter],
-                outputs=[articles_table, total_articles_metric, published_metric, total_views_metric]
-            )
-
-            search_btn.click(
-                fn=perform_search,
-                inputs=[search_query, search_type, top_k],
-                outputs=[search_results]
-            )
-
-            create_article_btn.click(
-                fn=create_new_article,
-                inputs=[article_title, article_summary, article_content, article_category,
-                       article_status, article_visibility, article_tags, article_author],
-                outputs=[create_article_output]
-            )
-
-            load_article_btn.click(
-                fn=load_article_for_edit,
-                inputs=[edit_article_id],
-                outputs=[edit_title, edit_summary, edit_content, edit_status,
-                        edit_visibility, versions_table]
-            )
-
-            update_article_btn.click(
-                fn=update_article_content,
-                inputs=[edit_article_id, edit_title, edit_summary, edit_content,
-                       edit_status, edit_visibility, changed_by, change_note],
-                outputs=[edit_output]
-            )
-
-            build_index_btn.click(
-                fn=lambda: build_search_index(force=False),
-                outputs=[index_output]
-            )
-
-            rebuild_index_btn.click(
-                fn=lambda: build_search_index(force=True),
-                outputs=[index_output]
-            )
-
-            # Load initial data
-            kb_interface.load(
-                fn=load_articles,
-                inputs=[category_filter, status_filter],
-                outputs=[articles_table, total_articles_metric, published_metric, total_views_metric]
-            )
-
-            kb_interface.load(
-                fn=get_search_engine_stats,
-                outputs=[search_stats, index_stats_display]
-            )
-
-        return kb_interface
-
-
-def render_kb_ui() -> gr.Blocks:
-    """Convenience function to render KB UI"""
-    ui = KnowledgeBaseUI()
-    return ui.render()

modules/tickets/__init__.py

@@ -1,9 +0,0 @@
-"""
-Ticket Management Module
-Handles customer support tickets, SLA tracking, and AI-powered routing
-"""
-
-from .manager import TicketManager
-from .ui import render_ticket_ui
-
-__all__ = ['TicketManager', 'render_ticket_ui']

modules/tickets/manager.py

@@ -1,552 +0,0 @@
-"""
-Ticket Manager - Business logic for ticket operations
-Handles CRUD, SLA tracking, routing, and AI categorization
-"""
-
-from typing import Optional, List, Dict, Any, Tuple
-from datetime import datetime, timedelta
-from sqlalchemy.orm import Session
-from sqlalchemy import and_, or_, desc, func
-import json
-
-from models.cx_models import CXTicket, CXTicketMessage, CXCustomer, CXInteraction
-from database.manager import get_db_manager
-
-
-class TicketManager:
-    """Manages all ticket operations"""
-
-    def __init__(self):
-        self.db = get_db_manager()
-
-        # SLA configuration (in minutes)
-        self.sla_config = {
-            'urgent': {'first_response': 15, 'resolution': 120},
-            'high': {'first_response': 60, 'resolution': 480},
-            'medium': {'first_response': 240, 'resolution': 1440},
-            'low': {'first_response': 480, 'resolution': 2880}
-        }
-
-    # =============================================================================
-    # TICKET CRUD OPERATIONS
-    # =============================================================================
-
-    def create_ticket(
-        self,
-        customer_id: int,
-        subject: str,
-        description: str,
-        priority: str = 'medium',
-        category: Optional[str] = None,
-        source: str = 'manual',
-        tags: Optional[List[str]] = None
-    ) -> CXTicket:
-        """
-        Create a new support ticket
-
-        Args:
-            customer_id: ID of the customer creating the ticket
-            subject: Ticket subject line
-            description: Detailed description of the issue
-            priority: low, medium, high, urgent
-            category: Optional category (technical, billing, etc.)
-            source: manual, email, chat, api, web_form
-            tags: Optional list of tags
-
-        Returns:
-            Created ticket object
-        """
-        with self.db.get_session() as session:
-            # Get customer
-            customer = session.query(CXCustomer).filter_by(id=customer_id).first()
-            if not customer:
-                raise ValueError(f"Customer {customer_id} not found")
-
-            # Calculate SLA due time
-            sla_due_at = self._calculate_sla_due(priority, 'resolution')
-
-            # Create ticket
-            ticket = CXTicket(
-                customer_id=customer_id,
-                subject=subject,
-                description=description,
-                priority=priority,
-                category=category,
-                source=source,
-                status='new',
-                sla_due_at=sla_due_at
-            )
-
-            if tags:
-                ticket.set_tags(tags)
-
-            session.add(ticket)
-            session.flush()  # Get ticket ID
-
-            # Create initial system message
-            self.add_message(
-                session=session,
-                ticket_id=ticket.id,
-                sender_type='system',
-                sender_id='system',
-                sender_name='System',
-                message=f"Ticket created by {customer.full_name}",
-                is_internal=True
-            )
-
-            # Update customer stats
-            customer.total_tickets += 1
-            customer.last_interaction_at = datetime.utcnow()
-
-            # Create interaction record
-            interaction = CXInteraction(
-                customer_id=customer_id,
-                type='ticket',
-                channel='web',
-                summary=subject,
-                reference_type='ticket',
-                reference_id=ticket.id,
-                occurred_at=datetime.utcnow()
-            )
-            session.add(interaction)
-
-            session.commit()
-            session.refresh(ticket)
-
-            return ticket
-
-    def get_ticket(self, ticket_id: int) -> Optional[CXTicket]:
-        """Get ticket by ID"""
-        with self.db.get_session() as session:
-            ticket = session.query(CXTicket).filter_by(id=ticket_id).first()
-            if ticket:
-                # Eagerly load relationships
-                _ = ticket.customer
-                _ = ticket.messages
-            return ticket
-
-    def get_all_tickets(
-        self,
-        status: Optional[str] = None,
-        priority: Optional[str] = None,
-        assigned_to: Optional[str] = None,
-        customer_id: Optional[int] = None,
-        limit: int = 100,
-        offset: int = 0
-    ) -> Tuple[List[CXTicket], int]:
-        """
-        Get tickets with optional filters
-
-        Returns:
-            Tuple of (tickets list, total count)
-        """
-        with self.db.get_session() as session:
-            query = session.query(CXTicket)
-
-            # Apply filters
-            if status:
-                query = query.filter(CXTicket.status == status)
-            if priority:
-                query = query.filter(CXTicket.priority == priority)
-            if assigned_to:
-                query = query.filter(CXTicket.assigned_to == assigned_to)
-            if customer_id:
-                query = query.filter(CXTicket.customer_id == customer_id)
-
-            # Get total count
-            total = query.count()
-
-            # Apply pagination and ordering
-            tickets = query.order_by(desc(CXTicket.created_at)).limit(limit).offset(offset).all()
-
-            # Eagerly load customers
-            for ticket in tickets:
-                _ = ticket.customer
-
-            return tickets, total
-
-    def update_ticket(
-        self,
-        ticket_id: int,
-        **updates
-    ) -> CXTicket:
-        """
-        Update ticket fields
-
-        Args:
-            ticket_id: ID of ticket to update
-            **updates: Fields to update (status, priority, category, assigned_to, etc.)
-        """
-        with self.db.get_session() as session:
-            ticket = session.query(CXTicket).filter_by(id=ticket_id).first()
-            if not ticket:
-                raise ValueError(f"Ticket {ticket_id} not found")
-
-            # Track status changes for metrics
-            old_status = ticket.status
-
-            # Update fields
-            for key, value in updates.items():
-                if hasattr(ticket, key):
-                    setattr(ticket, key, value)
-
-            # Update timestamps based on status changes
-            if 'status' in updates:
-                new_status = updates['status']
-
-                if new_status == 'resolved' and old_status != 'resolved':
-                    ticket.resolved_at = datetime.utcnow()
-                    # Calculate resolution time
-                    if ticket.created_at:
-                        delta = datetime.utcnow() - ticket.created_at
-                        ticket.resolution_time_minutes = int(delta.total_seconds() / 60)
-
-                elif new_status == 'closed' and old_status != 'closed':
-                    ticket.closed_at = datetime.utcnow()
-
-                # Track reopened tickets
-                elif new_status == 'open' and old_status in ['resolved', 'closed']:
-                    ticket.reopened_count += 1
-
-            session.commit()
-            session.refresh(ticket)
-
-            return ticket
-
-    def delete_ticket(self, ticket_id: int) -> bool:
-        """Delete a ticket (soft delete - set status to 'deleted')"""
-        with self.db.get_session() as session:
-            ticket = session.query(CXTicket).filter_by(id=ticket_id).first()
-            if not ticket:
-                return False
-
-            ticket.status = 'deleted'
-            session.commit()
-            return True
-
-    # =============================================================================
-    # TICKET MESSAGES
-    # =============================================================================
-
-    def add_message(
-        self,
-        ticket_id: int = None,
-        session: Session = None,
-        sender_type: str = 'agent',
-        sender_id: Optional[str] = None,
-        sender_name: Optional[str] = None,
-        message: str = '',
-        is_internal: bool = False,
-        sentiment: Optional[str] = None,
-        intent: Optional[str] = None
-    ) -> CXTicketMessage:
-        """
-        Add a message to a ticket
-
-        Args:
-            ticket_id: ID of the ticket
-            session: Optional existing session (for transactions)
-            sender_type: customer, agent, system, ai_bot
-            sender_id: ID of the sender
-            sender_name: Display name of sender
-            message: Message content
-            is_internal: True for internal notes
-            sentiment: Optional sentiment (positive, neutral, negative)
-            intent: Optional intent (question, complaint, praise, feedback)
-        """
-        def _add_msg(sess):
-            ticket = sess.query(CXTicket).filter_by(id=ticket_id).first()
-            if not ticket:
-                raise ValueError(f"Ticket {ticket_id} not found")
-
-            msg = CXTicketMessage(
-                ticket_id=ticket_id,
-                sender_type=sender_type,
-                sender_id=sender_id,
-                sender_name=sender_name,
-                message=message,
-                is_internal=is_internal,
-                sentiment=sentiment,
-                intent=intent
-            )
-
-            sess.add(msg)
-
-            # Update first response time if this is first agent response
-            if sender_type == 'agent' and not ticket.first_response_at:
-                ticket.first_response_at = datetime.utcnow()
-                if ticket.created_at:
-                    delta = datetime.utcnow() - ticket.created_at
-                    ticket.response_time_minutes = int(delta.total_seconds() / 60)
-
-            # Auto-open ticket if it's new
-            if ticket.status == 'new' and sender_type == 'agent':
-                ticket.status = 'open'
-
-            sess.flush()
-            return msg
-
-        if session:
-            return _add_msg(session)
-        else:
-            with self.db.get_session() as sess:
-                msg = _add_msg(sess)
-                sess.commit()
-                sess.refresh(msg)
-                return msg
-
-    def get_ticket_messages(
-        self,
-        ticket_id: int,
-        include_internal: bool = True
-    ) -> List[CXTicketMessage]:
-        """Get all messages for a ticket"""
-        with self.db.get_session() as session:
-            query = session.query(CXTicketMessage).filter(
-                CXTicketMessage.ticket_id == ticket_id
-            )
-
-            if not include_internal:
-                query = query.filter(CXTicketMessage.is_internal == False)
-
-            messages = query.order_by(CXTicketMessage.created_at).all()
-            return messages
-
-    # =============================================================================
-    # TICKET ASSIGNMENT & ROUTING
-    # =============================================================================
-
-    def assign_ticket(
-        self,
-        ticket_id: int,
-        agent_id: str,
-        agent_name: Optional[str] = None
-    ) -> CXTicket:
-        """Assign ticket to an agent"""
-        with self.db.get_session() as session:
-            ticket = session.query(CXTicket).filter_by(id=ticket_id).first()
-            if not ticket:
-                raise ValueError(f"Ticket {ticket_id} not found")
-
-            old_assignee = ticket.assigned_to
-            ticket.assigned_to = agent_id
-
-            # Add system message
-            if old_assignee:
-                msg = f"Ticket reassigned from {old_assignee} to {agent_name or agent_id}"
-            else:
-                msg = f"Ticket assigned to {agent_name or agent_id}"
-
-            self.add_message(
-                session=session,
-                ticket_id=ticket_id,
-                sender_type='system',
-                sender_id='system',
-                sender_name='System',
-                message=msg,
-                is_internal=True
-            )
-
-            # Update status if needed
-            if ticket.status == 'new':
-                ticket.status = 'open'
-
-            session.commit()
-            session.refresh(ticket)
-
-            return ticket
-
-    def auto_route_ticket(self, ticket_id: int) -> str:
-        """
-        Automatically route ticket to best agent/team
-        Uses AI categorization and workload balancing
-
-        Returns:
-            agent_id that ticket was assigned to
-        """
-        # TODO: Implement smart routing based on:
-        # 1. Ticket category
-        # 2. Agent skills/expertise
-        # 3. Current workload
-        # 4. SLA priority
-
-        # For now, simple round-robin
-        agent_id = "agent_1"  # Placeholder
-        self.assign_ticket(ticket_id, agent_id, "Auto-Assigned Agent")
-        return agent_id
-
-    # =============================================================================
-    # SLA MANAGEMENT
-    # =============================================================================
-
-    def _calculate_sla_due(self, priority: str, sla_type: str) -> datetime:
-        """Calculate SLA due time based on priority"""
-        minutes = self.sla_config.get(priority, {}).get(sla_type, 1440)
-        return datetime.utcnow() + timedelta(minutes=minutes)
-
-    def get_overdue_tickets(self) -> List[CXTicket]:
-        """Get all tickets that are past their SLA"""
-        with self.db.get_session() as session:
-            now = datetime.utcnow()
-            tickets = session.query(CXTicket).filter(
-                and_(
-                    CXTicket.sla_due_at < now,
-                    CXTicket.status.in_(['new', 'open', 'pending'])
-                )
-            ).order_by(CXTicket.sla_due_at).all()
-
-            return tickets
-
-    def get_tickets_by_sla_status(self) -> Dict[str, List[CXTicket]]:
-        """
-        Categorize tickets by SLA status
-
-        Returns:
-            Dict with keys: 'breached', 'at_risk', 'on_track'
-        """
-        with self.db.get_session() as session:
-            now = datetime.utcnow()
-            at_risk_threshold = now + timedelta(hours=2)
-
-            all_open = session.query(CXTicket).filter(
-                CXTicket.status.in_(['new', 'open', 'pending'])
-            ).all()
-
-            result = {
-                'breached': [],
-                'at_risk': [],
-                'on_track': []
-            }
-
-            for ticket in all_open:
-                if not ticket.sla_due_at:
-                    result['on_track'].append(ticket)
-                elif ticket.sla_due_at < now:
-                    result['breached'].append(ticket)
-                elif ticket.sla_due_at < at_risk_threshold:
-                    result['at_risk'].append(ticket)
-                else:
-                    result['on_track'].append(ticket)
-
-            return result
-
-    # =============================================================================
-    # ANALYTICS & REPORTING
-    # =============================================================================
-
-    def get_ticket_stats(
-        self,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None
-    ) -> Dict[str, Any]:
-        """Get ticket statistics for a date range"""
-        with self.db.get_session() as session:
-            query = session.query(CXTicket)
-
-            if start_date:
-                query = query.filter(CXTicket.created_at >= start_date)
-            if end_date:
-                query = query.filter(CXTicket.created_at <= end_date)
-
-            tickets = query.all()
-
-            # Calculate stats
-            total = len(tickets)
-            by_status = {}
-            by_priority = {}
-            resolved_times = []
-            response_times = []
-
-            for ticket in tickets:
-                # Count by status
-                by_status[ticket.status] = by_status.get(ticket.status, 0) + 1
-
-                # Count by priority
-                by_priority[ticket.priority] = by_priority.get(ticket.priority, 0) + 1
-
-                # Collect resolution times
-                if ticket.resolution_time_minutes:
-                    resolved_times.append(ticket.resolution_time_minutes)
-
-                # Collect response times
-                if ticket.response_time_minutes:
-                    response_times.append(ticket.response_time_minutes)
-
-            return {
-                'total_tickets': total,
-                'by_status': by_status,
-                'by_priority': by_priority,
-                'avg_resolution_time_minutes': sum(resolved_times) / len(resolved_times) if resolved_times else 0,
-                'avg_response_time_minutes': sum(response_times) / len(response_times) if response_times else 0,
-                'resolution_rate': by_status.get('resolved', 0) / total if total > 0 else 0
-            }
-
-    # =============================================================================
-    # AI FEATURES
-    # =============================================================================
-
-    def analyze_sentiment(self, text: str) -> str:
-        """
-        Analyze sentiment of ticket description or message
-
-        Returns:
-            'positive', 'neutral', or 'negative'
-        """
-        # TODO: Implement with AI agent
-        # For now, simple keyword-based
-
-        negative_keywords = ['angry', 'frustrated', 'terrible', 'worst', 'hate', 'disappointed']
-        positive_keywords = ['thanks', 'great', 'excellent', 'love', 'appreciate', 'wonderful']
-
-        text_lower = text.lower()
-
-        neg_count = sum(1 for word in negative_keywords if word in text_lower)
-        pos_count = sum(1 for word in positive_keywords if word in text_lower)
-
-        if neg_count > pos_count:
-            return 'negative'
-        elif pos_count > neg_count:
-            return 'positive'
-        else:
-            return 'neutral'
-
-    def suggest_category(self, subject: str, description: str) -> Tuple[str, float]:
-        """
-        Suggest ticket category using AI
-
-        Returns:
-            Tuple of (suggested_category, confidence)
-        """
-        # TODO: Implement with AI agent
-        # For now, simple keyword matching
-
-        categories = {
-            'technical': ['error', 'bug', 'crash', 'not working', 'broken', 'issue'],
-            'billing': ['invoice', 'payment', 'charge', 'refund', 'subscription', 'bill'],
-            'feature_request': ['feature', 'add', 'improve', 'enhancement', 'suggest'],
-            'account': ['login', 'password', 'access', 'account', 'profile']
-        }
-
-        text = f"{subject} {description}".lower()
-
-        scores = {}
-        for category, keywords in categories.items():
-            score = sum(1 for keyword in keywords if keyword in text)
-            scores[category] = score
-
-        if max(scores.values()) > 0:
-            best_category = max(scores, key=scores.get)
-            confidence = scores[best_category] / sum(scores.values())
-            return best_category, confidence
-        else:
-            return 'general', 0.5
-
-    def suggest_response(self, ticket_id: int) -> Optional[str]:
-        """
-        Generate AI-powered response suggestion for ticket
-
-        Returns:
-            Suggested response text or None
-        """
-        # TODO: Implement with AI agent using KB articles and canned responses
-        return None

modules/tickets/ui.py

@@ -1,506 +0,0 @@
-"""
-Ticket UI - Gradio interface for ticket management
-"""
-
-import gradio as gr
-from typing import Optional, List, Tuple
-from datetime import datetime, timedelta
-import pandas as pd
-
-from .manager import TicketManager
-from models.cx_models import CXTicket, CXCustomer
-from database.manager import get_db_manager
-
-
-class TicketUI:
-    """Gradio UI components for ticket management"""
-
-    def __init__(self):
-        self.manager = TicketManager()
-        self.db = get_db_manager()
-
-    def render(self) -> gr.Blocks:
-        """Render the complete ticket management UI"""
-
-        with gr.Blocks() as ticket_interface:
-            gr.Markdown("# 🎫 Ticket Management")
-
-            with gr.Tabs():
-                # TAB 1: Ticket List
-                with gr.Tab("📋 All Tickets"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            status_filter = gr.Dropdown(
-                                choices=['All', 'new', 'open', 'pending', 'resolved', 'closed'],
-                                value='All',
-                                label="Filter by Status"
-                            )
-                        with gr.Column(scale=1):
-                            priority_filter = gr.Dropdown(
-                                choices=['All', 'urgent', 'high', 'medium', 'low'],
-                                value='All',
-                                label="Filter by Priority"
-                            )
-                        with gr.Column(scale=1):
-                            refresh_btn = gr.Button("🔄 Refresh", variant="secondary")
-
-                    ticket_table = gr.Dataframe(
-                        headers=[
-                            "ID", "Customer", "Subject", "Status", "Priority",
-                            "Category", "Assigned To", "Created", "SLA Status"
-                        ],
-                        datatype=["number", "str", "str", "str", "str", "str", "str", "str", "str"],
-                        label="Support Tickets",
-                        interactive=False,
-                        wrap=True
-                    )
-
-                    # Metrics row
-                    with gr.Row():
-                        total_tickets_metric = gr.Textbox(label="Total Tickets", value="0")
-                        open_tickets_metric = gr.Textbox(label="Open Tickets", value="0")
-                        overdue_tickets_metric = gr.Textbox(label="Overdue", value="0")
-                        avg_response_metric = gr.Textbox(label="Avg Response Time", value="0 min")
-
-                # TAB 2: Create New Ticket
-                with gr.Tab("➕ Create Ticket"):
-                    gr.Markdown("### Create New Support Ticket")
-
-                    with gr.Row():
-                        with gr.Column():
-                            customer_email = gr.Textbox(
-                                label="Customer Email",
-                                placeholder="[email protected]"
-                            )
-                            ticket_subject = gr.Textbox(
-                                label="Subject",
-                                placeholder="Brief description of the issue"
-                            )
-                            ticket_description = gr.Textbox(
-                                label="Description",
-                                placeholder="Detailed description of the issue",
-                                lines=5
-                            )
-
-                        with gr.Column():
-                            ticket_priority = gr.Dropdown(
-                                choices=['low', 'medium', 'high', 'urgent'],
-                                value='medium',
-                                label="Priority"
-                            )
-                            ticket_category = gr.Dropdown(
-                                choices=['technical', 'billing', 'feature_request', 'account', 'general'],
-                                value='general',
-                                label="Category"
-                            )
-                            ticket_source = gr.Dropdown(
-                                choices=['manual', 'email', 'chat', 'web_form', 'api'],
-                                value='manual',
-                                label="Source"
-                            )
-
-                    create_ticket_btn = gr.Button("Create Ticket", variant="primary")
-                    create_ticket_output = gr.Textbox(label="Result", lines=2)
-
-                # TAB 3: Ticket Details
-                with gr.Tab("🔍 Ticket Details"):
-                    with gr.Row():
-                        ticket_id_input = gr.Number(label="Ticket ID", precision=0)
-                        load_ticket_btn = gr.Button("Load Ticket", variant="secondary")
-
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            ticket_info = gr.Markdown("Select a ticket to view details")
-
-                            gr.Markdown("### 💬 Conversation")
-                            ticket_messages = gr.Dataframe(
-                                headers=["Time", "Sender", "Message", "Type"],
-                                label="Messages",
-                                interactive=False
-                            )
-
-                            # Reply section
-                            with gr.Row():
-                                reply_message = gr.Textbox(
-                                    label="Add Reply",
-                                    placeholder="Type your response...",
-                                    lines=3
-                                )
-                            with gr.Row():
-                                reply_as_agent_btn = gr.Button("Send as Agent", variant="primary")
-                                add_internal_note_btn = gr.Button("Add Internal Note")
-
-                        with gr.Column(scale=1):
-                            gr.Markdown("### ⚙️ Actions")
-
-                            update_status = gr.Dropdown(
-                                choices=['new', 'open', 'pending', 'resolved', 'closed'],
-                                label="Update Status"
-                            )
-                            update_status_btn = gr.Button("Update Status")
-
-                            update_priority = gr.Dropdown(
-                                choices=['low', 'medium', 'high', 'urgent'],
-                                label="Update Priority"
-                            )
-                            update_priority_btn = gr.Button("Update Priority")
-
-                            assign_to_input = gr.Textbox(label="Assign To (Agent ID)")
-                            assign_btn = gr.Button("Assign Ticket")
-
-                            action_output = gr.Textbox(label="Action Result", lines=2)
-
-                # TAB 4: SLA Dashboard
-                with gr.Tab("⏰ SLA Dashboard"):
-                    gr.Markdown("## Service Level Agreement Monitoring")
-
-                    refresh_sla_btn = gr.Button("🔄 Refresh SLA Status", variant="secondary")
-
-                    with gr.Row():
-                        breached_count = gr.Textbox(label="🔴 SLA Breached", value="0")
-                        at_risk_count = gr.Textbox(label="🟡 At Risk", value="0")
-                        on_track_count = gr.Textbox(label="🟢 On Track", value="0")
-
-                    gr.Markdown("### 🔴 Breached SLA Tickets")
-                    breached_table = gr.Dataframe(
-                        headers=["ID", "Customer", "Subject", "Priority", "Due", "Overdue By"],
-                        label="Tickets Past SLA",
-                        interactive=False
-                    )
-
-                    gr.Markdown("### 🟡 At Risk Tickets (Due within 2 hours)")
-                    at_risk_table = gr.Dataframe(
-                        headers=["ID", "Customer", "Subject", "Priority", "Due In"],
-                        label="Tickets At Risk",
-                        interactive=False
-                    )
-
-            # =============================================================================
-            # EVENT HANDLERS
-            # =============================================================================
-
-            def load_ticket_list(status_filter_val, priority_filter_val):
-                """Load and display tickets based on filters"""
-                try:
-                    status = None if status_filter_val == 'All' else status_filter_val
-                    priority = None if priority_filter_val == 'All' else priority_filter_val
-
-                    tickets, total = self.manager.get_all_tickets(
-                        status=status,
-                        priority=priority,
-                        limit=100
-                    )
-                except Exception as e:
-                    error_msg = f"Database error: {str(e)}"
-                    return [[error_msg, "", "", "", "", "", "", "", ""]], "Error", "0", "0", "0 min"
-
-                # Build table data
-                rows = []
-                open_count = 0
-                overdue_count = 0
-
-                for ticket in tickets:
-                    # SLA status
-                    if ticket.is_overdue():
-                        sla_status = "🔴 OVERDUE"
-                        overdue_count += 1
-                    elif ticket.sla_due_at:
-                        time_left = ticket.sla_due_at - datetime.utcnow()
-                        if time_left.total_seconds() < 7200:  # 2 hours
-                            sla_status = f"🟡 {int(time_left.total_seconds() / 60)} min"
-                        else:
-                            sla_status = f"🟢 {int(time_left.total_seconds() / 3600)} hrs"
-                    else:
-                        sla_status = "N/A"
-
-                    if ticket.status in ['new', 'open', 'pending']:
-                        open_count += 1
-
-                    rows.append([
-                        ticket.id,
-                        ticket.customer.full_name if ticket.customer else "Unknown",
-                        ticket.subject[:50],
-                        self._format_status_badge(ticket.status),
-                        self._format_priority_badge(ticket.priority),
-                        ticket.category or "N/A",
-                        ticket.assigned_to or "Unassigned",
-                        ticket.created_at.strftime("%Y-%m-%d %H:%M") if ticket.created_at else "",
-                        sla_status
-                    ])
-
-                # Calculate avg response time
-                stats = self.manager.get_ticket_stats()
-                avg_response = int(stats.get('avg_response_time_minutes', 0))
-
-                return (
-                    rows,
-                    str(total),
-                    str(open_count),
-                    str(overdue_count),
-                    f"{avg_response} min"
-                )
-
-            def create_new_ticket(email, subject, description, priority, category, source):
-                """Create a new ticket"""
-                try:
-                    # Find or create customer
-                    with self.db.get_session() as session:
-                        customer = session.query(CXCustomer).filter_by(email=email).first()
-
-                        if not customer:
-                            # Create new customer
-                            customer = CXCustomer(
-                                email=email,
-                                first_interaction_at=datetime.utcnow()
-                            )
-                            session.add(customer)
-                            session.commit()
-                            session.refresh(customer)
-
-                        customer_id = customer.id
-
-                    # Create ticket
-                    ticket = self.manager.create_ticket(
-                        customer_id=customer_id,
-                        subject=subject,
-                        description=description,
-                        priority=priority,
-                        category=category,
-                        source=source
-                    )
-
-                    return f"✅ Ticket #{ticket.id} created successfully for {email}"
-
-                except Exception as e:
-                    return f"❌ Error creating ticket: {str(e)}"
-
-            def load_ticket_details(ticket_id):
-                """Load detailed ticket information"""
-                if not ticket_id:
-                    return "Please enter a ticket ID", []
-
-                try:
-                    ticket = self.manager.get_ticket(int(ticket_id))
-                    if not ticket:
-                        return "❌ Ticket not found", []
-
-                    # Build ticket info markdown
-                    info = f"""
-### Ticket #{ticket.id}: {ticket.subject}
-
-**Customer:** {ticket.customer.full_name if ticket.customer else 'Unknown'} ({ticket.customer.email if ticket.customer else 'N/A'})
-**Status:** {self._format_status_badge(ticket.status)}
-**Priority:** {self._format_priority_badge(ticket.priority)}
-**Category:** {ticket.category or 'N/A'}
-**Assigned To:** {ticket.assigned_to or 'Unassigned'}
-**Created:** {ticket.created_at.strftime("%Y-%m-%d %H:%M") if ticket.created_at else 'N/A'}
-**SLA Due:** {ticket.sla_due_at.strftime("%Y-%m-%d %H:%M") if ticket.sla_due_at else 'N/A'}
-**Sentiment:** {ticket.sentiment or 'Unknown'}
-
-**Description:**
-{ticket.description}
-                    """
-
-                    # Load messages
-                    messages = self.manager.get_ticket_messages(int(ticket_id))
-                    message_rows = []
-
-                    for msg in messages:
-                        msg_type = "🔒 Internal" if msg.is_internal else "💬 Public"
-                        message_rows.append([
-                            msg.created_at.strftime("%H:%M") if msg.created_at else "",
-                            msg.sender_name or msg.sender_type,
-                            msg.message[:100],
-                            msg_type
-                        ])
-
-                    return info, message_rows
-
-                except Exception as e:
-                    return f"❌ Error loading ticket: {str(e)}", []
-
-            def add_reply(ticket_id, message, is_internal=False):
-                """Add a reply to ticket"""
-                if not ticket_id or not message:
-                    return "Please enter ticket ID and message"
-
-                try:
-                    self.manager.add_message(
-                        ticket_id=int(ticket_id),
-                        sender_type='agent',
-                        sender_id='agent_1',
-                        sender_name='Support Agent',
-                        message=message,
-                        is_internal=is_internal
-                    )
-                    return f"✅ {'Internal note' if is_internal else 'Reply'} added successfully"
-                except Exception as e:
-                    return f"❌ Error: {str(e)}"
-
-            def update_ticket_field(ticket_id, field, value):
-                """Update a ticket field"""
-                if not ticket_id or not value:
-                    return "Please provide ticket ID and value"
-
-                try:
-                    self.manager.update_ticket(int(ticket_id), **{field: value})
-                    return f"✅ Ticket {field} updated to: {value}"
-                except Exception as e:
-                    return f"❌ Error: {str(e)}"
-
-            def load_sla_dashboard():
-                """Load SLA dashboard data"""
-                try:
-                    sla_tickets = self.manager.get_tickets_by_sla_status()
-
-                    breached = sla_tickets['breached']
-                    at_risk = sla_tickets['at_risk']
-                    on_track = sla_tickets['on_track']
-
-                    # Build breached table
-                    breached_rows = []
-                    for ticket in breached:
-                        overdue = datetime.utcnow() - ticket.sla_due_at
-                        overdue_str = f"{int(overdue.total_seconds() / 3600)}h {int((overdue.total_seconds() % 3600) / 60)}m"
-
-                        breached_rows.append([
-                            ticket.id,
-                            ticket.customer.full_name if ticket.customer else "Unknown",
-                            ticket.subject[:40],
-                            ticket.priority,
-                            ticket.sla_due_at.strftime("%Y-%m-%d %H:%M") if ticket.sla_due_at else "",
-                            overdue_str
-                        ])
-
-                    # Build at-risk table
-                    at_risk_rows = []
-                    for ticket in at_risk:
-                        time_left = ticket.sla_due_at - datetime.utcnow()
-                        due_in = f"{int(time_left.total_seconds() / 60)} min"
-
-                        at_risk_rows.append([
-                            ticket.id,
-                            ticket.customer.full_name if ticket.customer else "Unknown",
-                            ticket.subject[:40],
-                            ticket.priority,
-                            due_in
-                        ])
-
-                    return (
-                        str(len(breached)),
-                        str(len(at_risk)),
-                        str(len(on_track)),
-                        breached_rows,
-                        at_risk_rows
-                    )
-
-                except Exception as e:
-                    return "Error", "Error", "Error", [], []
-
-            # Wire up events
-            refresh_btn.click(
-                fn=load_ticket_list,
-                inputs=[status_filter, priority_filter],
-                outputs=[ticket_table, total_tickets_metric, open_tickets_metric,
-                        overdue_tickets_metric, avg_response_metric]
-            )
-
-            status_filter.change(
-                fn=load_ticket_list,
-                inputs=[status_filter, priority_filter],
-                outputs=[ticket_table, total_tickets_metric, open_tickets_metric,
-                        overdue_tickets_metric, avg_response_metric]
-            )
-
-            priority_filter.change(
-                fn=load_ticket_list,
-                inputs=[status_filter, priority_filter],
-                outputs=[ticket_table, total_tickets_metric, open_tickets_metric,
-                        overdue_tickets_metric, avg_response_metric]
-            )
-
-            create_ticket_btn.click(
-                fn=create_new_ticket,
-                inputs=[customer_email, ticket_subject, ticket_description,
-                       ticket_priority, ticket_category, ticket_source],
-                outputs=[create_ticket_output]
-            )
-
-            load_ticket_btn.click(
-                fn=load_ticket_details,
-                inputs=[ticket_id_input],
-                outputs=[ticket_info, ticket_messages]
-            )
-
-            reply_as_agent_btn.click(
-                fn=lambda tid, msg: add_reply(tid, msg, False),
-                inputs=[ticket_id_input, reply_message],
-                outputs=[action_output]
-            )
-
-            add_internal_note_btn.click(
-                fn=lambda tid, msg: add_reply(tid, msg, True),
-                inputs=[ticket_id_input, reply_message],
-                outputs=[action_output]
-            )
-
-            update_status_btn.click(
-                fn=lambda tid, val: update_ticket_field(tid, 'status', val),
-                inputs=[ticket_id_input, update_status],
-                outputs=[action_output]
-            )
-
-            update_priority_btn.click(
-                fn=lambda tid, val: update_ticket_field(tid, 'priority', val),
-                inputs=[ticket_id_input, update_priority],
-                outputs=[action_output]
-            )
-
-            assign_btn.click(
-                fn=lambda tid, agent: update_ticket_field(tid, 'assigned_to', agent),
-                inputs=[ticket_id_input, assign_to_input],
-                outputs=[action_output]
-            )
-
-            refresh_sla_btn.click(
-                fn=load_sla_dashboard,
-                outputs=[breached_count, at_risk_count, on_track_count,
-                        breached_table, at_risk_table]
-            )
-
-            # Load initial data
-            ticket_interface.load(
-                fn=load_ticket_list,
-                inputs=[status_filter, priority_filter],
-                outputs=[ticket_table, total_tickets_metric, open_tickets_metric,
-                        overdue_tickets_metric, avg_response_metric]
-            )
-
-        return ticket_interface
-
-    def _format_status_badge(self, status: str) -> str:
-        """Format status with emoji"""
-        badges = {
-            'new': '🆕 New',
-            'open': '📂 Open',
-            'pending': '⏸️ Pending',
-            'resolved': '✅ Resolved',
-            'closed': '🔒 Closed'
-        }
-        return badges.get(status, status)
-
-    def _format_priority_badge(self, priority: str) -> str:
-        """Format priority with emoji"""
-        badges = {
-            'urgent': '🔴 Urgent',
-            'high': '🟠 High',
-            'medium': '🟡 Medium',
-            'low': '🟢 Low'
-        }
-        return badges.get(priority, priority)
-
-
-def render_ticket_ui() -> gr.Blocks:
-    """Convenience function to render ticket UI"""
-    ui = TicketUI()
-    return ui.render()