Deploy VisionExtract to HF Spaces

.dockerignore

@@ -0,0 +1,46 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.eggs/
+
+# Environment
+.env
+.venv/
+venv/
+ENV/
+
+# Git
+.git/
+.gitignore
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Local files not needed in container
+render.yaml
+gunicorn.conf.py
+ngrok.exe
+*.md
+!README.md
+
+# Data directories (will be created fresh in container)
+uploads/*
+user_data/*
+vector_store/*
+instance/*
+*.db
+*.sqlite
+
+# Logs
+*.log
+
+# OS files
+.DS_Store
+Thumbs.db

.env.example

@@ -0,0 +1,9 @@
+# Chroma Cloud Configuration
+# Get these from https://trychroma.com
+CHROMA_TENANT=your-tenant-id
+CHROMA_DATABASE=your-database-name
+CHROMA_API_KEY=your-api-key-here
+
+# OpenRouter API Key (for AI models)
+# Get this from https://openrouter.ai
+OPENROUTER_API_KEY=your-openrouter-api-key-here

.gitignore

@@ -0,0 +1,30 @@
+# Environment variables (NEVER commit this!)
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+
+# Local data (user uploads and database)
+instance/
+uploads/
+user_data/
+vector_store/
+nltk_data/
+
+# Large binaries
+ngrok.exe
+*.exe
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,51 @@
+# Dockerfile for Hugging Face Spaces
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/app/.cache/huggingface
+
+# Install system dependencies for PyMuPDF and other libs
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (Docker layer caching optimization)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Download NLTK data during build
+COPY download_nltk.py .
+RUN python download_nltk.py
+
+# Copy application code
+COPY . .
+
+# Create necessary directories with write permissions
+# HF Spaces only allows writes to certain directories
+RUN mkdir -p /app/uploads /app/user_data /app/vector_store /app/instance /app/.cache
+RUN chmod -R 777 /app/uploads /app/user_data /app/vector_store /app/instance /app/.cache
+
+# Expose port 7860 (required by Hugging Face Spaces)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Start with gunicorn
+# - Single worker to conserve memory for ML models
+# - 120s timeout to allow model loading on first request
+# - Preload disabled to allow lazy loading
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--timeout", "120", "--workers", "1", "--threads", "2", "app:app"]

README.md

@@ -0,0 +1,36 @@
+---
+title: VisionExtract CRM
+emoji: 📄
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# VisionExtract CRM
+
+AI-powered document extraction application for business cards and brochures with RAG-based intelligent chat.
+
+## Features
+
+- 📇 **Business Card OCR** - Extract contact information from business card images
+- 📑 **Brochure Processing** - Parse PDF brochures to extract company and contact details
+- 💬 **RAG Chat** - Ask natural language questions about your uploaded documents
+- 🗄️ **Persistent Storage** - SQLite database for storing extracted data
+
+## Tech Stack
+
+- **Backend**: Flask + Gunicorn
+- **AI/ML**: OpenRouter API, Sentence-Transformers, ChromaDB
+- **Document Processing**: PyMuPDF, Pillow
+- **Database**: SQLite + ChromaDB Cloud
+
+## Environment Variables
+
+Set these in your Space secrets:
+- `OPENROUTER_API_KEY` - Your OpenRouter API key
+- `CHROMA_TENANT` - Chroma Cloud tenant
+- `CHROMA_DATABASE` - Chroma Cloud database
+- `CHROMA_API_KEY` - Chroma Cloud API key
+- `SESSION_SECRET` - Random secret for Flask sessions

app.py

@@ -0,0 +1,720 @@
+# app.py
+
+import os
+import io
+import json
+import hashlib
+import requests
+import base64
+from flask import Flask, request, jsonify, send_from_directory, render_template, session
+import webbrowser
+from flask_cors import CORS
+from PIL import Image
+import fitz  # PyMuPDF
+import rag_core
+from datetime import timedelta
+import traceback
+import time
+import re
+
+from dotenv import load_dotenv
+load_dotenv()
+
+# --- MODIFIED: Import db and models from models.py ---
+from models import db, BusinessCard, Brochure, Contact
+
+
+app = Flask(__name__)
+CORS(app)
+
+# Disable template caching for development
+app.config['TEMPLATES_AUTO_RELOAD'] = True
+app.jinja_env.auto_reload = True
+
+# Session configuration
+app.secret_key = os.environ.get("SESSION_SECRET", "a-very-secret-key-for-sessions")
+app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(hours=24)
+
+# --- FOLDER CONFIGURATION ---
+UPLOAD_FOLDER = 'uploads'
+DATA_FOLDER = 'user_data'
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER)
+if not os.path.exists(DATA_FOLDER):
+    os.makedirs(DATA_FOLDER)
+    
+# --- DATABASE CONFIGURATION ---
+app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get(
+    'DATABASE_URI',
+    'sqlite:///local_crm.db'
+)
+app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+
+# --- MODIFIED: Initialize the app with the database object ---
+db.init_app(app)
+
+# --- HARDCODED API KEY (loaded from environment) ---
+OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY")
+
+
+# --- DATABASE MODEL DEFINITIONS HAVE BEEN MOVED TO models.py ---
+
+
+MODEL_MAP = {
+    'gemini': 'google/gemma-3-4b-it:free',
+    'deepseek': 'google/gemma-3-27b-it:free',
+    
+    'qwen': 'mistralai/mistral-small-3.1-24b-instruct:free',
+    'nvidia': 'nvidia/nemotron-nano-12b-v2-vl:free',
+    'amazon': 'amazon/nova-2-lite-v1:free'
+}
+
+# Best → fallback order (OCR strength)
+FALLBACK_ORDER = [
+    'gemini',
+    'deepseek',
+    'qwen',
+    'nvidia',
+    'amazon'
+]
+
+
+
+# All your other functions (_call_openrouter_api_with_fallback, etc.) remain unchanged below...
+def _call_openrouter_api_with_fallback(api_key, selected_model_key, prompt, images=[]):
+    if images:
+        vision_models = ['gemini','deepseek','qwen','nvidia','amazon']
+        models_to_try = [m for m in vision_models if m == selected_model_key]
+        models_to_try.extend([m for m in vision_models if m != selected_model_key])
+        models_to_try.extend([m for m in FALLBACK_ORDER if m not in vision_models])
+    else:
+        models_to_try = [selected_model_key]
+        for model in FALLBACK_ORDER:
+            if model != selected_model_key:
+                models_to_try.append(model)
+    
+    last_error = None
+    
+    for model_key in models_to_try:
+        model_name = MODEL_MAP.get(model_key)
+        if not model_name: continue
+            
+        print(f"Attempting API call with model: {model_name}...")
+        content_parts = [{"type": "text", "text": prompt}]
+        
+        if images and model_key in ['gemini','deepseek','qwen','nvidia','amazon']:
+            for img in images:
+                buffered = io.BytesIO()
+                img_format = img.format or "PNG"
+                img.save(buffered, format=img_format)
+                img_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+                content_parts.append({
+                    "type": "image_url",
+                    "image_url": { "url": f"data:image/{img_format.lower()};base64,{img_base64}" }
+                })
+        elif images and model_key not in ['gemini','deepseek','qwen','nvidia','amazon']:
+            print(f"Skipping {model_name} - no image input support")
+            continue
+
+        try:
+            response = requests.post(
+                url="https://openrouter.ai/api/v1/chat/completions",
+                headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+                json={"model": model_name, "messages": [{"role": "user", "content": content_parts}]},
+                timeout=30
+            )
+            response.raise_for_status()
+            api_response = response.json()
+            
+            if 'choices' not in api_response or not api_response['choices']:
+                print(f"Model {model_name} returned empty response")
+                last_error = {"error": f"Model {model_name} returned empty response"}
+                continue
+                
+            json_text = api_response['choices'][0]['message']['content']
+            
+            cleaned_json_text = re.search(r'```json\s*([\s\S]+?)\s*```', json_text)
+            if cleaned_json_text:
+                json_text = cleaned_json_text.group(1)
+            else:
+                json_text = json_text.strip()
+            
+            result = json.loads(json_text)
+            print(f"Successfully processed with model: {model_name}")
+            return result
+        except requests.exceptions.HTTPError as http_err:
+            error_msg = f"HTTP error occurred for model {model_name}: {http_err}"
+            if hasattr(response, 'text'): error_msg += f"\nResponse: {response.text}"
+            print(error_msg)
+            last_error = {"error": f"API request failed for {model_name} with status {response.status_code}."}
+            continue
+        except requests.exceptions.Timeout:
+            print(f"Timeout error for model {model_name}")
+            last_error = {"error": f"Request timeout for model {model_name}"}
+            continue
+        except json.JSONDecodeError as json_err:
+            error_msg = f"JSON Decode Error for model {model_name}: {json_err}\nMalformed response: {json_text}"
+            print(error_msg)
+            last_error = {"error": f"Model {model_name} returned invalid JSON."}
+            continue
+        except Exception as e:
+            print(f"An error occurred with model {model_name}: {e}")
+            traceback.print_exc()
+            last_error = {"error": f"An unexpected error occurred with model {model_name}."}
+            continue
+    
+    return last_error or {"error": "All models failed to process the request."}
+
+def _call_openrouter_api_text_only_with_fallback(api_key, selected_model_key, prompt):
+    models_to_try = [selected_model_key] + [m for m in FALLBACK_ORDER if m != selected_model_key]
+    last_error = None
+    for model_key in models_to_try:
+        model_name = MODEL_MAP.get(model_key)
+        if not model_name: continue
+        print(f"Attempting text-only API call with model: {model_name}...")
+        try:
+            response = requests.post(
+                url="https://openrouter.ai/api/v1/chat/completions",
+                headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+                json={"model": model_name, "messages": [{"role": "user", "content": prompt}]},
+                timeout=30
+            )
+            response.raise_for_status()
+            api_response = response.json()
+            if 'choices' not in api_response or not api_response['choices']:
+                last_error = {"error": f"Model {model_name} returned unexpected response format"}
+                continue
+            result = api_response['choices'][0]['message']['content']
+            print(f"Successfully processed text with model: {model_name}")
+            return result
+        except requests.exceptions.HTTPError as http_err:
+            error_msg = f"HTTP error occurred for model {model_name}: {http_err}"
+            if hasattr(response, 'text'): error_msg += f"\nResponse: {response.text}"
+            print(error_msg)
+            last_error = {"error": f"API request failed for {model_name} with status {response.status_code}."}
+            continue
+        except requests.exceptions.Timeout:
+            print(f"Timeout error for model {model_name}")
+            last_error = {"error": f"Request timeout for model {model_name}"}
+            continue
+        except Exception as e:
+            print(f"An error occurred with model {model_name}: {e}")
+            traceback.print_exc()
+            last_error = {"error": f"An unexpected error occurred with model {model_name}."}
+            continue
+    if isinstance(last_error, dict) and "error" in last_error:
+        return last_error["error"]
+    return "All models failed to process the text request."
+
+
+def _extract_contact_info_from_text(text):
+    if not text: return "", []
+    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+    phone_pattern = r'(?:\+?\d{1,4}[-.\s]?)?(?:\(?\d{1,4}\)?[-.\s]?)?\d{1,4}[-.\s]?\d{1,4}[-.\s]?\d{1,9}'
+    emails = re.findall(email_pattern, text, re.IGNORECASE)
+    phones = re.findall(phone_pattern, text)
+    clean_text = text
+    clean_text = re.sub(email_pattern, '', clean_text, flags=re.IGNORECASE)
+    for phone in phones:
+        if len(phone.replace('-', '').replace('.', '').replace(' ', '').replace('(', '').replace(')', '').replace('+', '')) >= 7:
+            clean_text = clean_text.replace(phone, '')
+    clean_text = re.sub(r'\s+', ' ', clean_text).strip()
+    clean_text = re.sub(r'\n\s*\n', '\n', clean_text)
+    return clean_text, emails + phones
+
+def _create_clean_info_text(brochure_data):
+    company_name = brochure_data.get("company_name", "")
+    raw_text = brochure_data.get("raw_text", "")
+    info_parts = []
+    if company_name and company_name != "Unknown Company":
+        info_parts.append(f"Company: {company_name}")
+    if raw_text:
+        clean_text, _ = _extract_contact_info_from_text(raw_text)
+        contact_phrases = [r'contact\s+us\s*:?', r'for\s+more\s+information\s*:?', r'reach\s+out\s+to\s*:?', r'get\s+in\s+touch\s*:?', r'phone\s*:', r'email\s*:', r'tel\s*:', r'mobile\s*:', r'call\s+us\s*:?', r'write\s+to\s+us\s*:?',]
+        for phrase in contact_phrases:
+            clean_text = re.sub(phrase, '', clean_text, flags=re.IGNORECASE)
+        clean_text = re.sub(r'\s+', ' ', clean_text).strip()
+        clean_text = re.sub(r'\n\s*\n', '\n', clean_text)
+        if clean_text: info_parts.append(clean_text)
+    return "\n".join(info_parts) if info_parts else ""
+
+def _get_user_data_filepath(user_api_key, mode):
+    user_hash = hashlib.sha256(user_api_key.encode()).hexdigest()[:16]
+    return os.path.join(DATA_FOLDER, f'{user_hash}_{mode}_data.json')
+
+def _load_user_data(user_api_key, mode):
+    filepath = _get_user_data_filepath(user_api_key, mode)
+    try:
+        if os.path.exists(filepath):
+            with open(filepath, 'r') as f: return json.load(f)
+    except (IOError, json.JSONDecodeError): return []
+    return []
+
+def _save_user_data(user_api_key, mode, data):
+    filepath = _get_user_data_filepath(user_api_key, mode)
+    try:
+        with open(filepath, 'w') as f: json.dump(data, f, indent=4)
+        return True
+    except IOError: return False
+
+def _clean_and_validate_contacts(data):
+    if not data or "contacts" not in data: return data
+    cleaned_contacts = []
+    def is_placeholder(value):
+        if not isinstance(value, str): return True
+        test_val = value.strip().lower()
+        if not test_val: return True
+        placeholders = ["n/a", "na", "none", "null"]
+        if test_val in placeholders: return True
+        if "not available" in test_val or "not specified" in test_val or "not applicable" in test_val: return True
+        return False
+    for contact in data.get("contacts", []):
+        name = contact.get("Owner Name")
+        if is_placeholder(name): continue
+        cleaned_contacts.append({
+            "Owner Name": name.strip(),
+            "Email": None if is_placeholder(contact.get("Email")) else contact.get("Email").strip(),
+            "Number": None if is_placeholder(contact.get("Number")) else contact.get("Number").strip()
+        })
+    data["contacts"] = cleaned_contacts
+    return data
+
+def extract_card_data(image_bytes, user_api_key, selected_model_key):
+    print("Processing business card with OpenRouter API...")
+    if not user_api_key: return {"error": "A valid OpenRouter API Key was not provided."}
+    try:
+        img = Image.open(io.BytesIO(image_bytes))
+        prompt = """You are an expert at reading business cards. Analyze the image and extract information into a structured JSON format. The JSON object must use these exact keys: "Owner Name", "Company Name", "Email", "Number", "Address". If a piece of information is not present, its value must be `null`. Your entire response MUST be a single, valid JSON object."""
+        parsed_info = _call_openrouter_api_with_fallback(user_api_key, selected_model_key, prompt, images=[img])
+        if "error" in parsed_info: return parsed_info
+        return {"Owner Name": parsed_info.get("Owner Name"), "Company Name": parsed_info.get("Company Name"), "Email": parsed_info.get("Email"), "Number": parsed_info.get("Number"), "Address": parsed_info.get("Address")}
+    except Exception as e:
+        print(f"Error during OpenRouter API call for business card: {e}")
+        traceback.print_exc()
+        return {"error": f"Failed to parse AI response: {e}"}
+
+def _extract_brochure_data_with_vision(image_list, user_api_key, selected_model_key):
+    print(f"Vision Extraction: Analyzing {len(image_list)} images with OpenRouter...")
+    if not user_api_key: return {"error": "A valid OpenRouter API Key was not provided."}
+    try:
+        prompt = """You are a world-class document analysis expert. Analyze the provided document images with maximum precision. CRITICAL INSTRUCTIONS: 1. Extract the company name. 2. Extract ONLY contact information (names, emails, phone numbers) and put them in the "contacts" array. 3. Extract ALL OTHER content (company description, services, mission, addresses, general information) as "raw_text". 4. DO NOT include contact details like names, emails, or phone numbers in the raw_text. 5. Focus on separating contact information from general company information. OUTPUT FORMAT: Return a SINGLE, valid JSON object with these exact keys: "company_name", "contacts", "raw_text". The "contacts" key must contain a list of objects, each with "Owner Name", "Email", and "Number". If a piece of information is missing for a contact, use `null`. The "raw_text" should contain business information, services, descriptions, but NO contact details."""
+        raw_data = _call_openrouter_api_with_fallback(user_api_key, selected_model_key, prompt, images=image_list)
+        if "error" in raw_data: return raw_data
+        print("AI vision extraction complete. Applying bulletproof cleaning...")
+        cleaned_data = _clean_and_validate_contacts(raw_data)
+        return cleaned_data
+    except Exception as e:
+        print(f"Error during unified brochure vision extraction: {e}")
+        traceback.print_exc()
+        return {"error": f"Failed to parse data from brochure images: {e}"}
+
+@app.before_request
+def make_session_permanent():
+    session.permanent = True
+
+@app.route('/process_card', methods=['POST'])
+def process_card_endpoint():
+    if 'file' not in request.files: return jsonify({'error': 'No file part'}), 400
+    file, selected_model_key = request.files['file'], request.form.get('selectedModel')
+    user_api_key = OPENROUTER_API_KEY  # Use hardcoded server-side API key
+    if not user_api_key or not selected_model_key: return jsonify({'error': 'Server API key not configured or model not selected'}), 400
+    if selected_model_key not in MODEL_MAP: return jsonify({'error': 'Invalid model selected'}), 400
+    
+    try:
+        image_bytes = file.read()
+        extracted_info = extract_card_data(image_bytes, user_api_key, selected_model_key)
+        if "error" in extracted_info: return jsonify(extracted_info), 500
+
+        file_id = os.urandom(8).hex()
+        _, f_ext = os.path.splitext(file.filename)
+        safe_ext = f_ext if f_ext.lower() in ['.png', '.jpg', '.jpeg', '.webp'] else '.png'
+        image_filename = f"{file_id}{safe_ext}"
+        save_path = os.path.join(UPLOAD_FOLDER, image_filename)
+        with open(save_path, 'wb') as f: f.write(image_bytes)
+        
+        extracted_info['id'] = file_id
+        extracted_info['image_filename'] = image_filename
+        
+        user_contacts = _load_user_data(user_api_key, 'cards')
+        user_contacts.insert(0, extracted_info)
+        _save_user_data(user_api_key, 'cards', user_contacts)
+        
+        try:
+            user_hash = hashlib.sha256(user_api_key.encode()).hexdigest()
+            new_card = BusinessCard(
+                json_id=file_id,
+                owner_name=extracted_info.get("Owner Name"),
+                company_name=extracted_info.get("Company Name"),
+                email=extracted_info.get("Email"),
+                phone_number=extracted_info.get("Number"),
+                address=extracted_info.get("Address"),
+                source_document=file.filename,
+                user_hash=user_hash
+            )
+            db.session.add(new_card)
+            db.session.commit()
+            print(f"Successfully saved business card for '{extracted_info.get('Owner Name')}' to the database.")
+        except Exception as e:
+            db.session.rollback()
+            print(f"DATABASE ERROR: Failed to save business card data. Error: {e}")
+            traceback.print_exc()
+        
+        raw_text_for_rag = ' '.join(str(v) for k, v in extracted_info.items() if v and k not in ['id', 'image_filename'])
+        rag_core.add_document_to_knowledge_base(user_api_key, raw_text_for_rag, file_id, 'cards')
+        
+        return jsonify(extracted_info)
+    except Exception as e:
+        print(f"An error occurred in process_card endpoint: {e}")
+        traceback.print_exc()
+        return jsonify({'error': 'Server processing failed'}), 500
+
+@app.route('/process_brochure', methods=['POST'])
+def process_brochure_endpoint():
+    if 'file' not in request.files: return jsonify({'error': 'No file part'}), 400
+    file, selected_model_key = request.files['file'], request.form.get('selectedModel')
+    user_api_key = OPENROUTER_API_KEY  # Use hardcoded server-side API key
+    if not user_api_key or not selected_model_key: return jsonify({'error': 'Server API key not configured or model not selected'}), 400
+    if selected_model_key not in MODEL_MAP: return jsonify({'error': 'Invalid model selected'}), 400
+
+    try:
+        pdf_bytes = file.read()
+        pdf_doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        
+        brochure_json_id = os.urandom(8).hex()
+        pdf_filename = f"{brochure_json_id}.pdf"
+        save_path = os.path.join(UPLOAD_FOLDER, pdf_filename)
+        with open(save_path, 'wb') as f: f.write(pdf_bytes)
+
+        extracted_data = {}
+        full_text_from_pdf = "".join(page.get_text("text") for page in pdf_doc).strip()
+        
+        if len(full_text_from_pdf) > 100:
+            print("'Text-First' successful. Using text model.")
+            try:
+                prompt = """Analyze the following text and structure it into a JSON object with keys "company_name", "contacts", and "raw_text". CRITICAL INSTRUCTIONS: 1. Extract the company name. 2. Extract ONLY contact information (names, emails, phone numbers) into the "contacts" array. 3. Extract ALL OTHER content into "raw_text". 4. DO NOT include contact details in raw_text. "contacts" should be a list of objects with "Owner Name", "Email", and "Number". DOCUMENT TEXT: --- {full_text_from_pdf} ---"""
+                result = _call_openrouter_api_text_only_with_fallback(user_api_key, selected_model_key, prompt)
+                if isinstance(result, str) and not result.startswith("All models failed"):
+                    try: extracted_data = json.loads(result)
+                    except json.JSONDecodeError: extracted_data = {}
+                else: extracted_data = {}
+            except Exception: extracted_data = {}
+        
+        if "error" in extracted_data or not extracted_data:
+            print("Adaptive Vision: Attempting medium resolution (150 DPI)...")
+            med_res_images = [Image.open(io.BytesIO(page.get_pixmap(dpi=150).tobytes("png"))) for page in pdf_doc]
+            extracted_data = _extract_brochure_data_with_vision(med_res_images, user_api_key, selected_model_key)
+            is_poor_quality = "error" in extracted_data or (not extracted_data.get("contacts") and len(extracted_data.get("raw_text", "")) < 50)
+            if is_poor_quality:
+                print("Medium resolution failed. Retrying with high resolution (300 DPI)...")
+                high_res_images = [Image.open(io.BytesIO(page.get_pixmap(dpi=300).tobytes("png"))) for page in pdf_doc]
+                extracted_data = _extract_brochure_data_with_vision(high_res_images, user_api_key, selected_model_key)
+
+        if "error" in extracted_data: return jsonify(extracted_data), 500
+
+        final_brochure_object = {
+            "id": brochure_json_id,
+            "company_name": extracted_data.get("company_name", "Unknown Company"),
+            "contacts": extracted_data.get("contacts", []),
+            "raw_text": extracted_data.get("raw_text", ""),
+            "image_filename": pdf_filename
+        }
+        for contact in final_brochure_object["contacts"]: contact["id"] = os.urandom(8).hex()
+        
+        user_brochures = _load_user_data(user_api_key, 'brochures')
+        user_brochures.insert(0, final_brochure_object)
+        _save_user_data(user_api_key, 'brochures', user_brochures)
+        
+        try:
+            user_hash = hashlib.sha256(user_api_key.encode()).hexdigest()
+            new_brochure = Brochure(
+                json_id=brochure_json_id,
+                company_name=final_brochure_object.get("company_name"),
+                raw_text=final_brochure_object.get("raw_text"),
+                source_document=file.filename,
+                user_hash=user_hash
+            )
+            db.session.add(new_brochure)
+            
+            for contact_data in final_brochure_object.get("contacts", []):
+                new_contact = Contact(
+                    json_id=contact_data['id'],
+                    owner_name=contact_data.get("Owner Name"),
+                    email=contact_data.get("Email"),
+                    phone_number=contact_data.get("Number"),
+                    brochure=new_brochure 
+                )
+                db.session.add(new_contact)
+            
+            db.session.commit()
+            print(f"Successfully saved brochure '{new_brochure.company_name}' and {len(new_brochure.contacts)} contacts to the database.")
+        except Exception as e:
+            db.session.rollback()
+            print(f"DATABASE ERROR: Failed to save brochure data. Error: {e}")
+            traceback.print_exc()
+        
+        print("Indexing separated and cleaned content for high-quality RAG...")
+        contacts = final_brochure_object.get("contacts", [])
+        if contacts:
+            contact_text_parts = [f"Contact information for {final_brochure_object.get('company_name', 'this company')}:"]
+            for contact in contacts:
+                name, email, number = contact.get("Owner Name"), contact.get("Email"), contact.get("Number")
+                contact_info = [f"Name: {name}"]
+                if email: contact_info.append(f"Email: {email}")
+                if number: contact_info.append(f"Phone: {number}")
+                contact_text_parts.append("- " + ", ".join(contact_info))
+            contacts_document_text = "\n".join(contact_text_parts)
+            rag_core.add_document_to_knowledge_base(user_api_key, contacts_document_text, f"{brochure_json_id}_contacts", 'brochures')
+        clean_info_text = _create_clean_info_text(final_brochure_object)
+        if clean_info_text and clean_info_text.strip():
+            rag_core.add_document_to_knowledge_base(user_api_key, clean_info_text, f"{brochure_json_id}_info", 'brochures')
+        print("RAG indexing completed successfully!")
+        
+        return jsonify(final_brochure_object)
+    except Exception as e:
+        print(f"An error occurred in process_brochure endpoint: {e}")
+        traceback.print_exc()
+        return jsonify({'error': f'Server processing failed: {e}'}), 500
+
+@app.route('/chat', methods=['POST'])
+def chat_endpoint():
+    data = request.get_json()
+    query_text, mode, selected_model_key = data.get('query'), data.get('mode'), data.get('selectedModel')
+    user_api_key = OPENROUTER_API_KEY  # Use hardcoded server-side API key
+    if not all([user_api_key, query_text, mode, selected_model_key]): return jsonify({'error': 'Query, mode, and model are required.'}), 400
+    if selected_model_key not in MODEL_MAP: return jsonify({'error': 'Invalid model selected'}), 400
+    try:
+        session['api_key'] = user_api_key
+        intent = 'synthesis' if "table" in query_text.lower() or "list all" in query_text.lower() else 'research'
+        print(f"Intent detected: {intent}")
+        if intent == 'synthesis':
+            data_source = _load_user_data(user_api_key, mode)
+            synthesis_data = []
+            if mode == 'brochures':
+                for brochure in data_source:
+                    for contact in brochure.get('contacts', []):
+                        synthesis_data.append({"Company Name": brochure.get("company_name"), "Owner Name": contact.get("Owner Name"), "Email": contact.get("Email"), "Number": contact.get("Number")})
+            else:
+                synthesis_data = data_source
+            synthesis_prompt = f"As a data analyst, create a markdown table based on the user's request from the following JSON data.\nJSON: {json.dumps(synthesis_data, indent=2)}\nRequest: {query_text}\nAnswer:"
+            answer = _call_openrouter_api_text_only_with_fallback(user_api_key, selected_model_key, synthesis_prompt)
+        else:
+            answer = rag_core.query_knowledge_base(user_api_key, query_text, mode, selected_model_key)
+        return jsonify({'answer': answer})
+    except Exception as e:
+        print(f"Error in /chat endpoint: {e}"); traceback.print_exc()
+        return jsonify({'error': 'An internal error occurred.'}), 500
+
+@app.route('/load_data/<mode>', methods=['POST'])
+def load_data_endpoint(mode):
+    user_api_key = OPENROUTER_API_KEY  # Use hardcoded server-side API key
+    if not user_api_key: return jsonify({'error': 'Server API key not configured'}), 400
+    user_data = _load_user_data(user_api_key, mode)
+    return jsonify(user_data)
+
+@app.route('/update_card/<mode>/<item_id>', methods=['POST'])
+def update_card_endpoint(mode, item_id):
+    data = request.get_json()
+    field, value, contact_id = data.get('field'), data.get('value'), data.get('contactId')
+    user_api_key = OPENROUTER_API_KEY  # Use hardcoded server-side API key
+    if not user_api_key: return jsonify({'error': 'Server API key not configured'}), 400
+    
+    # Step 1: Update JSON file (Existing Logic, Unchanged)
+    user_data = _load_user_data(user_api_key, mode)
+    item_found_in_json = False
+    if mode == 'cards':
+        for card in user_data:
+            if card.get('id') == item_id:
+                card[field] = value
+                item_found_in_json = True
+                break
+    elif mode == 'brochures':
+        for brochure in user_data:
+            if brochure.get('id') == item_id and contact_id:
+                for contact in brochure.get('contacts', []):
+                    if contact.get('id') == contact_id:
+                        contact[field] = value
+                        item_found_in_json = True
+                        break
+                if item_found_in_json: break
+    if item_found_in_json:
+        _save_user_data(user_api_key, mode, user_data)
+        
+        # Step 1.5: Update ChromaDB (RAG knowledge base)
+        try:
+            if mode == 'cards':
+                # Get the updated card data
+                updated_card = next((c for c in user_data if c.get('id') == item_id), None)
+                if updated_card:
+                    # Remove old document and re-add with updated content
+                    rag_core.remove_document_from_knowledge_base(user_api_key, item_id, mode)
+                    raw_text = ' '.join(str(v) for k, v in updated_card.items() if v and k not in ['id', 'image_filename'])
+                    rag_core.add_document_to_knowledge_base(user_api_key, raw_text, item_id, mode)
+                    print(f"ChromaDB: Updated document {item_id} in {mode} knowledge base")
+        except Exception as e:
+            print(f"ChromaDB update warning: {e}")
+
+    # ## FINAL DATABASE CODE ##
+    # Step 2: Update Database (New Logic)
+    try:
+        user_hash = hashlib.sha256(user_api_key.encode()).hexdigest()
+        if mode == 'cards':
+            db_card = BusinessCard.query.filter_by(json_id=item_id, user_hash=user_hash).first()
+            if db_card:
+                field_map = {"Owner Name": "owner_name", "Company Name": "company_name", "Email": "email", "Number": "phone_number", "Address": "address"}
+                db_field = field_map.get(field)
+                if db_field:
+                    setattr(db_card, db_field, value)
+                    db.session.commit()
+                    print(f"Database updated for business card json_id: {item_id}")
+                    return jsonify({"success": True})
+        elif mode == 'brochures' and contact_id:
+            db_contact = Contact.query.filter_by(json_id=contact_id).first()
+            if db_contact and db_contact.brochure.user_hash == user_hash:
+                field_map = {"Owner Name": "owner_name", "Email": "email", "Number": "phone_number"}
+                db_field = field_map.get(field)
+                if db_field:
+                    setattr(db_contact, db_field, value)
+                    db.session.commit()
+                    print(f"Database updated for brochure contact json_id: {contact_id}")
+                    return jsonify({"success": True})
+        
+        if not item_found_in_json:
+            return jsonify({"success": False, "message": "Item not found in JSON"}), 404
+        return jsonify({"success": True, "message": "JSON updated, but item not found in DB."})
+
+    except Exception as e:
+        db.session.rollback()
+        print(f"DATABASE ERROR: Failed to update record. Error: {e}")
+        return jsonify({"success": False, "message": "Database update failed."}), 500
+    # ## END FINAL DATABASE CODE ##
+
+
+@app.route('/delete_card/<mode>/<item_id>', methods=['DELETE'])
+def delete_card_endpoint(mode, item_id):
+    data = request.get_json()
+    contact_id = data.get('contactId')
+    user_api_key = OPENROUTER_API_KEY  # Use hardcoded server-side API key
+    if not user_api_key: return jsonify({'error': 'Server API key not configured'}), 400
+
+    # Step 1: Delete from JSON file (Existing Logic, Unchanged)
+    user_data = _load_user_data(user_api_key, mode)
+    item_found_in_json = False
+    original_len = len(user_data)
+    if mode == 'cards':
+        user_data = [c for c in user_data if c.get('id') != item_id]
+        if len(user_data) < original_len: item_found_in_json = True
+    elif mode == 'brochures':
+        if contact_id:
+            for brochure in user_data:
+                if brochure.get('id') == item_id:
+                    original_contacts_len = len(brochure.get('contacts', []))
+                    brochure['contacts'] = [c for c in brochure.get('contacts', []) if c.get('id') != contact_id]
+                    if len(brochure.get('contacts', [])) < original_contacts_len:
+                        item_found_in_json = True
+                        break
+        else: # Delete whole brochure
+             user_data = [b for b in user_data if b.get('id') != item_id]
+             if len(user_data) < original_len: item_found_in_json = True
+    if item_found_in_json:
+        _save_user_data(user_api_key, mode, user_data)
+    
+    # Step 1.5: Delete from ChromaDB (RAG knowledge base)
+    try:
+        if mode == 'cards' or (mode == 'brochures' and not contact_id):
+            # Remove document vectors from ChromaDB
+            rag_core.remove_document_from_knowledge_base(user_api_key, item_id, mode)
+            print(f"ChromaDB: Removed document {item_id} from {mode} knowledge base")
+    except Exception as e:
+        print(f"ChromaDB removal warning: {e}")
+    
+    # ## FINAL DATABASE CODE ##
+    # Step 2: Delete from Database (New Logic)
+    try:
+        user_hash = hashlib.sha256(user_api_key.encode()).hexdigest()
+        if mode == 'cards':
+            db_card = BusinessCard.query.filter_by(json_id=item_id, user_hash=user_hash).first()
+            if db_card:
+                db.session.delete(db_card)
+                db.session.commit()
+                print(f"Database record deleted for business card json_id: {item_id}")
+                return jsonify({"success": True})
+        elif mode == 'brochures':
+            if contact_id:
+                db_contact = Contact.query.filter_by(json_id=contact_id).first()
+                if db_contact and db_contact.brochure.user_hash == user_hash:
+                    db.session.delete(db_contact)
+                    db.session.commit()
+                    print(f"Database record deleted for brochure contact json_id: {contact_id}")
+                    return jsonify({"success": True})
+            else: # Delete whole brochure
+                db_brochure = Brochure.query.filter_by(json_id=item_id, user_hash=user_hash).first()
+                if db_brochure:
+                    db.session.delete(db_brochure) # Cascading delete will handle linked contacts
+                    db.session.commit()
+                    print(f"Database record deleted for brochure json_id: {item_id}")
+                    return jsonify({"success": True})
+
+        if not item_found_in_json:
+            return jsonify({"success": False, "message": "Item not found in JSON"}), 404
+        return jsonify({"success": True, "message": "JSON deleted, but item not found in DB."})
+
+    except Exception as e:
+        db.session.rollback()
+        print(f"DATABASE ERROR: Failed to delete record. Error: {e}")
+        return jsonify({"success": False, "message": "Database delete failed."}), 500
+    # ## END FINAL DATABASE CODE ##
+
+@app.route('/')
+def serve_dashboard():
+    return render_template('index.html')
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(UPLOAD_FOLDER, filename)
+
+# Health check endpoint - responds immediately without waiting for model loading
+@app.route('/health')
+def health_check():
+    return jsonify({"status": "ok", "message": "Service is running"}), 200
+
+# Create database tables (lightweight - runs at import time)
+with app.app_context():
+    db.create_all()
+    print("Database tables (business_card, brochure, contact) checked and created if necessary.")
+
+# Lazy initialization for RAG system (deferred until first request)
+_rag_initialized = False
+
+@app.before_request
+def ensure_rag_initialized():
+    global _rag_initialized
+    # Skip initialization for health checks and static files
+    if request.endpoint in ('health_check', 'uploaded_file', 'static', 'serve_dashboard'):
+        return
+    if not _rag_initialized:
+        print("First request received - initializing RAG system...")
+        try:
+            success = rag_core.initialize_rag_system()
+            _rag_initialized = True
+            if success:
+                print("RAG system initialized successfully!")
+            else:
+                print("RAG system not available - OCR features will still work")
+        except Exception as e:
+            print(f"RAG initialization error (non-fatal): {e}")
+            _rag_initialized = True  # Mark as attempted so we don't retry
+
+if __name__ == "__main__":
+    # Local development - initialize immediately for better dev experience
+    try:
+        rag_core.initialize_rag_system()
+    except Exception as e:
+        print(f"RAG initialization failed: {e}")
+        print("App will start without RAG features")
+    print("--- Server is starting! ---")
+    print(f"User-specific data will be saved in '{os.path.abspath(DATA_FOLDER)}'")
+    print("To use the dashboard, open your web browser and go to: http://127.0.0.1:5000")
+    webbrowser.open_new('http://127.0.0.1:5000')
+    app.run(host='0.0.0.0', port=5000, debug=False, use_reloader=False)

download_nltk.py

@@ -0,0 +1,44 @@
+import nltk
+import os
+import ssl
+
+# --- This part is crucial to bypass potential SSL certificate verification issues ---
+try:
+    _create_unverified_https_context = ssl._create_unverified_context
+except AttributeError:
+    pass
+else:
+    ssl._create_default_https_context = _create_unverified_https_context
+# --- End of SSL fix ---
+
+# Define the local directory to store NLTK data
+DOWNLOAD_DIR = os.path.join(os.path.dirname(__file__), 'nltk_data')
+
+# Create the directory if it doesn't exist
+if not os.path.exists(DOWNLOAD_DIR):
+    os.makedirs(DOWNLOAD_DIR)
+    print(f"Created directory: {DOWNLOAD_DIR}")
+
+# Download the necessary packages to our local directory
+print(f"Downloading NLTK packages to: {DOWNLOAD_DIR}")
+nltk.download('punkt', download_dir=DOWNLOAD_DIR)
+nltk.download('stopwords', download_dir=DOWNLOAD_DIR)
+nltk.download('punkt_tab', download_dir=DOWNLOAD_DIR)
+
+print("\n✅ All necessary NLTK packages have been downloaded successfully.")
+
+# Pre-download sentence-transformer models for faster startup
+# These are cached by the library and will be reused at runtime
+print("\nPre-downloading ML models for faster startup (this may take a few minutes)...")
+try:
+    from sentence_transformers import SentenceTransformer, CrossEncoder
+    print("  - Downloading SentenceTransformer model...")
+    SentenceTransformer('all-mpnet-base-v2')
+    print("  - Downloading CrossEncoder model...")
+    CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+    print("✅ ML models cached successfully!")
+except Exception as e:
+    print(f"⚠️ Warning: Could not pre-download ML models: {e}")
+    print("   Models will be downloaded on first request.")
+
+print("\nYou can now run your main application.")

gunicorn.conf.py

@@ -0,0 +1,30 @@
+# Gunicorn configuration for Render deployment
+# See: https://docs.gunicorn.org/en/stable/settings.html
+
+import os
+
+# CRITICAL: Bind to the PORT environment variable that Render provides
+# This is the most important setting for Render deployment
+bind = f"0.0.0.0:{os.environ.get('PORT', '10000')}"
+
+# Allow 5 minutes for heavy model loading on first request
+timeout = 300
+
+# Graceful timeout for shutdown
+graceful_timeout = 120
+
+# Single worker for memory efficiency on free tier
+workers = 1
+
+# Don't preload app - defer initialization until worker starts
+preload_app = False
+
+# Log level for debugging
+loglevel = "info"
+
+# Enable access logging for debugging
+accesslog = "-"
+errorlog = "-"
+
+# Print startup message
+print(f"Gunicorn binding to: {bind}")

models.py

@@ -0,0 +1,612 @@
+# models.py - UPDATED
+
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime, date
+from sqlalchemy import Text
+import json
+
+db = SQLAlchemy()
+
+# Business Card Model
+class BusinessCard(db.Model):
+    __tablename__ = 'business_cards'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    json_id = db.Column(db.String(64), unique=True, nullable=False)  
+    owner_name = db.Column(db.String(200), nullable=False)
+    company_name = db.Column(db.String(200))
+    email = db.Column(db.String(120))
+    phone_number = db.Column(db.String(50))
+    address = db.Column(db.Text)
+    source_document = db.Column(db.String(500))
+    user_hash = db.Column(db.String(64), nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.json_id,
+            'Owner Name': self.owner_name,
+            'Company Name': self.company_name,
+            'Email': self.email,
+            'Number': self.phone_number,
+            'Address': self.address,
+            'source_document': self.source_document,
+            'image_filename': f"{self.json_id}.png",
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# Brochure Model
+class Brochure(db.Model):
+    __tablename__ = 'brochures'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    json_id = db.Column(db.String(64), unique=True, nullable=False)
+    company_name = db.Column(db.String(200), nullable=False)
+    raw_text = db.Column(db.Text)
+    source_document = db.Column(db.String(500))
+    user_hash = db.Column(db.String(64), nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    contacts = db.relationship('Contact', backref='brochure', lazy=True, cascade='all, delete-orphan')
+
+    def to_dict(self):
+        return {
+            'id': self.json_id,
+            'company_name': self.company_name,
+            'raw_text': self.raw_text,
+            'contacts': [contact.to_dict() for contact in self.contacts],
+            'image_filename': f"{self.json_id}.pdf",
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# Contact Model (for Brochures)
+class Contact(db.Model):
+    __tablename__ = 'brochure_contacts'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    json_id = db.Column(db.String(64), unique=True, nullable=False)
+    brochure_id = db.Column(db.Integer, db.ForeignKey('brochures.id'), nullable=False)
+    owner_name = db.Column(db.String(200), nullable=False)
+    email = db.Column(db.String(120))
+    phone_number = db.Column(db.String(50))
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.json_id,
+            'Owner Name': self.owner_name,
+            'Email': self.email,
+            'Number': self.phone_number,
+            'brochure_id': self.brochure_id,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# User Model for CRM - ENHANCED
+class User(db.Model):
+    __tablename__ = 'users'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    password_hash = db.Column(db.String(255), nullable=False)
+    email = db.Column(db.String(120))
+    name = db.Column(db.String(100))
+    phone = db.Column(db.String(20))
+    department = db.Column(db.String(100))
+    role = db.Column(db.String(20), default='employee')
+    status = db.Column(db.String(20), default='active')
+    dark_mode = db.Column(db.Boolean, default=False)  # NEW: Dark mode preference
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    last_login = db.Column(db.DateTime)
+    
+    # Relationships
+    contacts_assigned = db.relationship('CRMContact', foreign_keys='CRMContact.assigned_to', backref='assigned_user', lazy=True)
+    deals_assigned = db.relationship('Deal', foreign_keys='Deal.assigned_to', backref='assigned_user', lazy=True)
+    tasks_assigned = db.relationship('Task', foreign_keys='Task.assigned_to', backref='assigned_user', lazy=True)
+    activities = db.relationship('Activity', backref='user', lazy=True)
+    comments = db.relationship('Comment', backref='user', lazy=True)
+    notifications = db.relationship('Notification', backref='user', lazy=True)
+    # In User model
+    task_assignments_created = db.relationship(
+    'TaskAssignment',
+    foreign_keys='TaskAssignment.assigned_by',
+    backref='assigner',
+    lazy=True
+    )
+
+    task_assignments_received = db.relationship(
+    'TaskAssignment',
+    foreign_keys='TaskAssignment.user_id',
+    backref='assignee',
+    lazy=True
+    )
+
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'username': self.username,
+            'email': self.email,
+            'name': self.name,
+            'phone': self.phone,
+            'department': self.department,
+            'role': self.role,
+            'status': self.status,
+            'dark_mode': self.dark_mode,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+            'last_login': self.last_login.isoformat() if self.last_login else None
+        }
+
+# Company Model for CRM - ENHANCED
+class Company(db.Model):
+    __tablename__ = 'companies'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(200), unique=True, nullable=False)
+    industry = db.Column(db.String(100))
+    size = db.Column(db.String(50))
+    website = db.Column(db.String(200))
+    description = db.Column(db.Text)
+    tags = db.Column(db.String(500))  # NEW: Tags for companies
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'industry': self.industry,
+            'size': self.size,
+            'website': self.website,
+            'description': self.description,
+            'tags': self.tags,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# CRM Contact Model - ENHANCED
+class CRMContact(db.Model):
+    __tablename__ = 'crm_contacts'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(200), nullable=False)
+    email = db.Column(db.String(120))
+    phone = db.Column(db.String(50))
+    company = db.Column(db.String(200))
+    position = db.Column(db.String(100))
+    tags = db.Column(db.String(500))
+    status = db.Column(db.String(50), nullable=True)
+    source = db.Column(db.String(100), default='manual')
+    assigned_to = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    notes = db.Column(db.Text)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # Relationships
+    deals = db.relationship('Deal', backref='contact', lazy=True)
+    tasks = db.relationship('Task', backref='contact', lazy=True)
+    activities = db.relationship('Activity', backref='contact', lazy=True)
+    comments = db.relationship('Comment', backref='contact', lazy=True)
+    attachments = db.relationship('Attachment', backref='contact', lazy=True)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'email': self.email,
+            'phone': self.phone,
+            'company': self.company,
+            'position': self.position,
+            'tags': self.tags,
+            'status': self.status,
+            'source': self.source,
+            'assigned_to': self.assigned_to,
+            'notes': self.notes,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# Deal Model - ENHANCED with tags
+class Deal(db.Model):
+    __tablename__ = 'deals'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String(200), nullable=False)
+    company = db.Column(db.String(200))
+    value = db.Column(db.Float, default=0.0)
+    stage = db.Column(db.String(50), default='lead')
+    probability = db.Column(db.Integer, default=0)
+    contact_id = db.Column(db.Integer, db.ForeignKey('crm_contacts.id'))
+    assigned_to = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    expected_close = db.Column(db.Date)
+    tags = db.Column(db.String(500))  # ENHANCED: Tags for deals
+    description = db.Column(db.Text)
+    created_date = db.Column(db.Date, default=datetime.utcnow)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # Relationships
+    activities = db.relationship('Activity', backref='deal', lazy=True)
+    comments = db.relationship('Comment', backref='deal', lazy=True)
+    attachments = db.relationship('Attachment', backref='deal', lazy=True)
+    tasks = db.relationship('Task', backref='deal', lazy=True)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'title': self.title,
+            'company': self.company,
+            'value': self.value,
+            'stage': self.stage,
+            'probability': self.probability,
+            'contact_id': self.contact_id,
+            'assigned_to': self.assigned_to,
+            'expected_close': self.expected_close.isoformat() if self.expected_close else None,
+            'tags': self.tags,
+            'description': self.description,
+            'created_date': self.created_date.isoformat() if self.created_date else None,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# Task Model - ENHANCED with assignment and mentions
+class Task(db.Model):
+    __tablename__ = 'tasks'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String(200), nullable=False)
+    description = db.Column(db.Text)
+    due_date = db.Column(db.Date)
+    due_time = db.Column(db.Time)
+    priority = db.Column(db.String(20), default='medium')
+    assigned_to = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    contact_id = db.Column(db.Integer, db.ForeignKey('crm_contacts.id'))
+    deal_id = db.Column(db.Integer, db.ForeignKey('deals.id'))
+    completed = db.Column(db.Boolean, default=False)
+    completed_date = db.Column(db.DateTime)
+    tags = db.Column(db.String(500))  # ENHANCED: Tags for tasks
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    # Calendar fields
+    event_type = db.Column(db.String(20), default='task')
+    location = db.Column(db.String(200))
+    is_all_day = db.Column(db.Boolean, default=False)
+    reminder_minutes = db.Column(db.Integer, default=30)
+    # NEW: Mentions for tagging users
+    mentions = db.Column(db.String(500))  # Store mentioned user IDs
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'title': self.title,
+            'description': self.description,
+            'due_date': self.due_date.isoformat() if self.due_date else None,
+            'due_time': self.due_time.isoformat() if self.due_time else None,
+            'priority': self.priority,
+            'assigned_to': self.assigned_to,
+            'contact_id': self.contact_id,
+            'deal_id': self.deal_id,
+            'completed': self.completed,
+            'completed_date': self.completed_date.isoformat() if self.completed_date else None,
+            'tags': self.tags,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+            'event_type': self.event_type,
+            'location': self.location,
+            'is_all_day': self.is_all_day,
+            'reminder_minutes': self.reminder_minutes,
+            'mentions': self.mentions
+        }
+
+# Task Assignment Model - NEW
+class TaskAssignment(db.Model):
+    __tablename__ = 'task_assignments'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'), nullable=False)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    assigned_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    due_date = db.Column(db.Date)
+    notes = db.Column(db.Text)
+    status = db.Column(db.String(20), default='assigned')
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'task_id': self.task_id,
+            'user_id': self.user_id,
+            'assigned_by': self.assigned_by,
+            'due_date': self.due_date.isoformat() if self.due_date else None,
+            'notes': self.notes,
+            'status': self.status,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# Activity Model (Audit Log) - ENHANCED
+class Activity(db.Model):
+    __tablename__ = 'activities'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    contact_id = db.Column(db.Integer, db.ForeignKey('crm_contacts.id'))
+    deal_id = db.Column(db.Integer, db.ForeignKey('deals.id'))
+    task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    action = db.Column(db.String(100), nullable=False)
+    description = db.Column(db.Text)
+    entity_type = db.Column(db.String(50))  # NEW: contact, deal, task, company
+    entity_id = db.Column(db.Integer)  # NEW: ID of the entity
+    old_values = db.Column(db.Text)  # NEW: JSON string of old values
+    new_values = db.Column(db.Text)  # NEW: JSON string of new values
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'contact_id': self.contact_id,
+            'deal_id': self.deal_id,
+            'task_id': self.task_id,
+            'user_id': self.user_id,
+            'action': self.action,
+            'description': self.description,
+            'entity_type': self.entity_type,
+            'entity_id': self.entity_id,
+            'old_values': json.loads(self.old_values) if self.old_values else None,
+            'new_values': json.loads(self.new_values) if self.new_values else None,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None
+        }
+
+# Attachment Model - ENHANCED
+class Attachment(db.Model):
+    __tablename__ = 'attachments'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    contact_id = db.Column(db.Integer, db.ForeignKey('crm_contacts.id'))
+    deal_id = db.Column(db.Integer, db.ForeignKey('deals.id'))
+    task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
+    filename = db.Column(db.String(255), nullable=False)
+    file_path = db.Column(db.String(500), nullable=False)
+    file_size = db.Column(db.Integer)
+    file_type = db.Column(db.String(100))
+    uploaded_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    uploaded_at = db.Column(db.DateTime, default=datetime.utcnow)
+    description = db.Column(db.Text)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'contact_id': self.contact_id,
+            'deal_id': self.deal_id,
+            'task_id': self.task_id,
+            'filename': self.filename,
+            'file_path': self.file_path,
+            'file_size': self.file_size,
+            'file_type': self.file_type,
+            'uploaded_by': self.uploaded_by,
+            'uploaded_at': self.uploaded_at.isoformat() if self.uploaded_at else None,
+            'description': self.description
+        }
+
+# Comment Model - ENHANCED with mentions
+class Comment(db.Model):
+    __tablename__ = 'comments'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    contact_id = db.Column(db.Integer, db.ForeignKey('crm_contacts.id'))
+    deal_id = db.Column(db.Integer, db.ForeignKey('deals.id'))
+    task_id = db.Column(db.Integer, db.ForeignKey('tasks.id'))
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    text = db.Column(db.Text, nullable=False)
+    mentions = db.Column(db.String(500))  # NEW: Store mentioned user IDs
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'contact_id': self.contact_id,
+            'deal_id': self.deal_id,
+            'task_id': self.task_id,
+            'user_id': self.user_id,
+            'text': self.text,
+            'mentions': self.mentions,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None
+        }
+
+# Notification Model - ENHANCED
+class Notification(db.Model):
+    __tablename__ = 'notifications'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    title = db.Column(db.String(200), nullable=False)
+    message = db.Column(db.Text, nullable=False)
+    type = db.Column(db.String(50), default='info')
+    read = db.Column(db.Boolean, default=False)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+    link = db.Column(db.String(500))
+    category = db.Column(db.String(50), default='system')
+    is_urgent = db.Column(db.Boolean, default=False)
+    # NEW: For task assignments and mentions
+    related_entity_type = db.Column(db.String(50))  # task, deal, contact
+    related_entity_id = db.Column(db.Integer)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'title': self.title,
+            'message': self.message,
+            'type': self.type,
+            'read': self.read,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None,
+            'link': self.link,
+            'category': self.category,
+            'is_urgent': self.is_urgent,
+            'related_entity_type': self.related_entity_type,
+            'related_entity_id': self.related_entity_id
+        }
+
+# Reminder Model - NEW
+class Reminder(db.Model):
+    __tablename__ = 'reminders'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    title = db.Column(db.String(200), nullable=False)
+    description = db.Column(db.Text)
+    remind_at = db.Column(db.DateTime, nullable=False)
+    is_completed = db.Column(db.Boolean, default=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'title': self.title,
+            'description': self.description,
+            'remind_at': self.remind_at.isoformat() if self.remind_at else None,
+            'is_completed': self.is_completed,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# System Settings Model
+class SystemSetting(db.Model):
+    __tablename__ = 'system_settings'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    key = db.Column(db.String(100), unique=True, nullable=False)
+    value = db.Column(db.Text)
+    description = db.Column(db.String(500))
+    category = db.Column(db.String(50), default='general')
+    updated_by = db.Column(db.Integer, db.ForeignKey('users.id'))
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'key': self.key,
+            'value': self.value,
+            'description': self.description,
+            'category': self.category,
+            'updated_by': self.updated_by,
+            'updated_at': self.updated_at.isoformat() if self.updated_at else None
+        }
+
+# AI Chat History Model
+class AIChatHistory(db.Model):
+    __tablename__ = 'ai_chat_history'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    question = db.Column(db.Text, nullable=False)
+    answer = db.Column(db.Text, nullable=False)
+    category = db.Column(db.String(50), default='general')
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'question': self.question,
+            'answer': self.answer,
+            'category': self.category,
+            'timestamp': self.timestamp.isoformat() if self.timestamp else None
+        }
+
+# AI Insights Model
+class AIInsight(db.Model):
+    __tablename__ = 'ai_insights'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    insight_type = db.Column(db.String(50), nullable=False)
+    title = db.Column(db.String(200), nullable=False)
+    description = db.Column(db.Text, nullable=False)
+    data = db.Column(db.Text)
+    confidence = db.Column(db.Float, default=0.0)
+    is_active = db.Column(db.Boolean, default=True)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    expires_at = db.Column(db.DateTime)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'insight_type': self.insight_type,
+            'title': self.title,
+            'description': self.description,
+            'data': json.loads(self.data) if self.data else {},
+            'confidence': self.confidence,
+            'is_active': self.is_active,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'expires_at': self.expires_at.isoformat() if self.expires_at else None
+        }
+
+# Bulk Message Campaign Model - NEW
+class BulkMessageCampaign(db.Model):
+    __tablename__ = 'bulk_message_campaigns'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(200), nullable=False)
+    message_type = db.Column(db.String(20), nullable=False)  # email, whatsapp
+    subject = db.Column(db.String(300))
+    message = db.Column(db.Text, nullable=False)
+    contact_ids = db.Column(db.Text)  # JSON array of contact IDs
+    filters = db.Column(db.Text)  # JSON filter criteria
+    sent_count = db.Column(db.Integer, default=0)
+    total_contacts = db.Column(db.Integer, default=0)
+    status = db.Column(db.String(20), default='draft')  # draft, sending, completed, failed
+    created_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    sent_at = db.Column(db.DateTime)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'message_type': self.message_type,
+            'subject': self.subject,
+            'message': self.message,
+            'contact_ids': json.loads(self.contact_ids) if self.contact_ids else [],
+            'filters': json.loads(self.filters) if self.filters else {},
+            'sent_count': self.sent_count,
+            'total_contacts': self.total_contacts,
+            'status': self.status,
+            'created_by': self.created_by,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'sent_at': self.sent_at.isoformat() if self.sent_at else None
+        }
+
+# Export History Model - NEW
+class ExportHistory(db.Model):
+    __tablename__ = 'export_history'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    export_type = db.Column(db.String(50), nullable=False)  # contacts, companies, deals, tasks, master
+    file_format = db.Column(db.String(20), nullable=False)  # excel, pdf
+    file_path = db.Column(db.String(500))
+    filters = db.Column(db.Text)  # JSON filter criteria
+    record_count = db.Column(db.Integer, default=0)
+    exported_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    exported_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'export_type': self.export_type,
+            'file_format': self.file_format,
+            'file_path': self.file_path,
+            'filters': json.loads(self.filters) if self.filters else {},
+            'record_count': self.record_count,
+            'exported_by': self.exported_by,
+            'exported_at': self.exported_at.isoformat() if self.exported_at else None
+        }

rag_core.py

@@ -0,0 +1,713 @@
+# rag_core.py - Chroma Cloud Integration
+
+import os
+import sys
+import numpy as np
+import json
+from sentence_transformers import SentenceTransformer, CrossEncoder
+import hashlib
+import requests
+import re
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import sent_tokenize, word_tokenize
+from nltk.stem import PorterStemmer
+from typing import List, Dict, Tuple
+import time
+from dotenv import load_dotenv
+import chromadb
+
+# Load environment variables
+load_dotenv()
+
+# --- ROBUST NLTK SETUP ---
+# Point NLTK to the local 'nltk_data' directory if it exists.
+# On Render, this is created during the build step by download_nltk.py
+local_nltk_data_path = os.path.join(os.path.dirname(__file__), 'nltk_data')
+if os.path.exists(local_nltk_data_path):
+    nltk.data.path.insert(0, local_nltk_data_path)
+# If nltk_data doesn't exist locally, NLTK will use default paths or download on-demand
+# --- END SETUP ---
+
+# Model configuration - matching app.py
+MODEL_MAP = {
+    'gemini': 'google/gemma-3-4b-it:free',
+    'deepseek': 'google/gemma-3-27b-it:free',
+    'qwen': 'mistralai/mistral-small-3.1-24b-instruct:free',
+    'nvidia': 'nvidia/nemotron-nano-12b-v2-vl:free',
+    'amazon': 'amazon/nova-2-lite-v1:free'
+}
+
+# Best → fallback order (OCR strength)
+FALLBACK_ORDER = [
+    'gemini',
+    'deepseek',
+    'qwen',
+    'nvidia',
+    'amazon'
+]
+
+# Chroma Cloud configuration
+CHROMA_TENANT = os.getenv("CHROMA_TENANT")
+CHROMA_DATABASE = os.getenv("CHROMA_DATABASE")
+CHROMA_API_KEY = os.getenv("CHROMA_API_KEY")
+
+embedding_model = None
+reranker_model = None
+chroma_client = None
+collections: Dict[str, chromadb.Collection] = {}
+keyword_indexes: Dict[str, Dict[str, Dict]] = {}
+
+EMBEDDING_DIM = 768
+CHUNK_SIZE = 300
+CHUNK_OVERLAP = 50
+
+# Track if RAG system is properly initialized
+_rag_system_available = False
+
+# Initialize components
+def initialize_rag_system():
+    """
+    Loads the embedding model, reranker, and connects to Chroma Cloud.
+    Returns True if successful, False otherwise.
+    """
+    global embedding_model, reranker_model, chroma_client, _rag_system_available
+    print("RAG Core: Initializing Advanced RAG System with Chroma Cloud...")
+    
+    # Validate Chroma Cloud credentials - graceful handling
+    if not all([CHROMA_TENANT, CHROMA_DATABASE, CHROMA_API_KEY]):
+        print("WARNING: Chroma Cloud credentials not found. RAG system will be disabled.")
+        print("         Set CHROMA_TENANT, CHROMA_DATABASE, and CHROMA_API_KEY to enable RAG.")
+        _rag_system_available = False
+        return False
+    
+    try:
+        # Connect to Chroma Cloud
+        print("RAG Core: Connecting to Chroma Cloud...")
+        chroma_client = chromadb.CloudClient(
+            tenant=CHROMA_TENANT,
+            database=CHROMA_DATABASE,
+            api_key=CHROMA_API_KEY
+        )
+        print("RAG Core: Successfully connected to Chroma Cloud!")
+        
+        print("RAG Core: Loading advanced embedding model...")
+        embedding_model = SentenceTransformer('all-mpnet-base-v2')
+        
+        print("RAG Core: Loading cross-encoder reranker...")
+        reranker_model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+        
+        print("RAG Core: Advanced models loaded successfully.")
+        _rag_system_available = True
+        return True
+        
+    except Exception as e:
+        print(f"ERROR: Failed to initialize RAG system: {e}")
+        print("       RAG system will be disabled. The app will still work for OCR.")
+        _rag_system_available = False
+        return False
+
+
+def is_rag_available():
+    """Check if RAG system is available."""
+    return _rag_system_available
+
+
+def _call_openrouter_api_with_fallback(api_key, selected_model_key, prompt):
+    """
+    Calls OpenRouter API with fallback support for text-only requests.
+    """
+    # Start with the selected model, then try others in fallback order
+    models_to_try = [selected_model_key]
+    for model in FALLBACK_ORDER:
+        if model != selected_model_key:
+            models_to_try.append(model)
+    
+    last_error = None
+    
+    for model_key in models_to_try:
+        model_name = MODEL_MAP.get(model_key)
+        if not model_name:
+            continue
+            
+        print(f"RAG: Attempting API call with model: {model_name}...")
+        
+        try:
+            response = requests.post(
+                url="https://openrouter.ai/api/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": model_name,
+                    "messages": [{"role": "user", "content": prompt}]
+                }
+            )
+            response.raise_for_status()
+            api_response = response.json()
+            
+            if 'choices' not in api_response or not api_response['choices']:
+                print(f"RAG: Model {model_name} returned unexpected response format")
+                last_error = f"Model {model_name} returned unexpected response format"
+                continue
+            
+            result = api_response['choices'][0]['message']['content']
+            print(f"RAG: Successfully processed with model: {model_name}")
+            return result
+
+        except requests.exceptions.HTTPError as http_err:
+            error_msg = f"RAG: HTTP error for model {model_name}: {http_err}"
+            if hasattr(response, 'text'):
+                error_msg += f"\nResponse: {response.text}"
+            print(error_msg)
+            last_error = f"API request failed for {model_name} with status {response.status_code}."
+            continue
+        except Exception as e:
+            print(f"RAG: Error with model {model_name}: {e}")
+            last_error = f"An unexpected error occurred with model {model_name}."
+            continue
+    
+    # If all models failed, return a user-friendly error
+    return f"I'm having trouble connecting to the AI models right now. Please check your API key and try again. Last error: {last_error}"
+
+
+def _get_collection_name(user_api_key, mode):
+    """
+    Creates a unique collection name for a user based on a hash of their API key.
+    """
+    user_hash = hashlib.sha256(user_api_key.encode()).hexdigest()[:16]
+    return f"{user_hash}_{mode}"
+
+
+def _get_or_create_collection(user_api_key, mode):
+    """
+    Gets or creates a ChromaDB collection for the user/mode combination.
+    """
+    collection_name = _get_collection_name(user_api_key, mode)
+    
+    if collection_name in collections:
+        return collections[collection_name]
+    
+    print(f"RAG Core: Getting/creating collection '{collection_name}' in Chroma Cloud")
+    collection = chroma_client.get_or_create_collection(
+        name=collection_name,
+        metadata={"hnsw:space": "cosine"}  # Use cosine similarity
+    )
+    collections[collection_name] = collection
+    
+    # Load keyword index from collection if exists
+    _load_keyword_index(user_api_key, mode)
+    
+    return collection
+
+
+def _load_keyword_index(user_api_key, mode):
+    """
+    Loads keyword index from Chroma Cloud collection metadata.
+    """
+    collection_name = _get_collection_name(user_api_key, mode)
+    
+    if mode not in keyword_indexes:
+        keyword_indexes[mode] = {}
+    
+    if user_api_key in keyword_indexes[mode]:
+        return
+    
+    try:
+        collection = collections.get(collection_name)
+        if collection:
+            # Try to get keyword index document
+            results = collection.get(
+                ids=["__keyword_index__"],
+                include=["documents"]
+            )
+            if results and results['documents'] and results['documents'][0]:
+                keyword_indexes[mode][user_api_key] = json.loads(results['documents'][0])
+                print(f"RAG Core: Loaded keyword index from Chroma Cloud")
+            else:
+                keyword_indexes[mode][user_api_key] = {"documents": {}, "vocabulary": {}, "entities": {}}
+        else:
+            keyword_indexes[mode][user_api_key] = {"documents": {}, "vocabulary": {}, "entities": {}}
+    except Exception as e:
+        print(f"RAG Core: Could not load keyword index: {e}")
+        keyword_indexes[mode][user_api_key] = {"documents": {}, "vocabulary": {}, "entities": {}}
+
+
+def _save_keyword_index(user_api_key, mode):
+    """
+    Saves keyword index to Chroma Cloud collection.
+    """
+    collection_name = _get_collection_name(user_api_key, mode)
+    collection = collections.get(collection_name)
+    
+    if not collection or mode not in keyword_indexes or user_api_key not in keyword_indexes[mode]:
+        return
+    
+    keyword_data = json.dumps(keyword_indexes[mode][user_api_key])
+    
+    try:
+        # Upsert the keyword index document
+        collection.upsert(
+            ids=["__keyword_index__"],
+            documents=[keyword_data],
+            metadatas=[{"type": "keyword_index"}]
+        )
+        print("RAG Core: Saved keyword index to Chroma Cloud")
+    except Exception as e:
+        print(f"RAG Core: Error saving keyword index: {e}")
+
+
+def _smart_chunking(text, chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP):
+    """
+    Intelligent chunking that preserves context and meaning.
+    """
+    if not isinstance(text, str) or not text.strip():
+        return []
+    
+    paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+    
+    chunks = []
+    current_chunk = ""
+    
+    for paragraph in paragraphs:
+        if len(current_chunk) + len(paragraph) <= chunk_size:
+            if current_chunk:
+                current_chunk += "\n\n" + paragraph
+            else:
+                current_chunk = paragraph
+        else:
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+            
+            if len(paragraph) > chunk_size:
+                sentences = nltk.sent_tokenize(paragraph)
+                temp_chunk = ""
+                
+                for sentence in sentences:
+                    if len(temp_chunk) + len(sentence) <= chunk_size:
+                        temp_chunk += " " + sentence if temp_chunk else sentence
+                    else:
+                        if temp_chunk:
+                            chunks.append(temp_chunk.strip())
+                        temp_chunk = sentence
+                
+                current_chunk = temp_chunk
+            else:
+                current_chunk = paragraph
+    
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+    
+    final_chunks = []
+    for i, chunk in enumerate(chunks):
+        if i > 0 and chunk_overlap > 0:
+            prev_words = chunks[i-1].split()[-chunk_overlap:]
+            if prev_words:
+                chunk = " ".join(prev_words) + " " + chunk
+        final_chunks.append(chunk)
+    
+    return final_chunks
+
+
+def _enhanced_query_expansion(query: str) -> List[str]:
+    """
+    Advanced query expansion with business context awareness.
+    """
+    query_lower = query.lower()
+    expanded_queries = {query}
+    
+    business_expansions = {
+        r"\bgeneral manager\b": ["GM", "manager", "head", "director", "chief"],
+        r"\bCEO\b": ["chief executive officer", "president", "director"],
+        r"\bCFO\b": ["chief financial officer", "finance director"],
+        r"\blocation\b": ["address", "located", "office", "headquarters", "branch"],
+        r"\boffice\b": ["location", "branch", "headquarters", "situated"],
+        r"\bservices\b": ["offerings", "products", "solutions", "business"],
+        r"\bcompany\b": ["business", "organization", "firm", "corporation", "enterprise"],
+        r"\bcontact\b": ["reach", "get in touch", "communicate"],
+        r"\bbranch\b": ["office", "location", "division", "subsidiary"],
+        r"\bheadquarters\b": ["main office", "head office", "corporate office"],
+    }
+    
+    location_patterns = {
+        r"\bhong\s*kong\b": ["HK", "hongkong"],
+        r"\bsingapore\b": ["SG", "sing"],
+        r"\bunited\s*states\b": ["USA", "US", "America"],
+        r"\bunited\s*kingdom\b": ["UK", "Britain"],
+    }
+    
+    for pattern, replacements in business_expansions.items():
+        if re.search(pattern, query_lower):
+            for replacement in replacements:
+                expanded_query = re.sub(pattern, replacement, query, flags=re.IGNORECASE)
+                expanded_queries.add(expanded_query)
+    
+    for pattern, replacements in location_patterns.items():
+        if re.search(pattern, query_lower):
+            for replacement in replacements:
+                expanded_query = re.sub(pattern, replacement, query, flags=re.IGNORECASE)
+                expanded_queries.add(expanded_query)
+    
+    return list(expanded_queries)
+
+
+def _build_enhanced_keyword_index(text, doc_id, user_api_key, mode):
+    """
+    Build an enhanced keyword index with business context awareness.
+    """
+    if not isinstance(text, str) or not text.strip():
+        return
+
+    if mode not in keyword_indexes:
+        keyword_indexes[mode] = {}
+    
+    if user_api_key not in keyword_indexes[mode]:
+        keyword_indexes[mode][user_api_key] = {"documents": {}, "vocabulary": {}, "entities": {}}
+    
+    keyword_index = keyword_indexes[mode][user_api_key]
+    
+    words = re.findall(r'\b[a-zA-Z]{2,}\b', text.lower())
+    stop_words = set(stopwords.words('english'))
+    ps = PorterStemmer()
+    
+    business_entities = re.findall(r'\b[A-Z][a-zA-Z&\s]{1,30}(?:Ltd|Inc|Corp|Company|Group|Holdings|Limited|Corporation|Enterprise|Solutions)\b', text)
+    locations = re.findall(r'\b[A-Z][a-zA-Z\s]{2,20}(?:Street|Road|Avenue|Lane|Drive|Plaza|Square|Center|Centre|Building|Tower|Floor)\b', text)
+    
+    for word in words:
+        if word not in stop_words and len(word) > 2:
+            stemmed = ps.stem(word)
+            if stemmed not in keyword_index["vocabulary"]:
+                keyword_index["vocabulary"][stemmed] = []
+            
+            if doc_id not in keyword_index["vocabulary"][stemmed]:
+                keyword_index["vocabulary"][stemmed].append(doc_id)
+    
+    if "entities" not in keyword_index:
+        keyword_index["entities"] = {}
+    
+    for entity in business_entities + locations:
+        entity_key = entity.lower()
+        if entity_key not in keyword_index["entities"]:
+            keyword_index["entities"][entity_key] = []
+        if doc_id not in keyword_index["entities"][entity_key]:
+            keyword_index["entities"][entity_key].append(doc_id)
+    
+    keyword_index["documents"][doc_id] = {
+        "text": text,
+        "length": len(text),
+        "word_count": len(words),
+        "entities": business_entities + locations
+    }
+
+
+def _enhanced_keyword_search(query, user_api_key, mode, top_k=10):
+    """
+    Enhanced keyword search with business context awareness.
+    """
+    if mode not in keyword_indexes or user_api_key not in keyword_indexes[mode]:
+        return []
+    
+    keyword_index = keyword_indexes[mode][user_api_key]
+    ps = PorterStemmer()
+    
+    query_terms = [ps.stem(term) for term in query.lower().split()
+                   if term not in stopwords.words('english') and len(term) > 2]
+    
+    entity_matches = []
+    if "entities" in keyword_index:
+        for entity, docs in keyword_index["entities"].items():
+            if any(term in entity for term in query.lower().split()):
+                entity_matches.extend(docs)
+    
+    doc_scores: Dict[str, float] = {}
+    
+    for term in query_terms:
+        if term in keyword_index.get("vocabulary", {}):
+            for doc_id in keyword_index["vocabulary"][term]:
+                if doc_id not in doc_scores:
+                    doc_scores[doc_id] = 0
+                doc_scores[doc_id] += 1.0
+    
+    for doc_id in entity_matches:
+        if doc_id not in doc_scores:
+            doc_scores[doc_id] = 0
+        doc_scores[doc_id] += 2.0
+    
+    final_scores = {}
+    for doc_id, score in doc_scores.items():
+        if doc_id in keyword_index.get("documents", {}):
+            doc_length = keyword_index["documents"][doc_id].get("word_count", 1)
+            final_scores[doc_id] = score / (1 + np.log(1 + doc_length))
+
+    sorted_docs = sorted(final_scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
+    return [doc_id for doc_id, score in sorted_docs]
+
+
+def add_document_to_knowledge_base(user_api_key, document_text, document_id, mode):
+    """
+    Processes a document's text and adds it to the knowledge base with Chroma Cloud.
+    """
+    try:
+        print(f"\nRAG: Adding document '{document_id}' to Chroma Cloud...")
+        collection = _get_or_create_collection(user_api_key, mode)
+
+        chunks = _smart_chunking(document_text)
+        print(f"RAG: Created {len(chunks)} intelligent chunks")
+
+        _build_enhanced_keyword_index(document_text, document_id, user_api_key, mode)
+        print("RAG: Built enhanced keyword index")
+
+        if not chunks:
+            print("RAG: No chunks to vectorize, saving keyword index only")
+            _save_keyword_index(user_api_key, mode)
+            return
+
+        chunk_embeddings = embedding_model.encode(chunks, normalize_embeddings=True)
+        print("RAG: Generated embeddings")
+
+        # Prepare data for Chroma
+        ids = [f"{document_id}_chunk_{i}" for i in range(len(chunks))]
+        metadatas = [
+            {
+                "source_doc": document_id,
+                "chunk_id": i,
+                "length": len(chunk),
+                "type": "document_chunk"
+            }
+            for i, chunk in enumerate(chunks)
+        ]
+        
+        # Add to Chroma Cloud
+        collection.upsert(
+            ids=ids,
+            embeddings=chunk_embeddings.tolist(),
+            documents=chunks,
+            metadatas=metadatas
+        )
+        
+        # Save keyword index
+        _save_keyword_index(user_api_key, mode)
+        
+        print(f"RAG: Successfully indexed document to Chroma Cloud. Total chunks: {len(chunks)}")
+
+    except Exception as e:
+        print(f"CRITICAL ERROR in add_document_to_knowledge_base: {e}")
+        import traceback
+        traceback.print_exc()
+        raise e
+
+
+def remove_document_from_knowledge_base(user_api_key, document_id, mode):
+    """
+    Removes all chunks associated with a document from Chroma Cloud.
+    """
+    try:
+        collection = _get_or_create_collection(user_api_key, mode)
+        
+        # Delete all chunks from this document using where filter
+        collection.delete(
+            where={"source_doc": document_id}
+        )
+        
+        # Update keyword index
+        if mode in keyword_indexes and user_api_key in keyword_indexes[mode]:
+            keyword_index = keyword_indexes[mode][user_api_key]
+            
+            # Remove document from vocabulary
+            if "vocabulary" in keyword_index:
+                for term in list(keyword_index["vocabulary"].keys()):
+                    if document_id in keyword_index["vocabulary"][term]:
+                        keyword_index["vocabulary"][term].remove(document_id)
+                    if not keyword_index["vocabulary"][term]:
+                        del keyword_index["vocabulary"][term]
+            
+            # Remove document from entities
+            if "entities" in keyword_index:
+                for entity in list(keyword_index["entities"].keys()):
+                    if document_id in keyword_index["entities"][entity]:
+                        keyword_index["entities"][entity].remove(document_id)
+                    if not keyword_index["entities"][entity]:
+                        del keyword_index["entities"][entity]
+            
+            # Remove document metadata
+            if "documents" in keyword_index and document_id in keyword_index["documents"]:
+                del keyword_index["documents"][document_id]
+            
+            _save_keyword_index(user_api_key, mode)
+        
+        print(f"RAG: Removed document '{document_id}' from Chroma Cloud")
+        
+    except Exception as e:
+        print(f"Error removing document: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+def _advanced_hybrid_search(query, user_api_key, mode, top_k=10):
+    """
+    Advanced hybrid search using Chroma Cloud query.
+    """
+    collection = _get_or_create_collection(user_api_key, mode)
+    
+    # Check if collection has documents
+    try:
+        count = collection.count()
+        if count == 0:
+            return []
+    except:
+        return []
+
+    # Vector search with Chroma Cloud
+    expanded_queries = _enhanced_query_expansion(query)
+    all_results = {}
+    
+    for q in expanded_queries[:3]:  # Limit to avoid too much noise
+        query_embedding = embedding_model.encode([q], normalize_embeddings=True)
+        
+        try:
+            results = collection.query(
+                query_embeddings=query_embedding.tolist(),
+                n_results=min(top_k * 2, count),
+                where={"type": "document_chunk"},
+                include=["documents", "metadatas", "distances"]
+            )
+            
+            if results and results['ids'] and results['ids'][0]:
+                for i, (doc_id, doc, metadata, distance) in enumerate(zip(
+                    results['ids'][0],
+                    results['documents'][0],
+                    results['metadatas'][0],
+                    results['distances'][0]
+                )):
+                    # Convert distance to similarity score (Chroma returns L2 distance for cosine)
+                    score = 1 - distance if distance else 0
+                    if doc_id not in all_results or all_results[doc_id]['score'] < score:
+                        all_results[doc_id] = {
+                            'text': doc,
+                            'source_doc': metadata.get('source_doc', ''),
+                            'chunk_id': metadata.get('chunk_id', 0),
+                            'length': metadata.get('length', 0),
+                            'score': score
+                        }
+        except Exception as e:
+            print(f"RAG: Search error: {e}")
+            continue
+    
+    # Enhanced keyword search boost
+    keyword_doc_ids = set(_enhanced_keyword_search(query, user_api_key, mode, top_k=top_k*2))
+    
+    # Add keyword boost to scores
+    for doc_id, result in all_results.items():
+        if result.get('source_doc') in keyword_doc_ids:
+            result['score'] = result.get('score', 0) + 0.4
+    
+    # Sort and return top results
+    sorted_results = sorted(all_results.items(), key=lambda x: x[1]['score'], reverse=True)[:top_k]
+    return [result for doc_id, result in sorted_results]
+
+
+def _intelligent_rerank(query, candidate_chunks, top_k=5):
+    """
+    Intelligent reranking that considers both relevance and context completeness.
+    """
+    if not candidate_chunks or not reranker_model:
+        return candidate_chunks[:top_k]
+    
+    # Use cross-encoder for initial scoring
+    pairs = [(query, chunk["text"]) for chunk in candidate_chunks]
+    cross_encoder_scores = reranker_model.predict(pairs)
+    
+    # Additional scoring based on content completeness
+    enhanced_scores = []
+    for i, (chunk, ce_score) in enumerate(zip(candidate_chunks, cross_encoder_scores)):
+        text = chunk["text"]
+        
+        # Bonus for chunks that seem to contain complete information
+        completeness_bonus = 0
+        if any(marker in text.lower() for marker in ["located", "address", "office", "branch"]):
+            completeness_bonus += 0.1
+        if any(marker in text.lower() for marker in ["manager", "director", "ceo", "head"]):
+            completeness_bonus += 0.1
+        if any(marker in text.lower() for marker in ["company", "business", "organization"]):
+            completeness_bonus += 0.05
+        
+        final_score = ce_score + completeness_bonus
+        enhanced_scores.append((chunk, final_score))
+    
+    # Sort by enhanced scores and return top results
+    reranked = sorted(enhanced_scores, key=lambda x: x[1], reverse=True)
+    return [chunk for chunk, score in reranked[:top_k]]
+
+
+def query_knowledge_base(user_api_key, query_text, mode, selected_model_key):
+    """
+    Advanced query processing with human-like response generation using selected model with fallback.
+    """
+    collection = _get_or_create_collection(user_api_key, mode)
+    
+    try:
+        count = collection.count()
+        # Exclude keyword index from count
+        if count <= 1:
+            return "I don't have any documents in my knowledge base yet. Please upload some brochures or business cards first, and I'll be happy to help you find information from them!"
+    except:
+        return "I don't have any documents in my knowledge base yet. Please upload some brochures or business cards first, and I'll be happy to help you find information from them!"
+
+    print(f"RAG: Processing query: '{query_text}' with model: {selected_model_key}")
+    
+    # Advanced search with multiple strategies
+    expanded_queries = _enhanced_query_expansion(query_text)
+    print(f"RAG: Expanded to {len(expanded_queries)} query variations")
+    
+    all_candidates = []
+    seen_texts = set()
+    
+    for query in expanded_queries[:3]:  # Use top 3 expansions
+        candidates = _advanced_hybrid_search(query, user_api_key, mode, top_k=8)
+        for candidate in candidates:
+            text = candidate.get('text', '')
+            if text and text not in seen_texts:
+                seen_texts.add(text)
+                all_candidates.append(candidate)
+    
+    # Intelligent reranking
+    top_chunks = _intelligent_rerank(query_text, all_candidates, top_k=5)
+    
+    if not top_chunks:
+        return f"I couldn't find specific information about '{query_text}' in the uploaded documents. Could you try rephrasing your question or check if the information might be in a document that hasn't been uploaded yet?"
+
+    # Prepare context for AI model
+    context = "\n\n---DOCUMENT SECTION---\n\n".join([chunk["text"] for chunk in top_chunks])
+    print(f"RAG: Found {len(top_chunks)} relevant sections. Generating response with {selected_model_key}...")
+
+    try:
+        prompt = f"""You are a highly knowledgeable and helpful assistant who provides natural, conversational answers based on document information.
+
+**CRITICAL INSTRUCTIONS:**
+1. Answer the user's question in a natural, human-like way as if you're having a conversation
+2. Use the information from the document sections below to provide accurate, specific details
+3. If the user asks about a company, person, or location, provide comprehensive information from the documents
+4. Be direct and specific - if someone asks "where is X located" and you find the address, state it clearly
+5. If someone asks about a person's role, provide their title and any relevant details
+6. Write in a conversational tone, not like you're reading from a manual
+7. If you can't find the specific information requested, be honest but mention what related information you did find
+
+**USER'S QUESTION:**
+{query_text}
+
+**RELEVANT DOCUMENT SECTIONS:**
+{context}
+
+**YOUR NATURAL, CONVERSATIONAL RESPONSE:**"""
+        
+        response = _call_openrouter_api_with_fallback(user_api_key, selected_model_key, prompt)
+        return response
+        
+    except Exception as e:
+        print(f"RAG: An unexpected error occurred during response generation: {e}")
+        import traceback
+        traceback.print_exc()
+        return "I found relevant information but ran into an unexpected error while processing it. Please try again."

render.yaml

@@ -0,0 +1,20 @@
+services:
+  - type: web
+    name: visionextract-crm
+    runtime: python
+    buildCommand: pip install -r requirements.txt && python download_nltk.py
+    startCommand: gunicorn app:app --bind=0.0.0.0:$PORT --config gunicorn.conf.py
+    healthCheckPath: /health
+    envVars:
+      - key: CHROMA_TENANT
+        sync: false
+      - key: CHROMA_DATABASE
+        sync: false
+      - key: CHROMA_API_KEY
+        sync: false
+      - key: OPENROUTER_API_KEY
+        sync: false
+      - key: SESSION_SECRET
+        generateValue: true
+      - key: PYTHON_VERSION
+        value: "3.11.0"

requirements.txt

@@ -0,0 +1,13 @@
+flask
+flask-cors
+flask-sqlalchemy
+python-dotenv
+Pillow
+PyMuPDF
+requests
+chromadb
+nltk
+gunicorn
+sentence-transformers
+scikit-learn
+numpy

templates/index.html

@@ -0,0 +1,1429 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>VisionExtractAI | AI Command Center</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.2/css/all.min.css">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jspdf/2.5.1/jspdf.umd.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jspdf-autotable/3.5.23/jspdf.plugin.autotable.min.js"></script>
+    <style>
+        :root {
+            --bg-color: #0D0C14;
+            --surface-color: rgba(23, 22, 32, 0.5);
+            --border-color: rgba(255, 255, 255, 0.1);
+            --text-primary: #f0f0f5;
+            --text-secondary: #a1a1aa;
+            --accent-color: #9333ea;
+            --accent-hover: #a855f7;
+        }
+
+        body {
+            font-family: 'Inter', sans-serif;
+            background-color: var(--bg-color);
+            color: var(--text-primary);
+            overflow: hidden;
+        }
+
+        #hexagon-canvas {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 1;
+        }
+
+        .main-container {
+            position: relative;
+            z-index: 2;
+            height: 100vh;
+            overflow-y: auto;
+            overflow-x: hidden;
+        }
+
+        .page {
+            display: none;
+        }
+
+        .page.active {
+            display: block;
+            animation: fadeIn 0.7s ease-out forwards;
+        }
+
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(15px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .glass-card {
+            background-color: var(--surface-color);
+            border: 1px solid var(--border-color);
+            backdrop-filter: blur(16px);
+            -webkit-backdrop-filter: blur(16px);
+            transition: all 0.3s ease;
+        }
+
+        .glass-card:hover:not(.no-hover) {
+            border-color: var(--accent-color);
+            background-color: rgba(23, 22, 32, 0.7);
+        }
+
+        .chat-bubble,
+        .contact-card,
+        .brochure-row,
+        .model-choice-card {
+            animation: popIn 0.5s ease-out forwards;
+            opacity: 0;
+            transform: scale(0.95);
+        }
+
+        @keyframes popIn {
+            to {
+                opacity: 1;
+                transform: scale(1);
+            }
+        }
+
+        .contact-card {
+            transition: transform 0.3s ease, box-shadow 0.3s ease;
+        }
+
+        .contact-card:hover {
+            transform: translateY(-6px);
+            box-shadow: 0 0 30px rgba(147, 51, 234, 0.25);
+        }
+
+        .editable-field:hover {
+            background-color: rgba(255, 255, 255, 0.1);
+            cursor: pointer;
+            border-radius: 4px;
+        }
+
+        #chat-widget {
+            transition: transform 0.3s ease, box-shadow 0.3s ease;
+        }
+
+        #chat-widget:hover {
+            transform: scale(1.1);
+            box-shadow: 0 0 20px var(--accent-color);
+        }
+
+        #chat-panel {
+            transition: transform 0.4s cubic-bezier(0.25, 1, 0.5, 1);
+        }
+
+        .modal-container {
+            transition: opacity 0.3s ease;
+        }
+
+        .modal-content {
+            transition: transform 0.3s ease, opacity 0.3s ease;
+            transform: scale(0.95);
+        }
+
+        .modal-container.active .modal-content {
+            transform: scale(1);
+        }
+
+        /* ## START: Styles for Model Selector ## */
+        input[type="radio"].model-radio {
+            display: none;
+        }
+
+        input[type="radio"].model-radio:checked+.model-choice-card {
+            border-color: var(--accent-color);
+            background-color: rgba(147, 51, 234, 0.1);
+            transform: translateY(-4px);
+            box-shadow: 0 0 20px rgba(147, 51, 234, 0.3);
+        }
+
+        .model-choice-card {
+            transition: transform 0.2s ease, border-color 0.2s ease, background-color 0.2s ease, box-shadow 0.2s ease;
+        }
+
+        /* ## END: Styles for Model Selector ## */
+        /* ## Camera Capture Styles ## */
+        .camera-btn {
+            background: linear-gradient(135deg, #10b981, #059669);
+            transition: all 0.3s ease;
+        }
+
+        .camera-btn:hover {
+            transform: scale(1.05);
+            box-shadow: 0 0 20px rgba(16, 185, 129, 0.4);
+        }
+
+        #camera-modal video {
+            max-width: 100%;
+            max-height: 60vh;
+            border-radius: 0.75rem;
+        }
+
+        #camera-modal .camera-controls {
+            display: flex;
+            gap: 1rem;
+            justify-content: center;
+            margin-top: 1rem;
+        }
+
+        /* ## END: Camera Capture Styles ## */
+    </style>
+</head>
+
+<body class="antialiased">
+
+    <canvas id="hexagon-canvas"></canvas>
+
+    <div class="main-container p-6 sm:p-8 lg:p-12">
+
+        <header class="mb-10 flex justify-between items-center">
+            <div>
+                <h1 class="text-4xl font-bold text-white tracking-tighter">VisionExtractAI</h1>
+                <p id="header-subtitle" class="text-md text-gray-400 mt-1">AI-Powered Document Extraction</p>
+            </div>
+            <div class="flex items-center gap-4">
+                <button id="home-btn"
+                    class="hidden text-gray-400 hover:text-white transition-colors text-lg flex items-center">
+                    <i class="fas fa-home mr-2"></i> Home
+                </button>
+                <button id="back-btn"
+                    class="hidden text-gray-400 hover:text-white transition-colors text-lg flex items-center">
+                    <i class="fas fa-arrow-left mr-2"></i> Back
+                </button>
+            </div>
+        </header>
+
+        <div id="page-api-key" class="page active">
+            <div class="max-w-2xl mx-auto mt-10 text-center">
+                <h2
+                    class="text-5xl font-bold tracking-tighter text-transparent bg-clip-text bg-gradient-to-r from-purple-400 to-blue-500">
+                    Welcome to VisionExtractAI</h2>
+                <p class="text-lg text-gray-400 mt-4 max-w-xl mx-auto">
+                    Transform static documents into a dynamic, queryable knowledge base. This app uses the
+                    <strong>OpenRouter API</strong> to provide access to state-of-the-art AI models for OCR and an
+                    intelligent chat assistant that understands your content.
+                </p>
+
+                <div id="api-key-panel">
+                    <div class="mt-8 glass-card p-8 rounded-xl">
+                        <p class="text-gray-300 mb-4">To begin, please enter your OpenRouter API key below.</p>
+                        <input type="password" id="api-key-input" placeholder="Enter your OpenRouter API Key here"
+                            class="w-full bg-gray-800 border border-gray-600 rounded-lg px-4 py-3 text-white text-center focus:outline-none focus:ring-2 focus:ring-purple-500">
+                        <button id="continue-with-api-key-btn"
+                            class="w-full mt-6 font-bold py-2 px-4 rounded-lg transition-colors duration-300 flex items-center gap-2 justify-center bg-purple-600 hover:bg-purple-700 text-white">
+                            Continue <i class="fas fa-arrow-right"></i>
+                        </button>
+                        <p id="api-key-error" class="text-red-400 text-sm mt-2 hidden"></p>
+                    </div>
+                </div>
+                <div id="model-selector-panel" class="hidden">
+                    <div class="mt-8 glass-card p-8 rounded-xl">
+                        <h3 class="text-xl font-bold text-gray-200 mb-6">Select Your AI Engine</h3>
+                        <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
+
+                            <label for="model-deepseek">
+                                <input type="radio" name="model-choice" id="model-deepseek" value="deepseek"
+                                    class="model-radio">
+                                <div
+                                    class="model-choice-card glass-card no-hover p-4 rounded-lg cursor-pointer text-center h-full flex flex-col items-center justify-center">
+                                    <i class="fas fa-brain text-3xl text-green-400 mb-3"></i>
+                                    <span class="font-semibold">DeepSeek</span>
+                                    <span class="text-xs text-gray-400">DeepSeek V2 (free)</span>
+                                </div>
+                            </label>
+
+                            <label for="model-qwen">
+                                <input type="radio" name="model-choice" id="model-qwen" value="qwen"
+                                    class="model-radio">
+                                <div
+                                    class="model-choice-card glass-card no-hover p-4 rounded-lg cursor-pointer text-center h-full flex flex-col items-center justify-center">
+                                    <i class="fas fa-microchip text-3xl text-blue-400 mb-3"></i>
+                                    <span class="font-semibold">Qwen</span>
+                                    <span class="text-xs text-gray-400">Qwen 2.5 VL (free)(MOST PREFERRED)</span>
+                                </div>
+                            </label>
+
+                            <label for="model-nvidia">
+                                <input type="radio" name="model-choice" id="model-nvidia" value="nvidia"
+                                    class="model-radio">
+                                <div
+                                    class="model-choice-card glass-card no-hover p-4 rounded-lg cursor-pointer text-center h-full flex flex-col items-center justify-center">
+                                    <i class="fas fa-microchip text-3xl text-blue-400 mb-3"></i>
+                                    <span class="font-semibold">nvidia</span>
+                                    <span class="text-xs text-gray-400">nvidia</span>
+                                </div>
+                            </label>
+
+                            <label for="model-amazon">
+                                <input type="radio" name="model-choice" id="model-amazon" value="amazon"
+                                    class="model-radio">
+                                <div
+                                    class="model-choice-card glass-card no-hover p-4 rounded-lg cursor-pointer text-center h-full flex flex-col items-center justify-center">
+                                    <i class="fas fa-microchip text-3xl text-blue-400 mb-3"></i>
+                                    <span class="font-semibold">amazon</span>
+                                    <span class="text-xs text-gray-400">amazon</span>
+                                </div>
+                            </label>
+
+                            <label for="model-gemini">
+                                <input type="radio" name="model-choice" id="model-gemini" value="gemini"
+                                    class="model-radio">
+                                <div
+                                    class="model-choice-card glass-card no-hover p-4 rounded-lg cursor-pointer text-center h-full flex flex-col items-center justify-center">
+                                    <i class="fas fa-bolt text-3xl text-yellow-400 mb-3"></i>
+                                    <span class="font-semibold">Gemini</span>
+                                    <span class="text-xs text-gray-400">Gemini 1.5 Flash</span>
+                                </div>
+                            </label>
+                        </div>
+                        <button id="continue-with-model-btn"
+                            class="w-full mt-6 font-bold py-2 px-4 rounded-lg transition-colors duration-300 flex items-center gap-2 justify-center bg-purple-600 hover:bg-purple-700 text-white">
+                            Unlock Command Center
+                        </button>
+                        <p id="model-choice-error" class="text-red-400 text-sm mt-2 hidden"></p>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div id="page-select-mode" class="page">
+            <div class="grid grid-cols-1 md:grid-cols-2 gap-8 mt-12">
+                <div id="select-cards-btn" class="glass-card p-8 rounded-xl cursor-pointer">
+                    <i class="fas fa-id-card text-4xl text-blue-400 mb-4"></i>
+                    <h2 class="text-2xl font-bold mb-2">Business Card Extractor</h2>
+                    <p class="text-gray-400">Extract structured contact information from images of business cards.</p>
+                </div>
+                <div id="select-brochures-btn" class="glass-card p-8 rounded-xl cursor-pointer">
+                    <i class="fas fa-book-open text-4xl text-purple-400 mb-4"></i>
+                    <h2 class="text-2xl font-bold mb-2">Brochure Extractor</h2>
+                    <p class="text-gray-400">Extract multiple contacts and general information from PDF brochures.</p>
+                </div>
+            </div>
+        </div>
+
+        <div id="page-dashboard-cards" class="page">
+            <div id="upload-section-cards" class="mb-8">
+                <input type="file" id="file-upload-cards" class="hidden" multiple accept="image/*">
+                <div class="flex gap-4 items-stretch">
+                    <label for="file-upload-cards"
+                        class="drop-zone glass-card flex flex-col items-center justify-center flex-1 h-48 p-6 rounded-xl cursor-pointer border-dashed border-2">
+                        <div class="text-center">
+                            <i class="fas fa-cloud-upload-alt text-4xl text-gray-500 mb-3"></i>
+                            <p class="font-semibold">Drag & drop Business Cards or <span
+                                    class="text-purple-400">browse</span></p>
+                            <p class="text-sm text-gray-500 mt-1">Supports PNG, JPG, or WEBP</p>
+                        </div>
+                    </label>
+                    <button id="camera-btn-cards"
+                        class="camera-btn flex flex-col items-center justify-center w-32 h-48 rounded-xl text-white"
+                        style="background: linear-gradient(135deg, #10b981, #059669); min-width: 128px;">
+                        <i class="fas fa-camera text-4xl mb-3"></i>
+                        <span class="font-semibold text-sm">Take Photo</span>
+                    </button>
+                </div>
+            </div>
+            <div id="live-activity-section-cards" class="mb-8">
+                <h3 class="font-bold text-lg mb-2 flex items-center gap-2 text-gray-400"><i class="fas fa-history"></i>
+                    Live Activity</h3>
+                <div class="live-activity-feed space-y-2 text-sm"></div>
+            </div>
+            <div id="results-section-cards" class="results-section rounded-xl">
+                <div class="flex flex-wrap justify-between items-center mb-4 gap-4">
+                    <h3 class="font-bold text-lg">Extracted Contacts</h3>
+                    <div class="flex items-center gap-4">
+                        <div class="relative">
+                            <span class="absolute inset-y-0 left-0 flex items-center pl-3"><i
+                                    class="fas fa-search text-gray-500"></i></span>
+                            <input type="text"
+                                class="search-input glass-card no-hover w-full max-w-xs bg-transparent border-gray-700 rounded-lg pl-10 pr-4 py-2 text-white focus:outline-none focus:ring-2 focus:ring-purple-500"
+                                placeholder="Search contacts...">
+                        </div>
+                        <div class="relative actions-menu-container">
+                            <button
+                                class="actions-menu-btn glass-card font-bold py-2 px-4 rounded-lg transition-colors duration-300 flex items-center gap-2 justify-center">
+                                Actions <i class="fas fa-chevron-down text-xs ml-1"></i>
+                            </button>
+                            <div
+                                class="actions-dropdown hidden absolute right-0 mt-2 w-48 glass-card rounded-lg shadow-lg z-10">
+                                <a href="#"
+                                    class="export-pdf-btn block px-4 py-2 text-sm hover:bg-purple-600 rounded-t-lg">Export
+                                    to PDF</a>
+                                <a href="#" class="export-excel-btn block px-4 py-2 text-sm hover:bg-purple-600">Export
+                                    to Excel</a>
+                                <a href="#"
+                                    class="export-vcf-btn block px-4 py-2 text-sm hover:bg-purple-600 rounded-b-lg">
+                                    <i class="fas fa-address-book mr-1"></i>Export to Contacts (VCF)</a>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div class="card-grid-container grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6">
+                </div>
+                <div class="placeholder-row text-center py-24 text-gray-500">
+                    <i class="fas fa-id-card text-5xl mb-4"></i>
+                    <p class="text-lg">Your extracted contacts will appear here as cards.</p>
+                </div>
+            </div>
+        </div>
+
+        <div id="page-dashboard-brochures" class="page">
+            <div id="upload-section-brochures" class="mb-8">
+                <input type="file" id="file-upload-brochures" class="hidden" multiple accept=".pdf,image/*">
+                <div class="flex gap-4 items-stretch">
+                    <label for="file-upload-brochures"
+                        class="drop-zone glass-card flex flex-col items-center justify-center flex-1 h-48 p-6 rounded-xl cursor-pointer border-dashed border-2">
+                        <div class="text-center">
+                            <i class="fas fa-cloud-upload-alt text-4xl text-gray-500 mb-3"></i>
+                            <p class="font-semibold">Drag & drop PDF Brochures or <span
+                                    class="text-purple-400">browse</span></p>
+                            <p class="text-sm text-gray-500 mt-1">Supports PDF and image files</p>
+                        </div>
+                    </label>
+                    <button id="camera-btn-brochures"
+                        class="camera-btn flex flex-col items-center justify-center w-32 h-48 rounded-xl text-white"
+                        style="background: linear-gradient(135deg, #10b981, #059669); min-width: 128px;">
+                        <i class="fas fa-camera text-4xl mb-3"></i>
+                        <span class="font-semibold text-sm">Take Photo</span>
+                    </button>
+                </div>
+            </div>
+            <div id="live-activity-section-brochures" class="mb-8">
+                <h3 class="font-bold text-lg mb-2 flex items-center gap-2 text-gray-400"><i class="fas fa-history"></i>
+                    Live Activity</h3>
+                <div class="live-activity-feed space-y-2 text-sm"></div>
+            </div>
+            <div id="results-section-brochures" class="results-section rounded-xl">
+                <div class="flex flex-wrap justify-between items-center mb-4 gap-4">
+                    <h3 class="font-bold text-lg">Extracted Brochures</h3>
+                </div>
+                <div class="brochure-list-container space-y-3"></div>
+                <div class="placeholder-row text-center py-24 text-gray-500">
+                    <i class="fas fa-book-open text-5xl mb-4"></i>
+                    <p class="text-lg">Information extracted from your brochures will appear here.</p>
+                </div>
+            </div>
+        </div>
+
+    </div>
+
+    <button id="chat-widget"
+        class="hidden fixed bottom-8 right-8 bg-purple-600 hover:bg-purple-700 text-white w-16 h-16 rounded-full flex items-center justify-center shadow-lg z-40">
+        <i class="fas fa-comments text-2xl"></i>
+    </button>
+
+    <div id="chat-panel"
+        class="fixed bottom-0 right-0 h-full w-full max-w-md glass-card no-hover flex flex-col z-50 transform translate-x-full">
+        <div class="p-4 border-b border-gray-700 flex justify-between items-center">
+            <h3 class="font-bold text-lg flex items-center gap-3"><i class="fas fa-comments text-purple-400"></i> Ask
+                About Your Documents</h3>
+            <button id="chat-close-btn" class="text-gray-400 hover:text-white"><i
+                    class="fas fa-times text-xl"></i></button>
+        </div>
+        <div id="chat-messages" class="flex-1 p-4 space-y-4 overflow-y-auto">
+            <div class="flex justify-start">
+                <div class="chat-bubble bg-gray-700 rounded-lg p-3">
+                    <p class="text-sm">Hello! Ask me anything about your documents.</p>
+                </div>
+            </div>
+        </div>
+        <div class="p-4 border-t border-gray-700">
+            <div class="relative">
+                <input type="text" id="chat-input" placeholder="Type your question..."
+                    class="w-full bg-gray-900 border border-gray-700 rounded-full pl-4 pr-12 py-3 text-white focus:outline-none focus:ring-2 focus:ring-purple-500">
+                <button id="chat-send-btn"
+                    class="absolute inset-y-0 right-0 flex items-center justify-center bg-purple-600 hover:bg-purple-700 w-10 h-10 rounded-full m-1.5 transition-colors"><i
+                        class="fas fa-paper-plane"></i></button>
+            </div>
+        </div>
+    </div>
+
+    <div id="contacts-modal"
+        class="modal-container hidden fixed inset-0 bg-black/50 backdrop-blur-sm z-50 flex justify-center items-center p-4"
+        style="opacity: 0;">
+        <div class="modal-content glass-card w-full max-w-4xl rounded-xl max-h-[80vh] flex flex-col"
+            style="opacity: 0;">
+            <div class="p-4 border-b border-gray-700 flex justify-between items-center">
+                <h3 id="contacts-modal-title" class="font-bold text-lg">Contacts</h3>
+                <div class="flex items-center gap-4">
+                    <button id="export-contacts-pdf-btn" class="text-sm text-gray-300 hover:text-white"><i
+                            class="fas fa-file-pdf mr-1"></i> Export PDF</button>
+                    <button id="export-contacts-excel-btn" class="text-sm text-gray-300 hover:text-white"><i
+                            class="fas fa-file-excel mr-1"></i> Export Excel</button>
+                    <button onclick="toggleModal('contacts-modal', false)"
+                        class="text-gray-400 hover:text-white ml-4"><i class="fas fa-times text-xl"></i></button>
+                </div>
+            </div>
+            <div class="p-4 overflow-y-auto">
+                <div id="contacts-modal-body" class="space-y-2"></div>
+            </div>
+        </div>
+    </div>
+
+    <div id="info-modal"
+        class="modal-container hidden fixed inset-0 bg-black/50 backdrop-blur-sm z-50 flex justify-center items-center p-4"
+        style="opacity: 0;">
+        <div class="modal-content glass-card w-full max-w-4xl rounded-xl max-h-[80vh] flex flex-col"
+            style="opacity: 0;">
+            <div class="p-4 border-b border-gray-700 flex justify-between items-center">
+                <h3 id="info-modal-title" class="font-bold text-lg">Brochure Information</h3>
+                <div class="flex items-center gap-4">
+                    <button id="export-info-pdf-btn" class="text-sm text-gray-300 hover:text-white"><i
+                            class="fas fa-file-pdf mr-1"></i> Export PDF</button>
+                    <button onclick="toggleModal('info-modal', false)" class="text-gray-400 hover:text-white ml-4"><i
+                            class="fas fa-times text-xl"></i></button>
+                </div>
+            </div>
+            <div id="info-modal-body" class="p-4 overflow-y-auto text-gray-300 whitespace-pre-wrap"></div>
+        </div>
+    </div>
+
+    <!-- Camera Modal -->
+    <div id="camera-modal"
+        class="modal-container hidden fixed inset-0 bg-black/80 backdrop-blur-sm z-50 flex justify-center items-center p-4"
+        style="opacity: 0;">
+        <div class="modal-content glass-card w-full max-w-2xl rounded-xl flex flex-col" style="opacity: 0;">
+            <div class="p-4 border-b border-gray-700 flex justify-between items-center">
+                <h3 id="camera-modal-title" class="font-bold text-lg flex items-center gap-2">
+                    <i class="fas fa-camera text-green-400"></i> <span>Capture Photo</span>
+                </h3>
+                <button id="camera-close-btn" class="text-gray-400 hover:text-white">
+                    <i class="fas fa-times text-xl"></i>
+                </button>
+            </div>
+            <div class="p-6 flex flex-col items-center">
+                <video id="camera-video" autoplay playsinline class="hidden"></video>
+                <canvas id="camera-canvas" class="hidden"></canvas>
+                <img id="camera-preview" class="hidden max-w-full max-h-[50vh] rounded-xl" />
+                <div id="camera-loading" class="text-center py-12">
+                    <i class="fas fa-spinner animate-spin text-4xl text-green-400 mb-4"></i>
+                    <p class="text-gray-400">Accessing camera...</p>
+                </div>
+                <div id="camera-error" class="hidden text-center py-12">
+                    <i class="fas fa-exclamation-triangle text-4xl text-yellow-400 mb-4"></i>
+                    <p class="text-gray-400">Could not access camera. Please ensure you've granted camera permissions.
+                    </p>
+                </div>
+                <div class="camera-controls mt-4">
+                    <button id="camera-capture-btn"
+                        class="hidden bg-green-600 hover:bg-green-700 text-white font-bold py-3 px-8 rounded-full transition-colors flex items-center gap-2">
+                        <i class="fas fa-camera"></i> Capture
+                    </button>
+                    <button id="camera-retake-btn"
+                        class="hidden bg-gray-600 hover:bg-gray-700 text-white font-bold py-3 px-6 rounded-full transition-colors flex items-center gap-2">
+                        <i class="fas fa-redo"></i> Retake
+                    </button>
+                    <button id="camera-use-btn"
+                        class="hidden bg-purple-600 hover:bg-purple-700 text-white font-bold py-3 px-6 rounded-full transition-colors flex items-center gap-2">
+                        <i class="fas fa-check"></i> Use Photo
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+
+    <script>
+        // Dynamic API URL - works from mobile and laptop
+        const API_BASE_URL = window.location.origin;
+        // ## START: New State Variables ##
+        let userApiKey = null;
+        let selectedModel = null;
+        // ## END: New State Variables ##
+        let currentMode = null;
+        let contactData = { cards: [], brochures: [] };
+        const pages = document.querySelectorAll('.page');
+        const headerSubtitle = document.getElementById('header-subtitle');
+        const backBtn = document.getElementById('back-btn');
+        const homeBtn = document.getElementById('home-btn');
+        const chatMessages = document.getElementById('chat-messages');
+        const chatInput = document.getElementById('chat-input');
+        const chatSendBtn = document.getElementById('chat-send-btn');
+        const chatWidget = document.getElementById('chat-widget');
+        const chatPanel = document.getElementById('chat-panel');
+        const chatCloseBtn = document.getElementById('chat-close-btn');
+        const canvas = document.getElementById('hexagon-canvas');
+        const ctx = canvas.getContext('2d');
+        let hexagons = [];
+        const hexSize = 25;
+        const hexWidth = Math.sqrt(3) * hexSize;
+        const hexHeight = 2 * hexSize;
+        let mouse = { x: undefined, y: undefined, radius: 150 };
+
+        function initCanvas() {
+            canvas.width = window.innerWidth;
+            canvas.height = window.innerHeight;
+            hexagons = [];
+            const cols = Math.ceil(canvas.width / hexWidth) + 1;
+            const rows = Math.ceil(canvas.height / (hexHeight * 0.75)) + 1;
+            for (let row = 0; row < rows; row++) {
+                for (let col = 0; col < cols; col++) {
+                    const x = col * hexWidth + (row % 2) * (hexWidth / 2);
+                    const y = row * hexHeight * 0.75;
+                    hexagons.push({ x, y, size: hexSize, opacity: 0.05 });
+                }
+            }
+        }
+
+        function drawHexagon(x, y, size, opacity) {
+            ctx.beginPath();
+            for (let i = 0; i < 6; i++) {
+                const angle = (Math.PI / 3) * i + (Math.PI / 6);
+                const pointX = x + size * Math.cos(angle);
+                const pointY = y + size * Math.sin(angle);
+                if (i === 0) ctx.moveTo(pointX, pointY);
+                else ctx.lineTo(pointX, pointY);
+            }
+            ctx.closePath();
+            ctx.fillStyle = `rgba(147, 51, 234, ${opacity})`;
+            ctx.strokeStyle = `rgba(147, 51, 234, ${opacity * 1.5})`;
+            ctx.lineWidth = 1;
+            ctx.fill();
+            ctx.stroke();
+        }
+
+        function animate() {
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            hexagons.forEach(hex => {
+                const dist = Math.hypot(hex.x - mouse.x, hex.y - mouse.y);
+                const maxOpacity = 0.6;
+                const baseOpacity = 0.05;
+                let targetOpacity = baseOpacity;
+                if (dist < mouse.radius) {
+                    targetOpacity = Math.max(baseOpacity, (1 - dist / mouse.radius) * maxOpacity);
+                }
+                hex.opacity += (targetOpacity - hex.opacity) * 0.1;
+                drawHexagon(hex.x, hex.y, hex.size, hex.opacity);
+            });
+            requestAnimationFrame(animate);
+        }
+
+        window.addEventListener('mousemove', e => { mouse.x = e.clientX; mouse.y = e.clientY; });
+        window.addEventListener('resize', initCanvas);
+
+        function toggleChatPanel(show) {
+            chatPanel.style.transform = show ? 'translateX(0)' : 'translateX(100%)';
+            chatWidget.style.transform = show ? 'scale(0)' : 'scale(1)';
+        }
+
+        chatWidget.addEventListener('click', () => toggleChatPanel(true));
+        chatCloseBtn.addEventListener('click', () => toggleChatPanel(false));
+
+        function renderUI(mode) {
+            const dataToRender = contactData[mode];
+            if (mode === 'cards') {
+                renderCards(dataToRender);
+            } else if (mode === 'brochures') {
+                renderBrochures(dataToRender);
+            }
+        }
+
+        function renderCards(dataToRender) {
+            const container = document.querySelector('#page-dashboard-cards .card-grid-container');
+            const placeholder = document.querySelector('#page-dashboard-cards .placeholder-row');
+            const searchInput = document.querySelector('#page-dashboard-cards .search-input');
+
+            container.innerHTML = '';
+            if (!dataToRender || dataToRender.length === 0) {
+                placeholder.classList.remove('hidden');
+                placeholder.querySelector('p').textContent = searchInput.value ? 'No cards match your search.' : 'Your extracted business cards will appear here.';
+            } else {
+                placeholder.classList.add('hidden');
+                dataToRender.forEach((data, index) => addCardToGrid(data, index));
+            }
+        }
+
+        function addCardToGrid(data, index) {
+            const container = document.querySelector('#page-dashboard-cards .card-grid-container');
+            const card = document.createElement('div');
+            card.id = `card-${data.id}`;
+            card.className = 'contact-card glass-card p-4 rounded-xl flex flex-col justify-between h-full';
+            card.style.animationDelay = `${index * 50}ms`;
+            card.innerHTML = `
+                <div class="flex-grow space-y-1">
+                    <p class="font-bold text-lg truncate editable-field" data-field="Company Name">${data['Company Name'] || 'Unknown Company'}</p>
+                    <p class="text-sm text-gray-400 editable-field" data-field="Owner Name">${data['Owner Name'] || 'No Name'}</p>
+                    <div class="mt-3 text-xs space-y-2 text-gray-400">
+                        <p class="truncate editable-field" data-field="Email"><i class="fas fa-envelope fa-fw mr-2"></i>${data['Email'] || 'N/A'}</p>
+                        <p class="truncate editable-field" data-field="Number"><i class="fas fa-phone fa-fw mr-2"></i>${data['Number'] || 'N/A'}</p>
+                        <p class="truncate editable-field" data-field="Address"><i class="fas fa-map-marker-alt fa-fw mr-2"></i>${data['Address'] || 'N/A'}</p>
+                    </div>
+                </div>
+                <div class="flex justify-end items-center gap-2 mt-4 pt-3 border-t border-gray-700/50">
+                    <a href="/uploads/${data.image_filename}" target="_blank" class="text-blue-400 hover:text-blue-300 transition-colors px-2" title="View Source"><i class="fas fa-eye"></i></a>
+                    <button class="text-red-500 hover:text-red-400 transition-colors px-2" onclick="deleteItem('cards', '${data.id}')" title="Delete"><i class="fas fa-trash-alt"></i></button>
+                </div>`;
+            container.appendChild(card);
+        }
+
+        function renderBrochures(dataToRender) {
+            const container = document.querySelector('#page-dashboard-brochures .brochure-list-container');
+            const placeholder = document.querySelector('#page-dashboard-brochures .placeholder-row');
+
+            container.innerHTML = '';
+            if (!dataToRender || dataToRender.length === 0) {
+                placeholder.classList.remove('hidden');
+            } else {
+                placeholder.classList.add('hidden');
+                dataToRender.forEach((data, index) => addBrochureToList(data, index));
+            }
+        }
+
+        function addBrochureToList(data, index) {
+            const container = document.querySelector('#page-dashboard-brochures .brochure-list-container');
+            const row = document.createElement('div');
+            row.id = `brochure-${data.id}`;
+            row.className = 'brochure-row glass-card p-4 rounded-xl flex items-center justify-between';
+            row.style.animationDelay = `${index * 50}ms`;
+            row.innerHTML = `
+                <div class="flex-1 truncate font-bold">${data.company_name}</div>
+                <div class="flex items-center gap-4">
+                    <button onclick="showContactsModal('${data.id}')" class="text-sm text-blue-400 hover:text-blue-300">View Contacts (${data.contacts.length})</button>
+                    <button onclick="showInfoModal('${data.id}')" class="text-sm text-purple-400 hover:text-purple-300">View Info</button>
+                    <div class="flex items-center gap-2">
+                        <a href="/uploads/${data.image_filename}" target="_blank" class="text-gray-400 hover:text-white transition-colors px-2" title="View PDF"><i class="fas fa-eye"></i></a>
+                        <button class="text-red-500 hover:text-red-400 transition-colors px-2" onclick="deleteItem('brochures', '${data.id}')" title="Delete Brochure"><i class="fas fa-trash-alt"></i></button>
+                    </div>
+                </div>
+            `;
+            container.appendChild(row);
+        }
+
+        async function loadInitialData(mode) {
+            try {
+                const response = await fetch(`${API_BASE_URL}/load_data/${mode}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    // ## MODIFIED: Still only sends API key, model not needed for loading ##
+                    body: JSON.stringify({ apiKey: userApiKey })
+                });
+                const data = await response.json();
+                contactData[mode] = Array.isArray(data) ? data : [];
+                renderUI(mode);
+            } catch (error) {
+                console.error(`Failed to load data for ${mode}:`, error);
+                contactData[mode] = [];
+                renderUI(mode);
+            }
+        }
+
+        function showPage(pageId) {
+            pages.forEach(p => p.classList.remove('active'));
+            document.getElementById(pageId).classList.add('active');
+            headerSubtitle.textContent = pageId.includes('dashboard') ? "AI Command Center" : "AI-Powered Document Extraction";
+
+            const isApiPage = pageId === 'page-api-key';
+            backBtn.classList.toggle('hidden', isApiPage || pageId === 'page-select-mode');
+            homeBtn.classList.toggle('hidden', isApiPage);
+            chatWidget.classList.toggle('hidden', !pageId.includes('dashboard'));
+        }
+
+        // ## START: Updated API Key and Model Selection Logic ##
+        document.getElementById('continue-with-api-key-btn').addEventListener('click', async () => {
+            const keyInput = document.getElementById('api-key-input');
+            const errorEl = document.getElementById('api-key-error');
+            const key = keyInput.value.trim();
+            if (key.length < 73) {
+                errorEl.textContent = 'Please enter a valid OpenRouter API key.';
+                errorEl.classList.remove('hidden');
+                return;
+            }
+            errorEl.classList.add('hidden');
+            userApiKey = key;
+
+            // Transition to model selector
+            document.getElementById('api-key-panel').classList.add('hidden');
+            document.getElementById('model-selector-panel').classList.remove('hidden');
+        });
+
+        document.getElementById('continue-with-model-btn').addEventListener('click', () => {
+            const selectedRadio = document.querySelector('input[name="model-choice"]:checked');
+            const errorEl = document.getElementById('model-choice-error');
+            if (!selectedRadio) {
+                errorEl.textContent = 'Please select an AI engine to continue.';
+                errorEl.classList.remove('hidden');
+                return;
+            }
+            errorEl.classList.add('hidden');
+            selectedModel = selectedRadio.value;
+            showPage('page-select-mode');
+        });
+        // ## END: Updated API Key and Model Selection Logic ##
+
+        document.getElementById('select-cards-btn').addEventListener('click', () => {
+            currentMode = 'cards';
+            showPage('page-dashboard-cards');
+            loadInitialData('cards');
+        });
+
+        document.getElementById('select-brochures-btn').addEventListener('click', () => {
+            currentMode = 'brochures';
+            showPage('page-dashboard-brochures');
+            loadInitialData('brochures');
+        });
+
+        backBtn.addEventListener('click', () => showPage('page-select-mode'));
+
+        // ## START: Updated Home Button Logic ##
+        homeBtn.addEventListener('click', () => {
+            // Reset state
+            userApiKey = null;
+            selectedModel = null;
+            document.getElementById('api-key-input').value = '';
+            const selectedRadio = document.querySelector('input[name="model-choice"]:checked');
+            if (selectedRadio) selectedRadio.checked = false;
+
+            // Reset UI
+            document.getElementById('model-selector-panel').classList.add('hidden');
+            document.getElementById('api-key-panel').classList.remove('hidden');
+            showPage('page-api-key');
+        });
+        // ## END: Updated Home Button Logic ##
+
+        ['cards', 'brochures'].forEach(mode => {
+            const dashboard = document.getElementById(`page-dashboard-${mode}`);
+            if (!dashboard) return;
+
+            const dropZone = dashboard.querySelector('.drop-zone');
+            const fileUpload = dashboard.querySelector('input[type="file"]');
+
+            dropZone.addEventListener('dragover', e => e.preventDefault());
+            dropZone.addEventListener('drop', e => { e.preventDefault(); handleFiles(mode, e.dataTransfer.files); });
+            fileUpload.addEventListener('change', e => handleFiles(mode, e.target.files));
+
+            if (mode === 'cards') {
+                const searchInput = dashboard.querySelector('.search-input');
+                const actionsMenuBtn = dashboard.querySelector('.actions-menu-btn');
+                const actionsDropdown = dashboard.querySelector('.actions-dropdown');
+                const cardGridContainer = dashboard.querySelector('.card-grid-container');
+
+                searchInput.addEventListener('input', () => {
+                    const searchTerm = searchInput.value.toLowerCase();
+                    const filteredData = contactData.cards.filter(contact => Object.values(contact).some(value => String(value).toLowerCase().includes(searchTerm)));
+                    renderCards(filteredData);
+                });
+
+                actionsMenuBtn.addEventListener('click', () => actionsDropdown.classList.toggle('hidden'));
+
+                actionsDropdown.querySelector('.export-pdf-btn').addEventListener('click', e => { e.preventDefault(); exportData('cards', 'pdf'); });
+                actionsDropdown.querySelector('.export-excel-btn').addEventListener('click', e => { e.preventDefault(); exportData('cards', 'excel'); });
+                actionsDropdown.querySelector('.export-vcf-btn').addEventListener('click', e => { e.preventDefault(); exportToVCF(); });
+
+                cardGridContainer.addEventListener('click', (e) => {
+                    const fieldElement = e.target.closest('.editable-field');
+                    if (!fieldElement || fieldElement.querySelector('input')) return;
+
+                    // Get the text content properly - exclude icon text
+                    const icon = fieldElement.querySelector('i');
+                    let originalValue;
+                    if (icon) {
+                        // Clone the element, remove the icon, get remaining text
+                        const clone = fieldElement.cloneNode(true);
+                        clone.querySelector('i')?.remove();
+                        originalValue = clone.textContent.trim();
+                    } else {
+                        originalValue = fieldElement.textContent.trim();
+                    }
+
+                    const fieldName = fieldElement.dataset.field;
+                    fieldElement.innerHTML = `<input type="text" value="${originalValue}" class="w-full bg-gray-800 border border-purple-500 rounded px-2 py-1 text-sm">`;
+                    const input = fieldElement.querySelector('input');
+                    input.focus();
+                    input.select();
+
+                    const save = async () => {
+                        const newValue = input.value.trim() || 'N/A';
+                        const cardId = fieldElement.closest('.contact-card').id.replace('card-', '');
+
+                        // Restore the field HTML first
+                        const hasIcon = fieldName === 'Email' || fieldName === 'Number' || fieldName === 'Address';
+                        fieldElement.innerHTML = hasIcon ? `<i class="fas ${getIconForField(fieldName)} fa-fw mr-2"></i>${newValue}` : newValue;
+
+                        // Only save if value actually changed
+                        if (newValue !== originalValue) {
+                            const dataIndex = contactData.cards.findIndex(d => d.id === cardId);
+                            if (dataIndex > -1) contactData.cards[dataIndex][fieldName] = newValue;
+                            await saveEditToServer('cards', cardId, fieldName, newValue);
+                        }
+                    };
+                    input.addEventListener('blur', save);
+                    input.addEventListener('keydown', (e) => {
+                        if (e.key === 'Enter') input.blur();
+                        if (e.key === 'Escape') fieldElement.innerHTML = fieldElement.innerHTML.includes('fa-fw') ? `<i class="fas ${getIconForField(fieldName)} fa-fw mr-2"></i>${originalValue}` : originalValue;
+                    });
+                });
+            }
+        });
+
+        document.addEventListener('click', (e) => {
+            document.querySelectorAll('.actions-menu-container').forEach(container => {
+                if (!container.contains(e.target)) {
+                    container.querySelector('.actions-dropdown').classList.add('hidden');
+                }
+            });
+        });
+
+        function handleFiles(mode, files) {
+            if (files.length === 0) return;
+            if (!userApiKey || !selectedModel) {
+                alert("Please ensure you have entered an API key and selected a model.");
+                showPage('page-api-key');
+                return;
+            }
+            Array.from(files).forEach(file => processFile(mode, file));
+        }
+
+        async function processFile(mode, file) {
+            const fileId = `file-${Date.now()}-${Math.random()}`;
+            addFileToQueueUI(mode, fileId, file.name);
+            const formData = new FormData();
+            formData.append('file', file);
+            // ## MODIFIED: Send both API key and selected model ##
+            formData.append('apiKey', userApiKey);
+            formData.append('selectedModel', selectedModel);
+
+            const endpoint = mode === 'cards' ? '/process_card' : '/process_brochure';
+            try {
+                const response = await fetch(API_BASE_URL + endpoint, { method: 'POST', body: formData });
+                if (!response.ok) throw new Error((await response.json()).error || 'Server error');
+                const newData = await response.json();
+
+                if (mode === 'brochures') {
+                    contactData.brochures.unshift(newData);
+                } else {
+                    contactData.cards.unshift(newData);
+                }
+
+                renderUI(mode);
+                updateQueueUI(mode, fileId, 'success', 'Processing complete.');
+            } catch (error) { console.error('Error processing file:', error); updateQueueUI(mode, fileId, 'error', error.message); }
+        }
+
+        async function deleteItem(mode, itemId, contactId = null) {
+            const confirmMessage = contactId ? 'Are you sure you want to delete this contact?' : `Are you sure you want to delete this entire ${mode.slice(0, -1)}?`;
+            if (!confirm(confirmMessage)) return;
+            try {
+                const response = await fetch(`${API_BASE_URL}/delete_card/${mode}/${itemId}`, {
+                    method: 'DELETE',
+                    headers: { 'Content-Type': 'application/json' },
+                    // ## MODIFIED: Send API key with delete request ##
+                    body: JSON.stringify({ apiKey: userApiKey, contactId: contactId })
+                });
+                const result = await response.json();
+                if (!result.success) throw new Error(result.message);
+
+                await loadInitialData(mode);
+                if (contactId) {
+                    const brochure = contactData.brochures.find(b => b.id === itemId);
+                    if (brochure) {
+                        showContactsModal(itemId);
+                    } else {
+                        toggleModal('contacts-modal', false);
+                    }
+                }
+
+                addFileToQueueUI(mode, `delete-${itemId}`, `Item deleted.`, 'success');
+            } catch (error) { alert(`Failed to delete: ${error.message}`); }
+        }
+
+        function getIconForField(fieldName) {
+            const icons = { "Email": "fa-envelope", "Number": "fa-phone", "Address": "fa-map-marker-alt" };
+            return icons[fieldName] || "";
+        }
+
+        async function saveEditToServer(mode, itemId, field, value, contactId = null) {
+            try {
+                const response = await fetch(`${API_BASE_URL}/update_card/${mode}/${itemId}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    // ## MODIFIED: Send API key with update request ##
+                    body: JSON.stringify({ field, value, apiKey: userApiKey, contactId })
+                });
+                const result = await response.json();
+                if (!result.success) throw new Error(result.message);
+                addFileToQueueUI(mode, Date.now(), `Saved changes to ${field}.`, 'success');
+            } catch (error) {
+                alert(`Failed to save changes: ${error.message}`);
+                loadInitialData(mode);
+            }
+        }
+
+        function addFileToQueueUI(mode, id, name, status = 'processing') {
+            const feed = document.querySelector(`#page-dashboard-${mode} .live-activity-feed`);
+            if (!feed) {
+                console.log('Live activity feed not found for mode:', mode);
+                return;
+            }
+            const el = document.createElement('div');
+            el.id = id;
+            el.className = 'glass-card p-2 rounded-lg flex items-center justify-between text-sm opacity-0 transform -translate-y-2 transition-all duration-300';
+            el.innerHTML = `<span class="truncate"></span><div class="status-icon ml-2"></div>`;
+            feed.prepend(el);
+            setTimeout(() => { el.classList.remove('opacity-0', '-translate-y-2'); }, 10);
+            updateQueueUI(mode, id, status, name);
+        }
+
+        function updateQueueUI(mode, id, status, message = '') {
+            const el = document.getElementById(id);
+            if (!el) return;
+            let iconHtml = '', textHtml = '';
+            switch (status) {
+                case 'processing': iconHtml = '<i class="fas fa-spinner animate-spin"></i>'; textHtml = `Processing ${message}...`; break;
+                case 'success': iconHtml = '<i class="fas fa-check-circle text-green-500"></i>'; textHtml = message; setTimeout(() => el.classList.add('opacity-0'), 3000); setTimeout(() => el.remove(), 3500); break;
+                case 'error': iconHtml = `<i class="fas fa-exclamation-circle text-red-500" title="${message}"></i>`; textHtml = `Error: ${message.substring(0, 50)}...`; el.querySelector('span').classList.add('line-through'); break;
+            }
+            el.querySelector('span').innerHTML = textHtml;
+            el.querySelector('.status-icon').innerHTML = iconHtml;
+        }
+
+        function exportData(mode, format, brochureId = null) {
+            let dataToExport;
+            let companyName = "Exported_Data";
+
+            if (brochureId) {
+                const brochure = contactData.brochures.find(b => b.id === brochureId);
+                dataToExport = brochure ? brochure.contacts : [];
+                companyName = brochure ? brochure.company_name : "Brochure_Contacts";
+            } else {
+                dataToExport = contactData[mode];
+                companyName = mode === 'cards' ? "Business_Cards" : "All_Brochures";
+            }
+
+            if (!dataToExport || dataToExport.length === 0) return addFileToQueueUI(mode, Date.now(), `No data to export.`, 'error');
+
+            const headers = ["Company Name", "Owner Name", "Email", "Number"];
+
+            if (format === 'pdf') {
+                const { jsPDF } = window.jspdf;
+                const doc = new jsPDF();
+                const tableRows = dataToExport.map(contact => [
+                    contact['Company Name'] || (brochureId ? companyName : 'N/A'),
+                    contact["Owner Name"] || "N/A",
+                    contact["Email"] || "N/A",
+                    contact["Number"] || "N/A"
+                ]);
+                doc.text(`Extracted Contacts: ${companyName}`, 14, 15);
+                doc.autoTable({ head: [headers], body: tableRows, startY: 20 });
+                doc.save(`${companyName}_contacts.pdf`);
+                addFileToQueueUI(mode, Date.now(), `Exported to PDF.`, 'success');
+            } else if (format === 'excel') {
+                const csvRows = dataToExport.map(row => headers.map(fieldName => {
+                    const value = (row[fieldName] || (fieldName === 'Company Name' && brochureId ? companyName : 'N/A')).toString();
+                    return value.includes(',') ? `"${value}"` : value;
+                }).join(','));
+                const csvContent = [headers.join(','), ...csvRows].join('\n');
+                const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+                const link = document.createElement('a');
+                const url = URL.createObjectURL(blob);
+                link.setAttribute('href', url);
+                link.setAttribute('download', `${companyName}_contacts.csv`);
+                document.body.appendChild(link);
+                link.click();
+                document.body.removeChild(link);
+                addFileToQueueUI(mode, Date.now(), `Exported to Excel (CSV).`, 'success');
+            }
+        }
+
+        // Export contacts as VCF (vCard) - works on iOS and Android
+        function exportToVCF() {
+            const dataToExport = contactData.cards;
+            if (!dataToExport || dataToExport.length === 0) {
+                addFileToQueueUI('cards', Date.now(), 'No contacts to export.', 'error');
+                return;
+            }
+
+            // Helper to escape special characters in vCard fields
+            function escapeVCard(str) {
+                if (!str) return '';
+                return str.replace(/\\/g, '\\\\')
+                    .replace(/;/g, '\\;')
+                    .replace(/,/g, '\\,')
+                    .replace(/\n/g, '\\n');
+            }
+
+            let vcfContent = '';
+
+            dataToExport.forEach(contact => {
+                // Get the contact name - use Owner Name, fall back to Company Name
+                const fullName = (contact['Owner Name'] || contact['Company Name'] || 'Unknown Contact').trim();
+                const nameParts = fullName.split(/\s+/);
+                const firstName = nameParts[0] || '';
+                const lastName = nameParts.slice(1).join(' ') || '';
+
+                // Get phone numbers (may have multiple separated by comma or semicolon)
+                const phones = (contact['Number'] || '')
+                    .split(/[,;]/)
+                    .map(p => p.trim())
+                    .filter(p => p && p !== 'N/A' && p !== 'null');
+
+                // Build vCard 3.0 format (most compatible)
+                vcfContent += 'BEGIN:VCARD\r\n';
+                vcfContent += 'VERSION:3.0\r\n';
+                vcfContent += `N:${escapeVCard(lastName)};${escapeVCard(firstName)};;;\r\n`;
+                vcfContent += `FN:${escapeVCard(fullName)}\r\n`;
+
+                // Add organization/company
+                const company = contact['Company Name'];
+                if (company && company !== 'N/A' && company !== 'null' && company !== 'Unknown Company') {
+                    vcfContent += `ORG:${escapeVCard(company)}\r\n`;
+                }
+
+                // Add email
+                const email = contact['Email'];
+                if (email && email !== 'N/A' && email !== 'null') {
+                    vcfContent += `EMAIL;TYPE=WORK:${email}\r\n`;
+                }
+
+                // Add all phone numbers
+                phones.forEach(phone => {
+                    vcfContent += `TEL;TYPE=CELL:${phone.replace(/\s+/g, '')}\r\n`;
+                });
+
+                // Add address
+                const address = contact['Address'];
+                if (address && address !== 'N/A' && address !== 'null') {
+                    vcfContent += `ADR;TYPE=WORK:;;${escapeVCard(address)};;;;\r\n`;
+                }
+
+                vcfContent += 'END:VCARD\r\n';
+            });
+
+            // Create and download the VCF file with readable name
+            const blob = new Blob([vcfContent], { type: 'text/vcard;charset=utf-8' });
+            const link = document.createElement('a');
+            const url = URL.createObjectURL(blob);
+            link.setAttribute('href', url);
+            link.setAttribute('download', `BusinessCards_${dataToExport.length}_contacts.vcf`);
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            URL.revokeObjectURL(url);
+
+            addFileToQueueUI('cards', Date.now(), `Exported ${dataToExport.length} contacts to VCF.`, 'success');
+        }
+
+        async function handleChatSubmit() {
+            const query = chatInput.value.trim();
+            if (!query) return;
+            addChatMessage(query, 'user');
+            chatInput.value = '';
+            chatSendBtn.disabled = true;
+            addChatMessage('...', 'ai_typing');
+            try {
+                const response = await fetch(`${API_BASE_URL}/chat`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    // ## MODIFIED: Send both API key and selected model ##
+                    body: JSON.stringify({ query: query, apiKey: userApiKey, mode: currentMode, selectedModel: selectedModel })
+                });
+                document.querySelector('.ai_typing')?.parentElement.parentElement.remove();
+                if (!response.ok) throw new Error((await response.json()).error || 'Server error');
+                const data = await response.json();
+                addChatMessage(data.answer, 'ai');
+            } catch (error) {
+                document.querySelector('.ai_typing')?.parentElement.parentElement.remove();
+                addChatMessage(`Error: ${error.message}`, 'ai');
+            } finally {
+                chatSendBtn.disabled = false;
+            }
+        }
+
+        function addChatMessage(message, type) {
+            const bubble = document.createElement('div');
+            bubble.className = `chat-bubble rounded-lg p-3 max-w-xs break-words ${type === 'user' ? 'bg-purple-600 self-end' : 'bg-gray-700 self-start'}`;
+            if (type === 'ai_typing') {
+                bubble.innerHTML = `<p class="text-sm italic ai_typing">AI is thinking...</p>`;
+            } else {
+                // Basic Markdown to HTML conversion
+                let formattedMessage = message.replace(/\n/g, '<br>');
+                // Bold
+                formattedMessage = formattedMessage.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+                // Tables
+                formattedMessage = formattedMessage.replace(/\|(.+)\|/g, (match, row) => {
+                    const cells = row.split('|').map(c => c.trim()).filter(c => c);
+                    if (cells.length > 1) {
+                        if (row.includes('---')) {
+                            return ''; // Skip header separator line
+                        }
+                        const tag = row.includes('Company Name') ? 'th' : 'td'; // Simple header detection
+                        return `<tr>${cells.map(c => `<${tag} class="border border-gray-600 px-2 py-1">${c}</${tag}>`).join('')}</tr>`;
+                    }
+                    return match;
+                });
+                if (formattedMessage.includes('<tr>')) {
+                    formattedMessage = `<table class="table-auto w-full text-left my-2 border-collapse">${formattedMessage}</table>`;
+                }
+
+                bubble.innerHTML = `<p class="text-sm">${formattedMessage}</p>`;
+            }
+            const messageWrapper = document.createElement('div');
+            messageWrapper.className = `flex w-full ${type === 'user' ? 'justify-end' : 'justify-start'}`;
+            messageWrapper.appendChild(bubble);
+            chatMessages.appendChild(messageWrapper);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        function toggleModal(modalId, show) {
+            const modal = document.getElementById(modalId);
+            if (show) {
+                modal.classList.remove('hidden');
+                setTimeout(() => {
+                    modal.style.opacity = '1';
+                    modal.querySelector('.modal-content').style.opacity = '1';
+                    modal.querySelector('.modal-content').style.transform = 'scale(1)';
+                }, 10);
+            } else {
+                modal.style.opacity = '0';
+                modal.querySelector('.modal-content').style.opacity = '0';
+                modal.querySelector('.modal-content').style.transform = 'scale(0.95)';
+                setTimeout(() => modal.classList.add('hidden'), 300);
+            }
+        }
+
+        function showContactsModal(brochureId) {
+            const brochure = contactData.brochures.find(b => b.id === brochureId);
+            if (!brochure) return;
+
+            const modalTitle = document.getElementById('contacts-modal-title');
+            const modalBody = document.getElementById('contacts-modal-body');
+            modalTitle.textContent = `Contacts for ${brochure.company_name}`;
+            modalBody.innerHTML = '';
+
+            document.getElementById('export-contacts-pdf-btn').onclick = () => exportData('brochures', 'pdf', brochureId);
+            document.getElementById('export-contacts-excel-btn').onclick = () => exportData('brochures', 'excel', brochureId);
+
+            if (brochure.contacts.length === 0) {
+                modalBody.innerHTML = '<p class="text-gray-400">No individual contacts were found in this brochure.</p>';
+            } else {
+                brochure.contacts.forEach(contact => {
+                    const contactEl = document.createElement('div');
+                    contactEl.className = 'glass-card p-3 rounded-lg flex items-center justify-between';
+                    contactEl.innerHTML = `
+                        <div class="flex-1 grid grid-cols-3 gap-4 text-sm">
+                            <div class="editable-field" data-brochure-id="${brochure.id}" data-contact-id="${contact.id}" data-field="Owner Name">${contact['Owner Name'] || 'N/A'}</div>
+                            <div class="editable-field" data-brochure-id="${brochure.id}" data-contact-id="${contact.id}" data-field="Email">${contact['Email'] || 'N/A'}</div>
+                            <div class="editable-field" data-brochure-id="${brochure.id}" data-contact-id="${contact.id}" data-field="Number">${contact['Number'] || 'N/A'}</div>
+                        </div>
+                        <button class="text-red-500 hover:text-red-400 ml-4" onclick="deleteItem('brochures', '${brochure.id}', '${contact.id}')"><i class="fas fa-trash-alt"></i></button>
+                    `;
+                    modalBody.appendChild(contactEl);
+                });
+            }
+            toggleModal('contacts-modal', true);
+        }
+
+        function showInfoModal(brochureId) {
+            const brochure = contactData.brochures.find(b => b.id === brochureId);
+            if (!brochure) return;
+            document.getElementById('info-modal-title').textContent = `Information for ${brochure.company_name}`;
+            document.getElementById('info-modal-body').textContent = brochure.raw_text || "No additional information was extracted.";
+
+            document.getElementById('export-info-pdf-btn').onclick = () => {
+                const { jsPDF } = window.jspdf;
+                const doc = new jsPDF();
+                doc.text(`Information for ${brochure.company_name}`, 14, 15);
+                doc.text(brochure.raw_text, 14, 25, { maxWidth: 180 });
+                doc.save(`${brochure.company_name}_info.pdf`);
+                addFileToQueueUI('brochures', Date.now(), 'Exported info to PDF.', 'success');
+            };
+
+            toggleModal('info-modal', true);
+        }
+
+        document.getElementById('contacts-modal-body').addEventListener('click', (e) => {
+            const fieldElement = e.target.closest('.editable-field');
+            if (!fieldElement || fieldElement.querySelector('input')) return;
+
+            const originalValue = fieldElement.textContent;
+            const brochureId = fieldElement.dataset.brochureId;
+            const contactId = fieldElement.dataset.contactId;
+            const fieldName = fieldElement.dataset.field;
+
+            fieldElement.innerHTML = `<input type="text" value="${originalValue}" class="w-full bg-gray-800 border border-purple-500 rounded px-2 py-1 text-sm">`;
+            const input = fieldElement.querySelector('input');
+            input.focus();
+            input.select();
+
+            const save = async () => {
+                const newValue = input.value.trim() || 'N/A';
+                fieldElement.textContent = newValue;
+
+                const brochure = contactData.brochures.find(b => b.id === brochureId);
+                const contact = brochure.contacts.find(c => c.id === contactId);
+                contact[fieldName] = newValue;
+
+                await saveEditToServer('brochures', brochureId, fieldName, newValue, contactId);
+            };
+            input.addEventListener('blur', save);
+            input.addEventListener('keydown', (e) => {
+                if (e.key === 'Enter') input.blur();
+                if (e.key === 'Escape') fieldElement.textContent = originalValue;
+            });
+        });
+
+
+        chatSendBtn.addEventListener('click', handleChatSubmit);
+        chatInput.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); handleChatSubmit(); } });
+
+        // ## START: Camera Capture Functionality ##
+        let cameraStream = null;
+        let cameraCaptureMode = null; // 'cards' or 'brochures'
+        let capturedImageBlob = null;
+
+        const cameraModal = document.getElementById('camera-modal');
+        const cameraVideo = document.getElementById('camera-video');
+        const cameraCanvas = document.getElementById('camera-canvas');
+        const cameraPreview = document.getElementById('camera-preview');
+        const cameraLoading = document.getElementById('camera-loading');
+        const cameraError = document.getElementById('camera-error');
+        const cameraCaptureBtn = document.getElementById('camera-capture-btn');
+        const cameraRetakeBtn = document.getElementById('camera-retake-btn');
+        const cameraUseBtn = document.getElementById('camera-use-btn');
+        const cameraCloseBtn = document.getElementById('camera-close-btn');
+
+        // Open camera modal
+        async function openCamera(mode) {
+            cameraCaptureMode = mode;
+            capturedImageBlob = null;
+
+            // Reset UI state
+            cameraVideo.classList.add('hidden');
+            cameraPreview.classList.add('hidden');
+            cameraLoading.classList.remove('hidden');
+            cameraError.classList.add('hidden');
+            cameraCaptureBtn.classList.add('hidden');
+            cameraRetakeBtn.classList.add('hidden');
+            cameraUseBtn.classList.add('hidden');
+
+            // Update modal title
+            const titleText = mode === 'cards' ? 'Capture Business Card' : 'Capture Brochure Page';
+            document.querySelector('#camera-modal-title span').textContent = titleText;
+
+            // Show modal
+            toggleModal('camera-modal', true);
+
+            try {
+                // Request camera access (prefer back camera for documents)
+                cameraStream = await navigator.mediaDevices.getUserMedia({
+                    video: { facingMode: 'environment', width: { ideal: 1920 }, height: { ideal: 1080 } },
+                    audio: false
+                });
+
+                cameraVideo.srcObject = cameraStream;
+                await cameraVideo.play();
+
+                // Show video and capture button
+                cameraLoading.classList.add('hidden');
+                cameraVideo.classList.remove('hidden');
+                cameraCaptureBtn.classList.remove('hidden');
+
+            } catch (err) {
+                console.error('Camera access error:', err);
+                cameraLoading.classList.add('hidden');
+                cameraError.classList.remove('hidden');
+            }
+        }
+
+        // Stop camera stream
+        function stopCamera() {
+            if (cameraStream) {
+                cameraStream.getTracks().forEach(track => track.stop());
+                cameraStream = null;
+            }
+            cameraVideo.srcObject = null;
+        }
+
+        // Capture photo from video
+        function capturePhoto() {
+            cameraCanvas.width = cameraVideo.videoWidth;
+            cameraCanvas.height = cameraVideo.videoHeight;
+            const ctx = cameraCanvas.getContext('2d');
+            ctx.drawImage(cameraVideo, 0, 0);
+
+            // Convert to blob
+            cameraCanvas.toBlob((blob) => {
+                capturedImageBlob = blob;
+
+                // Show preview
+                cameraPreview.src = URL.createObjectURL(blob);
+                cameraVideo.classList.add('hidden');
+                cameraPreview.classList.remove('hidden');
+
+                // Toggle buttons
+                cameraCaptureBtn.classList.add('hidden');
+                cameraRetakeBtn.classList.remove('hidden');
+                cameraUseBtn.classList.remove('hidden');
+            }, 'image/jpeg', 0.92);
+        }
+
+        // Retake photo
+        function retakePhoto() {
+            capturedImageBlob = null;
+            cameraPreview.classList.add('hidden');
+            cameraVideo.classList.remove('hidden');
+
+            cameraRetakeBtn.classList.add('hidden');
+            cameraUseBtn.classList.add('hidden');
+            cameraCaptureBtn.classList.remove('hidden');
+        }
+
+        // Use captured photo
+        async function useCapturedPhoto() {
+            if (!capturedImageBlob || !cameraCaptureMode) {
+                console.error('No captured image or mode');
+                return;
+            }
+
+            // Save values before closing (closeCamera resets them)
+            const imageBlob = capturedImageBlob;
+            const mode = cameraCaptureMode;
+
+            // Close modal
+            closeCamera();
+
+            // Create file from blob
+            const fileName = `camera_${Date.now()}.jpg`;
+            const file = new File([imageBlob], fileName, { type: 'image/jpeg' });
+
+            console.log('Processing camera photo:', fileName, 'Mode:', mode);
+
+            // Process using existing function
+            processFile(mode, file);
+        }
+
+        // Close camera modal
+        function closeCamera() {
+            stopCamera();
+            toggleModal('camera-modal', false);
+            cameraCaptureMode = null;
+            capturedImageBlob = null;
+        }
+
+        // Event listeners for camera buttons
+        document.getElementById('camera-btn-cards').addEventListener('click', () => openCamera('cards'));
+        document.getElementById('camera-btn-brochures').addEventListener('click', () => openCamera('brochures'));
+        cameraCaptureBtn.addEventListener('click', capturePhoto);
+        cameraRetakeBtn.addEventListener('click', retakePhoto);
+        cameraUseBtn.addEventListener('click', useCapturedPhoto);
+        cameraCloseBtn.addEventListener('click', closeCamera);
+        // ## END: Camera Capture Functionality ##
+
+        initCanvas();
+        animate();
+        showPage('page-api-key');
+    </script>
+</body>
+
+</html>