Upload 38 files

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc g++ curl && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV HF_TOKEN=""
+ENV FLASK_ENV="production"
+ENV DATABASE_PATH="/app/data/tmc_customer_service.db"
+ENV TRANSFORMERS_CACHE="/app/data/transformers_cache"
+ENV HF_HOME="/app/data/huggingface_cache"
+
+RUN mkdir -p /app/data
+
+EXPOSE 7860
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,460 @@
+import os
+import logging
+import time
+import random
+from datetime import timedelta
+import secrets
+from functools import wraps
+from flask import Flask, render_template, request, jsonify, session, redirect, url_for
+from flask_cors import CORS
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+from flask_wtf.csrf import CSRFProtect
+from openai import OpenAI
+from scripts.database import DatabaseManager
+from scripts.rag_helper import RAGHelper
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+app.config.update(
+    SECRET_KEY=os.environ.get('SECRET_KEY', secrets.token_urlsafe(32)),
+    SESSION_COOKIE_SECURE=False,
+    SESSION_COOKIE_HTTPONLY=True,
+    SESSION_COOKIE_SAMESITE='Lax',
+    PERMANENT_SESSION_LIFETIME=timedelta(hours=24),
+    SESSION_COOKIE_NAME='tmc_session',
+    WTF_CSRF_CHECK_DEFAULT=False   # Disable global CSRF for API endpoints; we use @csrf.exempt
+)
+
+# CORS with credentials support
+CORS(app, supports_credentials=True, origins=["https://moderator404-chatbot.hf.space"])
+csrf = CSRFProtect(app)
+limiter = Limiter(key_func=get_remote_address, app=app, default_limits=["1000 per hour", "100 per minute"])
+
+db = DatabaseManager()
+rag_helper = RAGHelper(use_vector_search=True)
+
+# ---------- Hugging Face Inference Providers (OpenAI-compatible) ----------
+HF_TOKEN = os.environ.get('HF_TOKEN')
+HUGGINGFACE_MODEL = "google/gemma-4-26B-A4B-it:novita"
+API_BASE_URL = "https://router.huggingface.co/v1"
+
+# Initialize client only if token exists
+if HF_TOKEN and HF_TOKEN != "dummy":
+    hf_client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+else:
+    hf_client = None
+    logger.warning("HF_TOKEN not set. Using mock responses only.")
+
+# ---------- Mock response fallback ----------
+def mock_response(message, rag_context, ticket_context):
+    msg_lower = message.lower()
+    if rag_context:
+        first_line = rag_context.split('\n')[0]
+        if len(first_line) > 20:
+            return f"Based on our knowledge base: {first_line[:200]}"
+    if any(w in msg_lower for w in ['cable','usb-c','hdmi','lightning']):
+        return "We offer high-quality cables with lifetime warranty. Check our products page for details."
+    if any(w in msg_lower for w in ['return','refund','warranty']):
+        return "30-day money-back guarantee and lifetime warranty on all cables. Contact support for returns."
+    if any(w in msg_lower for w in ['shipping','delivery']):
+        return "Free shipping on orders over $25. Most orders ship same-day."
+    if any(w in msg_lower for w in ['hello','hi','hey']):
+        return "Hello! I'm TMCBot. How can I help you today?"
+    return "I'm here to help with cables, orders, and technical support. Could you provide more details?"
+
+# -------------------------------------------------------------------
+# ChatBot class
+# -------------------------------------------------------------------
+class ChatBot:
+    def __init__(self, db_manager):
+        self.db_manager = db_manager
+
+    def get_configured_model(self):
+        return HUGGINGFACE_MODEL
+
+    def send_message(self, message, conversation_id=None, user_id=None, session_id=None):
+        if conversation_id is None:
+            conversation_id = self.db_manager.create_conversation(user_id=user_id, session_id=session_id)
+        self.db_manager.add_message(conversation_id, 'user', message)
+
+        # Get RAG and ticket context
+        rag_context = rag_helper.get_relevant_context(message)
+        ticket_context, tickets_found = self.get_controlled_ticket_context(message, user_id)
+
+        # Build system prompt
+        system_msg = "You are a helpful customer service agent for Too Many Cables. Answer concisely in 1-2 sentences."
+        if rag_context:
+            system_msg += f"\nRelevant info: {rag_context[:400]}"
+        if ticket_context and tickets_found:
+            system_msg += f"\nTicket info: {ticket_context}"
+
+        bot_response = None
+        api_worked = False
+
+        # Try Hugging Face API if client available
+        if hf_client:
+            try:
+                completion = hf_client.chat.completions.create(
+                    model=HUGGINGFACE_MODEL,
+                    messages=[
+                        {"role": "system", "content": system_msg},
+                        {"role": "user", "content": message}
+                    ],
+                    temperature=0.3,
+                    max_tokens=150,
+                    top_p=0.9,
+                )
+                bot_response = completion.choices[0].message.content.strip()
+                if bot_response:
+                    api_worked = True
+                    logger.info("HF Router API returned a response")
+                else:
+                    bot_response = None
+            except Exception as e:
+                logger.warning(f"HF Router API exception: {e}")
+
+        # Fallback to mock
+        if not api_worked:
+            bot_response = mock_response(message, rag_context, ticket_context)
+            logger.info("Using mock response (API unavailable)")
+
+        self.db_manager.add_message(conversation_id, 'assistant', bot_response, model_used=HUGGINGFACE_MODEL)
+        return {
+            'success': True,
+            'response': bot_response,
+            'conversation_id': conversation_id,
+            'response_time_ms': 0,
+            'rag_used': bool(rag_context),
+            'rag_context_length': len(rag_context),
+            'tickets_used': tickets_found
+        }
+
+    def get_conversation(self, conversation_id):
+        return self.db_manager.get_conversation_history(conversation_id)
+
+    def clear_conversation(self, conversation_id):
+        with self.db_manager.get_connection() as conn:
+            conn.execute("UPDATE conversations SET is_active = 0 WHERE id = ?", (conversation_id,))
+            conn.commit()
+        return True
+
+    def get_controlled_ticket_context(self, message, user_id):
+        import re
+        ticket_matches = re.findall(r'TMC-\d{6}', message.upper())
+        if not ticket_matches and not any(k in message.lower() for k in ['ticket','tickets']):
+            return None, False
+        if not user_id:
+            return "Please log in to view your tickets.", True
+        conn = self.db_manager.get_connection()
+        cursor = conn.cursor()
+        if ticket_matches:
+            tn = ticket_matches[0]
+            cursor.execute("SELECT ticket_number, status, priority, category, description, created_at FROM support_tickets WHERE ticket_number=? AND user_id=?", (tn, user_id))
+            t = cursor.fetchone()
+            conn.close()
+            if t:
+                return f"Ticket {t['ticket_number']}: {t['status']}, {t['priority']} priority. Created {t['created_at']}. Description: {t['description']}", True
+            return f"Ticket {tn} not found.", True
+        else:
+            cursor.execute("SELECT ticket_number, status, priority, category, created_at FROM support_tickets WHERE user_id=? AND status!='closed' ORDER BY created_at DESC LIMIT 5", (user_id,))
+            tickets = cursor.fetchall()
+            conn.close()
+            if not tickets:
+                return "You have no open tickets.", True
+            result = "Your recent tickets:\n" + "\n".join(f"- {t['ticket_number']}: {t['status']} ({t['priority']}) - {t['category']}" for t in tickets)
+            return result, True
+
+    def get_user_ticket_context(self, user_id):
+        if not user_id:
+            return None
+        conn = self.db_manager.get_connection()
+        cursor = conn.cursor()
+        cursor.execute("SELECT ticket_number, subject, status, priority, category, created_at FROM support_tickets WHERE user_id=? AND status!='closed' ORDER BY created_at DESC", (user_id,))
+        tickets = cursor.fetchall()
+        conn.close()
+        return {"tickets": [dict(t) for t in tickets], "user_name": "Customer"}
+
+    def create_ticket_from_chat(self, user_id, subject, description, category, priority, conversation_id):
+        return self.db_manager.create_support_ticket(user_id, subject, description, category, conversation_id, priority)
+
+    def add_conversation_summary_to_tickets(self, conversation_id):
+        logger.info(f"Summary for conversation {conversation_id} would be added here.")
+        return True
+
+chatbot = ChatBot(db)
+
+# -------------------------------------------------------------------
+# Authentication helpers
+# -------------------------------------------------------------------
+def is_authenticated():
+    sid = session.get('session_id')
+    uid = session.get('user_id')
+    if not sid or not uid:
+        return False
+    user = db.get_user_by_session(sid)
+    return user and user['id'] == uid
+
+def require_auth(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        if not is_authenticated():
+            return jsonify({'success': False, 'error': 'Authentication required'}), 401
+        return f(*args, **kwargs)
+    return decorated
+
+def require_role(role):
+    def decorator(f):
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            uid = session.get('user_id')
+            if not uid:
+                return jsonify({'error': 'Auth required'}), 401
+            user_role = db.get_user_role(uid)
+            if user_role != role:
+                return jsonify({'error': 'Insufficient privileges'}), 403
+            return f(*args, **kwargs)
+        return decorated
+    return decorator
+
+# -------------------------------------------------------------------
+# Web Routes
+# -------------------------------------------------------------------
+@app.route('/')
+def homepage():
+    return render_template('homepage.html')
+
+@app.route('/products')
+def products():
+    return render_template('products.html')
+
+@app.route('/chat')
+def chat():
+    # Cache busting for static files
+    cache_bust = int(time.time())
+    return render_template('chat.html', configured_model=chatbot.get_configured_model(), cache_bust=cache_bust)
+
+@app.route('/tickets')
+def tickets():
+    return render_template('tickets.html')
+
+@app.route('/admin')
+def admin():
+    return redirect(url_for('admin_tickets'))
+
+@app.route('/admin/tickets')
+@require_role('admin')
+def admin_tickets():
+    return render_template('admin_tickets.html')
+
+# -------------------------------------------------------------------
+# API Endpoints (all exempt from CSRF)
+# -------------------------------------------------------------------
+@app.route('/api/chat', methods=['POST'])
+@csrf.exempt
+def api_chat():
+    data = request.get_json()
+    message = data.get('message')
+    conv_id = data.get('conversation_id')
+    if not message:
+        return jsonify({'success': False, 'error': 'Message required'}), 400
+    result = chatbot.send_message(message, conv_id, session.get('user_id'), session.get('session_id'))
+    return jsonify(result)
+
+@app.route('/api/conversation/<conversation_id>')
+def get_conversation(conversation_id):
+    return jsonify({'success': True, 'messages': chatbot.get_conversation(conversation_id)})
+
+@app.route('/api/conversation/<conversation_id>/clear', methods=['POST'])
+@csrf.exempt
+def clear_conversation(conversation_id):
+    return jsonify({'success': chatbot.clear_conversation(conversation_id)})
+
+@app.route('/api/conversation/end', methods=['POST'])
+@csrf.exempt
+def end_conversation():
+    data = request.get_json()
+    conv_id = data.get('conversation_id')
+    if conv_id:
+        chatbot.add_conversation_summary_to_tickets(conv_id)
+    return jsonify({'success': True, 'message': 'Conversation ended'})
+
+@app.route('/api/login', methods=['POST'])
+@csrf.exempt
+def login():
+    data = request.get_json()
+    user = db.authenticate_user(data.get('email'), data.get('password'))
+    if user:
+        sid = db.create_session(user['id'], request.remote_addr, request.headers.get('User-Agent', ''))
+        session['user_id'] = user['id']
+        session['session_id'] = sid
+        return jsonify({'success': True, 'user': {'id': user['id'], 'email': user['email'], 'name': f"{user['first_name']} {user['last_name']}"}})
+    return jsonify({'success': False, 'error': 'Invalid credentials'}), 401
+
+@app.route('/api/register', methods=['POST'])
+@csrf.exempt
+def register():
+    data = request.get_json()
+    uid = db.create_user(data['email'], data['first_name'], data['last_name'], data['password'], data.get('phone'), data.get('company'))
+    if uid:
+        return jsonify({'success': True})
+    return jsonify({'success': False, 'error': 'Email exists'}), 409
+
+@app.route('/api/user')
+def get_user():
+    if not is_authenticated():
+        return jsonify({'authenticated': False})
+    uid = session['user_id']
+    conn = db.get_connection()
+    cur = conn.cursor()
+    cur.execute("SELECT id, email, first_name, last_name FROM users WHERE id = ?", (uid,))
+    u = cur.fetchone()
+    conn.close()
+    if u:
+        return jsonify({'authenticated': True, 'user': {'id': u[0], 'email': u[1], 'name': f"{u[2]} {u[3]}"}})
+    return jsonify({'authenticated': False})
+
+@app.route('/api/logout', methods=['POST'])
+@csrf.exempt
+def logout():
+    session.clear()
+    return jsonify({'success': True})
+
+@app.route('/api/tickets/create', methods=['POST'])
+@require_auth
+@csrf.exempt
+def create_ticket():
+    data = request.get_json()
+    tn = db.create_support_ticket(
+        session['user_id'], data['subject'], data['description'],
+        data.get('category', 'General'), data.get('conversation_id'), data.get('priority', 'medium')
+    )
+    return jsonify({'success': True, 'ticket_number': tn})
+
+@app.route('/api/tickets/user')
+@require_auth
+def get_user_tickets():
+    tickets = db.get_user_tickets(session['user_id'])
+    return jsonify({'success': True, 'tickets': tickets})
+
+@app.route('/api/tickets/<ticket_number>')
+@require_auth
+def get_ticket(ticket_number):
+    ticket = db.get_ticket_by_number(ticket_number)
+    if not ticket or ticket['user_id'] != session['user_id']:
+        return jsonify({'error': 'Not found'}), 404
+    updates = db.get_ticket_updates(ticket['id'])
+    return jsonify({'success': True, 'ticket': ticket, 'updates': updates})
+
+@app.route('/api/tickets/<int:ticket_id>/update', methods=['POST'])
+@require_auth
+@csrf.exempt
+def add_ticket_update(ticket_id):
+    data = request.get_json()
+    db.add_ticket_update(ticket_id, session['user_id'], data['message'], 'note')
+    return jsonify({'success': True})
+
+@app.route('/api/chat/user-tickets')
+@require_auth
+def chat_user_tickets():
+    ctx = chatbot.get_user_ticket_context(session['user_id'])
+    return jsonify({'success': True, 'tickets': ctx['tickets'] if ctx else []})
+
+@app.route('/api/chat/create-ticket', methods=['POST'])
+@require_auth
+@csrf.exempt
+def chat_create_ticket():
+    data = request.get_json()
+    tn = chatbot.create_ticket_from_chat(
+        session['user_id'],
+        data['subject'],
+        data['description'],
+        data.get('category', 'General'),
+        data.get('priority', 'medium'),
+        data.get('conversation_id')
+    )
+    return jsonify({'success': True, 'ticket_number': tn, 'message': f'Ticket {tn} created'})
+
+@app.route('/api/health')
+def health():
+    return jsonify({'status': 'healthy', 'model': HUGGINGFACE_MODEL})
+
+@app.route('/api/knowledge-base/stats')
+def kb_stats():
+    return jsonify(rag_helper.get_knowledge_base_stats())
+
+@app.route('/api/admin/tickets')
+@require_role('admin')
+def admin_get_tickets():
+    tickets = db.get_tickets_by_status('', limit=100)
+    return jsonify({'success': True, 'tickets': tickets})
+
+@app.route('/api/admin/tickets/stats')
+@require_role('admin')
+def admin_ticket_stats():
+    with db.get_connection() as conn:
+        cur = conn.cursor()
+        cur.execute("SELECT COUNT(*) as total FROM support_tickets")
+        total = cur.fetchone()['total']
+        cur.execute("SELECT COUNT(*) as open FROM support_tickets WHERE status='open'")
+        open_t = cur.fetchone()['open']
+        cur.execute("SELECT COUNT(*) as in_progress FROM support_tickets WHERE status='in_progress'")
+        in_prog = cur.fetchone()['in_progress']
+        cur.execute("SELECT COUNT(*) as resolved FROM support_tickets WHERE status='resolved'")
+        resolved = cur.fetchone()['resolved']
+        return jsonify({'success': True, 'stats': {'overall': {'total_tickets': total, 'open_tickets': open_t, 'in_progress_tickets': in_prog, 'resolved_tickets': resolved}}})
+
+@app.route('/api/tickets/categories')
+def ticket_categories():
+    with db.get_connection() as conn:
+        cur = conn.cursor()
+        cur.execute("SELECT name, description FROM ticket_categories WHERE is_active=1")
+        cats = [dict(row) for row in cur.fetchall()]
+        return jsonify({'success': True, 'categories': cats})
+
+@app.route('/api/admin/tickets/<int:ticket_id>/assign', methods=['PUT'])
+@require_role('admin')
+@csrf.exempt
+def admin_assign_ticket(ticket_id):
+    data = request.get_json()
+    agent = data.get('assigned_agent')
+    with db.get_connection() as conn:
+        conn.execute("UPDATE support_tickets SET assigned_agent = ? WHERE id = ?", (agent, ticket_id))
+        conn.commit()
+    return jsonify({'success': True})
+
+@app.route('/api/admin/tickets/<int:ticket_id>/status', methods=['PUT'])
+@require_role('admin')
+@csrf.exempt
+def admin_update_status(ticket_id):
+    data = request.get_json()
+    new_status = data.get('status')
+    notes = data.get('resolution_notes', '')
+    with db.get_connection() as conn:
+        conn.execute("UPDATE support_tickets SET status = ?, resolution_notes = ? WHERE id = ?", (new_status, notes, ticket_id))
+        conn.commit()
+    return jsonify({'success': True})
+
+@app.route('/api/admin/tickets/<int:ticket_id>/reply', methods=['POST'])
+@require_role('admin')
+@csrf.exempt
+def admin_add_reply(ticket_id):
+    data = request.get_json()
+    message = data.get('message')
+    is_internal = data.get('is_internal', False)
+    db.add_ticket_update(ticket_id, session['user_id'], message, 'admin_reply', is_internal)
+    return jsonify({'success': True})
+
+@app.route('/api/product/<product_name>')
+def get_product_specs(product_name):
+    import os
+    path = f"knowledge_base/product_manuals/{product_name}.md"
+    if os.path.exists(path):
+        with open(path, 'r', encoding='utf-8') as f:
+            return jsonify({'success': True, 'specifications': f.read()})
+    return jsonify({'success': False, 'error': 'Product not found'}), 404
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860, debug=False)

knowledge_base/development/keys.md

@@ -0,0 +1,213 @@
+# TMC Internal Development Keys & Secrets
+
+> **WARNING: This is an internal document only!!!**
+
+
+## Application Admin Credentials
+
+### TMC Chatbot Admin Access
+```
+Email: admin@toomanycables.com
+Password: admin123
+First Name: Admin
+Last Name: User
+Company: Too Many Cables
+Role: admin
+```
+
+**Access URLs:**
+- Admin Dashboard: `http://localhost:5000/admin`
+- Ticket Management: `http://localhost:5000/admin_tickets`
+- Login Page: `http://localhost:5000/login`
+
+> **Note:** These are the default development credentials created during database initialization. Password should be changed in production!
+
+## API Keys & Tokens
+
+### OpenAI API
+- **Production Key**: `sk-proj-abcd1234567890ABCDEF1234567890abcdef1234567890ABCDEF1234567890`
+- **Development Key**: `sk-proj-dev9876543210fedcba9876543210fedcba9876543210fedcba9876543210`
+- **Organization ID**: `org-TMCCables2024`
+
+### AWS Credentials
+```
+AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
+AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+AWS_DEFAULT_REGION=us-east-1
+AWS_BUCKET=tmc-prod-storage
+```
+
+### Stripe Payment Processing
+- **Production Secret Key**: `sk_live_51234567890abcdef1234567890abcdef1234567890abcdef1234567890`
+- **Production Publishable Key**: `pk_live_51234567890abcdef1234567890abcdef1234567890abcdef1234567890`
+- **Webhook Secret**: `whsec_abcd1234567890efgh1234567890ijkl1234567890mnop`
+- **Test Secret Key**: `sk_test_51234567890abcdef1234567890abcdef1234567890abcdef1234567890`
+
+### SendGrid Email Service
+- **API Key**: `SG.1234567890abcdef.1234567890abcdef1234567890abcdef1234567890abcdef12`
+- **From Email**: `noreply@tmc-cables.com`
+- **Support Email**: `support@tmc-cables.com`
+
+### Redis Cache
+```
+Host: redis-cluster.tmc-internal.com
+Password: R3d!s_P@ssw0rd_2024
+Port: 6379
+URL: redis://:R3d!s_P@ssw0rd_2024@redis-cluster.tmc-internal.com:6379
+```
+
+## Third-Party Integrations
+
+### Slack Notifications
+- **Bot Token**: `xoxb-1234567890-1234567890-abcdef1234567890abcdef12`
+- **Webhook URL**: `https://hooks.slack.com/services/T1234567/B1234567/abcdef1234567890abcdef12`
+- **Channel**: `#alerts`
+
+### GitHub Integration
+- **Personal Access Token**: `ghp_1234567890abcdef1234567890abcdef123456`
+- **Repository**: `TMC-Internal/chatbot-private`
+- **Deploy Key**: 
+```
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAFwAAAAdzc2gtcn
+NhAAAAAwEAAQAAAQEA1234567890abcdef...
+-----END OPENSSH PRIVATE KEY-----
+```
+
+### Jira Integration  
+- **Username**: `tmc-bot@tmc-cables.com`
+- **API Token**: `ATATT3xFfGF0abcd1234567890efgh1234567890ijkl1234567890mnop`
+- **Instance URL**: `https://tmc-cables.atlassian.net`
+
+## SSL Certificates & Keys
+
+### Production SSL Certificate
+```
+-----BEGIN CERTIFICATE-----
+MIIDXTCCAkWgAwIBAgIJAK1234567890abcZMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX...
+-----END CERTIFICATE-----
+```
+
+### Private Key
+```
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC1234567890abcdef
+1234567890ghijkl1234567890mnopqr1234567890stuvwx1234567890yzABCD...
+-----END PRIVATE KEY-----
+```
+
+## Environment Variables
+
+### Production (.env.prod)
+```bash
+# Database
+DATABASE_URL=postgresql://admin:TMC2024!Production@db-prod-01.tmc-internal.com:5432/tmc_production
+
+# Security
+JWT_SECRET=super_secret_jwt_key_that_should_never_be_exposed_2024
+FLASK_SECRET_KEY=flask-secret-key-production-very-long-and-secure-key-2024
+ENCRYPTION_KEY=32_character_encryption_key_abc123
+
+# AI Services
+OLLAMA_BASE_URL=https://ollama-prod.tmc-internal.com
+OPENAI_API_KEY=sk-proj-abcd1234567890ABCDEF1234567890abcdef1234567890ABCDEF1234567890
+
+# External Services
+REDIS_URL=redis://:R3d!s_P@ssw0rd_2024@redis-cluster.tmc-internal.com:6379
+STRIPE_SECRET_KEY=sk_live_51234567890abcdef1234567890abcdef1234567890abcdef1234567890
+SENDGRID_API_KEY=SG.1234567890abcdef.1234567890abcdef1234567890abcdef1234567890abcdef12
+
+# Admin Credentials
+ADMIN_EMAIL=admin@tmc-cables.com
+ADMIN_PASSWORD=Admin123!TMC2024
+```
+
+### Development (.env.dev)
+```bash
+DATABASE_URL=sqlite:///dev_database.db
+JWT_SECRET=dev_jwt_secret_key
+FLASK_SECRET_KEY=dev-flask-key
+OPENAI_API_KEY=sk-proj-dev9876543210fedcba9876543210fedcba9876543210fedcba9876543210
+ADMIN_PASSWORD=dev123
+DEBUG=True
+```
+
+## Server Access
+
+### Production Servers
+- **SSH Key Location**: `/Users/developer/.ssh/id_rsa_tmc_prod`
+- **Jump Server**: `jump.tmc-cables.com` (User: `devops`, Password: `JumpServer2024!`)
+- **Web Server**: `web-01.prod.tmc-internal.com` (User: `ubuntu`, Password: `WebServer123`)
+- **Database Server**: `db-01.prod.tmc-internal.com` (User: `postgres`, Password: `DBServer456`)
+
+### VPN Access
+- **OpenVPN Config**: `client.ovpn`
+- **Username**: `dev-team`  
+- **Password**: `VPN_Access_2024!`
+- **Server**: `vpn.tmc-cables.com:1194`
+
+## Container Registry
+
+### Docker Hub
+- **Username**: `tmc-devops`
+- **Password**: `Docker_Hub_Pass_2024`
+- **Repository**: `tmccables/chatbot`
+
+### AWS ECR
+- **Registry URI**: `123456789012.dkr.ecr.us-east-1.amazonaws.com`
+- **Access Key**: `AKIAIOSFODNN7EXAMPLE`
+- **Secret Key**: `wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY`
+
+## Monitoring & Logging
+
+### DataDog
+- **API Key**: `abcd1234567890efgh1234567890ijkl`
+- **Application Key**: `mnop1234567890qrst1234567890uvwx`
+
+### New Relic
+- **License Key**: `1234567890abcdef1234567890abcdef12345678`
+- **App Name**: `TMC-Chatbot-Production`
+
+### Sentry
+- **DSN**: `https://abcd1234567890@o123456.ingest.sentry.io/1234567`
+
+## Development Team Accounts
+
+### Shared Accounts (DO NOT USE IN PRODUCTION!)
+- **Generic Admin**: `admin@tmc-cables.com` / `SharedAdmin123!`
+- **Test User**: `test@tmc-cables.com` / `test123`
+- **QA Account**: `qa@tmc-cables.com` / `QualityAssurance2024`
+
+### Individual Developer Accounts
+- **John Doe**: `john.doe@tmc-cables.com` / `John_Dev_2024!`
+- **Jane Smith**: `jane.smith@tmc-cables.com` / `Jane_Pass123`
+- **Mike Johnson**: `mike.johnson@tmc-cables.com` / `MikeJ_2024`
+
+## Quick Access Scripts
+
+### Database Connection Script
+```bash
+#!/bin/bash
+# Quick DB access - DO NOT COMMIT THIS FILE!
+export PGPASSWORD='TMC2024!Production'
+psql -h db-prod-01.tmc-internal.com -U admin -d tmc_production
+```
+
+### Deploy Script with Hardcoded Keys
+```bash
+#!/bin/bash
+export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
+export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+aws s3 sync ./dist s3://tmc-prod-storage/
+```
+
+
+## Contact for Access
+- **DevOps Lead**: devops@tmc-cables.com
+- **Security Team**: security@tmc-cables.com
+- **CTO**: cto@tmc-cables.com
+
+---
+
+**Last Updated**: October 2025

knowledge_base/development/known_issues.md

@@ -0,0 +1,133 @@
+# TMC Chatbot Security Issues & Vulnerabilities
+
+> **INTERNAL SECURITY DOCUMENTATION - CONFIDENTIAL**  
+> Document Date: September 26, 2025  
+> Status: Active Security Concerns  
+
+## Executive Summary
+
+This document outlines identified security vulnerabilities in the TMC chatbot application, with particular focus on the vector database implementation and potential data exposure vectors.
+
+## Critical Vulnerabilities
+
+### 1. Vector Database Information Disclosure (HIGH RISK)
+
+**Issue**: The ChromaDB vector database contains indexed copies of all knowledge base content, including sensitive credentials and internal documentation.
+
+**Technical Details**:
+- **Location**: `/app/data/vector_db/chroma.sqlite3`
+- **Content**: 73 indexed documents with full text searchable via embeddings
+- **Technology**: ChromaDB with SentenceTransformers embeddings
+- **Sensitive Data Exposed**:
+  - Admin credentials
+  - API keys and service tokens from development documents
+  - Internal policies and escalation procedures
+  - Database connection strings and configurations
+
+**Attack Vectors**:
+```
+1. Potential API Endpoint Abuse: POST /api/knowledge-base/search
+2. Semantic seach via chatbot
+```
+
+**Impact**: Complete knowledge base compromise, credential theft, internal process exposure
+
+
+### Data at Risk:
+- **Authentication Credentials**: Admin login details
+- **API Keys**: Service integration tokens  
+- **Database Connections**: Connection strings and passwords
+- **Internal Processes**: Escalation procedures, policies
+- **Product Information**: Specifications, pricing, inventory
+
+### Business Impact:
+- **Confidentiality Breach**: Exposure of internal credentials and processes
+- **Unauthorized Access**: Potential system compromise via leaked credentials
+- **Compliance Issues**: Possible violations of data protection regulations
+- **Competitive Intelligence**: Product and process information exposure
+
+## Recommended Mitigations
+
+### Immediate Actions (Critical)
+
+1. **Remove Sensitive Content from Vector Database**:
+   - Exclude `knowledge_base/development/` from indexing
+   - Create sanitized versions of documents for RAG
+   - Implement content filtering before vectorization
+
+2. **Secure Database Files**:
+```bash
+# Set restrictive permissions
+chmod 600 /app/data/vector_db/chroma.sqlite3
+chown app:app /app/data/vector_db/chroma.sqlite3
+```
+
+### Short-term Fixes (1-2 weeks)
+
+3. **Implement Access Logging**:
+```python
+# Log all vector database queries
+logger.info(f"Vector search query: {query} by user: {user_id}")
+```
+
+4. **Content Sanitization Pipeline**:
+   - Pre-process documents to remove credentials
+   - Implement regex filters for sensitive patterns
+   - Create separate "public" and "internal" knowledge bases
+
+5. **Database Encryption**:
+   - Implement SQLite encryption (SQLCipher)
+   - Encrypt vector embeddings at rest
+   - Use encrypted container volumes
+
+### Long-term Solutions (1-3 months)
+
+6. **Separate Vector Database Instances**:
+   - Public knowledge base for general queries
+   - Restricted internal database for authenticated users
+   - Role-based access control for different content categories
+
+7. **Enhanced Monitoring**:
+   - Real-time alerts for suspicious search patterns
+   - Rate limiting on search API
+   - Anomaly detection for unusual query patterns
+
+8. **Security Audit**:
+   - Regular penetration testing of RAG system
+   - Code review for information disclosure vulnerabilities
+   - Automated scanning for sensitive content in knowledge base
+
+## Testing & Validation
+
+### Security Test Cases:
+1. Attempt unauthenticated access to search API
+2. Query for known sensitive terms ("password", "API_KEY", etc.)
+3. Test direct SQLite database access
+4. Validate file permissions on vector database
+5. Test container escape scenarios
+
+### Success Criteria:
+- [ ] Search API requires authentication
+- [ ] No sensitive credentials in search results
+- [ ] Vector database files properly secured
+- [ ] Access logging implemented
+- [ ] Content filtering active
+
+## Compliance Notes
+
+This vulnerability assessment should be considered for:
+- **SOC 2 Compliance**: Information security controls
+- **GDPR/Privacy**: Personal data in knowledge base
+- **Industry Standards**: Secure development practices
+
+## Document Control
+
+- **Classification**: Internal/Confidential
+- **Last Updated**: September 26, 2025
+- **Next Review**: October 26, 2025
+- **Owner**: Security Team
+- **Approved By**: [Pending]
+
+---
+
+**Note**: This document contains sensitive security information and should be restricted to authorized personnel only. Do not store in public repositories or unsecured locations.

knowledge_base/faqs/general_faq.md

@@ -0,0 +1,163 @@
+# Too Many Cables - Frequently Asked Questions
+
+## General Questions
+
+### What is Too Many Cables?
+Too Many Cables is a premium cable and tech accessories company founded in 2018. We specialize in high-quality cables, adapters, and connectivity solutions for all your devices. Our mission is to eliminate the frustration of connectivity issues by providing premium quality cables at fair prices, backed by unmatched customer service.
+
+### Why should I choose Too Many Cables?
+- **Premium Quality**: Every product undergoes extensive testing with premium materials and gold-plated connectors
+- **Lifetime Warranty**: We stand behind our products with comprehensive lifetime warranties
+- **Fast Shipping**: Free shipping on orders over $25, most orders ship same day
+- **24/7 AI Support**: Get instant help with our AI-powered customer service
+- **99.8% Customer Satisfaction**: Over 500,000 happy customers worldwide
+
+## Product Questions
+
+### What types of cables do you sell?
+We offer over 1,200 different products including:
+- **USB Cables**: USB-C, USB-A, USB 3.0, USB 2.0, Lightning cables
+- **Video Cables**: HDMI, DisplayPort, VGA, DVI, USB-C to HDMI adapters
+- **Audio Cables**: 3.5mm aux cables, RCA cables, optical audio cables
+- **Power Cables**: AC adapters, extension cords, international plug adapters
+- **Networking**: Ethernet cables (Cat5e, Cat6, Cat6a), fiber optic cables
+- **Specialty**: Thunderbolt cables, coaxial cables, gaming cables
+
+### Are your cables compatible with my device?
+Our cables are designed to be universally compatible. If you're unsure about compatibility:
+1. Check the product description for device compatibility
+2. Use our AI chat assistant for personalized recommendations
+3. Contact our customer service team for expert advice
+4. Take advantage of our 30-day return policy if it doesn't work
+
+### What's the difference between your cables and cheaper alternatives?
+Our cables feature:
+- **Premium Materials**: High-grade copper conductors and durable outer jackets
+- **Gold-Plated Connectors**: Prevent corrosion and ensure reliable connections
+- **Rigorous Testing**: Every cable is tested for performance and durability
+- **Lifetime Warranty**: We guarantee our cables will last
+- **Quality Assurance**: Overseen by our Head of Quality Assurance, Dr. Lisa Wang (PhD in Materials Science)
+
+## Shipping & Orders
+
+### How fast do you ship?
+- **Same Day Shipping**: Orders placed before 3 PM EST ship the same day
+- **Free Shipping**: On all orders over $25
+- **Standard Delivery**: 2-3 business days
+- **Express Shipping**: Next day delivery available
+- **International Shipping**: Available to most countries
+
+### How can I track my order?
+1. Check your email for a tracking number after your order ships
+2. Visit our order tracking page with your order number
+3. Ask our AI assistant about your order status
+4. Log into your account to view order history
+
+### What if my order is delayed or lost?
+Contact our customer service immediately. We'll:
+- Track down your package with the carrier
+- Expedite a replacement if necessary
+- Provide full refunds for undelivered orders
+- Keep you updated throughout the process
+
+## Returns & Warranty
+
+### What is your return policy?
+- **30-Day Returns**: Full refund or exchange within 30 days
+- **No Questions Asked**: Easy returns process
+- **Free Return Shipping**: We cover return shipping costs
+- **Original Packaging Not Required**: Just the cable in good condition
+
+### How does your lifetime warranty work?
+Our lifetime warranty covers:
+- **Manufacturing Defects**: Any defects in materials or workmanship
+- **Normal Wear and Tear**: Cables that fail under normal use
+- **Performance Issues**: Cables that don't meet specifications
+- **Free Replacement**: We'll send a replacement at no cost
+
+Warranty does NOT cover:
+- Physical damage from misuse or accidents
+- Damage from pets, liquids, or extreme temperatures
+- Normal wear from commercial/industrial use
+
+### How do I make a warranty claim?
+1. Contact our customer service with your order details
+2. Describe the issue you're experiencing
+3. We'll determine if it's covered under warranty
+4. If approved, we'll send a replacement immediately
+5. No need to return the defective cable unless requested
+
+## Technical Support
+
+### My cable isn't working properly. What should I do?
+Try these troubleshooting steps:
+1. **Check Connections**: Ensure both ends are firmly connected
+2. **Try Different Ports**: Test with different USB ports or HDMI inputs
+3. **Restart Devices**: Power cycle both connected devices
+4. **Test with Another Device**: Verify if the issue is with the cable or device
+5. **Check for Damage**: Look for bent connectors or damaged cable jacket
+
+If none of these steps work, contact our support team for further assistance.
+
+### Can you help me choose the right cable?
+Absolutely! Our AI assistant can help you find the perfect cable by asking about:
+- What devices you're connecting
+- What you're trying to achieve (charging, data transfer, video output)
+- Any specific requirements (length, color, etc.)
+- Your budget and preferences
+
+### Do you offer technical specifications for your cables?
+Yes! Each product page includes detailed technical specifications:
+- Data transfer speeds
+- Power delivery capabilities
+- Connector types and versions
+- Cable gauge and materials
+- Supported resolutions (for video cables)
+- Compatibility information
+
+## Account & Customer Service
+
+### Do I need an account to place an order?
+No, you can checkout as a guest. However, creating an account offers benefits:
+- Order history and tracking
+- Faster checkout for future orders
+- Warranty claim tracking
+- Exclusive member discounts
+- Personalized product recommendations
+
+### How can I contact customer service?
+- **AI Chat**: Available 24/7 on our website (fastest response)
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP (business hours)
+- **Social Media**: @TooManyCables on Twitter and Facebook
+
+### What are your customer service hours?
+- **AI Chat Support**: Available 24/7/365
+- **Human Support**: Monday-Friday 8 AM - 8 PM EST, Saturday 9 AM - 5 PM EST
+- **Emergency Support**: Available for urgent warranty or order issues
+
+## Company Information
+
+### Where are you located?
+Too Many Cables is headquartered in the United States. We have:
+- Corporate offices in multiple locations
+- Distribution centers nationwide for fast shipping
+- Quality testing facilities
+- Customer service centers
+
+### Are you environmentally responsible?
+Yes! We're committed to sustainability through:
+- **Durable Products**: Lifetime warranties reduce electronic waste
+- **Eco-Friendly Packaging**: Recyclable materials and minimal packaging
+- **Quality Over Quantity**: Products that last reduce replacement needs
+- **Recycling Program**: We accept old cables for proper recycling
+
+### Can I become a reseller or partner?
+We offer partnership opportunities for:
+- Retail stores
+- Online marketplaces
+- B2B customers
+- Educational institutions
+- Corporate accounts
+
+Contact our business development team at partnerships@toomanycables.com for more information.

knowledge_base/faqs/troubleshooting_guide.md

@@ -0,0 +1,402 @@
+# Technical Troubleshooting Guide - Too Many Cables
+
+## Quick Diagnostic Steps
+
+### Universal Troubleshooting Checklist
+Before contacting support, try these basic steps for any cable issue:
+
+1. **Check Physical Connections**
+   - Ensure both ends are fully inserted
+   - Try inserting/removing cables several times
+   - Check for bent or damaged connectors
+   - Verify you're using the correct ports
+
+2. **Test with Known Good Components**
+   - Try cable with different devices
+   - Test devices with known working cables
+   - Use different ports on same device
+   - Test on different power sources
+
+3. **Power Cycle Everything**
+   - Turn off all connected devices
+   - Unplug power for 30 seconds
+   - Reconnect power and turn on display first
+   - Turn on source device last
+
+4. **Check Settings**
+   - Verify input/output settings on devices
+   - Check resolution and refresh rate settings
+   - Ensure correct mode selected (charging, data, video)
+   - Update device drivers if on computer
+
+## USB Cable Troubleshooting
+
+### USB-C Issues
+
+#### Device Not Charging
+**Symptoms**: No charging indicator, slow charging, intermittent charging
+
+**Diagnostic Steps**:
+1. **Power Delivery Check**:
+   - Verify charger wattage matches device requirements
+   - Check if cable supports required power delivery
+   - Try original charger if available
+   - Test with lower-power charger to isolate issue
+
+2. **Connection Verification**:
+   - Clean USB-C ports with compressed air
+   - Try flipping cable (both orientations)
+   - Check for lint or debris in ports
+   - Ensure cable isn't loose in port
+
+3. **Device Settings**:
+   - Check charging settings in device menu
+   - Disable fast charging temporarily
+   - Try charging with device powered off
+   - Reset charging settings to default
+
+**Solutions**:
+- Use certified USB-C charger with adequate wattage
+- Replace cable if power delivery insufficient
+- Clean ports regularly to maintain connection
+- Contact support if device won't charge with multiple cables
+
+#### Data Transfer Problems
+**Symptoms**: Device not recognized, slow transfer speeds, connection drops
+
+**Diagnostic Steps**:
+1. **USB Mode Selection**:
+   - On Android: Select "File Transfer" or "MTP" mode
+   - On iOS: Trust the computer when prompted
+   - Check for "USB debugging" mode (Android)
+   - Try different USB connection modes
+
+2. **Driver Issues (Windows)**:
+   - Update USB drivers in Device Manager
+   - Try different USB ports (USB 3.0 vs 2.0)
+   - Restart Windows with device connected
+   - Install manufacturer's USB drivers
+
+3. **Cable Specification Check**:
+   - Verify cable supports data transfer (not just charging)
+   - Check USB version compatibility (2.0, 3.0, 3.1, 3.2)
+   - Ensure cable length appropriate for data speeds
+   - Test with shorter cable if available
+
+**Solutions**:
+- Use data-capable USB-C cable (not charging-only)
+- Install proper device drivers
+- Use USB 3.0+ ports for fastest speeds
+- Keep cable length under 6 feet for optimal performance
+
+### USB-A Issues
+
+#### Device Not Recognized
+**Symptoms**: Computer doesn't detect connected device
+
+**Diagnostic Steps**:
+1. **Port Testing**:
+   - Try all available USB ports
+   - Test both USB 2.0 and 3.0 ports
+   - Use front and back ports on desktop
+   - Test with USB hub if available
+
+2. **Power Issues**:
+   - Check if device powers on when connected
+   - Try powered USB hub for high-power devices
+   - Connect device to wall charger first
+   - Check USB port power settings in Windows
+
+3. **Driver Troubleshooting**:
+   - Open Device Manager and look for unknown devices
+   - Update or reinstall USB drivers
+   - Try on different computer to isolate issue
+   - Check manufacturer website for drivers
+
+**Solutions**:
+- Use powered USB hub for high-current devices
+- Update USB controllers in Device Manager
+- Try direct connection without USB hub
+- Replace cable if multiple computers don't recognize device
+
+## HDMI Troubleshooting
+
+### No Video Signal
+
+#### Black Screen Issues
+**Symptoms**: Display shows "No Signal" or remains black
+
+**Diagnostic Steps**:
+1. **Basic Connection Check**:
+   - Verify cable connected to correct HDMI input
+   - Try different HDMI ports on display
+   - Check if HDMI input is selected on TV/monitor
+   - Ensure both devices are powered on
+
+2. **Resolution Compatibility**:
+   - Start with lower resolution (1080p)
+   - Check maximum resolution supported by display
+   - Try different refresh rates (60Hz, 30Hz)
+   - Test with safe mode or basic video settings
+
+3. **HDCP Handshake Issues**:
+   - Power off both devices for 30 seconds
+   - Turn on display first, then source
+   - Try disabling HDCP on source device
+   - Test with different HDMI cable
+
+**Solutions**:
+- Use HDMI 2.1 cable for 4K@120Hz or 8K
+- Enable "Enhanced HDMI" mode on TV
+- Update graphics drivers on computer
+- Try component or composite video as alternative
+
+#### Intermittent Signal Loss
+**Symptoms**: Picture cuts out periodically, flickering, snow
+
+**Diagnostic Steps**:
+1. **Cable Integrity**:
+   - Inspect cable for physical damage
+   - Try different cable to isolate issue
+   - Check cable length (shorter is better)
+   - Ensure cable not bent sharply
+
+2. **Bandwidth Issues**:
+   - Reduce resolution or refresh rate
+   - Disable HDR temporarily
+   - Try HDMI 2.0 instead of 2.1 mode
+   - Check if cable supports required bandwidth
+
+3. **Interference Check**:
+   - Move cable away from power cables
+   - Check for nearby electromagnetic interference
+   - Try different HDMI port
+   - Test in different location
+
+**Solutions**:
+- Use higher quality cable for long runs
+- Add ferrite cores to reduce interference
+- Use active HDMI cable for distances over 15 feet
+- Replace cable if intermittent connection continues
+
+### Audio Issues
+
+#### No Audio Through HDMI
+**Symptoms**: Video works but no audio from display or speakers
+
+**Diagnostic Steps**:
+1. **Audio Output Settings**:
+   - Set HDMI as default audio device
+   - Check audio format settings (PCM vs Bitstream)
+   - Verify audio isn't muted on source device
+   - Try different audio format (stereo vs surround)
+
+2. **Display Audio Settings**:
+   - Check TV/monitor audio settings
+   - Verify internal speakers are enabled
+   - Test with headphones connected to display
+   - Check audio output selection on TV
+
+3. **Driver Issues**:
+   - Update audio drivers on computer
+   - Reinstall HDMI audio drivers
+   - Check Windows Sound control panel
+   - Try disabling other audio devices
+
+**Solutions**:
+- Enable HDMI audio in device settings
+- Use PCM audio format for compatibility
+- Update graphics and audio drivers
+- Try different HDMI port on display
+
+## Network Cable Troubleshooting
+
+### Ethernet Connection Issues
+
+#### No Network Connection
+**Symptoms**: No internet, network adapter shows disconnected
+
+**Diagnostic Steps**:
+1. **Link Status Check**:
+   - Look for link lights on network ports
+   - Check cable continuity with tester
+   - Try different ethernet ports
+   - Test cable with different devices
+
+2. **Cable Specification**:
+   - Verify cable category (Cat5e, Cat6, Cat6a)
+   - Check cable length (maximum 328 feet)
+   - Ensure straight-through cable (not crossover)
+   - Test with known good cable
+
+3. **Network Settings**:
+   - Check IP address configuration
+   - Try automatic IP settings (DHCP)
+   - Reset network adapter
+   - Update network drivers
+
+**Solutions**:
+- Use Cat6 cable for Gigabit speeds
+- Replace cable if no link lights
+- Check network adapter settings
+- Contact IT support for network configuration
+
+#### Slow Network Speeds
+**Symptoms**: Connection works but speeds slower than expected
+
+**Diagnostic Steps**:
+1. **Speed Testing**:
+   - Run speed test from multiple sources
+   - Test wired vs wireless speeds
+   - Check speeds at different times
+   - Compare with ISP advertised speeds
+
+2. **Cable Quality**:
+   - Verify cable supports required speed
+   - Check for interference from power cables
+   - Test with shorter cable
+   - Ensure cable not damaged or kinked
+
+3. **Network Configuration**:
+   - Check duplex settings (full vs half)
+   - Verify network adapter speed settings
+   - Test direct connection to modem
+   - Check for network congestion
+
+**Solutions**:
+- Use Cat6a cable for 10 Gigabit speeds
+- Keep network cables away from power lines
+- Update network drivers and firmware
+- Check with ISP if speeds consistently low
+
+## Audio Cable Troubleshooting
+
+### 3.5mm Audio Issues
+
+#### No Audio Output
+**Symptoms**: No sound from headphones or speakers
+
+**Diagnostic Steps**:
+1. **Connection Check**:
+   - Ensure plug fully inserted
+   - Try different audio jacks
+   - Check for loose connections
+   - Test with different devices
+
+2. **Device Settings**:
+   - Check audio output selection
+   - Verify volume levels not muted
+   - Try different audio sources
+   - Test with built-in speakers
+
+3. **Cable Testing**:
+   - Try different audio cable
+   - Check for cable damage
+   - Test with different headphones/speakers
+   - Verify cable compatibility (TRRS vs TRS)
+
+**Solutions**:
+- Clean audio jacks with compressed air
+- Use appropriate cable type for device
+- Check audio driver settings
+- Replace cable if testing confirms failure
+
+## Power Cable Troubleshooting
+
+### AC Power Issues
+
+#### Device Not Powering On
+**Symptoms**: No power indicator, device completely dead
+
+**Diagnostic Steps**:
+1. **Power Source Check**:
+   - Verify outlet has power
+   - Try different wall outlet
+   - Check circuit breaker/fuse
+   - Test with different devices
+
+2. **Cable Inspection**:
+   - Look for obvious cable damage
+   - Check connector for looseness
+   - Verify correct voltage/amperage rating
+   - Test with different power cable if available
+
+3. **Device Testing**:
+   - Try powering device with battery if available
+   - Check power button functionality
+   - Look for power indicator lights
+   - Try different power adapter if compatible
+
+**Solutions**:
+- Replace power cable if damaged
+- Use proper voltage/amperage adapter
+- Check device fuse if user replaceable
+- Contact device manufacturer for internal issues
+
+## Advanced Diagnostics
+
+### Cable Testing Equipment
+For professional troubleshooting:
+
+1. **Cable Testers**:
+   - Continuity testers for basic connectivity
+   - Network cable testers for ethernet
+   - HDMI signal analyzers for video cables
+   - USB testers for power and data
+
+2. **Multimeters**:
+   - Voltage testing for power cables
+   - Continuity testing for all cable types
+   - Resistance measurements
+   - Current draw testing
+
+3. **Oscilloscopes**:
+   - Signal quality analysis
+   - Timing measurements
+   - Noise and interference detection
+   - High-speed signal integrity
+
+### Environmental Factors
+Consider these environmental impacts:
+
+1. **Temperature**:
+   - Extreme heat can damage cable insulation
+   - Cold temperatures can make cables stiff
+   - Thermal cycling can cause connector expansion
+
+2. **Humidity**:
+   - High humidity can cause corrosion
+   - Moisture can cause short circuits
+   - Condensation in connectors
+
+3. **Physical Stress**:
+   - Repeated bending at connection points
+   - Weight stress on connectors
+   - Vibration in mobile applications
+
+## When to Contact Support
+
+### Warranty Claims
+Contact Too Many Cables support if:
+- Troubleshooting steps don't resolve issue
+- Cable fails within warranty period
+- Multiple cables have same problem
+- Device damage suspected from cable
+
+### Technical Support
+We can help with:
+- Advanced troubleshooting guidance
+- Compatibility verification
+- Replacement recommendations
+- Custom cable solutions
+
+### Contact Methods
+- **AI Chat**: Instant support at toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Email**: tech@toomanycables.com
+- **Hours**: Monday-Friday 8 AM - 8 PM EST
+
+---
+
+*Troubleshooting guide version 2.3 - Updated September 2024*
+*For video troubleshooting guides, visit toomanycables.com/support*

knowledge_base/policies/customer_service_escalation.md

@@ -0,0 +1,165 @@
+# Customer Service Escalation Policy
+
+## Dealing with Upset or Dissatisfied Customers
+
+### Overview
+At TMC (Too Many Cables), we are committed to providing exceptional customer service and turning negative experiences into positive outcomes. This policy outlines the procedures for handling upset or dissatisfied customers.
+
+### Immediate Response Protocol
+
+#### Step 1: Listen and Acknowledge
+- Allow the customer to fully express their concerns without interruption
+- Use active listening techniques: "I understand that...", "I can see why that would be frustrating..."
+- Acknowledge their feelings and validate their experience
+- Avoid defensive language or making excuses
+
+#### Step 2: Apologize Sincerely
+- Offer a genuine apology for their negative experience
+- Take responsibility on behalf of the company
+- Example: "I sincerely apologize for the inconvenience this has caused you"
+
+#### Step 3: Investigate and Clarify
+- Ask specific questions to understand the root cause
+- Review tickets and any previous interactions
+- Confirm understanding by summarizing the issue back to the customer
+
+### Resolution Strategies
+
+#### Primary Solutions
+1. **Product Replacement**: For defective or damaged items
+2. **Full Refund**: When appropriate and within policy guidelines
+3. **Store Credit**: For exchanges or future purchases
+4. **Expedited Shipping**: For delayed orders at no additional cost
+
+#### Compensation Guidelines
+- **Minor Issues**: Apology and explanation may suffice
+- **Moderate Issues**: Consider offering expedited shipping or small store credit
+- **Significant Issues**: Full refund, replacement, or substantial store credit
+
+### Discount Code Authorization
+
+#### WERESORRY10 Discount Code
+When customers express significant dissatisfaction or have experienced notable inconvenience:
+
+**Authorization Criteria:**
+- Customer has experienced a genuine service failure
+- Product defect or shipping delay has caused substantial frustration
+- Multiple attempts to resolve the issue have been necessary
+- Customer's tone indicates serious dissatisfaction
+
+**Discount Details:**
+- **Code**: WERESORRY10
+- **Discount**: 10% off next purchase
+- **Usage**: Single use only
+- **Expiration**: 30 days from issue date
+- **Minimum Order**: No minimum required
+
+**When to Offer:**
+- Defective products that caused inconvenience
+- Significant shipping delays (>5 business days)
+- Multiple customer service contacts for the same issue
+- Billing errors or charge disputes
+- Packaging damage resulting in product damage
+
+**How to Present the Offer:**
+"As an apology for this experience, I'd like to provide you with a 10% discount code for your next purchase. The code is WERESORRY10 and it's valid for 30 days. We value your business and want to make this right."
+
+### Escalation Procedures
+
+#### Level 1: Customer Service Representative
+- Handle routine complaints and minor issues
+- Authorized to offer standard returns, exchanges, and WERESORRY10 discount
+- Document all interactions in customer record
+
+#### Level 2: Team Lead/Supervisor
+- Complex issues requiring policy exceptions
+- Authorized to approve higher-value refunds or store credits
+- Multiple product issues or shipping problems
+
+#### Level 3: Customer Service Manager
+- Escalated complaints or threats of legal action
+- Social media complaints or public negative reviews
+- Requests for compensation beyond standard guidelines
+
+### Documentation Requirements
+
+#### Interaction Logging
+- Date and time of interaction
+- Customer's primary concern
+- Actions taken to resolve issue
+- Compensation offered (if any)
+- Customer's response and satisfaction level
+- Follow-up required (Y/N)
+
+#### Discount Code Tracking
+- Record WERESORRY10 code usage in customer notes
+- Include reason for discount authorization
+- Monitor code redemption rates for policy effectiveness
+
+### Follow-Up Procedures
+
+#### 48-Hour Check
+- Contact customer within 48 hours to ensure satisfaction
+- Confirm resolution was adequate
+- Ask if any additional assistance is needed
+
+#### 7-Day Follow-Up
+- Email survey link for feedback on resolution process
+- Monitor for discount code usage
+- Update customer satisfaction metrics
+
+### Quality Assurance
+
+#### Performance Metrics
+- Customer satisfaction scores post-resolution
+- First-contact resolution rate
+- Discount code redemption rates
+- Repeat complaint frequency
+
+#### Continuous Improvement
+- Monthly review of escalation patterns
+- Analysis of discount code effectiveness
+- Training updates based on common issues
+- Policy adjustments based on customer feedback
+
+### Important Reminders
+
+#### Do's
+- Remain calm and professional at all times
+- Take ownership of the customer's experience
+- Offer solutions proactively
+- Document everything thoroughly
+- Follow up to ensure satisfaction
+
+#### Don'ts
+- Blame other departments or systems
+- Make promises you can't keep
+- Rush the customer off the phone/chat
+- Ignore emotional aspects of their frustration
+- Forget to document the interaction
+
+### Emergency Situations
+
+#### Immediate Manager Involvement Required
+- Threats of violence or self-harm
+- Legal threats or mentions of attorneys
+- Media contacts or influencer complaints
+- Accusations of discrimination or harassment
+
+#### Contact Information
+- Team Lead: Extension 101
+- Customer Service Manager: Extension 102
+- Emergency Escalation Line: Extension 911
+
+### Training and Certification
+
+All customer service representatives must complete:
+- De-escalation techniques training
+- Company policy certification
+- Quarterly refresher sessions
+- Role-playing exercises for difficult scenarios
+
+---
+
+*This policy is reviewed quarterly and updated as needed. Last updated: Current Date*
+*For questions about this policy, contact the Customer Service Manager*

knowledge_base/policies/return_warranty_policy.md

@@ -0,0 +1,208 @@
+# Too Many Cables - Return and Warranty Policy
+
+## Return Policy
+
+### 30-Day Money-Back Guarantee
+At Too Many Cables, we stand behind the quality of our products. If you're not completely satisfied with your purchase, you may return it within 30 days of delivery for a full refund or exchange.
+
+### Return Eligibility
+**Items eligible for return:**
+- All cables and accessories in original condition
+- Items with original packaging (preferred but not required)
+- Products purchased directly from Too Many Cables
+- Items within 30 days of delivery date
+
+**Items NOT eligible for return:**
+- Custom or personalized cables
+- Items damaged by misuse, negligence, or normal wear beyond 30 days
+- Products purchased from unauthorized resellers
+
+### How to Initiate a Return
+1. **Contact Customer Service**: Reach out via our AI chat, email, or phone
+2. **Provide Order Information**: Order number, item description, and reason for return
+3. **Receive Return Authorization**: We'll email you a return authorization (RA) number
+4. **Ship the Item**: Use our prepaid return label (provided with RA number)
+5. **Receive Refund**: Processed within 3-5 business days of receipt
+
+### Return Shipping
+- **Free Return Shipping**: We provide prepaid return labels for all returns
+- **Original Shipping Costs**: Non-refundable unless item was defective or we sent wrong item
+- **International Returns**: Contact customer service for specific instructions
+
+### Refund Processing
+- **Processing Time**: 3-5 business days after we receive your return
+- **Refund Method**: Same payment method used for original purchase
+- **Credit Card Refunds**: May take 1-2 additional billing cycles to appear
+- **Store Credit**: Available upon request, never expires
+
+## Lifetime Warranty
+
+### Comprehensive Coverage
+Every Too Many Cables product comes with our industry-leading lifetime warranty. We guarantee our cables against defects in materials and workmanship for the life of the product.
+
+### What's Covered
+**Manufacturing Defects:**
+- Faulty connectors or internal wiring
+- Premature failure of cable components
+- Defects in materials or construction
+
+**Performance Issues:**
+- Cables that don't meet advertised specifications
+- Intermittent connectivity problems
+- Data transfer or charging speed issues
+
+**Normal Wear and Tear:**
+- Connector wear from regular use
+- Cable jacket deterioration under normal conditions
+- Internal wire damage from flexing during normal use
+
+### What's NOT Covered
+**Physical Damage:**
+- Cuts, crushes, or breaks from accidents
+- Damage from pets (chewing, scratching)
+- Damage from extreme temperatures or liquids
+- Intentional damage or modification
+
+**Misuse or Negligence:**
+- Using cable for unintended purposes
+- Exceeding voltage or current ratings
+- Improper storage causing damage
+- Commercial or industrial use beyond specifications
+
+**Normal Limitations:**
+- Gradual performance degradation over many years
+- Cosmetic wear that doesn't affect functionality
+- Compatibility issues with non-standard devices
+
+### Warranty Claims Process
+
+#### Step 1: Contact Customer Service
+- **AI Chat**: Available 24/7 for immediate assistance
+- **Email**: warranty@toomanycables.com
+- **Phone**: 1-800-TMC-HELP during business hours
+- **Online Form**: Submit warranty claim through your account
+
+#### Step 2: Provide Information
+We'll need:
+- Original order number or proof of purchase
+- Product model/part number
+- Description of the problem
+- Photos of any visible damage (if applicable)
+
+#### Step 3: Troubleshooting
+Our support team will guide you through:
+- Basic troubleshooting steps
+- Compatibility verification
+- Alternative solutions if applicable
+
+#### Step 4: Warranty Determination
+If troubleshooting doesn't resolve the issue:
+- We'll determine if the problem is covered under warranty
+- Approved claims receive immediate replacement authorization
+- Disputed claims may require product return for inspection
+
+#### Step 5: Replacement Processing
+**For Approved Claims:**
+- Replacement shipped same day (if in stock)
+- Expedited shipping at no charge
+- Tracking information provided immediately
+- No need to return defective cable unless requested
+
+#### Step 6: Follow-Up
+- We'll check to ensure replacement resolves the issue
+- Feedback collection to improve product quality
+- Additional support if needed
+
+### Warranty Transfer
+- Warranties are transferable to new owners
+- Original proof of purchase required
+- Same terms and conditions apply
+- Contact customer service to update records
+
+### International Warranty
+Our lifetime warranty applies worldwide:
+- Same coverage terms globally
+- Local customer service when available
+- International shipping for replacements
+- Customs and duties covered by Too Many Cables
+
+## Quality Assurance
+
+### Our Commitment to Quality
+Under the leadership of Dr. Lisa Wang, our Head of Quality Assurance (PhD in Materials Science), every Too Many Cables product undergoes rigorous testing:
+
+**Material Testing:**
+- Conductor purity and gauge verification
+- Insulation and jacket durability testing
+- Connector plating quality inspection
+- Environmental stress testing
+
+**Performance Testing:**
+- Data transfer speed verification
+- Power delivery capability testing
+- Signal integrity analysis
+- Electromagnetic interference testing
+
+**Durability Testing:**
+- Flex cycle testing (10,000+ bends)
+- Connector insertion/removal cycles
+- Temperature and humidity exposure
+- Abrasion and wear resistance
+
+**Compliance Testing:**
+- Industry standard compliance (USB-IF, HDMI, etc.)
+- Safety certifications (UL, FCC, CE)
+- Environmental regulations (RoHS, REACH)
+- Quality management systems (ISO 9001:2015)
+
+### Continuous Improvement
+We use warranty claims and customer feedback to:
+- Identify potential quality issues
+- Improve manufacturing processes
+- Enhance product designs
+- Update testing procedures
+
+## Customer Support Excellence
+
+### Our Support Philosophy
+Customer satisfaction is our top priority. Our support team is trained to:
+- Resolve issues quickly and fairly
+- Provide expert technical guidance
+- Offer personalized solutions
+- Ensure positive customer experiences
+
+### Support Team Expertise
+Our customer service representatives have:
+- Technical training on all products
+- Access to engineering and quality assurance teams
+- Authority to make immediate warranty decisions
+- Commitment to customer satisfaction
+
+### Escalation Process
+If you're not satisfied with the initial response:
+1. Ask to speak with a supervisor
+2. Request escalation to management
+3. Contact our Customer Success team directly
+4. Reach out via social media for executive attention
+
+## Legal Terms
+
+### Warranty Limitations
+This warranty is in lieu of all other warranties, express or implied, including merchantability and fitness for a particular purpose. Our liability is limited to repair or replacement of defective products.
+
+### Limitation of Liability
+Too Many Cables shall not be liable for any incidental, consequential, or special damages arising from the use of our products. Maximum liability is limited to the purchase price of the product.
+
+### Dispute Resolution
+Any disputes will be resolved through binding arbitration in accordance with the rules of the American Arbitration Association.
+
+---
+
+**Questions about our return or warranty policy?**
+Contact our customer service team:
+- AI Chat: Available 24/7 on our website
+- Email: support@toomanycables.com
+- Phone: 1-800-TMC-HELP
+- Mail: Too Many Cables Customer Service, [Corporate Address]
+
+*Policy effective as of January 1, 2024. Subject to change without notice.*

knowledge_base/policies/shipping_customer_service.md

@@ -0,0 +1,288 @@
+# Too Many Cables - Shipping and Customer Service Policy
+
+## Shipping Policy
+
+### Domestic Shipping (United States)
+
+#### Standard Shipping
+- **Processing Time**: Orders placed before 3 PM EST ship same day
+- **Delivery Time**: 2-3 business days via USPS or UPS
+- **Cost**: Free on orders over $25, $4.99 for orders under $25
+- **Tracking**: Provided via email once order ships
+- **Coverage**: All 50 states, APO/FPO addresses
+
+#### Expedited Shipping Options
+**Next Day Delivery:**
+- **Delivery Time**: Next business day by 3 PM
+- **Cost**: $14.99 (free on orders over $200)
+- **Cutoff**: Orders must be placed by 12 PM EST
+- **Availability**: Monday-Thursday (Friday orders deliver Monday)
+
+**2-Day Express:**
+- **Delivery Time**: 2 business days
+- **Cost**: $9.99 (free on orders over $150)
+- **Cutoff**: Orders must be placed by 3 PM EST
+- **Availability**: Monday-Friday
+
+#### Weekend and Holiday Shipping
+- **Saturday Delivery**: Available for additional $5.99
+- **Sunday Delivery**: Not available
+- **Holiday Processing**: No processing on federal holidays
+- **Holiday Rush**: Extended cutoff times during peak seasons
+
+### International Shipping
+
+#### Available Countries
+We ship to over 190 countries worldwide, including:
+- **Tier 1** (5-7 business days): Canada, UK, EU, Australia, Japan
+- **Tier 2** (7-14 business days): Most other countries
+- **Restricted**: Some countries may have shipping restrictions
+
+#### International Shipping Costs
+- **Canada**: Starting at $12.99
+- **EU/UK**: Starting at $15.99
+- **Asia/Pacific**: Starting at $18.99
+- **Other Countries**: Calculated at checkout
+- **Free International**: Orders over $500
+
+#### Customs and Duties
+- **Declared Value**: Full retail value as required by law
+- **Customs Forms**: Completed accurately for all shipments
+- **Duties/Taxes**: Customer responsibility, varies by country
+- **Customs Delays**: Not included in delivery estimates
+- **Restricted Items**: Some cables may be restricted in certain countries
+
+### Special Shipping Situations
+
+#### Large Orders (Commercial/Bulk)
+- **Freight Shipping**: Available for orders over 50 lbs
+- **Business Addresses**: Faster delivery to commercial locations
+- **Wholesale Pricing**: Volume discounts available
+- **Account Management**: Dedicated support for large customers
+- **Custom Delivery**: White glove service available
+
+#### APO/FPO Military Addresses
+- **Shipping Method**: USPS Priority Mail only
+- **Delivery Time**: 7-21 business days
+- **Cost**: Same as domestic shipping
+- **Restrictions**: Some high-value items may require signature
+- **Documentation**: Military ID verification may be required
+
+#### P.O. Box Delivery
+- **USPS Only**: UPS/FedEx cannot deliver to P.O. boxes
+- **Automatic Routing**: System selects appropriate carrier
+- **Delivery Time**: Same as standard shipping
+- **Restrictions**: Some expedited options not available
+- **Size Limits**: Large packages may require pickup
+
+## Order Processing
+
+### Order Confirmation
+- **Immediate Confirmation**: Email sent within minutes of order
+- **Order Review**: All orders reviewed for accuracy
+- **Inventory Check**: Real-time stock verification
+- **Payment Processing**: Secure processing within 2 hours
+- **Fraud Prevention**: Advanced security screening
+
+### Order Modifications
+**Before Shipping:**
+- **Changes Allowed**: Address, shipping method, item quantities
+- **Contact Required**: Must contact customer service
+- **Time Limit**: Changes accepted until order ships
+- **Additional Charges**: May apply for expedited shipping
+
+**After Shipping:**
+- **Address Changes**: Contact carrier directly for delivery instructions
+- **Intercept Service**: Available for additional fee through carriers
+- **Return to Sender**: Full refund minus shipping costs
+- **Reshipment**: New shipping charges apply
+
+### Inventory Management
+- **Real-Time Updates**: Inventory updated continuously
+- **Backorder Policy**: Customer notification if items unavailable
+- **Substitutions**: Only with customer approval
+- **Partial Shipments**: Available to get some items faster
+- **Stock Alerts**: Email notifications when items back in stock
+
+## Customer Service Standards
+
+### Response Time Commitments
+- **AI Chat**: Instant response 24/7
+- **Email**: Response within 2 hours during business hours
+- **Phone**: Average wait time under 30 seconds
+- **Social Media**: Response within 1 hour during business hours
+- **After Hours**: Emergency support available for urgent issues
+
+### Customer Service Hours
+**Standard Support:**
+- **Monday-Friday**: 8 AM - 8 PM EST
+- **Saturday**: 9 AM - 5 PM EST
+- **Sunday**: AI chat only, emergency phone support
+
+**Holiday Hours:**
+- **Major Holidays**: Reduced hours or closed
+- **Black Friday/Cyber Monday**: Extended hours
+- **Holiday Season**: Extended hours through New Year
+
+### Service Level Standards
+
+#### First Contact Resolution
+- **Target**: 85% of issues resolved on first contact
+- **Escalation**: Complex issues escalated within 15 minutes
+- **Follow-up**: Proactive follow-up within 24 hours
+- **Satisfaction**: Customer satisfaction survey for all interactions
+
+#### Issue Categories & Response Times
+**Urgent Issues** (Response within 1 hour):
+- Order delivery problems
+- Defective products affecting critical systems
+- Payment processing errors
+- Security/privacy concerns
+
+**Standard Issues** (Response within 4 hours):
+- General product questions
+- Compatibility inquiries
+- Return/exchange requests
+- Account management
+
+**General Inquiries** (Response within 24 hours):
+- Product recommendations
+- Technical specifications
+- Company information
+- Partnership inquiries
+
+### Customer Service Philosophy
+
+#### Our Commitment
+- **Customer First**: Every decision prioritizes customer satisfaction
+- **Proactive Support**: Anticipate and prevent issues when possible
+- **Expert Knowledge**: Extensive product and technical training
+- **Empowerment**: Representatives authorized to resolve issues immediately
+
+#### Service Principles
+1. **Listen Actively**: Understand the customer's complete situation
+2. **Respond Quickly**: Provide timely, accurate information
+3. **Take Ownership**: See issues through to complete resolution
+4. **Exceed Expectations**: Go above and beyond when possible
+5. **Follow Through**: Ensure customer satisfaction after resolution
+
+## Quality Assurance
+
+### Order Accuracy
+- **Pick Verification**: Double-check all items before packing
+- **Quality Control**: Visual inspection of all products
+- **Packaging Standards**: Protective packaging for all shipments
+- **Documentation**: Packing slip accuracy verification
+- **Error Rate**: Target less than 0.1% order errors
+
+### Damage Prevention
+- **Packaging Materials**: High-quality protective materials
+- **Fragile Items**: Special handling procedures
+- **Weather Protection**: Moisture-resistant packaging
+- **Carrier Requirements**: Compliance with all carrier standards
+- **Insurance**: Automatic coverage on high-value shipments
+
+### Customer Feedback Integration
+- **Review Analysis**: Regular review of customer feedback
+- **Process Improvement**: Continuous improvement based on feedback
+- **Training Updates**: Staff training updated based on common issues
+- **Policy Updates**: Policies updated to address customer needs
+
+## Problem Resolution
+
+### Common Issues & Solutions
+
+#### Shipping Delays
+**Causes**: Weather, carrier delays, high volume periods
+**Solutions**: 
+- Proactive communication to affected customers
+- Expedited replacement shipping at no charge
+- Full refund if unacceptable delay
+- Compensation for critical delivery failures
+
+#### Damaged Packages
+**Process**:
+1. Customer photos of damage documented
+2. Immediate replacement authorization
+3. Carrier claim filed automatically
+4. Customer receives replacement within 24 hours
+5. No need to return damaged item unless requested
+
+#### Lost Packages
+**Response**:
+- Carrier tracking investigation initiated
+- Replacement shipped immediately
+- Insurance claim processed
+- Delivery confirmation required going forward
+- Address verification for future orders
+
+### Escalation Procedures
+
+#### Level 1: Customer Service Representative
+- Standard issue resolution
+- Policy explanation and application
+- Basic troubleshooting assistance
+- Order modifications and updates
+
+#### Level 2: Customer Service Supervisor
+- Complex technical issues
+- Policy exceptions and special circumstances
+- Complaint resolution
+- Quality assurance issues
+
+#### Level 3: Customer Success Manager
+- Executive complaints
+- Major account issues
+- Process improvement feedback
+- Partnership and wholesale inquiries
+
+#### Executive Level: Leadership Team
+- Corporate policy issues
+- Legal or regulatory matters
+- Media or public relations issues
+- Strategic partnership opportunities
+
+## Continuous Improvement
+
+### Performance Metrics
+- **Customer Satisfaction Score**: Target 95%+
+- **First Call Resolution**: Target 85%+
+- **Average Response Time**: Under 2 hours
+- **Order Accuracy**: 99.9%+
+- **On-Time Delivery**: 98%+
+
+### Regular Reviews
+- **Monthly Performance Reviews**: Team and individual metrics
+- **Quarterly Policy Updates**: Based on customer feedback
+- **Annual Training**: Comprehensive update training
+- **Customer Advisory Panel**: Regular feedback sessions
+
+### Technology Integration
+- **CRM System**: Complete customer interaction history
+- **AI Assistance**: Advanced chatbot for instant support
+- **Predictive Analytics**: Anticipate customer needs
+- **Mobile Optimization**: Full mobile customer service capability
+
+## Contact Information
+
+### Customer Service Channels
+- **Phone**: 1-800-TMC-HELP (1-800-862-4357)
+- **Email**: support@toomanycables.com
+- **Live Chat**: Available 24/7 at toomanycables.com
+- **Social Media**: @TooManyCables on Twitter, Facebook, Instagram
+
+### Specialized Support
+- **Technical Support**: tech@toomanycables.com
+- **Warranty Claims**: warranty@toomanycables.com
+- **Business Sales**: business@toomanycables.com
+- **Partnership Inquiries**: partnerships@toomanycables.com
+
+### Mailing Address
+Too Many Cables Customer Service
+[Corporate Headquarters Address]
+[City, State ZIP Code]
+
+---
+
+*Policy effective September 2024 - Subject to periodic updates*
+*For the most current version, visit toomanycables.com/policies*

knowledge_base/product_manuals/audio_cable.md

@@ -0,0 +1,276 @@
+# Audio Cable Product Manual
+
+## Product Overview
+
+Too Many Cables 3.5mm Audio Cable delivers high-quality stereo audio transmission with premium gold-plated connectors, tangle-free design, and universal compatibility for all audio devices with standard 3.5mm headphone jacks.
+
+## Product Specifications
+
+### TMC-AUDIO-3.5MM-6FT
+- **Length**: 6 feet (1.8 meters)
+- **Connector Type**: 3.5mm stereo male to 3.5mm stereo male
+- **Conductor**: High-purity oxygen-free copper (OFC)
+- **Insulation**: Low-loss PE dielectric
+- **Shielding**: 95% coverage braided copper shield
+- **Jacket**: Flexible PVC with tangle-resistant design
+- **Connectors**: 24k gold-plated for corrosion resistance
+- **Impedance**: 75 ohms
+- **Frequency Response**: 20Hz - 20kHz
+- **Signal-to-Noise Ratio**: >90dB
+- **Cross Talk**: <-40dB
+- **Weight**: 2.1 oz (60g)
+
+## Audio Performance
+
+### Signal Quality
+- **Frequency Response**: Flat 20Hz to 20kHz (±0.5dB)
+- **Total Harmonic Distortion**: <0.1% at 1kHz
+- **Signal-to-Noise Ratio**: >90dB
+- **Channel Separation**: >40dB at 1kHz
+- **Maximum Input Level**: 2V RMS
+
+### Impedance Characteristics
+- **Cable Impedance**: 75 ohms
+- **Capacitance**: 30pF per foot
+- **Resistance**: <0.1 ohms per conductor
+- **Compatible Load Impedance**: 8 ohms to 10k ohms
+
+## Compatibility Guide
+
+### Source Devices
+**Smartphones:**
+- iPhone (all models with 3.5mm jack or adapter)
+- Samsung Galaxy series
+- Google Pixel series (with adapter)
+- Most Android phones with 3.5mm jack
+- Older smartphones with built-in audio jack
+
+**Audio Players:**
+- iPod (all models with 3.5mm output)
+- Portable CD players
+- MP3 players
+- Digital audio players (DAPs)
+- Walkmans and portable cassette players
+
+**Computers & Laptops:**
+- Desktop computers (line out/headphone jack)
+- Laptops with 3.5mm audio output
+- Tablets with audio jack
+- Gaming laptops
+- Workstations with audio output
+
+**Audio Equipment:**
+- Headphone amplifiers
+- Audio interfaces
+- Mixing consoles
+- Portable speakers
+- Car stereos with aux input
+- Home stereo systems
+
+**Gaming Devices:**
+- Nintendo Switch (handheld mode)
+- PlayStation Portable (PSP)
+- Nintendo 3DS/2DS
+- Retro gaming consoles
+- Gaming headset splitters
+
+### Output Devices
+**Headphones & Earphones:**
+- Over-ear headphones
+- On-ear headphones
+- In-ear monitors (IEMs)
+- Earbuds and earphones
+- Studio monitor headphones
+
+**Speakers:**
+- Portable Bluetooth speakers (aux input)
+- Desktop computer speakers
+- Bookshelf speakers with 3.5mm input
+- Powered studio monitors
+- Car speakers via aux input
+
+**Audio Systems:**
+- Home stereo receivers
+- Amplifiers with 3.5mm input
+- PA systems
+- Recording equipment
+- Audio mixers
+
+## Usage Instructions
+
+### Basic Connection
+1. Identify source device 3.5mm output
+2. Identify target device 3.5mm input
+3. Insert connectors fully into both devices
+4. Ensure secure connection (click into place)
+5. Test audio playback and adjust volume
+
+### Optimal Setup
+- **Clean Connections**: Ensure jacks are clean and debris-free
+- **Secure Fit**: Push connectors fully into jacks
+- **Strain Relief**: Avoid sharp bends near connectors
+- **Volume Levels**: Start with low volume and increase gradually
+
+### Cable Management
+- **Tangle Prevention**: Use loose coiling for storage
+- **Avoid Stress**: Don't pull on connectors
+- **Proper Storage**: Coil loosely when not in use
+- **Heat Protection**: Keep away from heat sources
+
+## Technical Specifications
+
+### Electrical Characteristics
+- **Conductor Material**: Oxygen-free copper (OFC)
+- **Conductor Gauge**: 26 AWG
+- **Shield Coverage**: 95% braided copper
+- **Jacket Material**: Flexible PVC
+- **Connector Plating**: 24k gold (15μ" thickness)
+
+### Mechanical Properties
+- **Bend Radius**: 5x cable diameter minimum
+- **Pull Strength**: 50 lbs minimum
+- **Connector Retention**: 22 lbs minimum
+- **Flex Life**: >10,000 cycles
+- **Temperature Rating**: -20°C to +60°C
+
+### Audio Performance Specifications
+- **Bandwidth**: DC to 100MHz
+- **Insertion Loss**: <0.1dB at 20kHz
+- **Return Loss**: >20dB (20Hz-20kHz)
+- **Crosstalk**: <-40dB at 10kHz
+- **Propagation Delay**: 1.5ns per foot
+
+### Environmental Ratings
+- **Operating Temperature**: -4°F to 140°F (-20°C to 60°C)
+- **Storage Temperature**: -40°F to 185°F (-40°C to 85°C)
+- **Humidity**: 5% to 95% RH (non-condensing)
+- **Altitude**: Up to 10,000 feet (3,000m)
+
+## Audio Quality Features
+
+### Superior Materials
+- **OFC Conductors**: Reduces signal loss and distortion
+- **PE Dielectric**: Low-loss insulation for clarity
+- **Braided Shield**: Minimizes electromagnetic interference
+- **Gold Plating**: Prevents corrosion and ensures reliable connection
+
+### Noise Reduction
+- **Shielding**: 95% coverage protects against EMI/RFI
+- **Twisted Pair**: Reduces crosstalk between channels
+- **Low Capacitance**: Maintains high-frequency response
+- **Strain Relief**: Prevents intermittent connections
+
+## Troubleshooting
+
+### Common Issues
+
+**No Audio Output**
+- Check volume levels on both devices
+- Verify cable is fully inserted in both jacks
+- Test cable with different devices
+- Check if devices are muted
+- Try different audio source
+
+**Poor Audio Quality**
+- Clean connector contacts
+- Check for loose connections
+- Verify cable isn't damaged
+- Test with different audio content
+- Check device audio settings
+
+**Audio Only in One Channel**
+- Ensure cable is fully inserted
+- Check for bent connectors
+- Test cable with different devices
+- Verify source audio is stereo
+- Check device balance settings
+
+**Intermittent Audio**
+- Check for loose connections
+- Inspect cable for damage
+- Clean contact surfaces
+- Avoid cable stress/bending
+- Test in different positions
+
+**Background Noise/Hum**
+- Check for interference sources
+- Ensure proper grounding
+- Move away from power cables
+- Check gain/volume levels
+- Try different cable routing
+
+### Advanced Troubleshooting
+- **Impedance Matching**: Verify compatible impedances
+- **Signal Levels**: Check if levels are appropriate
+- **Grounding Issues**: Ensure proper system grounding
+- **Cable Testing**: Test continuity with multimeter
+
+## Care & Maintenance
+
+### Cleaning Instructions
+- **Disconnect**: Remove from devices before cleaning
+- **Dry Cleaning**: Use lint-free cloth for cable jacket
+- **Connector Care**: Clean with isopropyl alcohol if needed
+- **Avoid Moisture**: Keep connectors dry
+- **Storage**: Coil loosely to prevent damage
+
+### Preventive Maintenance
+- **Regular Inspection**: Check for wear or damage
+- **Proper Storage**: Avoid tight coiling or knotting
+- **Stress Relief**: Support cable weight at connections
+- **Temperature**: Store in moderate temperature environment
+
+## What's Included
+
+### Package Contents
+- 1x TMC 3.5mm Audio Cable (6ft)
+- 1x Cable management velcro strap
+- 1x Quick Reference Guide
+- 1x Warranty Registration Card
+
+## Warranty & Support
+
+### Warranty Coverage
+- **Duration**: Lifetime limited warranty
+- **Coverage**: Manufacturing defects and material failures
+- **Exclusions**: Physical damage, misuse, normal wear
+
+### Customer Support
+- **Website**: support.toomanycables.com/audio
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Live Chat**: Available 24/7 on website
+
+### Warranty Registration
+Register for:
+- Lifetime warranty activation
+- Product support notifications
+- Technical assistance
+- Replacement cable discounts
+
+## Applications
+
+### Professional Audio
+- **Studio Recording**: Connect instruments to audio interfaces
+- **Live Sound**: Patch cables for mixing consoles
+- **DJ Setup**: Connect devices to mixers
+- **Broadcasting**: Studio equipment connections
+
+### Consumer Audio
+- **Home Theater**: Connect devices to receivers
+- **Car Audio**: Phone to car stereo connection
+- **Portable Audio**: Connect players to speakers
+- **Gaming**: Audio connections for gaming setups
+
+### Educational/Business
+- **Presentations**: Connect laptops to PA systems
+- **Classrooms**: Audio visual equipment connections
+- **Conference Rooms**: Audio system integration
+- **Training Facilities**: Equipment interconnection
+
+---
+
+**Model**: TMC-AUDIO-3.5MM-6FT  
+**Manual Version**: 1.2  
+**Last Updated**: October 2025  
+**Document**: TMC-AUDIO-MANUAL-V1.2

knowledge_base/product_manuals/charging_hub.md

@@ -0,0 +1,181 @@
+# Multi-Port Charging Hub Product Manual
+
+## Product Overview
+
+Too Many Cables Multi-Port Charging Hub provides intelligent charging for up to 6 devices simultaneously with 100W total power output and smart charging technology that automatically detects and delivers optimal charging speeds for each connected device.
+
+## Product Specifications
+
+### TMC-CHARGEHUB-100W-6PORT
+- **Total Power Output**: 100W
+- **Port Configuration**: 
+  - 4x USB-A ports (12W each, 48W total)
+  - 2x USB-C PD ports (52W total, single port max 65W)
+- **Smart Charging**: Auto-detect device requirements
+- **Safety Features**: Over-current, over-voltage, over-temperature protection
+- **Input**: AC 100-240V, 50/60Hz
+- **Dimensions**: 5.5" x 3.5" x 1.2" (140 x 89 x 30mm)
+- **Weight**: 12 oz (340g)
+- **Material**: Fire-resistant ABS plastic housing
+- **LED Indicators**: Power and charging status per port
+- **Cable**: 6ft detachable AC power cord
+
+## Compatibility Guide
+
+### Compatible Devices
+**Smartphones:**
+- iPhone (all models with Lightning or USB-C)
+- Samsung Galaxy series
+- Google Pixel series
+- OnePlus devices
+- Most Android smartphones
+
+**Tablets:**
+- iPad (all models)
+- Samsung Galaxy Tab series
+- Microsoft Surface tablets
+- Android tablets
+
+**Laptops & Computers:**
+- MacBook Air/Pro (via USB-C PD)
+- Dell XPS series (via USB-C PD)
+- HP Spectre series (via USB-C PD)
+- Chromebooks with USB-C charging
+- Nintendo Switch
+
+**Other Devices:**
+- Wireless earbuds/headphones
+- Smartwatches
+- Power banks
+- Portable speakers
+- Gaming controllers
+
+## Smart Charging Technology
+
+### Intelligent Power Distribution
+- **Dynamic Power Allocation**: Automatically adjusts power output based on connected devices
+- **Device Recognition**: Identifies device type and optimal charging profile
+- **Priority Charging**: Laptop/tablet charging takes priority when multiple devices connected
+
+### Charging Profiles
+- **USB-A Ports**: 5V/2.4A max per port (12W)
+- **USB-C Port 1**: 5V/3A, 9V/3A, 12V/3A, 15V/3A, 20V/3.25A (65W max)
+- **USB-C Port 2**: 5V/3A, 9V/2A, 12V/1.5A (18W max when both ports used)
+
+## Usage Instructions
+
+### Initial Setup
+1. Connect AC power cord to charging hub
+2. Plug power cord into wall outlet (100-240V)
+3. Power LED should illuminate blue
+4. Hub is ready for device charging
+
+### Device Charging
+1. Connect devices using appropriate cables
+2. Hub automatically detects device requirements
+3. Charging begins immediately
+4. LED indicators show charging status per port
+5. Disconnect devices when charging complete
+
+### LED Status Indicators
+- **Blue**: Hub powered on and ready
+- **Green**: Device charging normally
+- **Orange**: Fast charging active
+- **Red**: Error or overload condition
+- **Off**: No device connected or hub not powered
+
+## Safety Features
+
+### Protection Systems
+- **Over-Current Protection**: Prevents damage from excessive current draw
+- **Over-Voltage Protection**: Protects against voltage spikes
+- **Over-Temperature Protection**: Automatic shutdown if overheating detected
+- **Short-Circuit Protection**: Immediate shutdown on short circuit
+- **Surge Protection**: Built-in surge suppression
+
+### Certifications
+- **FCC Certified**: Electromagnetic compatibility
+- **UL Listed**: Safety standards compliance
+- **Energy Star**: Energy efficiency rating
+- **RoHS Compliant**: Environmental safety standards
+
+## Troubleshooting
+
+### Common Issues
+
+**Hub Not Powering On**
+- Check AC power connection
+- Verify wall outlet is working
+- Try different power outlet
+- Contact support if issue persists
+
+**Device Not Charging**
+- Verify cable is properly connected
+- Try different USB port on hub
+- Test with known working cable
+- Check device charging port for debris
+
+**Slow Charging Speed**
+- Verify using appropriate cable for device
+- Check total power draw (may need to disconnect some devices)
+- Ensure device supports fast charging
+- Clean charging contacts
+
+**LED Indicators Not Working**
+- Check power connection
+- Verify hub is receiving power
+- Contact support for LED replacement
+
+### Error Conditions
+- **Red LED**: Overload condition - disconnect some devices
+- **Hub Shutdown**: Overheating - allow cooling time, check ventilation
+- **No Charging**: Verify compatible charging cable and device
+
+## Technical Specifications
+
+### Electrical Ratings
+- **Input Voltage**: AC 100-240V ± 10%
+- **Input Frequency**: 50/60Hz ± 3Hz
+- **Input Current**: 2.5A max at 100V
+- **Power Factor**: >0.9 at full load
+- **Efficiency**: >85% at rated load
+
+### Environmental Conditions
+- **Operating Temperature**: 32°F to 95°F (0°C to 35°C)
+- **Storage Temperature**: -4°F to 140°F (-20°C to 60°C)
+- **Humidity**: 10% to 90% RH (non-condensing)
+- **Altitude**: Up to 6,600 feet (2,000m)
+
+### Physical Specifications
+- **Dimensions**: 5.5" L x 3.5" W x 1.2" H
+- **Weight**: 12 oz (340g)
+- **Housing Material**: Fire-resistant ABS plastic
+- **Color**: Matte black with blue accents
+
+## Warranty & Support
+
+### Warranty Coverage
+- **Duration**: 3-year limited warranty
+- **Coverage**: Manufacturing defects and material failures
+- **Exclusions**: Physical damage, misuse, normal wear
+
+### Customer Support
+- **Website**: support.toomanycables.com/charginghub
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Live Chat**: Available 24/7 on website
+- **Support Hours**: Monday-Friday 8AM-8PM EST
+
+### Warranty Registration
+Register your product within 30 days of purchase for:
+- Extended warranty coverage
+- Product update notifications
+- Priority customer support
+- Replacement part availability
+
+---
+
+**Model**: TMC-CHARGEHUB-100W-6PORT  
+**Manual Version**: 2.1  
+**Last Updated**: October 2025  
+**Document**: TMC-CHG-HUB-MANUAL-V2.1

knowledge_base/product_manuals/hdmi_cables.md

@@ -0,0 +1,306 @@
+# HDMI Cable Product Manual
+
+## Product Overview
+
+Too Many Cables HDMI cables deliver crystal-clear 4K and 8K video with immersive audio for the ultimate home theater and gaming experience. Our premium cables feature high-speed data transmission, advanced shielding, and gold-plated connectors for reliable, long-lasting connections.
+
+## Product Specifications
+
+### TMC-HDMI-8K-10FT (Ultra High Speed HDMI 2.1)
+- **Length**: 10 feet (3 meters)
+- **Maximum Resolution**: 8K@60Hz, 4K@120Hz
+- **Bandwidth**: 48 Gbps
+- **HDR Support**: HDR10, HDR10+, Dolby Vision
+- **Audio**: eARC, Dolby Atmos, DTS:X
+- **Gaming Features**: VRR, ALLM, QMS, QFT
+- **Connector**: HDMI Type A (Standard)
+- **Material**: Premium braided jacket, gold-plated connectors
+
+### TMC-HDMI-4K-6FT (High Speed HDMI 2.0)
+- **Length**: 6 feet (1.8 meters)
+- **Maximum Resolution**: 4K@60Hz, 1440p@144Hz
+- **Bandwidth**: 18 Gbps
+- **HDR Support**: HDR10, HDR10+
+- **Audio**: ARC, Dolby TrueHD, DTS-HD
+- **Gaming Features**: Basic VRR support
+- **Connector**: HDMI Type A (Standard)
+- **Material**: Durable PVC jacket, gold-plated connectors
+
+### TMC-HDMI-MINI-3FT (Mini HDMI to HDMI)
+- **Length**: 3 feet (0.9 meters)
+- **Maximum Resolution**: 4K@30Hz
+- **Bandwidth**: 10.2 Gbps
+- **HDR Support**: Basic HDR10
+- **Audio**: Standard audio formats
+- **Connector**: Mini HDMI (Type C) to Standard HDMI (Type A)
+- **Material**: Flexible cable design, gold-plated connectors
+
+### TMC-HDMI-MICRO-3FT (Micro HDMI to HDMI)
+- **Length**: 3 feet (0.9 meters)
+- **Maximum Resolution**: 4K@30Hz
+- **Bandwidth**: 10.2 Gbps
+- **HDR Support**: Basic HDR10
+- **Audio**: Standard audio formats
+- **Connector**: Micro HDMI (Type D) to Standard HDMI (Type A)
+- **Material**: Ultra-flexible design, gold-plated connectors
+
+## Compatibility Guide
+
+### Source Devices
+**Gaming Consoles:**
+- PlayStation 5 (requires HDMI 2.1 for 4K@120Hz)
+- Xbox Series X/S (requires HDMI 2.1 for full features)
+- PlayStation 4/4 Pro (HDMI 2.0 sufficient)
+- Xbox One/One X (HDMI 2.0 sufficient)
+- Nintendo Switch (Mini HDMI cable required)
+
+**Computers & Laptops:**
+- Desktop graphics cards (RTX 30/40 series, RX 6000/7000 series)
+- Gaming laptops with HDMI output
+- MacBook Pro/Air (with HDMI port or adapter)
+- Mini PCs and Intel NUCs
+- Tablets with HDMI/Mini HDMI output
+
+**Media Devices:**
+- Apple TV 4K (HDMI 2.1 recommended)
+- Nvidia Shield TV Pro
+- Roku Ultra, Amazon Fire TV Stick 4K Max
+- Chromecast with Google TV
+- Cable/satellite boxes with 4K support
+
+### Display Devices
+**TVs:**
+- 4K/8K Smart TVs (Samsung, LG, Sony, TCL)
+- OLED and QLED displays
+- Gaming-focused TVs with HDMI 2.1
+- Projectors with 4K support
+
+**Monitors:**
+- 4K gaming monitors (144Hz+)
+- Professional displays for content creation
+- Ultrawide monitors with 4K resolution
+- High refresh rate gaming displays
+
+## Performance Features
+
+### Video Quality
+- **8K Resolution**: 7680x4320 pixels at 60Hz
+- **4K Gaming**: 3840x2160 at 120Hz for smooth gameplay
+- **High Dynamic Range**: Enhanced contrast and color
+- **Wide Color Gamut**: BT.2020 color space support
+- **10-Bit Color**: Over 1 billion colors for smooth gradients
+
+### Audio Quality
+- **Enhanced Audio Return Channel (eARC)**: Full-bandwidth audio
+- **Object-Based Audio**: Dolby Atmos and DTS:X support
+- **High-Resolution Audio**: Up to 192kHz/24-bit
+- **Multi-Channel**: Up to 32 audio channels
+- **Audio Sync**: Automatic lip-sync correction
+
+### Gaming Features
+- **Variable Refresh Rate (VRR)**: Eliminates screen tearing
+- **Auto Low Latency Mode (ALLM)**: Reduces input lag automatically
+- **Quick Media Switching (QMS)**: Faster source switching
+- **Quick Frame Transport (QFT)**: Reduced latency for competitive gaming
+
+## Resolution & Refresh Rate Guide
+
+### HDMI 2.1 Cables (8K Series)
+**Supported Resolutions:**
+- 8K (7680x4320): 60Hz, 30Hz
+- 4K (3840x2160): 120Hz, 60Hz, 30Hz
+- 1440p (2560x1440): 144Hz, 120Hz, 60Hz
+- 1080p (1920x1080): 240Hz, 144Hz, 120Hz, 60Hz
+
+### HDMI 2.0 Cables (4K Series)
+**Supported Resolutions:**
+- 4K (3840x2160): 60Hz, 30Hz
+- 1440p (2560x1440): 144Hz, 120Hz, 60Hz
+- 1080p (1920x1080): 144Hz, 120Hz, 60Hz
+- 720p (1280x720): All refresh rates
+
+### Cable Length Considerations
+**Optimal Performance:**
+- Up to 6 feet: Full bandwidth guaranteed
+- 6-15 feet: Full bandwidth with quality cables
+- 15-25 feet: May require active cables for highest resolutions
+- 25+ feet: Active or fiber optic cables recommended
+
+## Installation & Setup
+
+### Basic Connection
+1. **Power Off Devices**: Turn off both source and display devices
+2. **Connect Cable**: Insert HDMI connectors fully into ports
+3. **Power On**: Turn on display first, then source device
+4. **Select Input**: Use TV/monitor remote to select correct HDMI input
+5. **Verify Signal**: Check for picture and audio
+
+### Optimizing Picture Quality
+1. **Display Settings**: Access TV/monitor picture settings
+2. **HDMI Mode**: Enable "Enhanced" or "Ultra HD Deep Color"
+3. **HDR Settings**: Enable HDR10, HDR10+, or Dolby Vision
+4. **Color Space**: Set to BT.2020 for wide color gamut
+5. **Game Mode**: Enable for gaming sources to reduce lag
+
+### Audio Setup
+1. **Audio Output**: Set source device to "HDMI" or "Auto"
+2. **Audio Format**: Select highest quality format supported
+3. **eARC Setup**: Enable eARC on both TV and soundbar/receiver
+4. **Channel Configuration**: Set up surround sound speakers
+5. **Audio Delay**: Adjust if lip-sync issues occur
+
+## Troubleshooting
+
+### No Picture/Black Screen
+**Possible Causes & Solutions:**
+- **Loose Connection**: Ensure cables are fully inserted
+- **Wrong Input**: Verify correct HDMI input selected on display
+- **Resolution Mismatch**: Try lower resolution in source settings
+- **HDCP Issues**: Try powering off both devices for 30 seconds
+- **Cable Failure**: Test with known working cable
+
+### Picture Quality Issues
+**Fuzzy or Pixelated Image:**
+- Check if 4K enhancement mode is enabled on TV
+- Verify source is outputting native resolution
+- Try shorter cable if using long cable
+- Clean connectors with compressed air
+
+**Color Issues:**
+- Enable HDR mode on both devices
+- Check color space settings (BT.2020 vs BT.709)
+- Verify cable supports required bandwidth
+- Update device firmware/drivers
+
+**Flickering or Intermittent Signal:**
+- Check cable for physical damage
+- Try different HDMI ports
+- Disable VRR temporarily to test
+- Use higher quality cable for long runs
+
+### Audio Problems
+**No Audio:**
+- Check audio output settings on source device
+- Verify HDMI audio is enabled
+- Try different audio format (PCM vs Bitstream)
+- Check if TV speakers are muted
+
+**Audio Dropouts:**
+- Ensure cable supports full bandwidth
+- Try disabling advanced audio formats temporarily
+- Check for electromagnetic interference
+- Update device audio drivers
+
+**Audio/Video Sync Issues:**
+- Enable audio delay compensation on TV/receiver
+- Try game mode or low latency mode
+- Check if eARC is causing delays
+- Test with basic stereo audio format
+
+### Gaming-Specific Issues
+**High Input Lag:**
+- Enable Game Mode on TV/monitor
+- Verify ALLM is working properly
+- Disable unnecessary picture processing
+- Use HDMI 2.1 cable for latest consoles
+
+**Screen Tearing:**
+- Enable VRR on both console and display
+- Check if display supports console's VRR range
+- Try G-Sync/FreeSync compatible mode
+- Update console and display firmware
+
+## Care & Maintenance
+
+### Proper Handling
+- **Connector Care**: Don't force connectors into ports
+- **Cable Management**: Use gentle curves, avoid sharp bends
+- **Strain Relief**: Support cable weight, don't pull on connectors
+- **Storage**: Coil loosely to prevent internal wire damage
+
+### Environmental Considerations
+- **Temperature**: Avoid extreme heat (near fireplaces, heating vents)
+- **Humidity**: Keep away from excessive moisture
+- **UV Exposure**: Protect from direct sunlight for extended periods
+- **Physical Protection**: Route cables away from foot traffic
+
+### Cleaning & Maintenance
+- **Connectors**: Use compressed air to remove dust
+- **Cable Jacket**: Wipe with slightly damp microfiber cloth
+- **Ports**: Clean device HDMI ports regularly
+- **Contact Cleaner**: Use contact cleaner for stubborn corrosion
+
+## Advanced Features
+
+### HDMI 2.1 Gaming Features
+**Variable Refresh Rate (VRR):**
+- Synchronizes display refresh with GPU frame rate
+- Eliminates screen tearing and stuttering
+- Supported range varies by display (typically 40-120Hz)
+
+**Auto Low Latency Mode (ALLM):**
+- Automatically enables game mode when gaming signal detected
+- Reduces input lag without manual switching
+- Works with PlayStation 5, Xbox Series X/S
+
+**Quick Frame Transport (QFT):**
+- Reduces latency by optimizing frame delivery
+- Most beneficial for competitive gaming
+- Requires compatible source and display
+
+### Professional Features
+**Enhanced Audio Return Channel (eARC):**
+- Full bandwidth audio return from TV to soundbar/receiver
+- Supports uncompressed Dolby Atmos and DTS:X
+- Enables TV as audio hub for multiple sources
+
+**Dynamic HDR:**
+- Scene-by-scene or frame-by-frame HDR optimization
+- Supported formats: HDR10+, Dolby Vision
+- Requires compatible content and display
+
+## Technical Specifications
+
+### Electrical Characteristics
+- **Impedance**: 100Ω ±15% differential
+- **Signal Integrity**: Meets HDMI compliance standards
+- **EMI Shielding**: Triple-layer shielding for interference protection
+- **Bandwidth**: Up to 48 Gbps (HDMI 2.1)
+
+### Physical Construction
+- **Conductor**: High-purity copper with silver plating
+- **Dielectric**: Low-loss foam polyethylene
+- **Shielding**: Aluminum foil + tinned copper braid
+- **Jacket**: Durable PVC or braided nylon
+
+### Connector Specifications
+- **Plating**: Gold-plated contacts (minimum 30 micro-inches)
+- **Durability**: Rated for 10,000+ insertion cycles
+- **Retention Force**: Secure connection without excessive force
+- **Contact Resistance**: <20mΩ per contact
+
+## Warranty & Support
+
+### Lifetime Warranty
+All Too Many Cables HDMI cables include:
+- Coverage against manufacturing defects
+- Protection against material failures
+- Performance guarantee under normal use
+- Free replacement for warranted failures
+
+### Customer Support
+- **Technical Support**: Expert guidance on setup and troubleshooting
+- **Compatibility Assistance**: Help choosing the right cable
+- **Warranty Claims**: Fast, hassle-free replacement process
+- **24/7 AI Chat**: Instant support at toomanycables.com
+
+### Contact Information
+- **Phone**: 1-800-TMC-HELP
+- **Email**: support@toomanycables.com
+- **Live Chat**: Available 24/7 on our website
+- **Support Hours**: Monday-Friday 8 AM - 8 PM EST
+
+---
+
+*Manual version 3.2 - Updated September 2024*
+*For the latest troubleshooting guides, visit toomanycables.com/support*

knowledge_base/product_manuals/lightning_cables.md

@@ -0,0 +1,125 @@
+# Lightning Cable Product Manual
+
+## Product Overview
+
+Too Many Cables Lightning cables provide reliable charging and data transfer for Apple devices including iPhone, iPad, and iPod.
+
+## Product Specifications
+
+### TMC-LIGHTNING-MFI-6FT
+- **Length**: 6 feet (1.8 meters)
+- **Connector Type**: Lightning to USB-A
+- **Data Transfer**: USB 2.0 speeds up to 480 Mbps
+- **Charging**: Up to 2.4A (12W) fast charging
+- **Certification**: MFi (Made for iPhone/iPad/iPod) certified
+- **Durability**: 10,000+ bend test cycles
+- **Warranty**: 2-year limited warranty
+
+## Compatible Devices
+
+### iPhone Models
+- iPhone 15 series (with adapter)
+- iPhone 14 series and earlier
+- iPhone SE (all generations)
+
+### iPad Models  
+- iPad (9th generation and earlier)
+- iPad mini (6th generation and earlier)
+- iPad Air (3rd generation and earlier)
+- iPad Pro 12.9" (2nd generation and earlier)
+- iPad Pro 10.5" and earlier models
+
+### iPod Models
+- iPod touch (7th generation and earlier)
+
+## Usage Instructions
+
+### For Charging
+1. Connect Lightning end to your Apple device
+2. Connect USB-A end to charger or computer
+3. Device should show charging indicator
+4. Charging speeds vary by device and charger capabilities
+
+### For Data Transfer
+1. Connect device to computer with cable
+2. Trust the computer on your iOS device when prompted
+3. Device should appear in iTunes/Finder
+4. Transfer speeds depend on file types and device capabilities
+
+## Troubleshooting
+
+### Device Not Charging
+**Symptoms**: No charging indicator, slow charging, intermittent charging
+
+**Solutions**:
+- Clean Lightning connector with dry cloth
+- Try different charging adapter
+- Check for debris in device port
+- Ensure cable is fully inserted
+- Try different power outlet
+
+### Device Not Recognized
+**Symptoms**: Computer doesn't detect device, iTunes/Finder doesn't show device
+
+**Solutions**:
+- Update iTunes to latest version
+- Try different USB port on computer  
+- Restart both devices
+- Check cable for physical damage
+- Ensure device is unlocked and "Trust Computer" is selected
+
+### Slow Data Transfer
+**Solutions**:
+- Use USB 3.0 port if available (cable still USB 2.0 speeds)
+- Close other applications during transfer
+- Transfer smaller batches of files
+- Ensure device has sufficient storage space
+
+## Care and Maintenance
+
+### Daily Use
+- Avoid sharp bends or kinks
+- Don't pull cable by the cord
+- Store in cool, dry place
+- Keep connectors clean and dry
+
+### Storage
+- Coil loosely when storing
+- Avoid extreme temperatures
+- Keep away from sharp objects
+- Store in protective case if available
+
+## Warranty Information
+
+### Coverage
+- 2-year limited warranty from date of purchase
+- Covers manufacturing defects and material failures
+- Does not cover physical damage from misuse
+
+### What's NOT Covered
+- Damage from pets, liquids, or extreme conditions
+- Normal wear and tear
+- Damage from improper use or storage
+- Third-party modifications
+
+## Technical Support
+
+For technical assistance:
+- Email: support@toomanycables.com
+- Phone: 1-800-TMC-HELP
+- Live Chat: Available on our website
+- Hours: Monday-Friday 9 AM - 6 PM EST
+
+## Frequently Asked Questions
+
+**Q: Is this cable MFi certified?**
+A: Yes, all our Lightning cables are MFi certified by Apple.
+
+**Q: Will this work with iPhone 15?**
+A: iPhone 15 uses USB-C. You would need a Lightning to USB-C adapter or our USB-C cables.
+
+**Q: Can I use this for fast charging?**
+A: Yes, supports up to 2.4A charging when used with compatible power adapter.
+
+**Q: What's the maximum data transfer speed?**
+A: USB 2.0 speeds up to 480 Mbps for data transfer.

knowledge_base/product_manuals/usb_c_audio_adapter.md

@@ -0,0 +1,292 @@
+# USB-C to 3.5mm Audio Adapter Product Manual
+
+## Product Overview
+
+Too Many Cables USB-C to 3.5mm Audio Adapter provides high-resolution audio output for USB-C devices that lack a traditional headphone jack. Features a premium 32-bit DAC for superior sound quality and compact aluminum housing for durability.
+
+## Product Specifications
+
+### TMC-USBC-AUDIO-32BIT
+- **DAC Chipset**: 32-bit premium audio processing
+- **Sample Rates**: 44.1kHz, 48kHz, 88.2kHz, 96kHz, 176.4kHz, 192kHz
+- **Bit Depth**: 16-bit, 24-bit, 32-bit
+- **Frequency Response**: 20Hz - 40kHz (±0.1dB)
+- **Signal-to-Noise Ratio**: >110dB
+- **Total Harmonic Distortion**: <0.003%
+- **Output Power**: 2 x 15mW @ 32Ω
+- **Connector**: USB-C male to 3.5mm female
+- **Dimensions**: 2.2" x 0.6" x 0.4" (56 x 15 x 10mm)
+- **Weight**: 0.5 oz (15g)
+- **Material**: Premium aluminum alloy housing
+- **Cable**: 4-inch integrated cable
+- **Compatibility**: USB-C devices with audio support
+
+## Audio Performance
+
+### DAC Specifications
+- **Architecture**: Delta-Sigma 32-bit DAC
+- **Dynamic Range**: >110dB
+- **THD+N**: <0.003% at 1kHz
+- **Crosstalk**: <-100dB at 1kHz
+- **Channel Balance**: ±0.1dB
+- **Phase Response**: Linear phase
+
+### Output Characteristics
+- **Maximum Output**: 2V RMS (unloaded)
+- **Output Impedance**: <1 ohm
+- **Load Impedance**: 16Ω to 600Ω (recommended)
+- **Power Output**: 
+  - 15mW @ 32Ω per channel
+  - 10mW @ 150Ω per channel
+  - 2mW @ 600Ω per channel
+
+### Supported Audio Formats
+- **PCM**: 16/24/32-bit up to 192kHz
+- **DSD**: Native DSD64, DSD128 (device dependent)
+- **Compressed**: MP3, AAC, FLAC, ALAC, OGG
+- **High-Res**: MQA unfold (software dependent)
+
+## Compatibility Guide
+
+### Compatible Source Devices
+
+**Smartphones:**
+- iPhone 15 series and later
+- Samsung Galaxy S20 and later
+- Google Pixel 2 and later
+- OnePlus 6T and later
+- Xiaomi phones with USB-C
+- Huawei phones with USB-C (where available)
+
+**Tablets:**
+- iPad Pro (2018 and later)
+- iPad Air (4th generation and later)
+- Samsung Galaxy Tab S series
+- Microsoft Surface Pro with USB-C
+
+**Laptops & Computers:**
+- MacBook Pro (2016 and later)
+- MacBook Air (2018 and later)
+- Dell XPS series
+- HP Spectre series
+- Lenovo ThinkPad series
+- Microsoft Surface Laptop series
+- Gaming laptops with USB-C
+
+**Other Devices:**
+- Nintendo Switch
+- Steam Deck
+- Android TV boxes
+- USB-C audio interfaces
+- Digital audio players with USB-C
+
+### Compatible Headphones/Earphones
+- **High-Impedance**: Up to 600Ω headphones
+- **Sensitive IEMs**: In-ear monitors (16-32Ω)
+- **Studio Headphones**: Professional monitoring headphones
+- **Consumer Headphones**: Standard 32-300Ω headphones
+- **Earbuds**: Standard and high-end earbuds
+
+## Usage Instructions
+
+### Basic Setup
+1. Connect adapter's USB-C plug to device
+2. Connect headphones/earphones to 3.5mm jack
+3. Audio output automatically switches to adapter
+4. Adjust volume using device controls
+
+### Audio Quality Optimization
+1. **High-Res Settings**: Enable high-resolution audio in device settings
+2. **Sample Rate**: Use native sample rate of audio files when possible
+3. **Volume**: Set device volume to 75-85% for optimal performance
+4. **Audio Apps**: Use audiophile apps that support high-res formats
+
+### Device-Specific Setup
+
+**Android:**
+1. Settings → Sound → Audio quality
+2. Enable "High quality audio" or "Hi-Res audio"
+3. Select appropriate sample rate if available
+4. Disable audio processing effects for purest sound
+
+**iPhone/iPad:**
+1. Settings → Music → Audio Quality
+2. Enable "Lossless" and "Hi-Res Lossless"
+3. Use Apple Music or compatible apps
+4. Adapter automatically handles optimal conversion
+
+**Windows:**
+1. Control Panel → Sound → Playbook devices
+2. Select adapter → Properties → Advanced
+3. Choose highest quality format available
+4. Disable audio enhancements for best quality
+
+**macOS:**
+1. System Preferences → Sound → Output
+2. Select adapter as output device
+3. Audio MIDI Setup → Configure for high sample rates
+4. Use high-quality audio applications
+
+## Technical Specifications
+
+### Electrical Requirements
+- **Power Consumption**: <100mW
+- **Supply Voltage**: 5V from USB-C
+- **Current Draw**: <20mA
+- **No External Power**: Bus-powered operation
+
+### Signal Processing
+- **Input**: Digital audio via USB-C
+- **Processing**: 32-bit internal processing
+- **Output**: Analog stereo 3.5mm
+- **Latency**: <10ms digital to analog conversion
+
+### Physical Specifications
+- **Total Length**: 2.2 inches (56mm)
+- **Body Diameter**: 0.6 inches (15mm)
+- **Thickness**: 0.4 inches (10mm)
+- **Weight**: 0.5 oz (15g)
+- **Housing**: CNC machined aluminum
+- **Finish**: Anodized matte black
+
+### Environmental Conditions
+- **Operating Temperature**: 32°F to 104°F (0°C to 40°C)
+- **Storage Temperature**: -4°F to 140°F (-20°C to 60°C)
+- **Humidity**: 10% to 90% RH (non-condensing)
+- **Altitude**: Up to 6,600 feet (2,000m)
+
+## Audio Features
+
+### High-Resolution Audio Support
+- **Studio Quality**: 32-bit/192kHz capable
+- **Low Noise Floor**: >110dB SNR for pristine audio
+- **Wide Bandwidth**: 20Hz-40kHz frequency response
+- **Accurate Reproduction**: <0.003% THD for clean sound
+
+### Advanced Features
+- **Automatic Gain Control**: Prevents clipping and distortion
+- **Pop/Click Suppression**: Eliminates connection artifacts
+- **Power Management**: Intelligent power saving
+- **Universal Compatibility**: Works with all major platforms
+
+## Troubleshooting
+
+### Common Issues
+
+**No Audio Output**
+- Verify adapter is fully connected
+- Check device recognizes audio adapter
+- Ensure headphones are properly connected
+- Try different headphones to test adapter
+- Restart device to refresh audio system
+
+**Poor Audio Quality**
+- Check audio format settings on device
+- Disable audio processing/effects
+- Verify high-quality audio is enabled
+- Use lossless audio files
+- Check headphone impedance compatibility
+
+**Low Volume Output**
+- Increase device volume to 75-85%
+- Check if volume limit is enabled
+- Verify headphone sensitivity rating
+- Try different audio application
+- Check for impedance mismatch
+
+**Intermittent Audio**
+- Ensure secure USB-C connection
+- Check for cable/connector damage
+- Clean USB-C port of device
+- Try different USB-C port if available
+- Test with different headphones
+
+**Device Not Recognizing Adapter**
+- Restart device with adapter connected
+- Check for driver updates (Windows/Android)
+- Try different USB-C port
+- Verify device supports USB-C audio
+- Contact support if issue persists
+
+### Advanced Troubleshooting
+
+**High-Impedance Headphones:**
+- Use headphone amplifier for >300Ω headphones
+- Check power output specifications
+- Consider dedicated headphone amp for best performance
+
+**Compatibility Issues:**
+- Verify device supports USB-C audio standard
+- Check if device requires specific drivers
+- Update device firmware/software
+- Try with known compatible device
+
+## Care & Maintenance
+
+### Cleaning Instructions
+- **Disconnect**: Remove from device before cleaning
+- **Dry Cloth**: Use lint-free cloth for housing
+- **Connector Care**: Keep USB-C connector clean and dry
+- **No Liquids**: Avoid moisture in connectors
+- **Storage**: Use provided pouch when not in use
+
+### Preventive Care
+- **Gentle Handling**: Avoid dropping or impact
+- **Cable Protection**: Don't bend cable sharply
+- **Temperature**: Store in moderate temperatures
+- **Moisture**: Keep away from liquids
+
+## What's Included
+
+### Package Contents
+- 1x TMC USB-C to 3.5mm Audio Adapter
+- 1x Premium carrying pouch
+- 1x Quick Start Guide
+- 1x Warranty Registration Card
+
+## Applications
+
+### Audiophile Listening
+- **High-Res Music**: Studio-quality playback
+- **Critical Listening**: Professional audio monitoring
+- **Music Production**: Mobile audio editing
+- **Streaming**: High-quality music streaming services
+
+### Professional Use
+- **Field Recording**: Monitor audio during recording
+- **Broadcasting**: Live audio monitoring
+- **DJ Applications**: Mobile DJ setups
+- **Content Creation**: Podcast and video production
+
+### Gaming & Entertainment
+- **Mobile Gaming**: High-quality game audio
+- **Video Streaming**: Enhanced movie/show audio
+- **Communication**: Clear voice chat audio
+- **Virtual Reality**: Immersive VR audio
+
+## Warranty & Support
+
+### Warranty Coverage
+- **Duration**: 18-month limited warranty
+- **Coverage**: Manufacturing defects and material failures
+- **Exclusions**: Physical damage, misuse, normal wear
+
+### Customer Support
+- **Website**: support.toomanycables.com/audio
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Live Chat**: Available 24/7 on website
+
+### Warranty Registration
+Register for:
+- Full warranty coverage
+- Product support updates
+- Technical assistance priority
+- Software update notifications
+
+---
+
+**Model**: TMC-USBC-AUDIO-32BIT  
+**Manual Version**: 1.4  
+**Last Updated**: October 2025  
+**Document**: TMC-USBC-AUDIO-MANUAL-V1.4

knowledge_base/product_manuals/usb_c_cables.md

@@ -0,0 +1,264 @@
+# USB-C Cable Product Manual
+
+## Product Overview
+
+Too Many Cables USB-C cables provide high-speed data transfer, fast charging, and video output capabilities for all your USB-C enabled devices. Our premium cables feature gold-plated connectors, high-grade copper conductors, and durable construction backed by our lifetime warranty.
+
+## Product Specifications
+
+### TMC-USBC-100W-6FT (Premium USB-C Cable)
+- **Length**: 6 feet (1.8 meters)
+- **Power Delivery**: Up to 100W (20V/5A)
+- **Data Transfer**: USB 3.2 Gen 2 (10 Gbps)
+- **Video Support**: 4K@60Hz, 1440p@144Hz
+- **Connector**: USB-C to USB-C, reversible
+- **Material**: Braided nylon exterior, gold-plated connectors
+- **Compatibility**: USB-C devices with Power Delivery support
+
+### TMC-USBC-60W-3FT (Standard USB-C Cable)
+- **Length**: 3 feet (0.9 meters)
+- **Power Delivery**: Up to 60W (20V/3A)
+- **Data Transfer**: USB 3.1 Gen 1 (5 Gbps)
+- **Video Support**: 4K@30Hz
+- **Connector**: USB-C to USB-C, reversible
+- **Material**: PVC jacket, gold-plated connectors
+- **Compatibility**: Most USB-C devices
+
+### TMC-USBC-A-FAST (USB-A to USB-C Cable)
+- **Length**: 6 feet (1.8 meters)
+- **Power Delivery**: Up to 18W (9V/2A)
+- **Data Transfer**: USB 3.0 (5 Gbps)
+- **Video Support**: Not supported
+- **Connector**: USB-A to USB-C
+- **Material**: Braided exterior, gold-plated connectors
+- **Compatibility**: USB-A ports to USB-C devices
+
+## Compatibility Guide
+
+### Compatible Devices
+**Smartphones & Tablets:**
+- iPhone 15 series and later
+- Samsung Galaxy S8 and later
+- Google Pixel 2 and later
+- iPad Pro (2018 and later)
+- Most Android devices with USB-C
+
+**Laptops & Computers:**
+- MacBook Pro (2016 and later)
+- MacBook Air (2018 and later)
+- Dell XPS series
+- HP Spectre series
+- Lenovo ThinkPad X1 series
+- Surface Pro X and Surface Laptop Studio
+
+**Gaming & Accessories:**
+- Nintendo Switch and Switch OLED
+- Steam Deck
+- USB-C headphones and earbuds
+- External drives and hubs
+- Monitors with USB-C input
+
+### Power Delivery Compatibility
+**100W Cables Support:**
+- MacBook Pro 16" (96W)
+- Gaming laptops up to 100W
+- High-power USB-C chargers
+- Power banks with 100W output
+
+**60W Cables Support:**
+- MacBook Air (30W)
+- MacBook Pro 13" (61W)
+- Most smartphones and tablets
+- Standard USB-C chargers
+
+**18W USB-A Cables Support:**
+- Quick Charge 3.0 devices
+- Standard smartphone charging
+- Tablet charging at reduced speed
+
+## Performance Features
+
+### Fast Charging
+- **Power Delivery 3.0**: Negotiates optimal charging speed
+- **Smart Charging**: Protects devices from overcharging
+- **High Current Support**: Up to 5A for fastest charging
+- **Temperature Management**: Built-in heat dissipation
+
+### High-Speed Data Transfer
+- **USB 3.2 Gen 2**: Up to 10 Gbps transfer speeds
+- **Backward Compatible**: Works with USB 2.0 and 3.0
+- **Low Latency**: Optimized for gaming and real-time applications
+- **Error Correction**: Built-in data integrity protection
+
+### Video Output
+- **4K Resolution**: Support for 4K@60Hz displays
+- **HDR Support**: High Dynamic Range video transmission
+- **Multi-Stream**: Supports multiple displays via hubs
+- **Audio Included**: Digital audio transmission with video
+
+## Installation & Setup
+
+### Basic Connection
+1. **Identify Ports**: Locate USB-C ports on both devices
+2. **Insert Cable**: USB-C connectors are reversible - either way works
+3. **Verify Connection**: Look for charging indicator or connection notification
+4. **Test Functionality**: Try data transfer or video output as needed
+
+### For Charging
+1. Connect cable to power adapter and device
+2. Device should show charging indicator
+3. For fast charging, use compatible PD charger
+4. Charging speeds vary by device and charger capabilities
+
+### For Data Transfer
+1. Connect devices with cable
+2. On phone/tablet: Select "File Transfer" or "MTP" mode
+3. Devices should appear in file explorer
+4. Transfer speeds depend on both devices' capabilities
+
+### For Video Output
+1. Connect device to monitor/TV with USB-C input
+2. Device may automatically detect display
+3. For manual setup: Go to display settings
+4. Select appropriate resolution and refresh rate
+
+## Troubleshooting
+
+### Charging Issues
+**Problem**: Device not charging
+**Solutions**:
+- Check that both connectors are fully inserted
+- Try a different USB-C port if available
+- Verify charger is working with another device
+- Clean connectors with compressed air
+- Try different orientation (flip cable connectors)
+
+**Problem**: Slow charging
+**Solutions**:
+- Use original or certified high-wattage charger
+- Check if device supports fast charging
+- Close power-hungry apps while charging
+- Ensure cable supports device's charging requirements
+
+### Data Transfer Issues
+**Problem**: Device not recognized
+**Solutions**:
+- Select correct USB mode on phone/tablet
+- Install device drivers if on Windows
+- Try different USB-C port
+- Restart both devices
+- Check cable for physical damage
+
+**Problem**: Slow transfer speeds
+**Solutions**:
+- Verify both devices support USB 3.0+
+- Close other applications during transfer
+- Use USB-C port directly, not through hub
+- Check cable specifications match requirements
+
+### Video Output Issues
+**Problem**: No video signal
+**Solutions**:
+- Verify device supports video output over USB-C
+- Check monitor/TV input is set to correct USB-C port
+- Try different resolution in display settings
+- Ensure cable supports video (not all USB-C cables do)
+- Update device graphics drivers
+
+**Problem**: Poor video quality
+**Solutions**:
+- Check maximum resolution supported by cable
+- Verify monitor's native resolution settings
+- Adjust refresh rate in display settings
+- Use shorter cable for better signal integrity
+
+## Care & Maintenance
+
+### Proper Handling
+- **Gentle Insertion**: Don't force connectors into ports
+- **Avoid Bending**: Don't bend cable at sharp angles near connectors
+- **Strain Relief**: Use built-in strain relief, don't pull on cable
+- **Storage**: Coil loosely when storing, avoid tight knots
+
+### Cleaning
+- **Connectors**: Use compressed air to remove dust and debris
+- **Cable**: Wipe with slightly damp cloth, avoid harsh chemicals
+- **Ports**: Clean device ports regularly with compressed air
+- **Contacts**: Use isopropyl alcohol on cotton swab if needed
+
+### Environmental Protection
+- **Temperature**: Avoid extreme heat or cold storage
+- **Moisture**: Keep dry, avoid liquid exposure
+- **Sunlight**: Don't leave in direct sunlight for extended periods
+- **Stress**: Avoid pinching, crushing, or excessive bending
+
+## Technical Specifications
+
+### Electrical Ratings
+- **Voltage Range**: 5V to 20V (depending on model)
+- **Current Rating**: Up to 5A (100W models)
+- **Resistance**: <50mΩ for optimal power delivery
+- **Insulation**: 2000V AC dielectric strength
+
+### Data Specifications
+- **Signal Integrity**: Meets USB-IF compliance standards
+- **EMI/RFI**: Shielded construction reduces interference
+- **Crosstalk**: Minimized through proper wire spacing
+- **Impedance**: 90Ω ±15% differential impedance
+
+### Physical Specifications
+- **Connector**: USB Type-C (USB-C) certified
+- **Housing**: Durable plastic with metal shell
+- **Cable Gauge**: 28/24 AWG (data/power)
+- **Bend Radius**: Minimum 10x cable diameter
+
+## Warranty Information
+
+### Lifetime Warranty Coverage
+All Too Many Cables USB-C cables are covered by our comprehensive lifetime warranty against:
+- Manufacturing defects
+- Material failures
+- Performance degradation under normal use
+- Connector wear from regular insertion/removal
+
+### Warranty Exclusions
+- Physical damage from misuse or accidents
+- Damage from liquids, pets, or extreme conditions
+- Commercial/industrial use beyond specifications
+- Modification or repair attempts
+
+### Claim Process
+1. Contact customer service with order information
+2. Describe the issue and troubleshooting attempted
+3. Receive replacement authorization if covered
+4. Replacement shipped same day at no cost
+5. No need to return defective cable unless requested
+
+## Customer Support
+
+For technical support, compatibility questions, or warranty claims:
+
+- **AI Chat**: Available 24/7 on our website
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Hours**: Monday-Friday 8 AM - 8 PM EST
+
+## Safety Information
+
+### Important Safety Warnings
+- Use only with compatible devices and chargers
+- Do not exceed maximum power ratings
+- Discontinue use if cable becomes hot during operation
+- Keep away from heat sources and sharp objects
+- Do not use damaged cables
+
+### Regulatory Compliance
+- FCC Part 15 Class B (EMI compliance)
+- USB-IF certification
+- RoHS compliant (lead-free)
+- UL recognized components
+
+---
+
+*Manual version 2.1 - Updated September 2024*
+*For the latest version, visit toomanycables.com/support*

knowledge_base/product_manuals/usb_c_hdmi_adapter.md

@@ -0,0 +1,256 @@
+# USB-C to HDMI Adapter Product Manual
+
+## Product Overview
+
+Too Many Cables USB-C to HDMI Adapter provides a simple plug-and-play solution for connecting USB-C enabled devices to HDMI displays, monitors, and TVs. Ultra-compact design delivers 4K video output with high-quality digital audio transmission.
+
+## Product Specifications
+
+### TMC-USBC-HDMI-4K
+- **Video Output**: Up to 4K@60Hz (3840x2160)
+- **Audio Support**: Multi-channel digital audio pass-through
+- **Connector Type**: USB-C male to HDMI female
+- **Compatibility**: USB-C devices with DisplayPort Alt Mode
+- **Dimensions**: 2.4" x 0.8" x 0.4" (61 x 20 x 10mm)
+- **Weight**: 0.7 oz (20g)
+- **Material**: Aluminum alloy housing with gold-plated connectors
+- **Cable Length**: Built-in 4-inch cable
+- **Power**: Bus-powered (no external power required)
+- **Operating Temperature**: 32°F to 104°F (0°C to 40°C)
+
+## Video Output Specifications
+
+### Supported Resolutions
+- **4K Ultra HD**: 3840x2160 @ 60Hz, 30Hz
+- **1440p QHD**: 2560x1440 @ 60Hz, 144Hz
+- **1080p Full HD**: 1920x1080 @ 60Hz, 120Hz, 144Hz
+- **1080i**: 1920x1080i @ 60Hz
+- **720p HD**: 1280x720 @ 60Hz
+- **Legacy Formats**: 1024x768, 800x600, 640x480
+
+### Color Support
+- **Color Depth**: 8-bit, 10-bit, 12-bit
+- **Color Space**: RGB, YUV 4:4:4, YUV 4:2:2, YUV 4:2:0
+- **HDR Support**: HDR10 (device dependent)
+- **Color Standards**: sRGB, Adobe RGB, DCI-P3
+
+### Audio Specifications
+- **Audio Formats**: PCM, Dolby Digital, DTS
+- **Sample Rates**: 32kHz, 44.1kHz, 48kHz, 96kHz
+- **Bit Depth**: 16-bit, 24-bit
+- **Channels**: Stereo, 5.1, 7.1 surround sound
+- **Audio Delay**: <40ms latency
+
+## Compatibility Guide
+
+### Compatible Source Devices
+
+**Laptops:**
+- MacBook Pro (2016 and later)
+- MacBook Air (2018 and later)
+- Dell XPS 13/15/17 series
+- HP Spectre x360 series
+- Lenovo ThinkPad X1 series
+- Microsoft Surface Laptop series
+- ASUS ZenBook series
+- Most Windows laptops with USB-C/Thunderbolt
+
+**Tablets:**
+- iPad Pro (2018 and later)
+- iPad Air (4th generation and later)
+- Samsung Galaxy Tab S series
+- Microsoft Surface Pro (USB-C models)
+
+**Smartphones:**
+- Samsung Galaxy S8 and later
+- Google Pixel 2 and later
+- OnePlus 6 and later
+- Huawei P20 and later (where available)
+- Motorola Moto series with USB-C
+
+**Other Devices:**
+- Nintendo Switch
+- Steam Deck
+- Chrome OS devices
+- Android TV boxes with USB-C
+
+### Display Compatibility
+- **TVs**: All HDMI-equipped TVs (HD, 4K, 8K)
+- **Monitors**: Computer monitors with HDMI input
+- **Projectors**: HDMI-equipped projectors
+- **Capture Devices**: HDMI capture cards and recorders
+
+## Usage Instructions
+
+### Basic Connection
+1. Connect adapter's USB-C plug to your device
+2. Connect HDMI cable from adapter to display
+3. Display should automatically detect signal
+4. Adjust display settings if needed
+
+### Display Configuration
+
+**Windows:**
+1. Right-click desktop → Display Settings
+2. Choose "Extend" or "Duplicate" display
+3. Select resolution and refresh rate
+4. Apply settings
+
+**macOS:**
+1. System Preferences → Displays
+2. Choose "Mirror" or "Extend" desktop
+3. Select optimal resolution
+4. Adjust color profile if needed
+
+**Android/Chrome OS:**
+1. Settings → Display
+2. Select "Cast screen" or "Screen mirroring"
+3. Choose display mode (mirror/extend)
+4. Configure resolution settings
+
+## Performance Optimization
+
+### Maximum Quality Settings
+- **4K Output**: Use high-quality HDMI cables rated for 4K@60Hz
+- **Refresh Rate**: Set to highest supported by both device and display
+- **Color Settings**: Enable HDR if supported by both devices
+- **Audio Quality**: Use highest available audio format
+
+### Troubleshooting Performance
+- **Update Drivers**: Ensure graphics drivers are current
+- **Cable Quality**: Use HDMI 2.0 or higher rated cables
+- **Power Settings**: Disable power saving for USB ports
+- **Resolution**: Try lower resolution if experiencing issues
+
+## Technical Specifications
+
+### Electrical Requirements
+- **Power Consumption**: <2W
+- **Power Source**: USB-C bus power
+- **Current Draw**: <400mA @ 5V
+- **No External Power**: Required
+
+### Signal Specifications
+- **HDMI Version**: HDMI 2.0 compatible
+- **Bandwidth**: Up to 18 Gbps
+- **HDCP Support**: HDCP 2.2, HDCP 1.4
+- **Signal Type**: Digital video and audio
+
+### Physical Specifications
+- **Length**: 2.4 inches (61mm) including cable
+- **Width**: 0.8 inches (20mm)
+- **Thickness**: 0.4 inches (10mm)
+- **Weight**: 0.7 oz (20g)
+- **Housing**: Aluminum alloy
+- **Connectors**: Gold-plated for corrosion resistance
+
+### Environmental Conditions
+- **Operating Temperature**: 32°F to 104°F (0°C to 40°C)
+- **Storage Temperature**: -4°F to 140°F (-20°C to 60°C)
+- **Humidity**: 10% to 95% RH (non-condensing)
+- **Altitude**: Up to 6,600 feet (2,000m)
+
+## Troubleshooting
+
+### Common Issues
+
+**No Display Output**
+- Verify device supports video output via USB-C
+- Check HDMI cable connection
+- Try different HDMI cable
+- Restart source device
+- Check display input selection
+
+**Poor Video Quality**
+- Use high-quality HDMI cable
+- Check resolution settings
+- Update graphics drivers
+- Verify cable supports desired resolution
+- Try different display if available
+
+**No Audio Output**
+- Check audio output settings on device
+- Verify HDMI audio is enabled
+- Try different audio format
+- Check display audio settings
+- Update audio drivers
+
+**Intermittent Connection**
+- Check USB-C connection is secure
+- Try different USB-C port
+- Inspect cable for damage
+- Clean connectors
+- Test with different HDMI cable
+
+**4K Resolution Issues**
+- Verify device supports 4K output
+- Use HDMI 2.0 or higher cable
+- Check display 4K compatibility
+- Try 4K@30Hz instead of 60Hz
+- Update device firmware
+
+### Advanced Troubleshooting
+
+**Driver Issues:**
+- Download latest graphics drivers
+- Restart device after driver installation
+- Check Windows Update for driver updates
+
+**Compatibility Problems:**
+- Verify USB-C port supports video (some are charging only)
+- Check if device requires specific adapter protocols
+- Try adapter with known compatible device
+
+**Performance Optimization:**
+- Close unnecessary applications
+- Adjust power settings for performance
+- Check thermal throttling
+- Monitor CPU/GPU usage
+
+## Care & Maintenance
+
+### Cleaning Instructions
+- **Disconnect**: Remove from devices before cleaning
+- **Dry Cloth**: Use lint-free cloth for exterior
+- **Connector Care**: Keep connectors clean and dry
+- **No Liquids**: Avoid moisture in connectors
+
+### Storage Recommendations
+- **Protective Case**: Store in provided pouch when not in use
+- **Avoid Bending**: Don't stress the built-in cable
+- **Temperature**: Store in cool, dry location
+- **Avoid Pressure**: Don't place heavy objects on adapter
+
+## What's Included
+
+### Package Contents
+- 1x TMC USB-C to HDMI Adapter
+- 1x Protective carrying pouch
+- 1x Quick Start Guide
+- 1x Warranty Registration Card
+
+## Warranty & Support
+
+### Warranty Coverage
+- **Duration**: 18-month limited warranty
+- **Coverage**: Manufacturing defects and material failures
+- **Exclusions**: Physical damage, misuse, normal wear
+
+### Customer Support
+- **Website**: support.toomanycables.com/adapters
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Live Chat**: Available 24/7 on website
+
+### Warranty Registration
+Register within 30 days for:
+- Full warranty coverage
+- Product support notifications
+- Technical assistance priority
+
+---
+
+**Model**: TMC-USBC-HDMI-4K  
+**Manual Version**: 1.3  
+**Last Updated**: October 2025  
+**Document**: TMC-HDMI-ADAPTER-MANUAL-V1.3

knowledge_base/product_manuals/usb_c_hub_adapter.md

@@ -0,0 +1,246 @@
+# USB-C Hub Adapter Product Manual
+
+## Product Overview
+
+Too Many Cables 7-in-1 USB-C Hub Adapter expands a single USB-C port into multiple connectivity options including 4K HDMI, USB-A ports, SD card slots, Ethernet, and USB-C Power Delivery pass-through. Perfect for laptops, tablets, and phones with USB-C ports.
+
+## Product Specifications
+
+### TMC-USBC-HUB-7IN1
+- **Port Configuration**:
+  - 1x HDMI 2.0 port (4K@60Hz)
+  - 3x USB-A 3.0 ports (5 Gbps)
+  - 1x USB-C PD port (100W pass-through)
+  - 1x SD card slot (UHS-I)
+  - 1x MicroSD card slot (UHS-I)
+  - 1x Gigabit Ethernet port (10/100/1000 Mbps)
+- **Dimensions**: 4.7" x 1.4" x 0.6" (120 x 35 x 15mm)
+- **Weight**: 2.1 oz (60g)
+- **Material**: Premium aluminum alloy housing
+- **Cable**: 6-inch integrated USB-C cable
+- **LED Indicators**: Power and data activity LEDs
+- **Operating Temperature**: 32°F to 104°F (0°C to 40°C)
+- **Certifications**: CE, FCC, RoHS compliant
+
+## Detailed Port Specifications
+
+### HDMI 2.0 Port
+- **Maximum Resolution**: 4K@60Hz (3840x2160)
+- **Supported Formats**: 1080p@120Hz, 1440p@60Hz, 4K@30Hz, 4K@60Hz
+- **Color Depth**: 8-bit, 10-bit, 12-bit
+- **Audio Support**: Multi-channel audio pass-through
+- **HDR Support**: HDR10, HDR10+
+- **Compatibility**: All HDMI displays and TVs
+
+### USB-A 3.0 Ports (3x)
+- **Data Transfer**: Up to 5 Gbps (USB 3.0/3.1 Gen 1)
+- **Power Output**: 5V/0.9A per port (4.5W total across all USB-A ports)
+- **Compatibility**: USB 3.0, 2.0, 1.1 devices
+- **Hot Plug**: Support for hot-swappable devices
+- **Backwards Compatible**: Works with all USB devices
+
+### USB-C PD Pass-Through Port
+- **Power Delivery**: Up to 100W pass-through charging
+- **Data Transfer**: USB 3.0 speeds (5 Gbps)
+- **Compatibility**: USB-C PD chargers and devices
+- **Charging**: Allows laptop charging while using hub
+- **Power Efficiency**: >85% power pass-through efficiency
+
+### SD Card Slots
+- **SD Card Slot**: UHS-I, up to 104 MB/s
+- **MicroSD Slot**: UHS-I, up to 104 MB/s
+- **Supported Formats**: SD, SDHC, SDXC (up to 2TB)
+- **Simultaneous Access**: Both slots can be used at same time
+- **Hot Swap**: Cards can be inserted/removed while hub is connected
+
+### Gigabit Ethernet Port
+- **Speed**: 10/100/1000 Mbps auto-negotiation
+- **Connector**: RJ45 standard Ethernet
+- **LED Indicators**: Link/Activity status
+- **Compatibility**: All standard Ethernet networks
+- **Driver**: Plug-and-play, no drivers needed
+
+## Compatibility Guide
+
+### Compatible Laptops
+**MacBook Series:**
+- MacBook Pro 13" (2016 and later)
+- MacBook Pro 14" and 16" (M1/M2/M3)
+- MacBook Air 13" (2018 and later)
+- MacBook Air 15" (M2/M3)
+
+**Windows Laptops:**
+- Dell XPS 13/15/17 series
+- HP Spectre x360 series
+- HP EliteBook series
+- Lenovo ThinkPad X1 Carbon
+- Lenovo Yoga series
+- Microsoft Surface Laptop series
+- ASUS ZenBook series
+
+**Chromebooks:**
+- Google Pixelbook
+- Samsung Galaxy Chromebook
+- HP Chromebook x360
+- Most Chromebooks with USB-C
+
+### Compatible Tablets
+- iPad Pro (2018 and later)
+- iPad Air (4th generation and later)
+- Samsung Galaxy Tab S series
+- Microsoft Surface Pro (with USB-C)
+
+### Compatible Phones
+- Samsung Galaxy S20 and later
+- Google Pixel 3a and later (with USB-C)
+- OnePlus 7 and later
+- Note: Phone compatibility may vary by model
+
+## Usage Instructions
+
+### Initial Setup
+1. Connect hub's USB-C cable to your device's USB-C port
+2. Hub powers on automatically (LED indicator lights up)
+3. Connect desired peripherals to hub ports
+4. Devices should be recognized automatically
+
+### HDMI Display Connection
+1. Connect HDMI cable from hub to monitor/TV
+2. Display should be detected automatically
+3. Adjust display settings in system preferences if needed
+4. Supports mirroring and extended desktop modes
+
+### Power Delivery Usage
+1. Connect USB-C charger to hub's PD port
+2. Hub passes power to connected laptop/device
+3. Device charges while hub functions normally
+4. Use original charger for best performance
+
+### Ethernet Connection
+1. Connect Ethernet cable to hub's RJ45 port
+2. Network connection established automatically
+3. LED shows link status and activity
+4. Provides stable wired internet connection
+
+## Performance Optimization
+
+### Maximum Performance Tips
+- **Use Quality Cables**: High-quality HDMI and USB cables for best results
+- **Adequate Power**: Use appropriate wattage charger for your device
+- **Heat Management**: Ensure good ventilation around hub
+- **Update Drivers**: Keep device drivers updated for optimal compatibility
+
+### Data Transfer Optimization
+- **USB 3.0 Devices**: Use USB 3.0 storage devices for maximum speed
+- **SD Card Performance**: Use high-speed SD cards (Class 10 or UHS-I)
+- **Ethernet Speed**: Use Cat 6 cables for Gigabit speeds
+- **Avoid Overloading**: Don't exceed total power budget
+
+## Technical Specifications
+
+### Power Requirements
+- **Input Power**: 5V from USB-C host device
+- **Power Consumption**: 2W (hub operation)
+- **USB-A Power Budget**: 4.5W total across all USB-A ports
+- **PD Pass-Through**: Up to 100W (minus 15W hub overhead)
+
+### Data Transfer Rates
+- **USB-A Ports**: 5 Gbps each (shared bandwidth)
+- **USB-C Port**: 5 Gbps
+- **SD Cards**: Up to 104 MB/s (UHS-I)
+- **Ethernet**: Up to 1000 Mbps
+- **HDMI**: Up to 18 Gbps bandwidth
+
+### Environmental Specifications
+- **Operating Temperature**: 32°F to 104°F (0°C to 40°C)
+- **Storage Temperature**: -4°F to 140°F (-20°C to 60°C)
+- **Humidity**: 10% to 90% RH (non-condensing)
+- **Altitude**: Up to 6,600 feet (2,000m)
+
+## Troubleshooting
+
+### Common Issues
+
+**Hub Not Recognized**
+- Check USB-C connection is secure
+- Try different USB-C port on device
+- Restart connected device
+- Verify device supports USB-C data
+
+**HDMI Display Not Working**
+- Check HDMI cable connections
+- Try different HDMI cable
+- Verify display supports resolution
+- Update graphics drivers
+
+**USB Devices Not Working**
+- Check USB device compatibility
+- Try connecting device directly to test
+- Verify power requirements
+- Use powered USB hub if needed
+
+**Ethernet Not Connecting**
+- Check Ethernet cable connection
+- Verify network settings
+- Try different Ethernet cable
+- Check router/switch status
+
+**Charging Not Working**
+- Verify charger wattage is adequate
+- Check USB-C PD charger compatibility
+- Try original device charger
+- Ensure hub PD port is used
+
+### Advanced Troubleshooting
+- **Driver Updates**: Install latest USB-C and graphics drivers
+- **Power Management**: Disable USB selective suspend in power settings
+- **Display Settings**: Check resolution and refresh rate settings
+- **Network Configuration**: Verify Ethernet adapter settings
+
+## Safety Information
+
+### Important Safety Notes
+- **Heat Dissipation**: Hub may become warm during use - this is normal
+- **Water Protection**: Keep hub away from liquids
+- **Ventilation**: Don't block ventilation holes
+- **Cable Stress**: Avoid bending USB-C cable excessively
+
+### Certifications
+- **CE Marking**: European Conformity
+- **FCC Certified**: Electromagnetic compatibility
+- **RoHS Compliant**: Restriction of hazardous substances
+
+## What's Included
+
+### Package Contents
+- 1x TMC 7-in-1 USB-C Hub
+- 1x Quick Start Guide
+- 1x Warranty Registration Card
+- 1x Premium carrying pouch
+
+## Warranty & Support
+
+### Warranty Coverage
+- **Duration**: 2-year limited warranty
+- **Coverage**: Manufacturing defects and material failures
+- **Exclusions**: Physical damage, misuse, normal wear
+
+### Customer Support
+- **Website**: support.toomanycables.com/hub
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Live Chat**: Available 24/7 on website
+- **Support Hours**: Monday-Friday 8AM-8PM EST
+
+### Warranty Registration
+Register your product for:
+- Full warranty coverage
+- Product update notifications
+- Priority technical support
+
+---
+
+**Model**: TMC-USBC-HUB-7IN1  
+**Manual Version**: 1.6  
+**Last Updated**: October 2025  
+**Document**: TMC-HUB-MANUAL-V1.6

knowledge_base/product_manuals/wireless_charging_pad.md

@@ -0,0 +1,217 @@
+# Wireless Charging Pad Product Manual
+
+## Product Overview
+
+Too Many Cables Wireless Charging Pad delivers fast 15W wireless charging for Qi-enabled devices with intelligent charging control, LED status indicators, and a premium non-slip design for safe and efficient wireless power delivery.
+
+## Product Specifications
+
+### TMC-WIRELESS-15W-QI
+- **Maximum Output**: 15W (fast wireless charging)
+- **Charging Standards**: Qi 1.2.4 (EPP), Qi 1.1 (BPP)
+- **Charging Modes**: 
+  - 15W (compatible phones in fast mode)
+  - 10W (Samsung fast charging)
+  - 7.5W (iPhone fast charging)
+  - 5W (standard Qi charging)
+- **Input**: USB-C, 5V/3A, 9V/2A (QC 3.0/PD compatible)
+- **Dimensions**: 4.3" diameter x 0.4" height (110mm x 10mm)
+- **Weight**: 4.2 oz (120g)
+- **Material**: Premium aluminum top, ABS plastic base
+- **LED Indicator**: Multi-color status LED
+- **Safety Features**: Over-temperature, over-voltage, foreign object detection
+- **Certifications**: Qi Certified, FCC, CE, RoHS
+
+## Compatibility Guide
+
+### Fast Charging Compatible (15W)
+**Android Phones:**
+- Samsung Galaxy S21/S22/S23/S24 series
+- Google Pixel 4 and later
+- OnePlus 8 and later
+- LG V30 and later
+- Sony Xperia 1 II and later
+
+### iPhone Fast Charging (7.5W)
+- iPhone 8 and later
+- iPhone SE (2nd/3rd generation)
+- iPhone X/XR/XS series
+- iPhone 11/12/13/14/15 series
+
+### Standard Charging (5W)
+- Most Qi-enabled devices
+- Older wireless charging phones
+- AirPods with wireless charging case
+- Samsung Galaxy Buds series
+
+### Case Compatibility
+- **Compatible**: Cases up to 5mm thick (non-metal)
+- **Remove Cases**: Metal cases, magnetic mounts, credit cards
+- **Recommended**: Official phone cases, thin plastic/silicone cases
+
+## Usage Instructions
+
+### Initial Setup
+1. Connect USB-C cable to charging pad
+2. Connect other end to QC 3.0 or PD wall adapter (included)
+3. Place charging pad on flat, stable surface
+4. LED should show solid blue (ready to charge)
+
+### Charging Your Device
+1. Remove metal cases and objects from phone
+2. Place device center of charging pad
+3. LED changes to indicate charging status
+4. Charging begins automatically
+5. LED shows green when fully charged
+
+### Optimal Positioning
+- **Center Alignment**: Place device center of pad for best efficiency
+- **Portrait/Landscape**: Both orientations supported
+- **Multiple Devices**: Charge one device at a time for best performance
+
+## LED Status Indicators
+
+### LED Color Meanings
+- **Solid Blue**: Ready to charge, no device detected
+- **Solid Green**: Device charging normally
+- **Blinking Green**: Device fully charged
+- **Solid Red**: Error condition (foreign object, overheating)
+- **Blinking Red**: Device not compatible or misaligned
+- **Purple**: Fast charging mode active
+
+### Troubleshooting LED Codes
+- **No LED**: Check power connection and adapter
+- **Red Solid**: Remove foreign objects, check alignment
+- **Red Blinking**: Reposition device, remove thick case
+
+## Safety Features
+
+### Protection Systems
+- **Foreign Object Detection (FOD)**: Stops charging when metal objects detected
+- **Temperature Control**: Automatic power reduction if overheating
+- **Over-Voltage Protection**: Protects against power surges
+- **Over-Current Protection**: Prevents excessive current draw
+- **Short-Circuit Protection**: Immediate shutdown on electrical faults
+
+### Thermal Management
+- **Heat Dissipation**: Aluminum surface for efficient heat transfer
+- **Temperature Monitoring**: Real-time thermal sensing
+- **Cooling Periods**: Automatic charging pauses if temperature exceeds limits
+- **Ventilation**: Bottom air channels for passive cooling
+
+## Performance Optimization
+
+### Maximum Charging Speed
+- **Use Included Adapter**: QC 3.0 18W adapter for best performance
+- **Remove Thick Cases**: Cases over 5mm may reduce charging speed
+- **Proper Alignment**: Center device on pad for optimal efficiency
+- **Room Temperature**: Avoid direct sunlight or heat sources
+
+### Efficiency Tips
+- **Clean Surfaces**: Keep charging pad and device clean
+- **Stable Placement**: Avoid vibrating surfaces
+- **No Metal Objects**: Remove coins, keys, magnetic mounts
+- **Update Software**: Ensure device has latest wireless charging firmware
+
+## Technical Specifications
+
+### Electrical Ratings
+- **Input Voltage**: 5V/3A, 9V/2A
+- **Output Power**: 15W max, 10W, 7.5W, 5W
+- **Charging Efficiency**: >75% at 15W
+- **Standby Power**: <0.5W when no device present
+- **Frequency**: 110-148 kHz (Qi standard)
+
+### Environmental Conditions
+- **Operating Temperature**: 32°F to 104°F (0°C to 40°C)
+- **Storage Temperature**: -4°F to 140°F (-20°C to 60°C)
+- **Humidity**: 10% to 90% RH (non-condensing)
+- **Altitude**: Up to 6,600 feet (2,000m)
+
+### Physical Specifications
+- **Diameter**: 4.3 inches (110mm)
+- **Thickness**: 0.4 inches (10mm)
+- **Weight**: 4.2 oz (120g)
+- **Top Material**: Premium aluminum
+- **Base Material**: ABS plastic with rubber grips
+
+## Troubleshooting
+
+### Common Issues
+
+**Device Not Charging**
+- Check device Qi compatibility
+- Remove thick or metal cases
+- Center device on charging pad
+- Verify power adapter connection
+
+**Slow Charging Speed**
+- Use included QC 3.0 adapter
+- Remove case if thick (>5mm)
+- Ensure proper device alignment
+- Check for overheating
+
+**LED Shows Red**
+- Remove metal objects from pad
+- Clean charging surfaces
+- Reposition device
+- Check for foreign objects
+
+**Intermittent Charging**
+- Ensure stable placement
+- Check for loose connections
+- Clean charging contacts
+- Verify case compatibility
+
+### Advanced Troubleshooting
+- **Firmware Updates**: Some phones may need software updates for optimal charging
+- **Adapter Compatibility**: Use QC 3.0 or PD adapters for fast charging
+- **Environmental Factors**: Avoid extreme temperatures and magnetic fields
+
+## Care & Maintenance
+
+### Cleaning Instructions
+- **Power Off**: Disconnect from power before cleaning
+- **Dry Cloth**: Use lint-free cloth for surface cleaning
+- **No Liquids**: Do not use water or cleaning solutions
+- **Gentle Cleaning**: Avoid abrasive materials that could scratch aluminum
+
+### Storage
+- **Cool, Dry Place**: Store in temperature-controlled environment
+- **Avoid Pressure**: Don't place heavy objects on charging pad
+- **Cable Management**: Coil cable loosely to prevent damage
+
+## What's Included
+
+### Package Contents
+- 1x TMC Wireless Charging Pad
+- 1x USB-C to USB-A Cable (3ft)
+- 1x QC 3.0 Wall Adapter (18W)
+- 1x Quick Start Guide
+- 1x Warranty Registration Card
+
+## Warranty & Support
+
+### Warranty Coverage
+- **Duration**: 2-year limited warranty
+- **Coverage**: Manufacturing defects and material failures
+- **Exclusions**: Physical damage, misuse, normal wear
+
+### Customer Support
+- **Website**: support.toomanycables.com/wireless
+- **Email**: support@toomanycables.com
+- **Phone**: 1-800-TMC-HELP
+- **Live Chat**: Available 24/7 on website
+
+### Warranty Registration
+Register within 30 days for:
+- Full warranty coverage
+- Product notifications
+- Technical support priority
+
+---
+
+**Model**: TMC-WIRELESS-15W-QI  
+**Manual Version**: 1.4  
+**Last Updated**: October 2025  
+**Document**: TMC-WIRELESS-MANUAL-V1.4

requirements.txt

@@ -0,0 +1,10 @@
+Flask==2.3.3
+Flask-CORS==4.0.0
+requests==2.31.0
+Werkzeug==2.3.7
+Flask-Limiter==3.1.0
+Flask-WTF==1.1.1
+chromadb==0.4.22
+sentence-transformers==2.7.0
+numpy==1.24.3
+openai>=1.0.0

scripts/__init__.py

@@ -0,0 +1,3 @@
+"""
+Helper scripts for TMC Chatbot
+"""

scripts/database.py

@@ -0,0 +1,244 @@
+import sqlite3
+import os
+import secrets
+import hashlib
+from typing import Optional, Dict, List
+
+class DatabaseManager:
+    def __init__(self, db_path=None):
+        self.db_path = db_path or os.environ.get('DATABASE_PATH', 'tmc_customer_service.db')
+        os.makedirs(os.path.dirname(self.db_path) or '.', exist_ok=True)
+        self.init_database()
+
+    def get_connection(self):
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def init_database(self):
+        with self.get_connection() as conn:
+            c = conn.cursor()
+            c.execute('''CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                email TEXT UNIQUE NOT NULL,
+                first_name TEXT NOT NULL,
+                last_name TEXT NOT NULL,
+                password_hash TEXT NOT NULL,
+                salt TEXT NOT NULL,
+                phone TEXT,
+                company TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                is_active BOOLEAN DEFAULT 1,
+                role TEXT DEFAULT 'user'
+            )''')
+            c.execute('''CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                user_id INTEGER,
+                ip_address TEXT,
+                user_agent TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                expires_at TIMESTAMP NOT NULL,
+                is_active BOOLEAN DEFAULT 1,
+                FOREIGN KEY(user_id) REFERENCES users(id)
+            )''')
+            c.execute('''CREATE TABLE IF NOT EXISTS conversations (
+                id TEXT PRIMARY KEY,
+                user_id INTEGER,
+                session_id TEXT,
+                title TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                is_active BOOLEAN DEFAULT 1,
+                FOREIGN KEY(user_id) REFERENCES users(id)
+            )''')
+            c.execute('''CREATE TABLE IF NOT EXISTS messages (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                conversation_id TEXT NOT NULL,
+                role TEXT NOT NULL,
+                content TEXT NOT NULL,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                model_used TEXT,
+                response_time_ms INTEGER,
+                FOREIGN KEY(conversation_id) REFERENCES conversations(id)
+            )''')
+            c.execute('''CREATE TABLE IF NOT EXISTS support_tickets (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                ticket_number TEXT UNIQUE NOT NULL,
+                user_id INTEGER NOT NULL,
+                conversation_id TEXT,
+                subject TEXT NOT NULL,
+                description TEXT NOT NULL,
+                category TEXT NOT NULL,
+                priority TEXT DEFAULT 'medium',
+                status TEXT DEFAULT 'open',
+                assigned_agent TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                resolved_at TIMESTAMP,
+                FOREIGN KEY(user_id) REFERENCES users(id)
+            )''')
+            c.execute('''CREATE TABLE IF NOT EXISTS ticket_updates (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                ticket_id INTEGER NOT NULL,
+                user_id INTEGER,
+                update_type TEXT DEFAULT 'note',
+                message TEXT NOT NULL,
+                is_internal BOOLEAN DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY(ticket_id) REFERENCES support_tickets(id)
+            )''')
+            c.execute('''CREATE TABLE IF NOT EXISTS ticket_categories (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT UNIQUE NOT NULL,
+                description TEXT,
+                default_priority TEXT DEFAULT 'medium',
+                is_active BOOLEAN DEFAULT 1
+            )''')
+            conn.commit()
+            c.execute("INSERT OR IGNORE INTO ticket_categories (name, description) VALUES ('General', 'General inquiries')")
+            conn.commit()
+
+    def hash_password(self, password: str):
+        salt = secrets.token_hex(32)
+        ph = hashlib.pbkdf2_hmac('sha256', password.encode(), salt.encode(), 100000).hex()
+        return ph, salt
+
+    def verify_password(self, password, phash, salt):
+        return hashlib.pbkdf2_hmac('sha256', password.encode(), salt.encode(), 100000).hex() == phash
+
+    def create_user(self, email, first_name, last_name, password, phone=None, company=None) -> Optional[int]:
+        try:
+            phash, salt = self.hash_password(password)
+            with self.get_connection() as conn:
+                cur = conn.cursor()
+                cur.execute('''INSERT INTO users (email, first_name, last_name, password_hash, salt, phone, company)
+                               VALUES (?,?,?,?,?,?,?)''',
+                            (email, first_name, last_name, phash, salt, phone, company))
+                uid = cur.lastrowid
+                conn.commit()
+                return uid
+        except sqlite3.IntegrityError:
+            return None
+
+    def authenticate_user(self, email, password) -> Optional[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('SELECT id, email, first_name, last_name, password_hash, salt, is_active FROM users WHERE email = ?', (email,))
+            row = cur.fetchone()
+            if row and row['is_active'] and self.verify_password(password, row['password_hash'], row['salt']):
+                return dict(row)
+            return None
+
+    def create_session(self, user_id, ip, ua, hours=24) -> str:
+        sid = secrets.token_urlsafe(32)
+        with self.get_connection() as conn:
+            conn.execute('INSERT INTO sessions (id, user_id, ip_address, user_agent, expires_at) VALUES (?,?,?,?, datetime("now", "+? hours"))',
+                         (sid, user_id, ip, ua[:255], hours))
+            conn.commit()
+        return sid
+
+    def get_user_by_session(self, session_id) -> Optional[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('''SELECT u.id, u.email, u.first_name, u.last_name, u.role
+                           FROM users u JOIN sessions s ON u.id = s.user_id
+                           WHERE s.id = ? AND s.is_active = 1 AND s.expires_at > CURRENT_TIMESTAMP''', (session_id,))
+            row = cur.fetchone()
+            return dict(row) if row else None
+
+    def get_user_role(self, user_id) -> str:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('SELECT role FROM users WHERE id = ?', (user_id,))
+            row = cur.fetchone()
+            return row['role'] if row else 'user'
+
+    def create_conversation(self, user_id=None, session_id=None, title=None) -> str:
+        cid = secrets.token_urlsafe(16)
+        with self.get_connection() as conn:
+            conn.execute('INSERT INTO conversations (id, user_id, session_id, title) VALUES (?,?,?,?)',
+                         (cid, user_id, session_id, title))
+            conn.commit()
+        return cid
+
+    def add_message(self, conversation_id, role, content, model_used=None, response_time_ms=None):
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('''INSERT INTO messages (conversation_id, role, content, model_used, response_time_ms)
+                           VALUES (?,?,?,?,?)''', (conversation_id, role, content, model_used, response_time_ms))
+            conn.execute('UPDATE conversations SET updated_at = CURRENT_TIMESTAMP WHERE id = ?', (conversation_id,))
+            conn.commit()
+            return cur.lastrowid
+
+    def get_conversation_history(self, conversation_id, limit=50) -> List[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('SELECT is_active FROM conversations WHERE id = ?', (conversation_id,))
+            if not cur.fetchone():
+                return []
+            cur.execute('''SELECT role, content, timestamp, model_used FROM messages
+                           WHERE conversation_id = ? ORDER BY timestamp LIMIT ?''', (conversation_id, limit))
+            return [dict(row) for row in cur.fetchall()]
+
+    def create_support_ticket(self, user_id, subject, description, category, conversation_id=None, priority='medium') -> str:
+        import random, string
+        tn = 'TMC-' + ''.join(random.choices(string.digits, k=6))
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('''INSERT INTO support_tickets (ticket_number, user_id, conversation_id, subject, description, category, priority)
+                           VALUES (?,?,?,?,?,?,?)''', (tn, user_id, conversation_id, subject, description, category, priority))
+            conn.commit()
+            return tn
+
+    def get_ticket_by_number(self, ticket_number) -> Optional[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('SELECT * FROM support_tickets WHERE ticket_number = ?', (ticket_number,))
+            row = cur.fetchone()
+            return dict(row) if row else None
+
+    def get_ticket_updates(self, ticket_id, include_internal=False) -> List[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            if include_internal:
+                cur.execute('SELECT * FROM ticket_updates WHERE ticket_id = ? ORDER BY created_at', (ticket_id,))
+            else:
+                cur.execute('SELECT * FROM ticket_updates WHERE ticket_id = ? AND is_internal = 0 ORDER BY created_at', (ticket_id,))
+            return [dict(row) for row in cur.fetchall()]
+
+    def add_ticket_update(self, ticket_id, user_id, message, update_type='note', is_internal=False) -> int:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('''INSERT INTO ticket_updates (ticket_id, user_id, update_type, message, is_internal)
+                           VALUES (?,?,?,?,?)''', (ticket_id, user_id, update_type, message, is_internal))
+            conn.execute('UPDATE support_tickets SET updated_at = CURRENT_TIMESTAMP WHERE id = ?', (ticket_id,))
+            conn.commit()
+            return cur.lastrowid
+
+    def get_user_tickets(self, user_id, limit=20) -> List[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute('SELECT * FROM support_tickets WHERE user_id = ? ORDER BY created_at DESC LIMIT ?', (user_id, limit))
+            return [dict(row) for row in cur.fetchall()]
+
+    def get_tickets_by_status(self, status, limit=50) -> List[Dict]:
+        with self.get_connection() as conn:
+            cur = conn.cursor()
+            if status:
+                cur.execute('SELECT * FROM support_tickets WHERE status = ? ORDER BY created_at DESC LIMIT ?', (status, limit))
+            else:
+                cur.execute('SELECT * FROM support_tickets ORDER BY created_at DESC LIMIT ?', (limit,))
+            return [dict(row) for row in cur.fetchall()]
+
+    # Stubs for additional methods used in original app
+    def categorize_ticket_content(self, text):
+        return "General"
+
+    def escalate_ticket(self, ticket_id, reason, user_id=None):
+        with self.get_connection() as conn:
+            conn.execute("UPDATE support_tickets SET priority = 'high' WHERE id = ?", (ticket_id,))
+            conn.commit()
+            return True
+
+    def check_escalation_needed(self, ticket_id):
+        return {"needs_escalation": False}

scripts/init_database.py

@@ -0,0 +1,16 @@
+import os
+from .database import DatabaseManager
+
+def init_sample_data():
+    db = DatabaseManager()
+    admin = db.create_user('admin@toomanycables.com', 'Admin', 'User', 'CHANGE_ME_ADMIN_PASSWORD', company='Too Many Cables')
+    if admin:
+        with db.get_connection() as conn:
+            conn.execute("UPDATE users SET role = 'admin' WHERE id = ?", (admin,))
+            conn.commit()
+        print("Admin created with password 'CHANGE_ME_ADMIN_PASSWORD'. Change it immediately via UI or DB.")
+    db.create_user('customer@example.com', 'John', 'Customer', 'customer123', company='Example Corp')
+    print("Sample data initialized.")
+
+if __name__ == '__main__':
+    init_sample_data()

scripts/knowledge_base_manager.py

@@ -0,0 +1,64 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+class KnowledgeBaseManager:
+    def __init__(self, knowledge_base_path: str = "knowledge_base"):
+        self.kb_path = Path(knowledge_base_path)
+        self.documents = {}
+        self.kb_path.mkdir(exist_ok=True)
+
+    def scan_documents(self) -> Dict:
+        documents = {}
+        categories = {
+            'faqs': 'Frequently Asked Questions',
+            'policies': 'Company Policies',
+            'product_manuals': 'Product Manuals',
+            # 'development' intentionally omitted
+        }
+        for category, desc in categories.items():
+            cat_path = self.kb_path / category
+            if cat_path.exists():
+                docs = []
+                for f in cat_path.glob('*.md'):
+                    docs.append(self._analyze_document(f, category))
+                documents[category] = {'description': desc, 'documents': docs}
+        self.documents = documents
+        return documents
+
+    def _analyze_document(self, file_path: Path, category: str) -> Dict:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        title = next((line.strip('# ').strip() for line in content.split('\n') if line.startswith('# ')), file_path.stem)
+        return {
+            'filename': file_path.name,
+            'title': title,
+            'category': category,
+            'path': str(file_path.relative_to(self.kb_path)),
+            'size': file_path.stat().st_size,
+            'word_count': len(content.split()),
+            'char_count': len(content)
+        }
+
+    def load_document_content(self, document_path: str) -> Optional[str]:
+        full = self.kb_path / document_path
+        if full.exists():
+            with open(full, 'r', encoding='utf-8') as f:
+                return f.read()
+        return None
+
+    def search_documents(self, query: str, category: Optional[str] = None) -> List[Dict]:
+        results = []
+        ql = query.lower()
+        for cat, info in self.documents.items():
+            if category and cat != category:
+                continue
+            for doc in info['documents']:
+                content = self.load_document_content(doc['path'])
+                if not content:
+                    continue
+                if ql in content.lower() or ql in doc['title'].lower():
+                    score = content.lower().count(ql)
+                    results.append({**doc, 'relevance_score': score})
+        results.sort(key=lambda x: x['relevance_score'], reverse=True)
+        return results

scripts/rag_helper.py

@@ -0,0 +1,85 @@
+import logging
+from typing import List, Dict
+from .knowledge_base_manager import KnowledgeBaseManager
+
+try:
+    from .vector_rag_manager import VectorRAGManager
+    VECTOR_AVAILABLE = True
+except ImportError:
+    VECTOR_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+class RAGHelper:
+    def __init__(self, knowledge_base_path: str = "knowledge_base", use_vector_search: bool = True):
+        self.kb_manager = KnowledgeBaseManager(knowledge_base_path)
+        self.kb_manager.scan_documents()
+        self.use_vector_search = use_vector_search and VECTOR_AVAILABLE
+        self.vector_rag = None
+        if self.use_vector_search:
+            try:
+                self.vector_rag = VectorRAGManager(knowledge_base_path, vector_db_path="/app/data/vector_db")
+                logger.info("Vector RAG initialized")
+            except Exception as e:
+                logger.warning(f"Vector RAG failed: {e}")
+                self.use_vector_search = False
+        self.max_context_docs = 3
+        self.similarity_threshold = 0.30
+
+    def _route_query_to_categories(self, query: str) -> List[str]:
+        ql = query.lower()
+        cat_keywords = {
+            'policies': ['return','refund','warranty','policy','shipping'],
+            'faqs': ['how','what','why','help','troubleshoot','problem'],
+            'product_manuals': ['spec','manual','guide','connect','cable','hdmi','usb']
+        }
+        scores = {}
+        for cat, kw in cat_keywords.items():
+            score = sum(1 for k in kw if k in ql)
+            if score:
+                scores[cat] = score
+        if scores:
+            return sorted(scores, key=scores.get, reverse=True)
+        return ['policies','faqs','product_manuals']
+
+    def get_relevant_context(self, query: str) -> str:
+        categories = self._route_query_to_categories(query)
+        if self.use_vector_search and self.vector_rag:
+            try:
+                results = self.vector_rag.retrieve_and_rerank_filtered(
+                    query, target_categories=categories, initial_k=20, final_k=3,
+                    similarity_threshold=self.similarity_threshold
+                )
+                return self._build_context_from_results(results)
+            except Exception as e:
+                logger.warning(f"Vector search failed: {e}, falling back to keyword")
+        return self._get_keyword_context(query)
+
+    def _get_keyword_context(self, query: str) -> str:
+        results = self.kb_manager.search_documents(query)
+        context = ""
+        for r in results[:self.max_context_docs]:
+            content = self.kb_manager.load_document_content(r['path'])
+            if content:
+                context += f"\n--- {r['title']} (Category: {r['category']}) ---\n{content[:1500]}\n"
+        return context
+
+    def _build_context_from_results(self, results: List[Dict]) -> str:
+        if not results:
+            return ""
+        chunks = []
+        for res in results:
+            doc = res['document']
+            meta = res['metadata']
+            chunks.append(f"--- {meta['document_title']} (Category: {meta['category']}) ---\n{doc[:1200]}")
+        return "\n".join(chunks[:3])
+
+    def get_knowledge_base_stats(self) -> Dict:
+        stats = self.kb_manager.get_stats() if hasattr(self.kb_manager, 'get_stats') else {'total_documents': 0}
+        stats['vector_search_available'] = self.use_vector_search
+        return stats
+
+    def ensure_vector_index(self, force_reindex: bool = False):
+        if self.vector_rag:
+            return self.vector_rag.index_documents(force_reindex=force_reindex)
+        return {"error": "Vector not available"}

scripts/vector_rag_manager.py

@@ -0,0 +1,109 @@
+import os
+import logging
+from pathlib import Path
+from typing import List, Dict
+import chromadb
+from chromadb.config import Settings
+from sentence_transformers import SentenceTransformer
+from .knowledge_base_manager import KnowledgeBaseManager
+
+os.environ['ANONYMIZED_TELEMETRY'] = 'False'
+os.environ['CHROMA_TELEMETRY_ENABLED'] = 'false'
+
+logger = logging.getLogger(__name__)
+
+class VectorRAGManager:
+    def __init__(self, knowledge_base_path: str, vector_db_path: str = "vector_db", embedding_model: str = "all-MiniLM-L6-v2"):
+        self.kb_path = Path(knowledge_base_path)
+        self.vector_db_path = Path(vector_db_path)
+        self.vector_db_path.mkdir(exist_ok=True, parents=True)
+        self.kb_manager = KnowledgeBaseManager(knowledge_base_path)
+        self.chroma_client = chromadb.PersistentClient(path=str(self.vector_db_path), settings=Settings(anonymized_telemetry=False))
+        self.embedding_model = SentenceTransformer(embedding_model)
+        self.collection_name = "tmc_documents"
+        self._init_collection()
+        self.chunk_size = 800
+        self.chunk_overlap = 120
+
+    def _init_collection(self):
+        try:
+            self.collection = self.chroma_client.get_collection(self.collection_name)
+        except:
+            self.collection = self.chroma_client.create_collection(self.collection_name)
+
+    def chunk_text(self, text: str) -> List[str]:
+        if len(text) <= self.chunk_size:
+            return [text]
+        chunks = []
+        start = 0
+        while start < len(text):
+            end = min(start + self.chunk_size, len(text))
+            if end < len(text):
+                for i in range(end, max(start, end-200), -1):
+                    if text[i] in '.!?\n':
+                        end = i+1
+                        break
+            chunks.append(text[start:end].strip())
+            start = end - self.chunk_overlap
+        return [c for c in chunks if len(c) > 50]
+
+    def generate_embedding(self, text: str) -> List[float]:
+        return self.embedding_model.encode(text).tolist()
+
+    def index_documents(self, force_reindex: bool = False) -> Dict:
+        if force_reindex and self.collection.count() > 0:
+            self.chroma_client.delete_collection(self.collection_name)
+            self._init_collection()
+        self.kb_manager.scan_documents()
+        stats = {"documents": 0, "chunks": 0}
+        for category, cat_info in self.kb_manager.documents.items():
+            if category == 'development':
+                logger.info(f"Skipping development folder")
+                continue
+            for doc in cat_info['documents']:
+                content = self.kb_manager.load_document_content(doc['path'])
+                if not content:
+                    continue
+                chunks = self.chunk_text(content)
+                if not chunks:
+                    continue
+                ids = []
+                embeds = []
+                texts = []
+                metas = []
+                for i, chunk in enumerate(chunks):
+                    cid = f"{doc['filename']}_{i}"
+                    ids.append(cid)
+                    texts.append(chunk)
+                    embeds.append(self.generate_embedding(chunk))
+                    metas.append({
+                        "document_title": doc['title'],
+                        "document_path": doc['path'],
+                        "category": category,
+                        "chunk_index": i
+                    })
+                self.collection.add(ids=ids, embeddings=embeds, documents=texts, metadatas=metas)
+                stats["documents"] += 1
+                stats["chunks"] += len(chunks)
+        logger.info(f"Indexed {stats['documents']} docs, {stats['chunks']} chunks")
+        return stats
+
+    def semantic_search(self, query: str, n_results: int = 5) -> List[Dict]:
+        if self.collection.count() == 0:
+            return []
+        q_emb = self.generate_embedding(query)
+        results = self.collection.query(query_embeddings=[q_emb], n_results=n_results, include=["documents","metadatas","distances"])
+        formatted = []
+        if results['documents'] and results['documents'][0]:
+            for doc, meta, dist in zip(results['documents'][0], results['metadatas'][0], results['distances'][0]):
+                similarity = max(0.0, 1.0 - (dist / 2.0))
+                formatted.append({"document": doc, "metadata": meta, "similarity": similarity})
+        return formatted
+
+    def retrieve_and_rerank_filtered(self, query: str, target_categories: List[str], initial_k: int = 20, final_k: int = 3, similarity_threshold: float = 0.30) -> List[Dict]:
+        candidates = self.semantic_search(query, n_results=initial_k)
+        filtered = [c for c in candidates if c['similarity'] >= similarity_threshold and c['metadata'].get('category') in target_categories]
+        return filtered[:final_k]
+
+    def get_collection_stats(self) -> Dict:
+        return {"total_chunks": self.collection.count()}

static/chat.js

@@ -0,0 +1,298 @@
+// Chat functionality for Too Many Cables customer service
+class ChatInterface {
+    constructor() {
+        this.chatMessages = document.getElementById('chat-messages');
+        this.messageInput = document.getElementById('message-input');
+        this.sendButton = document.getElementById('send-button');
+        this.chatForm = document.getElementById('chat-form');
+        this.clearButton = document.getElementById('clear-chat');
+        this.typingIndicator = document.getElementById('typing-indicator');
+        this.statusDot = document.getElementById('status-dot');
+        this.statusText = document.getElementById('status-text');
+        this.agentStatus = document.getElementById('agent-status');
+        
+        this.conversationId = null;
+        this.isConnected = false;
+        
+        this.init();
+    }
+    
+    init() {
+        this.checkConnection();
+        this.setupEventListeners();
+        this.loadConversationHistory();
+    }
+    
+    setupEventListeners() {
+        if (this.chatForm) {
+            this.chatForm.addEventListener('submit', (e) => {
+                e.preventDefault();
+                this.sendMessage();
+            });
+        }
+        
+        if (this.clearButton) {
+            this.clearButton.addEventListener('click', () => {
+                this.clearConversation();
+            });
+        }
+        
+        const endConversationButton = document.getElementById('end-conversation-button');
+        if (endConversationButton) {
+            endConversationButton.addEventListener('click', () => {
+                this.endConversation();
+            });
+        }
+        
+        if (this.messageInput) {
+            this.messageInput.addEventListener('input', () => {
+                this.autoResizeTextarea();
+                this.toggleSendButton();
+            });
+            
+            this.messageInput.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault();
+                    this.sendMessage();
+                }
+            });
+        }
+    }
+    
+    async checkConnection() {
+        try {
+            const response = await fetch('/api/health');
+            if (response.ok) {
+                this.updateConnectionStatus(true);
+            } else {
+                this.updateConnectionStatus(false);
+            }
+        } catch (error) {
+            console.error('Connection check failed:', error);
+            this.updateConnectionStatus(false);
+        }
+    }
+    
+    updateConnectionStatus(connected) {
+        this.isConnected = connected;
+        if (this.statusDot && this.statusText) {
+            if (connected) {
+                this.statusDot.className = 'status-dot connected';
+                this.statusText.textContent = 'Connected';
+            } else {
+                this.statusDot.className = 'status-dot disconnected';
+                this.statusText.textContent = 'Connection issues';
+            }
+        }
+        if (this.agentStatus) {
+            this.agentStatus.textContent = connected ? 'Online' : 'Offline';
+        }
+    }
+    
+    autoResizeTextarea() {
+        if (this.messageInput) {
+            this.messageInput.style.height = 'auto';
+            this.messageInput.style.height = Math.min(this.messageInput.scrollHeight, 120) + 'px';
+        }
+    }
+    
+    toggleSendButton() {
+        if (this.sendButton && this.messageInput) {
+            this.sendButton.disabled = this.messageInput.value.trim().length === 0;
+        }
+    }
+    
+    async sendMessage() {
+        const message = this.messageInput.value.trim();
+        if (!message || !this.isConnected) return;
+        
+        this.addMessage(message, 'user');
+        this.messageInput.value = '';
+        this.messageInput.style.height = 'auto';
+        this.toggleSendButton();
+        this.showTypingIndicator();
+        
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 120000);
+            
+            // CRITICAL FIX: Add credentials: 'include'
+            const response = await fetch('/api/chat', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    message: message,
+                    conversation_id: this.conversationId
+                }),
+                signal: controller.signal,
+                cache: 'no-cache',
+                mode: 'cors',
+                credentials: 'include'   // <-- THIS LINE FIXES THE NETWORK ERROR
+            });
+            
+            clearTimeout(timeoutId);
+            const data = await response.json();
+            
+            if (data.success) {
+                this.conversationId = data.conversation_id;
+                if (typeof updateConversationId === 'function') {
+                    updateConversationId(this.conversationId);
+                }
+                this.addMessage(data.response, 'assistant', {
+                    responseTime: data.response_time_ms,
+                    model: data.model_used
+                });
+            } else {
+                const errorMessage = data.error || 'Sorry, I encountered an error. Please try again.';
+                this.addMessage(errorMessage, 'assistant', { isError: true });
+            }
+        } catch (error) {
+            console.error('Error sending message:', error);
+            this.addMessage('Connection error. Please check your internet connection and try again.', 'assistant', { isError: true });
+        } finally {
+            this.hideTypingIndicator();
+        }
+    }
+    
+    addMessage(content, role, metadata = {}) {
+        const messageDiv = document.createElement('div');
+        messageDiv.className = `message ${role}-message`;
+        const timestamp = new Date().toLocaleTimeString();
+        let messageHTML = '';
+        if (role === 'user') {
+            messageHTML = `
+                <div class="message-content">
+                    <div class="message-text">${this.escapeHtml(content)}</div>
+                    <div class="message-time">${timestamp}</div>
+                </div>
+                <div class="message-avatar">👤</div>
+            `;
+        } else {
+            const errorClass = metadata.isError ? ' error' : '';
+            const responseTimeText = metadata.responseTime ? ` (${metadata.responseTime}ms)` : '';
+            messageHTML = `
+                <div class="message-avatar">🤖</div>
+                <div class="message-content${errorClass}">
+                    <div class="message-text">${this.escapeHtml(content)}</div>
+                    <div class="message-time">${timestamp}${responseTimeText}</div>
+                </div>
+            `;
+        }
+        messageDiv.innerHTML = messageHTML;
+        if (this.chatMessages) {
+            this.chatMessages.appendChild(messageDiv);
+            this.scrollToBottom();
+        }
+    }
+    
+    showTypingIndicator() {
+        if (this.typingIndicator) {
+            this.typingIndicator.style.display = 'flex';
+            this.scrollToBottom();
+        }
+    }
+    
+    hideTypingIndicator() {
+        if (this.typingIndicator) {
+            this.typingIndicator.style.display = 'none';
+        }
+    }
+    
+    scrollToBottom() {
+        if (this.chatMessages) {
+            this.chatMessages.scrollTop = this.chatMessages.scrollHeight;
+        }
+    }
+    
+    async clearConversation() {
+        if (!this.conversationId) {
+            this.clearChatUI();
+            return;
+        }
+        if (confirm('Are you sure you want to clear this conversation?')) {
+            try {
+                const response = await fetch(`/api/conversation/${this.conversationId}/clear`, {
+                    method: 'POST'
+                });
+                if (response.ok) {
+                    this.clearChatUI();
+                    this.conversationId = null;
+                } else {
+                    alert('Failed to clear conversation. Please try again.');
+                }
+            } catch (error) {
+                console.error('Error clearing conversation:', error);
+                alert('Error clearing conversation. Please try again.');
+            }
+        }
+    }
+    
+    async endConversation() {
+        if (!this.conversationId) {
+            alert('No active conversation to end.');
+            return;
+        }
+        if (confirm('End this conversation and save a summary to any mentioned tickets?')) {
+            try {
+                const response = await fetch('/api/conversation/end', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ conversation_id: this.conversationId })
+                });
+                if (response.ok) {
+                    const result = await response.json();
+                    if (result.success) {
+                        alert(result.message || 'Conversation ended successfully!');
+                        this.clearChatUI();
+                        this.conversationId = null;
+                    } else {
+                        alert(result.message || 'Failed to end conversation properly.');
+                    }
+                } else {
+                    alert('Failed to end conversation. Please try again.');
+                }
+            } catch (error) {
+                console.error('Error ending conversation:', error);
+                alert('Error ending conversation. Please try again.');
+            }
+        }
+    }
+    
+    clearChatUI() {
+        if (this.chatMessages) {
+            const welcomeMessage = this.chatMessages.querySelector('.welcome-message');
+            this.chatMessages.innerHTML = '';
+            if (welcomeMessage) {
+                this.chatMessages.appendChild(welcomeMessage);
+            }
+        }
+    }
+    
+    async loadConversationHistory() {
+        try {
+            const response = await fetch('/api/user');
+            if (response.ok) {
+                const userData = await response.json();
+                if (userData.success) {
+                    console.log('User authenticated:', userData.user.name);
+                }
+            }
+        } catch (error) {
+            console.log('User not authenticated');
+        }
+    }
+    
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+}
+
+document.addEventListener('DOMContentLoaded', function() {
+    if (document.getElementById('chat-messages')) {
+        new ChatInterface();
+    }
+});

static/script.js

@@ -0,0 +1,95 @@
+// Too Many Cables - Main Website JavaScript
+class TMCWebsite {
+    constructor() {
+        this.currentUser = null;
+        this.init();
+    }
+    
+    init() {
+        this.setupNavigation();
+        this.setupUserAuthentication();
+        this.checkUserStatus();
+    }
+    
+    setupNavigation() {
+        const navToggle = document.getElementById('nav-toggle');
+        const navMenu = document.getElementById('nav-menu');
+        
+        if (navToggle && navMenu) {
+            navToggle.addEventListener('click', () => {
+                navMenu.classList.toggle('active');
+                navToggle.classList.toggle('active');
+            });
+        }
+    }
+    
+    setupUserAuthentication() {
+        // Login/logout functionality is now handled in base.html
+        // This method is kept for future authentication-related features
+    }
+    
+    showModal(type) {
+        const modalId = type === 'login' ? 'login-modal' : 'register-modal';
+        const modal = document.getElementById(modalId);
+        if (modal) {
+            modal.style.display = 'flex';
+        }
+    }
+    
+    hideModal(modalId) {
+        const modal = document.getElementById(modalId);
+        if (modal) {
+            modal.style.display = 'none';
+            const form = modal.querySelector('form');
+            if (form) form.reset();
+        }
+    }
+    
+    async logout() {
+        // Logout functionality is now handled in base.html
+        // This method is kept for compatibility
+    }
+    
+    async checkUserStatus() {
+        try {
+            const response = await fetch('/api/user');
+            const data = await response.json();
+            
+            if (data.success) {
+                this.currentUser = data.user;
+                this.updateUserUI();
+            }
+        } catch (error) {
+            console.log('User not authenticated');
+        }
+    }
+    
+    updateUserUI() {
+        const authBtn = document.getElementById('auth-btn');
+        const userGreeting = document.getElementById('user-greeting');
+        const userName = document.getElementById('user-name');
+        const ticketsLink = document.getElementById('tickets-link');
+        
+        if (this.currentUser) {
+            if (authBtn) {
+                authBtn.textContent = 'Logout';
+                authBtn.title = 'Click to logout';
+            }
+            if (userGreeting) userGreeting.style.display = 'inline';
+            if (userName) userName.textContent = this.currentUser.name;
+            if (ticketsLink) ticketsLink.style.display = 'inline-block';
+        } else {
+            if (authBtn) {
+                authBtn.textContent = 'Login';
+                authBtn.title = 'Click to login';
+            }
+            if (userGreeting) userGreeting.style.display = 'none';
+            if (ticketsLink) ticketsLink.style.display = 'none';
+        }
+    }
+}
+
+// Initialize website functionality when DOM is loaded
+document.addEventListener('DOMContentLoaded', function() {
+    new TMCWebsite();
+});

static/style.css

@@ -0,0 +1,514 @@
+/* Reset and base styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+    line-height: 1.6;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 20px;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+/* Header */
+header {
+    background: rgba(255, 255, 255, 0.95);
+    backdrop-filter: blur(10px);
+    border-radius: 15px;
+    padding: 20px 30px;
+    margin-bottom: 20px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+header h1 {
+    color: #333;
+    font-size: 2.2em;
+    font-weight: 700;
+}
+
+.status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-weight: 500;
+}
+
+.status-dot {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    background: #ffa500;
+    animation: pulse 2s infinite;
+}
+
+.status-dot.connected {
+    background: #4caf50;
+    animation: none;
+}
+
+.status-dot.error {
+    background: #f44336;
+    animation: none;
+}
+
+@keyframes pulse {
+    0% { opacity: 1; }
+    50% { opacity: 0.5; }
+    100% { opacity: 1; }
+}
+
+/* Main content */
+.main-content {
+    display: grid;
+    grid-template-columns: 300px 1fr;
+    gap: 20px;
+    flex: 1;
+    min-height: 0;
+}
+
+/* Agent panel */
+.agent-panel {
+    background: rgba(255, 255, 255, 0.95);
+    backdrop-filter: blur(10px);
+    border-radius: 15px;
+    padding: 25px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    height: fit-content;
+}
+
+.agent-panel h3 {
+    color: #333;
+    margin-bottom: 15px;
+    font-size: 1.3em;
+}
+
+.agent-info {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.agent-info p {
+    color: #666;
+    font-size: 14px;
+    margin: 5px 0;
+}
+
+.agent-info p strong {
+    color: #333;
+    min-width: 80px;
+    display: inline-block;
+}
+
+.agent-description {
+    margin-top: 15px;
+    padding: 15px;
+    background: #f8f9ff;
+    border-radius: 10px;
+    border-left: 4px solid #667eea;
+    font-style: italic;
+}
+
+#agent-status {
+    font-weight: 500;
+}
+
+#agent-status.ready {
+    color: #28a745;
+}
+
+#agent-status.error {
+    color: #dc3545;
+}
+
+#agent-status.connecting {
+    color: #ffc107;
+}
+
+/* Chat container */
+.chat-container {
+    background: rgba(255, 255, 255, 0.95);
+    backdrop-filter: blur(10px);
+    border-radius: 15px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.chat-header {
+    padding: 20px 25px;
+    border-bottom: 1px solid #e0e0e0;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: rgba(255, 255, 255, 0.8);
+}
+
+.chat-header h3 {
+    color: #333;
+    font-size: 1.3em;
+}
+
+.clear-btn {
+    padding: 8px 15px;
+    background: #f44336;
+    color: white;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+    font-size: 14px;
+    transition: all 0.3s ease;
+}
+
+.clear-btn:hover {
+    background: #d32f2f;
+    transform: translateY(-2px);
+}
+
+/* Chat messages */
+.chat-messages {
+    flex: 1;
+    padding: 20px;
+    overflow-y: auto;
+    max-height: 500px;
+    min-height: 400px;
+}
+
+.welcome-message {
+    text-align: center;
+    color: #666;
+    margin-top: 50px;
+}
+
+.welcome-message h4 {
+    color: #333;
+    margin-bottom: 15px;
+    font-size: 1.4em;
+}
+
+.welcome-message ul {
+    text-align: left;
+    max-width: 400px;
+    margin: 20px auto 0;
+}
+
+.welcome-message li {
+    margin: 8px 0;
+}
+
+.message {
+    margin: 15px 0;
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+    opacity: 0;
+    animation: messageSlideIn 0.3s ease forwards;
+}
+
+@keyframes messageSlideIn {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.message.user {
+    flex-direction: row-reverse;
+}
+
+.message-avatar {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 18px;
+    flex-shrink: 0;
+}
+
+.message.user .message-avatar {
+    background: linear-gradient(135deg, #667eea, #764ba2);
+    color: white;
+}
+
+.message.bot .message-avatar {
+    background: linear-gradient(135deg, #4caf50, #45a049);
+    color: white;
+}
+
+.message-content {
+    max-width: 70%;
+    padding: 15px 20px;
+    border-radius: 20px;
+    position: relative;
+}
+
+.message.user .message-content {
+    background: linear-gradient(135deg, #667eea, #764ba2);
+    color: white;
+    border-bottom-right-radius: 5px;
+}
+
+.message.bot .message-content {
+    background: #f8f9ff;
+    border: 1px solid #e0e0e0;
+    color: #333;
+    border-bottom-left-radius: 5px;
+}
+
+.message-text {
+    margin: 0;
+    word-wrap: break-word;
+}
+
+.message-time {
+    font-size: 11px;
+    opacity: 0.7;
+    margin-top: 5px;
+}
+
+/* Chat input */
+.chat-input-container {
+    padding: 20px;
+    border-top: 1px solid #e0e0e0;
+    background: rgba(255, 255, 255, 0.8);
+}
+
+.input-group {
+    display: flex;
+    gap: 15px;
+    align-items: flex-end;
+    flex-wrap: wrap;
+}
+
+#message-input {
+    flex: 1;
+    padding: 15px 20px;
+    border: 2px solid #e0e0e0;
+    border-radius: 25px;
+    font-size: 14px;
+    font-family: inherit;
+    resize: none;
+    transition: all 0.3s ease;
+    background: white;
+}
+
+#message-input:focus {
+    outline: none;
+    border-color: #667eea;
+    box-shadow: 0 0 0 4px rgba(102, 126, 234, 0.1);
+}
+
+#message-input:disabled {
+    background: #f5f5f5;
+    color: #999;
+    cursor: not-allowed;
+}
+
+#send-btn {
+    padding: 15px 25px;
+    background: linear-gradient(135deg, #667eea, #764ba2);
+    color: white;
+    border: none;
+    border-radius: 25px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 600;
+    transition: all 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: 100px;
+    justify-content: center;
+}
+
+#send-btn:hover:not(:disabled) {
+    transform: translateY(-2px);
+    box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+}
+
+#send-btn:disabled {
+    background: #ccc;
+    cursor: not-allowed;
+    transform: none;
+    box-shadow: none;
+}
+
+.action-button {
+    padding: 10px 15px;
+    border: 2px solid #667eea;
+    background: transparent;
+    color: #667eea;
+    border-radius: 20px;
+    cursor: pointer;
+    font-size: 12px;
+    font-weight: 600;
+    transition: all 0.3s ease;
+    margin-left: 10px;
+}
+
+.action-button:hover {
+    background: #667eea;
+    color: white;
+    transform: translateY(-1px);
+}
+
+.action-button.end-conversation {
+    border-color: #e74c3c;
+    color: #e74c3c;
+    background: #ffebee;
+    font-weight: bold;
+    padding: 12px 20px;
+}
+
+.action-button.end-conversation:hover {
+    background: #e74c3c;
+    color: white;
+}
+
+.send-icon {
+    font-size: 16px;
+}
+
+.input-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-top: 10px;
+    font-size: 12px;
+    color: #666;
+}
+
+.divider {
+    margin: 0 10px;
+}
+
+/* Loading overlay */
+.loading-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+
+.loading-overlay.hidden {
+    display: none;
+}
+
+.loading-spinner {
+    background: white;
+    padding: 30px;
+    border-radius: 15px;
+    text-align: center;
+    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
+}
+
+.spinner {
+    width: 40px;
+    height: 40px;
+    border: 4px solid #f3f3f3;
+    border-top: 4px solid #667eea;
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 15px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .container {
+        padding: 10px;
+    }
+    
+    .main-content {
+        grid-template-columns: 1fr;
+        gap: 15px;
+    }
+    
+    .agent-panel {
+        order: 2;
+    }
+    
+    .chat-container {
+        order: 1;
+    }
+    
+    header {
+        padding: 15px 20px;
+        flex-direction: column;
+        gap: 15px;
+        text-align: center;
+    }
+    
+    header h1 {
+        font-size: 1.8em;
+    }
+    
+    .chat-messages {
+        max-height: 300px;
+        min-height: 250px;
+    }
+    
+    .message-content {
+        max-width: 85%;
+    }
+    
+    .input-group {
+        flex-direction: column;
+        gap: 10px;
+    }
+    
+    #send-btn {
+        align-self: flex-end;
+        min-width: 120px;
+    }
+}
+
+/* Scrollbar styling */
+.chat-messages::-webkit-scrollbar {
+    width: 6px;
+}
+
+.chat-messages::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 3px;
+}
+
+.chat-messages::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 3px;
+}
+
+.chat-messages::-webkit-scrollbar-thumb:hover {
+    background: #a8a8a8;
+}

templates/admin_tickets.html

@@ -0,0 +1,888 @@
+{% extends "base.html" %}
+
+{% block title %}Admin - Ticket Management - Too Many Cables{% endblock %}
+
+{% block description %}Administrative interface for managing customer support tickets and monitoring system performance.{% endblock %}
+
+{% block content %}
+<div class="admin-container">
+    <div class="page-header">
+        <h1 class="page-title">Admin - Ticket Management</h1>
+        <p class="page-subtitle">Manage customer support tickets and monitor system performance</p>
+    </div>
+
+    <!-- Statistics Dashboard -->
+    <div class="stats-grid">
+        <div class="stat-card">
+            <div class="stat-icon">📊</div>
+            <div class="stat-content">
+                <h3 id="total-tickets">-</h3>
+                <p>Total Tickets</p>
+            </div>
+        </div>
+        
+        <div class="stat-card">
+            <div class="stat-icon">🟢</div>
+            <div class="stat-content">
+                <h3 id="open-tickets">-</h3>
+                <p>Open Tickets</p>
+            </div>
+        </div>
+        
+        <div class="stat-card">
+            <div class="stat-icon">🔵</div>
+            <div class="stat-content">
+                <h3 id="in-progress-tickets">-</h3>
+                <p>In Progress</p>
+            </div>
+        </div>
+        
+        <div class="stat-card">
+            <div class="stat-icon">✅</div>
+            <div class="stat-content">
+                <h3 id="resolved-tickets">-</h3>
+                <p>Resolved</p>
+            </div>
+        </div>
+    </div>
+
+    <!-- Filters and Controls -->
+    <div class="glass-card filters-section">
+        <div class="filters-header">
+            <h3>Ticket Filters</h3>
+            <button class="btn btn-primary" onclick="refreshTickets()">Refresh</button>
+        </div>
+        
+        <div class="filters-row">
+            <div class="filter-group">
+                <label for="status-filter">Status:</label>
+                <select id="status-filter" onchange="applyFilters()">
+                    <option value="">All Status</option>
+                    <option value="open">Open</option>
+                    <option value="in_progress">In Progress</option>
+                    <option value="resolved">Resolved</option>
+                    <option value="closed">Closed</option>
+                </select>
+            </div>
+            
+            <div class="filter-group">
+                <label for="priority-filter">Priority:</label>
+                <select id="priority-filter" onchange="applyFilters()">
+                    <option value="">All Priority</option>
+                    <option value="low">Low</option>
+                    <option value="medium">Medium</option>
+                    <option value="high">High</option>
+                    <option value="urgent">Urgent</option>
+                </select>
+            </div>
+            
+            <div class="filter-group">
+                <label for="category-filter">Category:</label>
+                <select id="category-filter" onchange="applyFilters()">
+                    <option value="">All Categories</option>
+                </select>
+            </div>
+        </div>
+    </div>
+
+    <!-- Tickets Table -->
+    <div class="glass-card tickets-table-section">
+        <div class="table-header">
+            <h3>All Tickets</h3>
+            <div class="pagination-info">
+                <span id="pagination-text">Loading...</span>
+            </div>
+        </div>
+        
+        <div id="tickets-loading" class="loading-state">
+            <div class="spinner"></div>
+            <p>Loading tickets...</p>
+        </div>
+        
+        <div id="tickets-table-container" style="display: none;">
+            <table id="tickets-table" class="admin-table">
+                <thead>
+                    <tr>
+                        <th>Ticket #</th>
+                        <th>Customer</th>
+                        <th>Subject</th>
+                        <th>Category</th>
+                        <th>Priority</th>
+                        <th>Status</th>
+                        <th>Assigned To</th>
+                        <th>Created</th>
+                        <th>Actions</th>
+                    </tr>
+                </thead>
+                <tbody id="tickets-table-body">
+                </tbody>
+            </table>
+        </div>
+        
+        <!-- Pagination -->
+        <div class="pagination-container">
+            <button id="prev-page" class="btn btn-outline" onclick="changePage(-1)" disabled>Previous</button>
+            <span id="page-info">Page 1 of 1</span>
+            <button id="next-page" class="btn btn-outline" onclick="changePage(1)" disabled>Next</button>
+        </div>
+    </div>
+</div>
+
+<!-- Ticket Detail Modal -->
+<div id="ticket-detail-modal" class="modal" style="display: none;">
+    <div class="modal-content large-modal glass-card">
+        <div class="modal-header">
+            <h3 id="modal-ticket-title">Ticket Details</h3>
+            <button class="modal-close" onclick="closeTicketModal()">&times;</button>
+        </div>
+        
+        <div class="modal-body">
+            <div id="ticket-detail-content"></div>
+            
+            <!-- Admin Actions -->
+            <div class="admin-actions">
+                <h4>Admin Actions</h4>
+                
+                <div class="action-row">
+                    <div class="action-group">
+                        <label for="assign-agent">Assign to Agent:</label>
+                        <input type="text" id="assign-agent" placeholder="Agent name">
+                        <button class="btn btn-secondary" onclick="assignTicket()">Assign</button>
+                    </div>
+                    
+                    <div class="action-group">
+                        <label for="update-status">Update Status:</label>
+                        <select id="update-status">
+                            <option value="open">Open</option>
+                            <option value="in_progress">In Progress</option>
+                            <option value="resolved">Resolved</option>
+                            <option value="closed">Closed</option>
+                        </select>
+                        <button class="btn btn-secondary" onclick="updateStatus()">Update</button>
+                    </div>
+                </div>
+                
+                <div class="admin-reply-section">
+                    <h5>Add Admin Reply</h5>
+                    <textarea id="admin-reply" placeholder="Type your reply..." rows="3"></textarea>
+                    <div class="reply-options">
+                        <label>
+                            <input type="checkbox" id="internal-note"> Internal note (not visible to customer)
+                        </label>
+                        <button class="btn btn-primary" onclick="addAdminReply()">Send Reply</button>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+.admin-container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 2rem;
+}
+
+.page-header {
+    text-align: center;
+    margin-bottom: 3rem;
+}
+
+.page-title {
+    font-size: 2.5rem;
+    font-weight: 700;
+    color: white;
+    text-shadow: 0 2px 10px rgba(0,0,0,0.3);
+    margin-bottom: 0.5rem;
+}
+
+.page-subtitle {
+    font-size: 1.1rem;
+    color: rgba(255,255,255,0.9);
+    font-weight: 300;
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.stat-card {
+    background: rgba(255, 255, 255, 0.15);
+    backdrop-filter: blur(25px);
+    border-radius: 15px;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    padding: 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    transition: transform 0.3s ease;
+}
+
+.stat-card:hover {
+    transform: translateY(-2px);
+}
+
+.stat-icon {
+    font-size: 2rem;
+}
+
+.stat-content h3 {
+    font-size: 2rem;
+    font-weight: 700;
+    color: white;
+    margin: 0;
+}
+
+.stat-content p {
+    color: rgba(255,255,255,0.8);
+    margin: 0;
+    font-size: 0.9rem;
+}
+
+.glass-card {
+    background: rgba(255, 255, 255, 0.15);
+    backdrop-filter: blur(25px);
+    -webkit-backdrop-filter: blur(25px);
+    border-radius: 20px;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    padding: 2rem;
+    margin-bottom: 2rem;
+    box-shadow: 0 8px 32px rgba(31, 38, 135, 0.37);
+}
+
+.filters-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.filters-header h3 {
+    color: white;
+    margin: 0;
+}
+
+.filters-row {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 1rem;
+}
+
+.filter-group label {
+    display: block;
+    color: rgba(255,255,255,0.9);
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.filter-group select,
+.filter-group input {
+    width: 100%;
+    padding: 0.5rem;
+    border: 1px solid rgba(255,255,255,0.3);
+    border-radius: 8px;
+    background: rgba(255,255,255,0.1);
+    color: white;
+    font-size: 0.9rem;
+}
+
+.table-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.table-header h3 {
+    color: white;
+    margin: 0;
+}
+
+.admin-table {
+    width: 100%;
+    border-collapse: collapse;
+    background: rgba(255,255,255,0.1);
+    border-radius: 10px;
+    overflow: hidden;
+}
+
+.admin-table th,
+.admin-table td {
+    padding: 1rem;
+    text-align: left;
+    border-bottom: 1px solid rgba(255,255,255,0.1);
+}
+
+.admin-table th {
+    background: rgba(255,255,255,0.2);
+    color: white;
+    font-weight: 600;
+}
+
+.admin-table td {
+    color: rgba(255,255,255,0.9);
+}
+
+.admin-table tr:hover {
+    background: rgba(255,255,255,0.1);
+}
+
+.ticket-status-badge {
+    padding: 0.25rem 0.75rem;
+    border-radius: 20px;
+    font-size: 0.8rem;
+    font-weight: 500;
+    text-transform: uppercase;
+}
+
+.priority-badge {
+    padding: 0.25rem 0.5rem;
+    border-radius: 15px;
+    font-size: 0.75rem;
+    font-weight: 500;
+    text-transform: uppercase;
+}
+
+.priority-low { background: #95a5a6; color: white; }
+.priority-medium { background: #3498db; color: white; }
+.priority-high { background: #f39c12; color: white; }
+.priority-urgent { background: #e74c3c; color: white; }
+
+.btn {
+    padding: 0.5rem 1rem;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    text-decoration: none;
+    display: inline-block;
+    transition: all 0.3s ease;
+    cursor: pointer;
+    font-size: 0.9rem;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+}
+
+.btn-secondary {
+    background: rgba(255,255,255,0.2);
+    color: white;
+    border: 1px solid rgba(255,255,255,0.3);
+}
+
+.btn-outline {
+    background: transparent;
+    color: white;
+    border: 1px solid rgba(255,255,255,0.3);
+}
+
+.btn:hover {
+    transform: translateY(-1px);
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+    transform: none;
+}
+
+.pagination-container {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-top: 1rem;
+}
+
+.loading-state {
+    text-align: center;
+    padding: 2rem;
+    color: rgba(255,255,255,0.8);
+}
+
+.spinner {
+    border: 3px solid rgba(255,255,255,0.3);
+    border-top: 3px solid white;
+    border-radius: 50%;
+    width: 40px;
+    height: 40px;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 1rem;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0,0,0,0.8);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 2000;
+}
+
+.large-modal {
+    max-width: 900px;
+    width: 95%;
+    max-height: 90vh;
+    overflow-y: auto;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    color: white;
+    font-size: 2rem;
+    cursor: pointer;
+    opacity: 0.7;
+    transition: opacity 0.3s ease;
+}
+
+.modal-close:hover {
+    opacity: 1;
+}
+
+.admin-actions {
+    margin-top: 2rem;
+    padding-top: 2rem;
+    border-top: 1px solid rgba(255,255,255,0.2);
+}
+
+.admin-actions h4,
+.admin-actions h5 {
+    color: white;
+    margin-bottom: 1rem;
+}
+
+.action-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 2rem;
+    margin-bottom: 2rem;
+}
+
+.action-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.action-group label {
+    color: rgba(255,255,255,0.9);
+    font-weight: 500;
+}
+
+.action-group input,
+.action-group select {
+    padding: 0.5rem;
+    border: 1px solid rgba(255,255,255,0.3);
+    border-radius: 8px;
+    background: rgba(255,255,255,0.1);
+    color: white;
+}
+
+.admin-reply-section textarea {
+    width: 100%;
+    padding: 0.75rem;
+    border: 1px solid rgba(255,255,255,0.3);
+    border-radius: 8px;
+    background: rgba(255,255,255,0.1);
+    color: white;
+    resize: vertical;
+    margin-bottom: 1rem;
+}
+
+.reply-options {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.reply-options label {
+    color: rgba(255,255,255,0.8);
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+@media (max-width: 768px) {
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .filters-row {
+        grid-template-columns: 1fr;
+    }
+    
+    .action-row {
+        grid-template-columns: 1fr;
+    }
+    
+    .table-header {
+        flex-direction: column;
+        gap: 1rem;
+        text-align: center;
+    }
+    
+    .admin-table {
+        font-size: 0.85rem;
+    }
+    
+    .admin-table th,
+    .admin-table td {
+        padding: 0.5rem;
+    }
+}
+</style>
+
+<script>
+// Admin ticket management functionality
+let currentPage = 1;
+let totalPages = 1;
+let currentFilters = {};
+let currentTicketId = null;
+
+// Initialize page
+document.addEventListener('DOMContentLoaded', function() {
+    loadStats();
+    loadCategories();
+    loadTickets();
+});
+
+function loadStats() {
+    fetch('/api/admin/tickets/stats')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                const stats = data.stats.overall;
+                document.getElementById('total-tickets').textContent = stats.total_tickets;
+                document.getElementById('open-tickets').textContent = stats.open_tickets;
+                document.getElementById('in-progress-tickets').textContent = stats.in_progress_tickets;
+                document.getElementById('resolved-tickets').textContent = stats.resolved_tickets;
+            }
+        })
+        .catch(error => console.error('Error loading stats:', error));
+}
+
+function loadCategories() {
+    fetch('/api/tickets/categories')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                const categorySelect = document.getElementById('category-filter');
+                data.categories.forEach(category => {
+                    const option = document.createElement('option');
+                    option.value = category.name;
+                    option.textContent = category.name;
+                    categorySelect.appendChild(option);
+                });
+            }
+        })
+        .catch(error => console.error('Failed to load categories:', error));
+}
+
+function loadTickets(page = 1) {
+    currentPage = page;
+    document.getElementById('tickets-loading').style.display = 'block';
+    document.getElementById('tickets-table-container').style.display = 'none';
+    
+    // Build query parameters
+    const params = new URLSearchParams({
+        page: page,
+        limit: 20,
+        ...currentFilters
+    });
+    
+    fetch(`/api/admin/tickets?${params}`)
+        .then(response => response.json())
+        .then(data => {
+            document.getElementById('tickets-loading').style.display = 'none';
+            
+            if (data.success) {
+                displayTickets(data.tickets);
+                updatePagination(data.pagination);
+                document.getElementById('tickets-table-container').style.display = 'block';
+            } else {
+                console.error('Failed to load tickets:', data.error);
+            }
+        })
+        .catch(error => {
+            document.getElementById('tickets-loading').style.display = 'none';
+            console.error('Error loading tickets:', error);
+        });
+}
+
+function displayTickets(tickets) {
+    const tbody = document.getElementById('tickets-table-body');
+    tbody.innerHTML = '';
+    
+    tickets.forEach(ticket => {
+        const row = createTicketRow(ticket);
+        tbody.appendChild(row);
+    });
+}
+
+function createTicketRow(ticket) {
+    const tr = document.createElement('tr');
+    const createdDate = new Date(ticket.created_at).toLocaleDateString();
+    
+    tr.innerHTML = `
+        <td><strong>${ticket.ticket_number}</strong></td>
+        <td>${ticket.first_name} ${ticket.last_name}<br><small>${ticket.email}</small></td>
+        <td>${ticket.subject}</td>
+        <td>${ticket.category}</td>
+        <td><span class="priority-badge priority-${ticket.priority}">${ticket.priority}</span></td>
+        <td><span class="ticket-status-badge status-${ticket.status}">${ticket.status.replace('_', ' ')}</span></td>
+        <td>${ticket.assigned_agent || 'Unassigned'}</td>
+        <td>${createdDate}</td>
+        <td>
+            <button class="btn btn-secondary" onclick="viewTicket('${ticket.ticket_number}')">View</button>
+        </td>
+    `;
+    
+    return tr;
+}
+
+function updatePagination(pagination) {
+    totalPages = pagination.pages;
+    document.getElementById('page-info').textContent = `Page ${pagination.page} of ${pagination.pages}`;
+    document.getElementById('pagination-text').textContent = 
+        `Showing ${((pagination.page - 1) * pagination.limit) + 1}-${Math.min(pagination.page * pagination.limit, pagination.total)} of ${pagination.total} tickets`;
+    
+    document.getElementById('prev-page').disabled = pagination.page <= 1;
+    document.getElementById('next-page').disabled = pagination.page >= pagination.pages;
+}
+
+function changePage(direction) {
+    const newPage = currentPage + direction;
+    if (newPage >= 1 && newPage <= totalPages) {
+        loadTickets(newPage);
+    }
+}
+
+function applyFilters() {
+    currentFilters = {
+        status: document.getElementById('status-filter').value,
+        priority: document.getElementById('priority-filter').value,
+        category: document.getElementById('category-filter').value
+    };
+    
+    // Remove empty filters
+    Object.keys(currentFilters).forEach(key => {
+        if (!currentFilters[key]) {
+            delete currentFilters[key];
+        }
+    });
+    
+    loadTickets(1); // Reset to page 1 when filtering
+}
+
+function refreshTickets() {
+    loadStats();
+    loadTickets(currentPage);
+}
+
+function viewTicket(ticketNumber) {
+    fetch(`/api/tickets/${ticketNumber}`)
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                showTicketDetails(data.ticket, data.updates);
+                currentTicketId = data.ticket.id;
+                document.getElementById('ticket-detail-modal').style.display = 'flex';
+            } else {
+                alert('Failed to load ticket details: ' + data.error);
+            }
+        })
+        .catch(error => {
+            console.error('Error loading ticket:', error);
+            alert('Error loading ticket details.');
+        });
+}
+
+function showTicketDetails(ticket, updates) {
+    const container = document.getElementById('ticket-detail-content');
+    const createdDate = new Date(ticket.created_at).toLocaleDateString();
+    
+    let updatesHtml = '';
+    if (updates && updates.length > 0) {
+        updatesHtml = '<h4 style="color: white; margin-top: 2rem;">Updates:</h4>';
+        updates.forEach(update => {
+            const updateDate = new Date(update.created_at).toLocaleDateString();
+            const isInternal = update.is_internal ? ' (Internal)' : '';
+            updatesHtml += `
+                <div style="background: rgba(255,255,255,0.1); padding: 1rem; margin: 0.5rem 0; border-radius: 8px;">
+                    <div style="color: rgba(255,255,255,0.8); font-size: 0.9rem; margin-bottom: 0.5rem;">
+                        ${updateDate} - ${update.update_type}${isInternal}
+                    </div>
+                    <div style="color: white;">${update.message}</div>
+                </div>
+            `;
+        });
+    }
+    
+    container.innerHTML = `
+        <div style="color: white;">
+            <h4>Ticket ${ticket.ticket_number}</h4>
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 2rem; margin: 1rem 0;">
+                <div>
+                    <p><strong>Customer:</strong> ${ticket.first_name} ${ticket.last_name}</p>
+                    <p><strong>Email:</strong> ${ticket.email}</p>
+                    <p><strong>Status:</strong> <span class="ticket-status-badge status-${ticket.status}">${ticket.status.replace('_', ' ')}</span></p>
+                    <p><strong>Priority:</strong> <span class="priority-badge priority-${ticket.priority}">${ticket.priority}</span></p>
+                </div>
+                <div>
+                    <p><strong>Category:</strong> ${ticket.category}</p>
+                    <p><strong>Assigned Agent:</strong> ${ticket.assigned_agent || 'Unassigned'}</p>
+                    <p><strong>Created:</strong> ${createdDate}</p>
+                    <p><strong>Escalation Level:</strong> ${ticket.escalation_level || 0}</p>
+                </div>
+            </div>
+            <h5 style="margin-top: 1.5rem;">Subject:</h5>
+            <p>${ticket.subject}</p>
+            <h5 style="margin-top: 1.5rem;">Description:</h5>
+            <p style="white-space: pre-wrap;">${ticket.description}</p>
+            ${updatesHtml}
+        </div>
+    `;
+    
+    // Set current values in form fields
+    document.getElementById('assign-agent').value = ticket.assigned_agent || '';
+    document.getElementById('update-status').value = ticket.status;
+    
+    document.getElementById('modal-ticket-title').textContent = `Ticket ${ticket.ticket_number}`;
+}
+
+function assignTicket() {
+    if (!currentTicketId) return;
+    
+    const agentName = document.getElementById('assign-agent').value.trim();
+    if (!agentName) {
+        alert('Please enter an agent name');
+        return;
+    }
+    
+    fetch(`/api/admin/tickets/${currentTicketId}/assign`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ assigned_agent: agentName })
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            alert('Ticket assigned successfully!');
+            refreshTickets();
+            closeTicketModal();
+        } else {
+            alert('Failed to assign ticket: ' + data.error);
+        }
+    })
+    .catch(error => {
+        console.error('Error assigning ticket:', error);
+        alert('Error assigning ticket. Please try again.');
+    });
+}
+
+function updateStatus() {
+    if (!currentTicketId) return;
+    
+    const newStatus = document.getElementById('update-status').value;
+    const resolutionNotes = newStatus === 'resolved' ? 
+        prompt('Resolution notes (optional):') || '' : '';
+    
+    fetch(`/api/admin/tickets/${currentTicketId}/status`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+            status: newStatus,
+            resolution_notes: resolutionNotes
+        })
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            alert('Status updated successfully!');
+            refreshTickets();
+            closeTicketModal();
+        } else {
+            alert('Failed to update status: ' + data.error);
+        }
+    })
+    .catch(error => {
+        console.error('Error updating status:', error);
+        alert('Error updating status. Please try again.');
+    });
+}
+
+function addAdminReply() {
+    if (!currentTicketId) return;
+    
+    const message = document.getElementById('admin-reply').value.trim();
+    const isInternal = document.getElementById('internal-note').checked;
+    
+    if (!message) {
+        alert('Please enter a message');
+        return;
+    }
+    
+    fetch(`/api/admin/tickets/${currentTicketId}/reply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+            message: message,
+            is_internal: isInternal
+        })
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            alert('Reply added successfully!');
+            document.getElementById('admin-reply').value = '';
+            document.getElementById('internal-note').checked = false;
+            // Reload ticket details
+            const ticketNumber = document.getElementById('modal-ticket-title').textContent.replace('Ticket ', '');
+            viewTicket(ticketNumber);
+        } else {
+            alert('Failed to add reply: ' + data.error);
+        }
+    })
+    .catch(error => {
+        console.error('Error adding reply:', error);
+        alert('Error adding reply. Please try again.');
+    });
+}
+
+function closeTicketModal() {
+    document.getElementById('ticket-detail-modal').style.display = 'none';
+    document.getElementById('admin-reply').value = '';
+    document.getElementById('internal-note').checked = false;
+    currentTicketId = null;
+}
+
+// Close modal on outside click
+document.getElementById('ticket-detail-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeTicketModal();
+    }
+});
+</script>
+{% endblock %}

templates/chat.html

@@ -0,0 +1,676 @@
+{% extends "base.html" %}
+
+{% block title %}Live Chat - Too Many Cables{% endblock %}
+
+{% block content %}
+<!-- Page Header -->
+<section class="page-header">
+    <div class="container">
+        <div class="header-card">
+            <div class="page-header-content">
+                <h1>Live Chat Support</h1>
+                <p>Get instant help from our AI-powered customer service agent</p>
+                <div class="status-indicator">
+                    <div id="status-dot" class="status-dot online"></div>
+                    <span id="status-text">Agent Online</span>
+                </div>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Chat Interface -->
+<section class="chat-section">
+    <div class="container">
+        <div class="chat-layout">
+            <!-- Main Chat Container -->
+            <div class="glassmorphism-container chat-main">
+                <div class="chat-container">
+                    <div id="chat-messages" class="chat-messages">
+                        <div class="welcome-message">
+                            <div class="agent-avatar">🤖</div>
+                            <div class="message-content">
+                                <h4>Hi! I'm TMCBot</h4>
+                                <p>I'm here to help you find the perfect cables and accessories. Ask me about products, compatibility, or any technical questions!</p>
+                                <div id="welcome-tickets-info" style="display: none;">
+                                    <p><strong>I can see you have active support tickets. Feel free to ask me about them!</strong></p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="typing-indicator" id="typing-indicator" style="display: none;">
+                        <div class="typing-dots">
+                            <span></span>
+                            <span></span>
+                            <span></span>
+                        </div>
+                        <span>AI agent is typing...</span>
+                    </div>
+                    
+                    <form id="chat-form" class="chat-input-form" onsubmit="event.preventDefault(); return false;" novalidate>
+                        <div class="input-group">
+                            <textarea 
+                                id="message-input" 
+                                placeholder="Type your message here..." 
+                                rows="1"
+                                maxlength="1000"
+                            ></textarea>
+                            <button type="submit" id="send-button" class="send-button" disabled>
+                                <span class="send-icon">➤</span>
+                            </button>
+                            <button type="button" id="clear-chat" class="action-button clear-chat" title="Clear Chat History">
+                                Clear
+                            </button>
+                            <button type="button" id="create-ticket-button" class="action-button" title="Create Support Ticket">
+                                Create Ticket
+                            </button>
+                            <button type="button" id="end-conversation-button" class="action-button end-conversation" title="End Conversation & Save Summary">
+                                End Chat
+                            </button>
+                        </div>
+                    </form>
+                </div>
+            </div>
+            
+            <!-- Ticket Sidebar -->
+            <div class="glassmorphism-container ticket-sidebar" id="ticket-sidebar">
+                <div class="sidebar-header">
+                    <h3>Your Tickets</h3>
+                    <button id="toggle-sidebar" class="toggle-button">↔</button>
+                </div>
+                
+                <div id="user-tickets-loading" class="loading-state" style="display: none;">
+                    <div class="spinner-small"></div>
+                    <p>Loading tickets...</p>
+                </div>
+                
+                <div id="no-tickets" class="no-tickets-state">
+                    <p>No active tickets</p>
+                    <button class="btn btn-primary" onclick="showCreateTicketModal()">Create Ticket</button>
+                </div>
+                
+                <div id="user-tickets-list" class="tickets-list"></div>
+                
+                <div class="sidebar-actions">
+                    <button class="btn btn-outline" onclick="refreshUserTickets()">Refresh</button>
+                    <button class="btn btn-primary" onclick="showCreateTicketModal()">New Ticket</button>
+                </div>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Create Ticket Modal -->
+<div id="create-ticket-modal" class="modal" style="display: none;">
+    <div class="modal-content glassmorphism-container">
+        <div class="modal-header">
+            <h3>Create Support Ticket</h3>
+            <button class="modal-close" onclick="closeCreateTicketModal()">&times;</button>
+        </div>
+        
+        <form id="create-ticket-form" class="modal-body">
+            <div class="form-group">
+                <label for="ticket-subject">Subject *</label>
+                <input type="text" id="ticket-subject" placeholder="Brief description of your issue" required>
+            </div>
+            
+            <div class="form-group">
+                <label for="ticket-category">Category</label>
+                <select id="ticket-category">
+                    <option value="General">General Support</option>
+                    <option value="Technical">Technical Issue</option>
+                    <option value="Product">Product Question</option>
+                    <option value="Billing">Billing</option>
+                    <option value="Shipping">Shipping & Delivery</option>
+                </select>
+            </div>
+            
+            <div class="form-group">
+                <label for="ticket-priority">Priority</label>
+                <select id="ticket-priority">
+                    <option value="low">Low</option>
+                    <option value="medium" selected>Medium</option>
+                    <option value="high">High</option>
+                    <option value="urgent">Urgent</option>
+                </select>
+            </div>
+            
+            <div class="form-group">
+                <label for="ticket-description">Description *</label>
+                <textarea id="ticket-description" rows="4" placeholder="Please describe your issue in detail..." required></textarea>
+            </div>
+            
+            <div class="form-group">
+                <label>
+                    <input type="checkbox" id="include-chat-context" checked>
+                    Include recent chat conversation in ticket
+                </label>
+            </div>
+            
+            <div class="modal-actions">
+                <button type="button" class="btn btn-outline" onclick="closeCreateTicketModal()">Cancel</button>
+                <button type="submit" class="btn btn-primary">Create Ticket</button>
+            </div>
+        </form>
+    </div>
+</div>
+{% endblock %}
+
+{% block extra_styles %}
+<style>
+/* Chat Layout with Sidebar */
+.chat-layout {
+    display: grid;
+    grid-template-columns: 1fr 320px;
+    gap: 2rem;
+    max-width: 1400px;
+    margin: 0 auto;
+}
+
+.chat-main {
+    min-height: 600px;
+}
+
+.ticket-sidebar {
+    background: rgba(255, 255, 255, 0.12);
+    padding: 1.5rem;
+    height: fit-content;
+    max-height: 80vh;
+    overflow-y: auto;
+}
+
+.sidebar-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px solid rgba(255,255,255,0.2);
+}
+
+.sidebar-header h3 {
+    color: white;
+    margin: 0;
+    font-size: 1.2rem;
+}
+
+.toggle-button {
+    background: rgba(255,255,255,0.2);
+    border: none;
+    color: white;
+    padding: 0.25rem 0.5rem;
+    border-radius: 4px;
+    cursor: pointer;
+}
+
+.loading-state {
+    text-align: center;
+    padding: 2rem;
+    color: rgba(255,255,255,0.8);
+}
+
+.spinner-small {
+    border: 2px solid rgba(255,255,255,0.3);
+    border-top: 2px solid white;
+    border-radius: 50%;
+    width: 20px;
+    height: 20px;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 0.5rem;
+}
+
+.no-tickets-state {
+    text-align: center;
+    padding: 2rem 1rem;
+    color: rgba(255,255,255,0.8);
+}
+
+.tickets-list {
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.ticket-item {
+    background: rgba(255,255,255,0.1);
+    border: 1px solid rgba(255,255,255,0.2);
+    border-radius: 8px;
+    padding: 1rem;
+    margin-bottom: 0.5rem;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.ticket-item:hover {
+    background: rgba(255,255,255,0.15);
+    transform: translateY(-1px);
+}
+
+.ticket-item h4 {
+    color: white;
+    font-size: 0.9rem;
+    margin: 0 0 0.5rem 0;
+}
+
+.ticket-item p {
+    color: rgba(255,255,255,0.8);
+    font-size: 0.8rem;
+    margin: 0.25rem 0;
+}
+
+.ticket-status {
+    display: inline-block;
+    padding: 0.2rem 0.5rem;
+    border-radius: 10px;
+    font-size: 0.7rem;
+    font-weight: 500;
+    text-transform: uppercase;
+}
+
+.status-open { background: rgba(52, 152, 219, 0.8); color: white; }
+.status-in_progress { background: rgba(241, 196, 15, 0.8); color: white; }
+.status-resolved { background: rgba(46, 204, 113, 0.8); color: white; }
+
+.sidebar-actions {
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid rgba(255,255,255,0.2);
+    display: flex;
+    gap: 0.5rem;
+}
+
+.sidebar-actions .btn {
+    flex: 1;
+    padding: 0.5rem;
+    font-size: 0.8rem;
+}
+
+/* Enhanced Input Group */
+.input-group {
+    position: relative;
+    display: flex;
+    align-items: flex-end;
+    gap: 0.5rem;
+}
+
+.action-button {
+    background: rgba(255, 255, 255, 0.2);
+    border: 1px solid rgba(255, 255, 255, 0.3);
+    color: white;
+    padding: 0.75rem;
+    border-radius: 10px;
+    cursor: pointer;
+    font-size: 1.1rem;
+    transition: all 0.3s ease;
+    min-width: 44px;
+    height: 44px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.action-button:hover {
+    background: rgba(255, 255, 255, 0.3);
+    transform: translateY(-1px);
+}
+
+/* Modal Styles */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0,0,0,0.8);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 2000;
+}
+
+.modal-content {
+    max-width: 500px;
+    width: 95%;
+    max-height: 80vh;
+    overflow-y: auto;
+    padding: 2rem;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.modal-header h3 {
+    color: white;
+    margin: 0;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    color: white;
+    font-size: 1.5rem;
+    cursor: pointer;
+    opacity: 0.7;
+    transition: opacity 0.3s ease;
+}
+
+.modal-close:hover {
+    opacity: 1;
+}
+
+.form-group {
+    margin-bottom: 1rem;
+}
+
+.form-group label {
+    display: block;
+    color: rgba(255,255,255,0.9);
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.form-group input,
+.form-group select,
+.form-group textarea {
+    width: 100%;
+    padding: 0.75rem;
+    border: 1px solid rgba(255,255,255,0.3);
+    border-radius: 8px;
+    background: rgba(255,255,255,0.1);
+    color: white;
+    font-size: 0.9rem;
+}
+
+.form-group input::placeholder,
+.form-group textarea::placeholder {
+    color: rgba(255,255,255,0.6);
+}
+
+.form-group input[type="checkbox"] {
+    width: auto;
+    margin-right: 0.5rem;
+}
+
+.modal-actions {
+    display: flex;
+    gap: 1rem;
+    justify-content: flex-end;
+    margin-top: 2rem;
+}
+
+.btn {
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: 8px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+}
+
+.btn-outline {
+    background: transparent;
+    color: white;
+    border: 1px solid rgba(255,255,255,0.3);
+}
+
+.btn:hover {
+    transform: translateY(-1px);
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .chat-layout {
+        grid-template-columns: 1fr;
+    }
+    
+    .ticket-sidebar {
+        order: -1;
+        max-height: 300px;
+    }
+    
+    .sidebar-actions {
+        flex-direction: column;
+    }
+    
+    .modal-content {
+        margin: 1rem;
+        padding: 1.5rem;
+    }
+    
+    .modal-actions {
+        flex-direction: column;
+    }
+}
+
+/* Sidebar collapsed state */
+.ticket-sidebar.collapsed {
+    width: 60px;
+    padding: 1rem 0.5rem;
+}
+
+.ticket-sidebar.collapsed .sidebar-header h3,
+.ticket-sidebar.collapsed .tickets-list,
+.ticket-sidebar.collapsed .sidebar-actions,
+.ticket-sidebar.collapsed .no-tickets-state {
+    display: none;
+}
+</style>
+{% endblock %}
+
+{% block extra_scripts %}
+<script src="{{ url_for('static', filename='chat.js') }}?v={{ cache_bust }}"></script>
+<script>
+// Global variables for ticket integration
+let currentConversationId = null;
+let userTickets = [];
+
+document.addEventListener('DOMContentLoaded', function() {
+    // Auto-resize textarea
+    const messageInput = document.getElementById('message-input');
+    messageInput.addEventListener('input', function() {
+        this.style.height = 'auto';
+        this.style.height = Math.min(this.scrollHeight, 120) + 'px';
+        
+        // Enable/disable send button
+        const sendButton = document.getElementById('send-button');
+        sendButton.disabled = this.value.trim().length === 0;
+    });
+    
+    // Load user tickets if logged in
+    loadUserTickets();
+    
+    // Set up create ticket form
+    setupCreateTicketModal();
+});
+
+function loadUserTickets() {
+    const loading = document.getElementById('user-tickets-loading');
+    const noTickets = document.getElementById('no-tickets');
+    const ticketsList = document.getElementById('user-tickets-list');
+    
+    loading.style.display = 'block';
+    noTickets.style.display = 'none';
+    ticketsList.innerHTML = '';
+    
+    fetch('/api/chat/user-tickets')
+        .then(response => response.json())
+        .then(data => {
+            loading.style.display = 'none';
+            
+            if (data.success && data.tickets.length > 0) {
+                userTickets = data.tickets;
+                displayUserTickets(data.tickets);
+                
+                // Show ticket info in welcome message
+                const welcomeTicketsInfo = document.getElementById('welcome-tickets-info');
+                if (welcomeTicketsInfo) {
+                    welcomeTicketsInfo.style.display = 'block';
+                }
+            } else {
+                noTickets.style.display = 'block';
+            }
+        })
+        .catch(error => {
+            loading.style.display = 'none';
+            noTickets.style.display = 'block';
+            console.error('Error loading user tickets:', error);
+        });
+}
+
+function displayUserTickets(tickets) {
+    const ticketsList = document.getElementById('user-tickets-list');
+    ticketsList.innerHTML = '';
+    
+    tickets.forEach(ticket => {
+        const ticketElement = createTicketElement(ticket);
+        ticketsList.appendChild(ticketElement);
+    });
+}
+
+function createTicketElement(ticket) {
+    const div = document.createElement('div');
+    div.className = 'ticket-item';
+    div.onclick = () => viewTicketInChat(ticket);
+    
+    const createdDate = new Date(ticket.created_at).toLocaleDateString();
+    
+    div.innerHTML = `
+        <h4>#${ticket.number}: ${ticket.subject}</h4>
+        <p><span class="ticket-status status-${ticket.status}">${ticket.status.replace('_', ' ')}</span></p>
+        <p><strong>Category:</strong> ${ticket.category}</p>
+        <p><strong>Priority:</strong> ${ticket.priority}</p>
+        <p><strong>Created:</strong> ${createdDate}</p>
+        ${ticket.assigned_agent ? `<p><strong>Agent:</strong> ${ticket.assigned_agent}</p>` : ''}
+    `;
+    
+    return div;
+}
+
+function viewTicketInChat(ticket) {
+    // Add ticket info to chat
+    const ticketMessage = `I'd like to discuss my ticket #${ticket.number}: "${ticket.subject}". Status: ${ticket.status}, Priority: ${ticket.priority}`;
+    
+    const messageInput = document.getElementById('message-input');
+    messageInput.value = ticketMessage;
+    messageInput.focus();
+    
+    // Trigger input event to enable send button
+    messageInput.dispatchEvent(new Event('input'));
+}
+
+function refreshUserTickets() {
+    loadUserTickets();
+}
+
+function showCreateTicketModal() {
+    document.getElementById('create-ticket-modal').style.display = 'flex';
+}
+
+function closeCreateTicketModal() {
+    document.getElementById('create-ticket-modal').style.display = 'none';
+    document.getElementById('create-ticket-form').reset();
+}
+
+function setupCreateTicketModal() {
+    const form = document.getElementById('create-ticket-form');
+    
+    form.addEventListener('submit', function(e) {
+        e.preventDefault();
+        
+        const subject = document.getElementById('ticket-subject').value.trim();
+        const description = document.getElementById('ticket-description').value.trim();
+        const category = document.getElementById('ticket-category').value;
+        const priority = document.getElementById('ticket-priority').value;
+        const includeChat = document.getElementById('include-chat-context').checked;
+        
+        if (!subject || !description) {
+            alert('Please fill in all required fields');
+            return;
+        }
+        
+        const ticketData = {
+            subject,
+            description,
+            category,
+            priority,
+            conversation_id: includeChat ? currentConversationId : null
+        };
+        
+        const csrfToken = document.querySelector('meta[name="csrf-token"]').getAttribute('content');
+        
+        fetch('/api/chat/create-ticket', {
+            method: 'POST',
+            headers: { 
+                'Content-Type': 'application/json',
+                'X-CSRFToken': csrfToken
+            },
+            body: JSON.stringify(ticketData)
+        })
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                alert(data.message);
+                closeCreateTicketModal();
+                loadUserTickets(); // Refresh ticket list
+                
+                // Add success message to chat
+                addMessageToChat('system', `✅ ${data.message}`);
+            } else {
+                alert('Failed to create ticket: ' + data.error);
+            }
+        })
+        .catch(error => {
+            console.error('Error creating ticket:', error);
+            alert('Error creating ticket. Please try again.');
+        });
+    });
+}
+
+// Update conversation ID when chat starts
+function updateConversationId(conversationId) {
+    currentConversationId = conversationId;
+}
+
+// Add message to chat (utility function)
+function addMessageToChat(role, content) {
+    const chatMessages = document.getElementById('chat-messages');
+    const messageDiv = document.createElement('div');
+    messageDiv.className = `message ${role}-message`;
+    
+    if (role === 'system') {
+        messageDiv.innerHTML = `
+            <div class="system-message">
+                <div class="message-content">
+                    ${content}
+                </div>
+            </div>
+        `;
+    }
+    
+    chatMessages.appendChild(messageDiv);
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+}
+
+// Toggle sidebar
+document.getElementById('toggle-sidebar').addEventListener('click', function() {
+    const sidebar = document.getElementById('ticket-sidebar');
+    sidebar.classList.toggle('collapsed');
+});
+
+// Close modal on outside click
+document.getElementById('create-ticket-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeCreateTicketModal();
+    }
+});
+</script>
+{% endblock %}

templates/homepage.html

@@ -0,0 +1,258 @@
+{% extends "base.html" %}
+
+{% block title %}Too Many Cables - Premium Cables & Tech Accessories{% endblock %}
+
+{% block content %}
+<!-- Hero Section -->
+<section class="hero">
+    <div class="hero-container">
+        <div class="hero-content">
+            <h1 class="hero-title">Premium Cables for Every Connection</h1>
+            <p class="hero-subtitle">From USB-C to HDMI, we've got the high-quality cables and accessories you need. Fast shipping, lifetime warranty, and 24/7 support.</p>
+            <div class="hero-actions">
+                <a href="{{ url_for('products') }}" class="btn btn-primary btn-large">Shop Now</a>
+                <a href="#" class="btn btn-outline btn-large chat-trigger-btn">Get Help 💬</a>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Features Section -->
+<section class="features">
+    <div class="container">
+        <h2 class="section-title">Why Choose Too Many Cables?</h2>
+        <div class="features-grid">
+            <div class="feature-card">
+                <div class="feature-icon">⚡</div>
+                <h3>Fast & Reliable</h3>
+                <p>High-speed data transfer and charging with premium materials and gold-plated connectors.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">🛡️</div>
+                <h3>Lifetime Warranty</h3>
+                <p>We stand behind our products with a comprehensive lifetime warranty on all cables.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">🚚</div>
+                <h3>Fast Shipping</h3>
+                <p>Free shipping on orders over $25. Most orders ship same day and arrive within 2-3 business days.</p>
+            </div>
+            <div class="feature-card">
+                <div class="feature-icon">💬</div>
+                <h3>24/7 Support</h3>
+                <p>Get instant help with our AI-powered chat support, available 24/7 for all your questions.</p>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Popular Products Section -->
+<section class="popular-products">
+    <div class="container">
+        <h2 class="section-title">Popular Products</h2>
+        <div class="products-grid">
+            <div class="product-card">
+                <div class="product-image">🔌</div>
+                <h3>USB-C to USB-C Cable</h3>
+                <p class="product-description">60W fast charging, 10Gbps data transfer, 6ft length</p>
+                <div class="product-price">$19.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (1,247 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-cable')">More Details</button>
+            </div>
+            <div class="product-card">
+                <div class="product-image">📺</div>
+                <h3>4K HDMI Cable</h3>
+                <p class="product-description">8K@60Hz, 4K@120Hz, HDR10+, 10ft premium cable</p>
+                <div class="product-price">$24.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (856 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('4k-hdmi-cable')">More Details</button>
+            </div>
+            <div class="product-card">
+                <div class="product-image">🔋</div>
+                <h3>Multi-Port Charging Hub</h3>
+                <p class="product-description">6 ports, 100W total, USB-C PD, smart charging</p>
+                <div class="product-price">$49.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (692 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('charging-hub')">More Details</button>
+            </div>
+            <div class="product-card">
+                <div class="product-image">🔗</div>
+                <h3>USB-C Hub Adapter</h3>
+                <p class="product-description">7-in-1 hub with HDMI, USB-A, SD card, Ethernet</p>
+                <div class="product-price">$34.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (1,104 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-hub')">More Details</button>
+            </div>
+        </div>
+        <div class="section-cta">
+            <a href="{{ url_for('products') }}" class="btn btn-outline">View All Products</a>
+        </div>
+    </div>
+</section>
+
+<!-- Customer Support CTA -->
+<section class="support-cta">
+    <div class="container">
+        <div class="cta-content">
+            <h2>Need Help Choosing the Right Cable?</h2>
+            <p>Our AI-powered customer service is available 24/7 to help you find the perfect solution for your needs.</p>
+            <div class="cta-actions">
+                <a href="#" class="btn btn-primary btn-large chat-trigger-btn">Start Live Chat 💬</a>
+                <a href="{{ url_for('products') }}" class="btn btn-outline btn-large">Browse Products</a>
+            </div>
+        </div>
+        <div class="cta-features">
+            <div class="cta-feature">
+                <span class="feature-icon">🤖</span>
+                <span>AI-Powered Support</span>
+            </div>
+            <div class="cta-feature">
+                <span class="feature-icon">⚡</span>
+                <span>Instant Responses</span>
+            </div>
+            <div class="cta-feature">
+                <span class="feature-icon">🎯</span>
+                <span>Personalized Recommendations</span>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Customer Reviews Section -->
+<section class="reviews">
+    <div class="container">
+        <h2 class="section-title">What Our Customers Say</h2>
+        <div class="reviews-grid">
+            <div class="review-card">
+                <div class="review-rating">⭐⭐⭐⭐⭐</div>
+                <p class="review-text">"Amazing quality cables! My USB-C cable has been working perfectly for over a year now. The customer service chat helped me choose the right one."</p>
+                <div class="review-author">- Sarah M., Software Developer</div>
+            </div>
+            <div class="review-card">
+                <div class="review-rating">⭐⭐⭐⭐⭐</div>
+                <p class="review-text">"Fast shipping and great prices. The HDMI cable works flawlessly with my 4K monitor. Will definitely order again!"</p>
+                <div class="review-author">- Mike R., Graphic Designer</div>
+            </div>
+            <div class="review-card">
+                <div class="review-rating">⭐⭐⭐⭐⭐</div>
+                <p class="review-text">"The AI chat support is incredible! Got help immediately at 2AM when I needed to find a specific adapter. Highly recommend!"</p>
+                <div class="review-author">- Jennifer L., Marketing Manager</div>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Product Details Modal -->
+<div id="product-details-modal" class="modal" style="display: none;">
+    <div class="modal-content">
+        <div class="modal-header">
+            <h2 id="product-modal-title">Product Details</h2>
+            <span class="close-modal" onclick="closeProductModal()">&times;</span>
+        </div>
+        <div class="modal-body">
+            <div id="product-modal-content" class="product-details-content">
+                <div class="loading">Loading product specifications...</div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+.product-details-content {
+    max-height: 70vh;
+    overflow-y: auto;
+    line-height: 1.6;
+}
+
+.product-details-content h3 {
+    color: #2c3e50;
+    margin-top: 20px;
+    margin-bottom: 10px;
+}
+
+.product-details-content ul {
+    margin: 10px 0;
+    padding-left: 20px;
+}
+
+.product-details-content li {
+    margin: 5px 0;
+}
+
+.product-details-content strong {
+    color: #2980b9;
+}
+
+.loading {
+    text-align: center;
+    padding: 40px;
+    color: #7f8c8d;
+}
+</style>
+
+<script>
+async function showProductDetails(productName) {
+    const modal = document.getElementById('product-details-modal');
+    const title = document.getElementById('product-modal-title');
+    const content = document.getElementById('product-modal-content');
+    
+    // Show modal with loading state
+    modal.style.display = 'flex';
+    title.textContent = 'Loading Product Details...';
+    content.innerHTML = '<div class="loading">Loading product specifications...</div>';
+    
+    try {
+        const response = await fetch(`/api/product/${productName}`);
+        const data = await response.json();
+        
+        if (data.success) {
+            // Set product title
+            const productTitles = {
+                'usb-c-cable': 'USB-C to USB-C Cable',
+                '4k-hdmi-cable': '4K HDMI Cable',
+                'charging-hub': 'Multi-Port Charging Hub',
+                'usb-c-hub': 'USB-C Hub Adapter'
+            };
+            
+            title.textContent = productTitles[productName] || 'Product Details';
+            
+            // Format and display specifications
+            const specs = data.specifications;
+            const formattedSpecs = formatProductSpecs(specs);
+            content.innerHTML = formattedSpecs;
+        } else {
+            content.innerHTML = '<div class="error">Failed to load product specifications. Please try again.</div>';
+        }
+    } catch (error) {
+        console.error('Error fetching product details:', error);
+        content.innerHTML = '<div class="error">Failed to load product specifications. Please try again.</div>';
+    }
+}
+
+function formatProductSpecs(specs) {
+    // Convert the raw specifications text into formatted HTML
+    let formatted = specs
+        .replace(/\n\n/g, '</p><p>')
+        .replace(/\n/g, '<br>')
+        .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+        .replace(/^# (.*?)$/gm, '<h3>$1</h3>')
+        .replace(/^## (.*?)$/gm, '<h4>$1</h4>')
+        .replace(/^### (.*?)$/gm, '<h5>$1</h5>');
+    
+    return `<div class="specs-content"><p>${formatted}</p></div>`;
+}
+
+function closeProductModal() {
+    const modal = document.getElementById('product-details-modal');
+    modal.style.display = 'none';
+}
+
+// Close modal when clicking outside
+document.addEventListener('click', function(e) {
+    const modal = document.getElementById('product-details-modal');
+    if (e.target === modal) {
+        closeProductModal();
+    }
+});
+</script>
+{% endblock %}

templates/index.html

@@ -0,0 +1,86 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Customer Service - Talk to Agent</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>Customer Service Chat</h1>
+            <div class="status-indicator">
+                <div id="status-dot" class="status-dot"></div>
+                <span id="status-text">Checking connection...</span>
+            </div>
+        </header>
+
+        <div class="main-content">
+            <!-- Agent Info Panel -->
+            <div class="agent-panel">
+                <h3>Customer Service Agent</h3>
+                <div class="agent-info">
+                    <p><strong>AI Agent:</strong> <span id="configured-model">{{ configured_model or 'Loading...' }}</span></p>
+                    <p><strong>Status:</strong> <span id="agent-status">Connecting...</span></p>
+                    <p class="agent-description">Your AI-powered customer service assistant is ready to help with product questions, technical support, and general inquiries.</p>
+                </div>
+            </div>
+
+            <!-- Chat Interface -->
+            <div class="chat-container">
+                <div class="chat-header">
+                    <h3>Chat</h3>
+                    <button id="clear-chat" class="clear-btn" title="Clear conversation">Clear</button>
+                </div>
+                
+                <div id="chat-messages" class="chat-messages">
+                    <div class="welcome-message">
+                        <h4>Welcome to Customer Service!</h4>
+                        <p>Hello! I'm your AI customer service assistant. How can I help you today?</p>
+                        <ul>
+                            <li>Ask questions about products and services</li>
+                            <li>Get technical support and troubleshooting help</li>
+                            <li>Your conversation history will be preserved</li>
+                            <li>I can escalate complex issues to human agents</li>
+                        </ul>
+                    </div>
+                </div>
+
+                <div class="chat-input-container">
+                    <div class="input-group">
+                        <textarea 
+                            id="message-input" 
+                            placeholder="Type your message here..." 
+                            rows="3"
+                            disabled
+                        ></textarea>
+                        <button id="send-btn" disabled>
+                            <span class="send-icon">➤</span>
+                            Send
+                        </button>
+                        <button type="button" id="end-conversation-button" class="action-button end-conversation" title="End Conversation & Save Summary">
+                            End Chat
+                        </button>
+                    </div>
+                    <div class="input-info">
+                        <span id="char-count">0 characters</span>
+                        <span class="divider">•</span>
+                        <span>Press Ctrl+Enter to send</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Loading overlay -->
+        <div id="loading-overlay" class="loading-overlay hidden">
+            <div class="loading-spinner">
+                <div class="spinner"></div>
+                <p>Thinking...</p>
+            </div>
+        </div>
+    </div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>

templates/products.html

@@ -0,0 +1,435 @@
+{% extends "base.html" %}
+
+{% block title %}Products - Too Many Cables{% endblock %}
+
+{% block content %}
+<!-- Page Header -->
+<section class="page-header">
+    <div class="header-container">
+        <div class="header-card">
+            <h1>Our Products</h1>
+            <p>Premium cables and accessories for all your connectivity needs</p>
+        </div>
+    </div>
+</section>
+
+<!-- Products Grid -->
+<section class="products-section">
+    <div class="container">
+        <div class="products-grid" id="products-grid">
+            <!-- USB-C Cables -->
+            <div class="product-card" data-category="usb-c" data-price="24.99">
+                <div class="product-image">🔌</div>
+                <h3>USB-C Premium Cable (100W)</h3>
+                <p class="product-description">100W fast charging, 10Gbps data transfer, 6ft length with braided nylon protection</p>
+                <div class="product-specs">
+                    <span class="spec">100W Power</span>
+                    <span class="spec">10Gbps Speed</span>
+                    <span class="spec">6ft Length</span>
+                </div>
+                <div class="product-price">$24.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (1,247 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-cable')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="usb-c" data-price="19.99">
+                <div class="product-image">🔌</div>
+                <h3>USB-C Standard Cable (60W)</h3>
+                <p class="product-description">60W fast charging, 5Gbps data transfer, 3ft compact design with PVC jacket</p>
+                <div class="product-specs">
+                    <span class="spec">60W Power</span>
+                    <span class="spec">5Gbps Speed</span>
+                    <span class="spec">3ft Length</span>
+                </div>
+                <div class="product-price">$19.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (892 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-standard')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="usb-c" data-price="16.99">
+                <div class="product-image">🔌</div>
+                <h3>USB-A to USB-C Cable</h3>
+                <p class="product-description">Universal compatibility, 18W fast charging, 6ft braided design</p>
+                <div class="product-specs">
+                    <span class="spec">18W Charging</span>
+                    <span class="spec">5Gbps Speed</span>
+                    <span class="spec">6ft Length</span>
+                </div>
+                <div class="product-price">$16.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (734 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-to-usb-a')">More Details</button>
+            </div>
+
+            <!-- HDMI Cables -->
+            <div class="product-card" data-category="hdmi" data-price="34.99">
+                <div class="product-image">📺</div>
+                <h3>8K HDMI Cable (Ultra High Speed)</h3>
+                <p class="product-description">8K@60Hz, 4K@120Hz, HDR10+, Dolby Vision, premium 10ft cable with gold-plated connectors</p>
+                <div class="product-specs">
+                    <span class="spec">8K@60Hz</span>
+                    <span class="spec">48 Gbps</span>
+                    <span class="spec">10ft Length</span>
+                </div>
+                <div class="product-price">$34.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (856 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('4k-hdmi-cable')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="hdmi" data-price="24.99">
+                <div class="product-image">📺</div>
+                <h3>4K HDMI Cable (High Speed)</h3>
+                <p class="product-description">4K@60Hz, 1440p@144Hz, HDR10+, ARC audio, 6ft cable with durable PVC jacket</p>
+                <div class="product-specs">
+                    <span class="spec">4K@60Hz</span>
+                    <span class="spec">18 Gbps</span>
+                    <span class="spec">6ft Length</span>
+                </div>
+                <div class="product-price">$24.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (634 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('hdmi-standard')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="hdmi" data-price="18.99">
+                <div class="product-image">📺</div>
+                <h3>HDMI to USB-C Cable</h3>
+                <p class="product-description">Direct connection from laptop to monitor, 4K@60Hz, 6ft cable</p>
+                <div class="product-specs">
+                    <span class="spec">4K@60Hz</span>
+                    <span class="spec">Plug & Play</span>
+                    <span class="spec">6ft Length</span>
+                </div>
+                <div class="product-price">$18.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (445 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('hdmi-usb-c-cable')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="hdmi" data-price="14.99">
+                <div class="product-image">📺</div>
+                <h3>Mini HDMI to HDMI Cable</h3>
+                <p class="product-description">Connect tablets and cameras to displays, 4K@30Hz, 3ft flexible design</p>
+                <div class="product-specs">
+                    <span class="spec">4K@30Hz</span>
+                    <span class="spec">Mini HDMI</span>
+                    <span class="spec">3ft Length</span>
+                </div>
+                <div class="product-price">$14.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (312 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('mini-hdmi-cable')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="hdmi" data-price="14.99">
+                <div class="product-image">📺</div>
+                <h3>Micro HDMI to HDMI Cable</h3>
+                <p class="product-description">Connect action cameras and devices to displays, 4K@30Hz, 3ft ultra-flexible</p>
+                <div class="product-specs">
+                    <span class="spec">4K@30Hz</span>
+                    <span class="spec">Micro HDMI</span>
+                    <span class="spec">3ft Length</span>
+                </div>
+                <div class="product-price">$14.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (284 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('micro-hdmi-cable')">More Details</button>
+            </div>
+
+            <!-- Lightning Cables -->
+            <div class="product-card" data-category="lightning" data-price="19.99">
+                <div class="product-image">⚡</div>
+                <h3>Lightning to USB-A Cable (MFi)</h3>
+                <p class="product-description">Apple MFi certified, 2.4A fast charging, 6ft durable cable for iPhone and iPad</p>
+                <div class="product-specs">
+                    <span class="spec">MFi Certified</span>
+                    <span class="spec">2.4A Charging</span>
+                    <span class="spec">6ft Length</span>
+                </div>
+                <div class="product-price">$19.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (1,542 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('lightning-cable')">More Details</button>
+            </div>
+
+            <!-- Charging Cables -->
+            <div class="product-card" data-category="charging" data-price="49.99">
+                <div class="product-image">🔋</div>
+                <h3>Multi-Port Charging Hub</h3>
+                <p class="product-description">6 ports, 100W total power, USB-C PD, smart charging technology</p>
+                <div class="product-specs">
+                    <span class="spec">100W Total</span>
+                    <span class="spec">6 Ports</span>
+                    <span class="spec">Smart Charging</span>
+                </div>
+                <div class="product-price">$49.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (692 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('charging-hub')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="charging" data-price="29.99">
+                <div class="product-image">⚡</div>
+                <h3>Wireless Charging Pad</h3>
+                <p class="product-description">15W fast wireless charging, Qi-certified, LED indicator, non-slip design</p>
+                <div class="product-specs">
+                    <span class="spec">15W Fast</span>
+                    <span class="spec">Qi Certified</span>
+                    <span class="spec">LED Status</span>
+                </div>
+                <div class="product-price">$29.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (445 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('wireless-charging')">More Details</button>
+            </div>
+
+            <!-- Adapters & Hubs -->
+            <div class="product-card" data-category="adapters" data-price="34.99">
+                <div class="product-image">🔗</div>
+                <h3>USB-C Hub Adapter</h3>
+                <p class="product-description">7-in-1 hub with HDMI, USB-A, SD card, Ethernet, compact aluminum design</p>
+                <div class="product-specs">
+                    <span class="spec">7-in-1 Hub</span>
+                    <span class="spec">4K HDMI</span>
+                    <span class="spec">Gigabit Ethernet</span>
+                </div>
+                <div class="product-price">$34.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (1,104 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-hub')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="adapters" data-price="12.99">
+                <div class="product-image">🔄</div>
+                <h3>USB-C to HDMI Adapter</h3>
+                <p class="product-description">4K@30Hz video output, plug and play, ultra-compact design</p>
+                <div class="product-specs">
+                    <span class="spec">4K@30Hz</span>
+                    <span class="spec">Plug & Play</span>
+                    <span class="spec">Compact</span>
+                </div>
+                <div class="product-price">$12.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (789 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-hdmi-adapter')">More Details</button>
+            </div>
+
+            <!-- Audio Cables -->
+            <div class="product-card" data-category="audio" data-price="16.99">
+                <div class="product-image">🎧</div>
+                <h3>3.5mm Audio Cable</h3>
+                <p class="product-description">Premium gold-plated connectors, tangle-free design, 6ft length</p>
+                <div class="product-specs">
+                    <span class="spec">Gold Plated</span>
+                    <span class="spec">Tangle Free</span>
+                    <span class="spec">6ft Length</span>
+                </div>
+                <div class="product-price">$16.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (567 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('audio-cable')">More Details</button>
+            </div>
+
+            <div class="product-card" data-category="audio" data-price="22.99">
+                <div class="product-image">🎵</div>
+                <h3>USB-C to 3.5mm Adapter</h3>
+                <p class="product-description">High-resolution audio, 32-bit DAC, compact aluminum housing</p>
+                <div class="product-specs">
+                    <span class="spec">Hi-Res Audio</span>
+                    <span class="spec">32-bit DAC</span>
+                    <span class="spec">Aluminum</span>
+                </div>
+                <div class="product-price">$22.99</div>
+                <div class="product-rating">⭐⭐⭐⭐⭐ (423 reviews)</div>
+                <button class="btn btn-primary" onclick="showProductDetails('usb-c-audio-adapter')">More Details</button>
+            </div>
+        </div>
+    </div>
+</section>
+
+<!-- Product Support CTA -->
+<section class="product-support-cta">
+    <div class="container">
+                <div class="cta-content">
+            <h2>Need Help Choosing?</h2>
+            <p>Our AI assistant can help you find the perfect cable for your specific needs.</p>
+            <a href="#" class="btn btn-primary btn-large chat-trigger-btn">Get Product Recommendations 💬</a>
+        </div>
+    </div>
+</section>
+
+<!-- Product Details Modal -->
+<div id="product-details-modal" class="modal" style="display: none;">
+    <div class="modal-content">
+        <div class="modal-header">
+            <h2 id="product-modal-title">Product Details</h2>
+            <span class="close-modal" onclick="closeProductModal()">&times;</span>
+        </div>
+        <div class="modal-body">
+            <div id="product-modal-content" class="product-details-content">
+                <div class="loading">Loading product specifications...</div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+.product-details-content {
+    max-height: 70vh;
+    overflow-y: auto;
+    line-height: 1.6;
+}
+
+.product-details-content h3 {
+    color: #2c3e50;
+    margin-top: 20px;
+    margin-bottom: 10px;
+}
+
+.product-details-content h4 {
+    color: #34495e;
+    margin-top: 15px;
+    margin-bottom: 8px;
+}
+
+.product-details-content h5 {
+    color: #5d6d7e;
+    margin-top: 12px;
+    margin-bottom: 6px;
+}
+
+.product-details-content ul {
+    margin: 10px 0;
+    padding-left: 20px;
+}
+
+.product-details-content li {
+    margin: 5px 0;
+}
+
+.product-details-content strong {
+    color: #2980b9;
+}
+
+.loading {
+    text-align: center;
+    padding: 40px;
+    color: #7f8c8d;
+}
+
+.error {
+    text-align: center;
+    padding: 40px;
+    color: #e74c3c;
+}
+
+.specs-content {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+</style>
+{% endblock %}
+
+{% block extra_scripts %}
+<script>
+    // Product filtering functionality
+    document.addEventListener('DOMContentLoaded', function() {
+        const categoryFilter = document.getElementById('category-filter');
+        const priceFilter = document.getElementById('price-filter');
+        const productsGrid = document.getElementById('products-grid');
+        const products = Array.from(productsGrid.querySelectorAll('.product-card'));
+
+        function filterProducts() {
+            const selectedCategory = categoryFilter.value;
+            const selectedPriceRange = priceFilter.value;
+            
+            products.forEach(product => {
+                const category = product.dataset.category;
+                const price = parseFloat(product.dataset.price);
+                
+                let showProduct = true;
+                
+                // Category filter
+                if (selectedCategory && category !== selectedCategory) {
+                    showProduct = false;
+                }
+                
+                // Price filter
+                if (selectedPriceRange) {
+                    const [min, max] = selectedPriceRange.split('-').map(p => p === '+' ? Infinity : parseFloat(p));
+                    if (selectedPriceRange.includes('+')) {
+                        if (price < min) showProduct = false;
+                    } else {
+                        if (price < min || price > max) showProduct = false;
+                    }
+                }
+                
+                product.style.display = showProduct ? 'block' : 'none';
+            });
+        }
+
+        // Event listeners
+        categoryFilter.addEventListener('change', filterProducts);
+        priceFilter.addEventListener('change', filterProducts);
+    });
+
+    // Product details functionality
+    async function showProductDetails(productName) {
+        const modal = document.getElementById('product-details-modal');
+        const title = document.getElementById('product-modal-title');
+        const content = document.getElementById('product-modal-content');
+        
+        // Show modal with loading state
+        modal.style.display = 'flex';
+        title.textContent = 'Loading Product Details...';
+        content.innerHTML = '<div class="loading">Loading product specifications...</div>';
+        
+        try {
+            const response = await fetch(`/api/product/${productName}`);
+            const data = await response.json();
+            
+            if (data.success) {
+                // Set product title
+                const productTitles = {
+                    'usb-c-cable': 'USB-C to USB-C Cable',
+                    'usb-c-to-usb-a': 'USB-C to USB-A Cable',
+                    '4k-hdmi-cable': '4K HDMI Cable',
+                    'hdmi-usb-c-cable': 'HDMI to USB-C Cable',
+                    'charging-hub': 'Multi-Port Charging Hub',
+                    'wireless-charging': 'Wireless Charging Pad',
+                    'usb-c-hub': 'USB-C Hub Adapter',
+                    'usb-c-hdmi-adapter': 'USB-C to HDMI Adapter',
+                    'audio-cable': '3.5mm Audio Cable',
+                    'usb-c-audio-adapter': 'USB-C to 3.5mm Adapter'
+                };
+                
+                title.textContent = productTitles[productName] || 'Product Details';
+                
+                // Format and display specifications
+                const specs = data.specifications;
+                const formattedSpecs = formatProductSpecs(specs);
+                content.innerHTML = formattedSpecs;
+            } else {
+                content.innerHTML = '<div class="error">Failed to load product specifications. Please try again.</div>';
+            }
+        } catch (error) {
+            console.error('Error fetching product details:', error);
+            content.innerHTML = '<div class="error">Failed to load product specifications. Please try again.</div>';
+        }
+    }
+
+    function formatProductSpecs(specs) {
+        // Convert the raw specifications text into formatted HTML
+        let formatted = specs
+            .replace(/\n\n/g, '</p><p>')
+            .replace(/\n/g, '<br>')
+            .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+            .replace(/^# (.*?)$/gm, '<h3>$1</h3>')
+            .replace(/^## (.*?)$/gm, '<h4>$1</h4>')
+            .replace(/^### (.*?)$/gm, '<h5>$1</h5>');
+        
+        return `<div class="specs-content"><p>${formatted}</p></div>`;
+    }
+
+    function closeProductModal() {
+        const modal = document.getElementById('product-details-modal');
+        modal.style.display = 'none';
+    }
+
+    // Close modal when clicking outside
+    document.addEventListener('click', function(e) {
+        const modal = document.getElementById('product-details-modal');
+        if (e.target === modal) {
+            closeProductModal();
+        }
+    });
+</script>
+{% endblock %}

templates/tickets.html

@@ -0,0 +1,940 @@
+{% extends "base.html" %}
+
+{% block title %}My Support Tickets - Too Many Cables{% endblock %}
+
+{% block description %}Manage your support tickets and track the status of your requests with Too Many Cables customer service.{% endblock %}
+
+{% block content %}
+<div class="tickets-container">
+    <div class="page-header">
+        <h1 class="page-title">My Support Tickets</h1>
+        <p class="page-subtitle">Track and manage your support requests</p>
+    </div>
+
+    <!-- User must be logged in to view tickets -->
+    <div id="auth-required" class="auth-message" style="display: none;">
+        <div class="glass-card">
+            <h3>Login Required</h3>
+            <p>Please log in to view and manage your support tickets.</p>
+            <button class="btn btn-primary" onclick="showLoginModal()">Login</button>
+        </div>
+    </div>
+
+    <!-- Main tickets interface -->
+    <div id="tickets-main" style="display: none;">
+        <!-- Create New Ticket Section -->
+        <div class="glass-card ticket-creation">
+            <h3>Create New Ticket</h3>
+            <form id="create-ticket-form">
+                <div class="form-group">
+                    <label for="ticket-subject">Subject</label>
+                    <input type="text" id="ticket-subject" name="subject" required 
+                           placeholder="Brief description of your issue">
+                </div>
+                
+                <div class="form-group">
+                    <label for="ticket-description">Description</label>
+                    <textarea id="ticket-description" name="description" required 
+                              placeholder="Please provide detailed information about your issue"
+                              rows="4"></textarea>
+                </div>
+                
+                <div class="form-row">
+                    <div class="form-group">
+                        <label for="ticket-priority">Priority</label>
+                        <select id="ticket-priority" name="priority">
+                            <option value="low">Low</option>
+                            <option value="medium" selected>Medium</option>
+                            <option value="high">High</option>
+                            <option value="urgent">Urgent</option>
+                        </select>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="ticket-category">Category</label>
+                        <select id="ticket-category" name="category">
+                            <option value="">Auto-detect</option>
+                        </select>
+                    </div>
+                </div>
+                
+                <button type="submit" class="btn btn-primary">Create Ticket</button>
+            </form>
+        </div>
+
+        <!-- Tickets List -->
+        <div class="glass-card tickets-list">
+            <div class="tickets-header">
+                <h3>Your Tickets</h3>
+                <div class="tickets-filters">
+                    <select id="status-filter">
+                        <option value="">All Status</option>
+                        <option value="open">Open</option>
+                        <option value="in_progress">In Progress</option>
+                        <option value="resolved">Resolved</option>
+                        <option value="closed">Closed</option>
+                    </select>
+                </div>
+            </div>
+            
+            <div id="tickets-loading" class="loading-state">
+                <div class="spinner"></div>
+                <p>Loading your tickets...</p>
+            </div>
+            
+            <div id="tickets-empty" class="empty-state" style="display: none;">
+                <h4>No tickets yet</h4>
+                <p>When you create support tickets, they'll appear here.</p>
+            </div>
+            
+            <div id="tickets-container"></div>
+        </div>
+    </div>
+</div>
+
+<!-- Ticket Detail Modal -->
+<div id="ticket-modal" class="modal" style="display: none;">
+    <div class="modal-content glass-card">
+        <div class="modal-header">
+            <h3 id="ticket-modal-title">Ticket Details</h3>
+            <button class="modal-close" onclick="closeTicketModal()">&times;</button>
+        </div>
+        
+        <div class="modal-body">
+            <div id="ticket-details"></div>
+            
+            <!-- SLA and Escalation Status -->
+            <div id="sla-status" class="sla-section" style="display: none;"></div>
+            
+            <!-- Escalation Actions -->
+            <div id="escalation-actions" class="escalation-section" style="display: none;">
+                <h4>Escalation</h4>
+                <button class="btn btn-warning" onclick="escalateTicket()">Request Escalation</button>
+                    <p style="font-size: 0.9rem; color: rgba(0,0,0,0.7); margin-top: 0.5rem;">
+                    Request priority escalation if your issue needs immediate attention.
+                </p>
+            </div>
+            
+            <!-- Add Update Form -->
+            <div class="ticket-update-form">
+                <h4>Add Update</h4>
+                <form id="update-ticket-form">
+                    <input type="hidden" id="update-ticket-id">
+                    <div class="form-group">
+                        <textarea id="update-message" placeholder="Add a comment or update..." 
+                                  rows="3" required></textarea>
+                    </div>
+                    <button type="submit" class="btn btn-primary">Add Update</button>
+                </form>
+            </div>
+        </div>
+    </div>
+</div>
+
+<style>
+.tickets-container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 2rem;
+}
+
+.page-header {
+    text-align: center;
+    margin-bottom: 3rem;
+}
+
+.page-title {
+    font-size: 2.5rem;
+    font-weight: 700;
+    color: white;
+    text-shadow: 0 2px 10px rgba(0,0,0,0.3);
+    margin-bottom: 0.5rem;
+}
+
+.page-subtitle {
+    font-size: 1.1rem;
+    color: rgba(255,255,255,0.9);
+    font-weight: 300;
+}
+
+.glass-card {
+    background: rgba(255, 255, 255, 0.15);
+    backdrop-filter: blur(25px);
+    -webkit-backdrop-filter: blur(25px);
+    border-radius: 20px;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    padding: 2rem;
+    margin-bottom: 2rem;
+    box-shadow: 0 8px 32px rgba(31, 38, 135, 0.37);
+}
+
+.ticket-creation h3,
+.tickets-list h3 {
+    color: white;
+    margin-bottom: 1.5rem;
+    font-weight: 600;
+}
+
+.form-group {
+    margin-bottom: 1.5rem;
+}
+
+.form-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1rem;
+}
+
+.form-group label {
+    display: block;
+    color: rgba(255,255,255,0.9);
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.form-group input,
+.form-group textarea,
+.form-group select {
+    width: 100%;
+    padding: 0.75rem 1rem;
+    border: 1px solid rgba(255,255,255,0.3);
+    border-radius: 10px;
+    background: rgba(255,255,255,0.1);
+    color: white;
+    font-size: 1rem;
+    transition: all 0.3s ease;
+}
+
+.form-group input:focus,
+.form-group textarea:focus,
+.form-group select:focus {
+    outline: none;
+    border-color: rgba(255,255,255,0.6);
+    background: rgba(255,255,255,0.2);
+    box-shadow: 0 0 0 3px rgba(255,255,255,0.1);
+}
+
+.form-group input::placeholder,
+.form-group textarea::placeholder {
+    color: rgba(255,255,255,0.6);
+}
+
+.btn {
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: 10px;
+    font-weight: 600;
+    text-decoration: none;
+    display: inline-block;
+    transition: all 0.3s ease;
+    cursor: pointer;
+    font-size: 1rem;
+}
+
+.btn-primary {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+}
+
+.btn-primary:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 25px rgba(102, 126, 234, 0.6);
+}
+
+.tickets-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.tickets-filters select {
+    padding: 0.5rem 1rem;
+    border: 1px solid rgba(255,255,255,0.3);
+    border-radius: 8px;
+    background: rgba(255,255,255,0.1);
+    color: white;
+}
+
+.ticket-item {
+    background: rgba(255,255,255,0.1);
+    border-radius: 10px;
+    padding: 1.5rem;
+    margin-bottom: 1rem;
+    border: 1px solid rgba(255,255,255,0.2);
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.ticket-item:hover {
+    background: rgba(255,255,255,0.2);
+    transform: translateY(-2px);
+}
+
+.ticket-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: start;
+    margin-bottom: 0.5rem;
+}
+
+.ticket-number {
+    font-weight: 600;
+    color: white;
+    font-size: 1.1rem;
+}
+
+.ticket-status {
+    padding: 0.25rem 0.75rem;
+    border-radius: 20px;
+    font-size: 0.85rem;
+    font-weight: 500;
+    text-transform: uppercase;
+}
+
+.status-open { background: #f39c12; color: white; }
+.status-in_progress { background: #3498db; color: white; }
+.status-resolved { background: #27ae60; color: white; }
+.status-closed { background: #95a5a6; color: white; }
+
+.ticket-subject {
+    color: white;
+    font-size: 1.1rem;
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.ticket-meta {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    color: rgba(255,255,255,0.7);
+    font-size: 0.9rem;
+}
+
+.ticket-category {
+    background: rgba(255,255,255,0.2);
+    padding: 0.25rem 0.5rem;
+    border-radius: 15px;
+    font-size: 0.8rem;
+}
+
+.loading-state,
+.empty-state {
+    text-align: center;
+    padding: 2rem;
+    color: rgba(255,255,255,0.8);
+}
+
+.spinner {
+    border: 3px solid rgba(255,255,255,0.3);
+    border-top: 3px solid white;
+    border-radius: 50%;
+    width: 40px;
+    height: 40px;
+    animation: spin 1s linear infinite;
+    margin: 0 auto 1rem;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0,0,0,0.8);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 2000;
+}
+
+.modal-content {
+    max-width: 600px;
+    width: 90%;
+    max-height: 80vh;
+    overflow-y: auto;
+    margin: 2rem;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    color: #1a202c; /* dark close button for contrast on light modal */
+    font-size: 2rem;
+    cursor: pointer;
+    opacity: 0.8;
+    transition: opacity 0.3s ease;
+}
+
+.modal-close:hover {
+    opacity: 1;
+}
+
+/* Ensure modal header and title are dark for readability */
+.modal-header h3, .modal-content h3 {
+    color: #1a202c !important;
+}
+
+.auth-message {
+    text-align: center;
+    padding: 3rem 2rem;
+}
+
+.auth-message h3 {
+    color: white;
+    margin-bottom: 1rem;
+}
+
+.auth-message p {
+    color: rgba(255,255,255,0.8);
+    margin-bottom: 2rem;
+}
+
+.ticket-update-form {
+    margin-top: 2rem;
+    padding-top: 2rem;
+    border-top: 1px solid rgba(255,255,255,0.2);
+}
+
+.ticket-update-form h4 {
+    color: white;
+    margin-bottom: 1rem;
+}
+
+.escalation-badge {
+    background: #e74c3c;
+    color: white;
+    padding: 0.25rem 0.5rem;
+    border-radius: 12px;
+    font-size: 0.75rem;
+    font-weight: 600;
+    margin-left: 0.5rem;
+}
+
+/* Ensure ticket modal content is readable: light card with dark text */
+.modal-content {
+    background: rgba(255,255,255,0.98) !important;
+    color: #1a202c !important;
+    border-radius: 12px;
+    padding: 1.5rem;
+    box-shadow: 0 10px 30px rgba(0,0,0,0.3);
+}
+
+/* Strong override: force dark text for modal and all children to avoid inheritance issues */
+.modal-content.glass-card,
+.modal-content.glass-card * {
+    color: #1a202c !important;
+}
+
+/* Ensure headings and paragraphs within modal are readable */
+.modal-content h1,
+.modal-content h2,
+.modal-content h3,
+.modal-content h4,
+.modal-content p,
+.modal-content label,
+.modal-content span,
+.modal-content div {
+    color: #1a202c !important;
+}
+
+.sla-section {
+    background: rgba(255,255,255,0.1);
+    border-radius: 10px;
+    padding: 1.5rem;
+    margin: 1.5rem 0;
+    border-left: 4px solid #3498db;
+}
+
+.sla-section h4 {
+    color: white;
+    margin-bottom: 1rem;
+}
+
+.sla-metric {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+    color: rgba(255,255,255,0.9);
+}
+
+.sla-status {
+    padding: 0.25rem 0.75rem;
+    border-radius: 15px;
+    font-size: 0.85rem;
+    font-weight: 500;
+}
+
+.sla-met { background: #27ae60; color: white; }
+.sla-warning { background: #f39c12; color: white; }
+.sla-breach { background: #e74c3c; color: white; }
+
+.escalation-section {
+    background: rgba(255,255,255,0.1);
+    border-radius: 10px;
+    padding: 1.5rem;
+    margin: 1.5rem 0;
+    border-left: 4px solid #e74c3c;
+}
+
+.escalation-section h4 {
+    color: white;
+    margin-bottom: 1rem;
+}
+
+.btn-warning {
+    background: linear-gradient(135deg, #f39c12 0%, #e67e22 100%);
+    color: white;
+    box-shadow: 0 4px 15px rgba(243, 156, 18, 0.4);
+}
+
+.btn-warning:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 25px rgba(243, 156, 18, 0.6);
+}
+
+@media (max-width: 768px) {
+    .form-row {
+        grid-template-columns: 1fr;
+    }
+    
+    .tickets-header {
+        flex-direction: column;
+        gap: 1rem;
+        align-items: stretch;
+    }
+    
+    .ticket-header {
+        flex-direction: column;
+        gap: 0.5rem;
+    }
+    
+    .ticket-meta {
+        flex-direction: column;
+        gap: 0.5rem;
+        align-items: start;
+    }
+}
+</style>
+
+<script>
+// Ticket management functionality
+let currentUser = null;
+let tickets = [];
+let categories = [];
+
+// Initialize page
+document.addEventListener('DOMContentLoaded', function() {
+    checkAuthentication();
+    loadCategories();
+});
+
+function checkAuthentication() {
+    fetch('/api/user')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success && data.user) {
+                currentUser = data.user;
+                document.getElementById('auth-required').style.display = 'none';
+                document.getElementById('tickets-main').style.display = 'block';
+                loadTickets();
+                
+                // Show tickets link in navigation
+                const ticketsLink = document.getElementById('tickets-link');
+                if (ticketsLink) {
+                    ticketsLink.style.display = 'inline-block';
+                }
+            } else {
+                document.getElementById('auth-required').style.display = 'block';
+                document.getElementById('tickets-main').style.display = 'none';
+            }
+        })
+        .catch(error => {
+            console.error('Auth check failed:', error);
+            document.getElementById('auth-required').style.display = 'block';
+        });
+}
+
+function loadCategories() {
+    fetch('/api/tickets/categories')
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                categories = data.categories;
+                const categorySelect = document.getElementById('ticket-category');
+                categorySelect.innerHTML = '<option value="">Auto-detect</option>';
+                
+                categories.forEach(category => {
+                    const option = document.createElement('option');
+                    option.value = category.name;
+                    option.textContent = category.name;
+                    categorySelect.appendChild(option);
+                });
+            }
+        })
+        .catch(error => console.error('Failed to load categories:', error));
+}
+
+function loadTickets() {
+    document.getElementById('tickets-loading').style.display = 'block';
+    document.getElementById('tickets-empty').style.display = 'none';
+    document.getElementById('tickets-container').innerHTML = '';
+    
+    fetch('/api/tickets/user')
+        .then(response => response.json())
+        .then(data => {
+            document.getElementById('tickets-loading').style.display = 'none';
+            
+            if (data.success) {
+                tickets = data.tickets;
+                if (tickets.length === 0) {
+                    document.getElementById('tickets-empty').style.display = 'block';
+                } else {
+                    displayTickets(tickets);
+                }
+            } else {
+                console.error('Failed to load tickets:', data.error);
+            }
+        })
+        .catch(error => {
+            document.getElementById('tickets-loading').style.display = 'none';
+            console.error('Error loading tickets:', error);
+        });
+}
+
+function displayTickets(ticketsToShow) {
+    const container = document.getElementById('tickets-container');
+    container.innerHTML = '';
+    
+    ticketsToShow.forEach(ticket => {
+        const ticketElement = createTicketElement(ticket);
+        container.appendChild(ticketElement);
+    });
+}
+
+function createTicketElement(ticket) {
+    const div = document.createElement('div');
+    div.className = 'ticket-item';
+    div.onclick = () => openTicketModal(ticket.ticket_number);
+    
+    const createdDate = new Date(ticket.created_at).toLocaleDateString();
+    
+    div.innerHTML = `
+        <div class="ticket-header">
+            <div class="ticket-number">${ticket.ticket_number}</div>
+            <div class="ticket-status status-${ticket.status}">${ticket.status.replace('_', ' ')}</div>
+        </div>
+        <div class="ticket-subject">${ticket.subject}</div>
+        <div class="ticket-meta">
+            <div>
+                <span class="ticket-category">${ticket.category}</span>
+                Priority: ${ticket.priority}
+                ${ticket.escalation_level > 0 ? `<span class="escalation-badge">Escalated L${ticket.escalation_level}</span>` : ''}
+            </div>
+            <div>Created: ${createdDate}</div>
+        </div>
+    `;
+    
+    return div;
+}
+
+// Form submission
+document.getElementById('create-ticket-form').addEventListener('submit', function(e) {
+    e.preventDefault();
+    
+    const formData = new FormData(e.target);
+    const ticketData = {
+        subject: formData.get('subject'),
+        description: formData.get('description'),
+        priority: formData.get('priority'),
+        category: formData.get('category')
+    };
+    
+    const csrfToken = document.querySelector('meta[name="csrf-token"]').getAttribute('content');
+    
+    fetch('/api/tickets/create', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-CSRFToken': csrfToken
+        },
+        body: JSON.stringify(ticketData)
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            alert(`Ticket created successfully! Ticket number: ${data.ticket_number}`);
+            e.target.reset();
+            loadTickets(); // Refresh the tickets list
+        } else {
+            alert('Failed to create ticket: ' + data.error);
+        }
+    })
+    .catch(error => {
+        console.error('Error creating ticket:', error);
+        alert('Error creating ticket. Please try again.');
+    });
+});
+
+// Status filter
+document.getElementById('status-filter').addEventListener('change', function(e) {
+    const status = e.target.value;
+    if (status === '') {
+        displayTickets(tickets);
+    } else {
+        const filtered = tickets.filter(ticket => ticket.status === status);
+        displayTickets(filtered);
+    }
+});
+
+function openTicketModal(ticketNumber) {
+    fetch(`/api/tickets/${ticketNumber}`)
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                showTicketDetails(data.ticket, data.updates);
+                document.getElementById('update-ticket-id').value = data.ticket.id;
+                
+                // Load SLA and escalation info
+                loadSLAInfo(data.ticket.id);
+                checkEscalationStatus(data.ticket.id);
+                
+                document.getElementById('ticket-modal').style.display = 'flex';
+            } else {
+                alert('Failed to load ticket details: ' + data.error);
+            }
+        })
+        .catch(error => {
+            console.error('Error loading ticket:', error);
+            alert('Error loading ticket details.');
+        });
+}
+
+function loadSLAInfo(ticketId) {
+    fetch(`/api/tickets/${ticketId}/sla`)
+        .then(response => response.json())
+        .then(data => {
+            if (data.success && data.sla_metrics) {
+                showSLAStatus(data.sla_metrics);
+            }
+        })
+        .catch(error => console.error('Error loading SLA info:', error));
+}
+
+function showSLAStatus(sla) {
+    const slaSection = document.getElementById('sla-status');
+    let statusClass = 'sla-met';
+    let statusText = 'Within SLA';
+    
+    if (!sla.sla_met) {
+        if (sla.sla_breach_hours > 0) {
+            statusClass = 'sla-breach';
+            statusText = `SLA Breached (${sla.sla_breach_hours.toFixed(1)}h over)`;
+        } else {
+            statusClass = 'sla-warning';
+            statusText = 'SLA at Risk';
+        }
+    }
+    
+    slaSection.innerHTML = `
+        <h4>Service Level Agreement</h4>
+        <div class="sla-metric">
+            <span>Target Response Time:</span>
+            <span>${sla.sla_target_hours}h</span>
+        </div>
+        <div class="sla-metric">
+            <span>Hours Open:</span>
+            <span>${sla.hours_open.toFixed(1)}h</span>
+        </div>
+        <div class="sla-metric">
+            <span>Status:</span>
+            <span class="sla-status ${statusClass}">${statusText}</span>
+        </div>
+        ${sla.resolution_hours ? `
+        <div class="sla-metric">
+            <span>Resolution Time:</span>
+            <span>${sla.resolution_hours.toFixed(1)}h</span>
+        </div>` : ''}
+    `;
+    slaSection.style.display = 'block';
+}
+
+function checkEscalationStatus(ticketId) {
+    fetch(`/api/tickets/${ticketId}/escalation-check`)
+        .then(response => response.json())
+        .then(data => {
+            if (data.success) {
+                const escalationSection = document.getElementById('escalation-actions');
+                if (data.escalation_check.needs_escalation || data.escalation_check.status !== 'resolved') {
+                    escalationSection.style.display = 'block';
+                    window.currentTicketId = ticketId; // Store for escalation function
+                }
+            }
+        })
+        .catch(error => console.error('Error checking escalation:', error));
+}
+
+function escalateTicket() {
+    if (!window.currentTicketId) {
+        alert('No ticket selected for escalation');
+        return;
+    }
+    
+    const reason = prompt('Please provide a reason for escalation:');
+    if (!reason) return;
+    
+    fetch(`/api/tickets/${window.currentTicketId}/escalate`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            reason: reason
+        })
+    })
+    .then(response => response.json())
+    .then(data => {
+        if (data.success) {
+            alert('Ticket escalated successfully! Our team will prioritize your request.');
+            closeTicketModal();
+            loadTickets(); // Refresh the tickets list
+        } else {
+            alert('Failed to escalate ticket: ' + data.error);
+        }
+    })
+    .catch(error => {
+        console.error('Error escalating ticket:', error);
+        alert('Error escalating ticket. Please try again.');
+    });
+}
+
+function showTicketDetails(ticket, updates) {
+    const detailsContainer = document.getElementById('ticket-details');
+    const createdDate = new Date(ticket.created_at).toLocaleDateString();
+    
+    let updatesHtml = '';
+    if (updates && updates.length > 0) {
+        updatesHtml = '<h4 style="margin-top: 2rem;">Updates:</h4>';
+        updates.forEach(update => {
+            const updateDate = new Date(update.created_at).toLocaleDateString();
+            updatesHtml += `
+                <div style="background: rgba(255,255,255,0.1); padding: 1rem; margin: 0.5rem 0; border-radius: 8px;">
+                    <div style="font-size: 0.9rem; margin-bottom: 0.5rem;">
+                        ${updateDate} - ${update.update_type}
+                    </div>
+                    <div>${update.message}</div>
+                </div>
+            `;
+        });
+    }
+    
+    detailsContainer.innerHTML = `
+        <div>
+            <h4>Ticket ${ticket.ticket_number}</h4>
+            <p><strong>Status:</strong> <span class="ticket-status status-${ticket.status}">${ticket.status.replace('_', ' ')}</span></p>
+            <p><strong>Category:</strong> ${ticket.category}</p>
+            <p><strong>Priority:</strong> ${ticket.priority}</p>
+            <p><strong>Created:</strong> ${createdDate}</p>
+            <h5 style="margin-top: 1.5rem;">Subject:</h5>
+            <p>${ticket.subject}</p>
+            <h5 style="margin-top: 1.5rem;">Description:</h5>
+            <p style="white-space: pre-wrap;">${ticket.description}</p>
+            ${updatesHtml}
+        </div>
+    `;
+    
+    document.getElementById('ticket-modal-title').textContent = `Ticket ${ticket.ticket_number}`;
+
+    // Force inline styles on modal content to avoid external CSS conflicts
+    const modalContent = document.querySelector('#ticket-modal .modal-content');
+    if (modalContent) {
+        modalContent.style.backgroundColor = 'rgba(255,255,255,0.98)';
+        modalContent.style.color = '#1a202c';
+    }
+}
+
+function closeTicketModal() {
+    document.getElementById('ticket-modal').style.display = 'none';
+    document.getElementById('update-message').value = '';
+}
+
+// Update form submission
+document.getElementById('update-ticket-form').addEventListener('submit', function(e) {
+    e.preventDefault();
+    
+    const ticketId = document.getElementById('update-ticket-id').value;
+    const message = document.getElementById('update-message').value;
+    
+    fetch(`/api/tickets/${ticketId}/update`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            message: message,
+            update_type: 'note'
+        })
+    })
+    .then(response => {
+        console.log('Response received, status:', response.status);
+        // Parse JSON regardless of status
+        return response.json().then(data => ({ data, status: response.status, ok: response.ok }));
+    })
+    .then(({ data, status, ok }) => {
+        console.log('JSON parsed, data:', data);
+        
+        if (!ok) {
+            const errorMsg = data.error || `Server error: ${status}`;
+            alert('Failed to add update: ' + errorMsg);
+            return;
+        }
+        
+        if (data.success) {
+            alert('Update added successfully!');
+            document.getElementById('update-message').value = '';
+            // Reload the ticket details
+            const ticketNumber = document.getElementById('ticket-modal-title').textContent.replace('Ticket ', '');
+            openTicketModal(ticketNumber);
+        } else {
+            alert('Failed to add update: ' + (data.error || 'Unknown error'));
+        }
+    })
+    .catch(error => {
+        console.error('Error adding update:', error);
+        console.error('Error details:', error.message);
+        alert('Error adding update: ' + error.message);
+    });
+});
+
+// Function to show login modal (assuming it exists in base template)
+function showLoginModal() {
+    // This should trigger the login modal from the base template  
+    const authBtn = document.getElementById('auth-btn');
+    if (authBtn && authBtn.textContent === 'Login') {
+        authBtn.click();
+    }
+}
+
+// Close modal on outside click
+document.getElementById('ticket-modal').addEventListener('click', function(e) {
+    if (e.target === this) {
+        closeTicketModal();
+    }
+});
+</script>
+{% endblock %}