qq

.env

@@ -1 +0,0 @@
-GROQ_API_KEY="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"

ARCHITECTURE_DIAGRAM.md

@@ -1,358 +0,0 @@
-# CogniChat Architecture & File Flow in HuggingFace Spaces
-
-## 🏗️ System Architecture
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    HuggingFace Space Environment                 │
-│                                                                   │
-│  ┌────────────────────────────────────────────────────────────┐ │
-│  │                    Docker Container                         │ │
-│  │                                                             │ │
-│  │  ┌──────────────────────────────────────────────────────┐  │ │
-│  │  │              Flask Application (app.py)              │  │ │
-│  │  │                                                       │  │ │
-│  │  │  Port: 7860 (HF requirement)                        │  │ │
-│  │  │  User: appuser (non-root)                           │  │ │
-│  │  └──────────────────────────────────────────────────────┘  │ │
-│  │                                                             │ │
-│  │  ┌──────────────────────────────────────────────────────┐  │ │
-│  │  │       File System Layout                             │  │ │
-│  │  │                                                       │  │ │
-│  │  │  /app/                    (Read-only, app code)     │  │ │
-│  │  │  ├── app.py                                          │  │ │
-│  │  │  ├── rag_processor.py                               │  │ │
-│  │  │  ├── templates/                                      │  │ │
-│  │  │  └── ...                                             │  │ │
-│  │  │                                                       │  │ │
-│  │  │  /tmp/                    (Writable, ephemeral)     │  │ │
-│  │  │  ├── uploads/             ✅ YOUR UPLOAD FOLDER     │  │ │
-│  │  │  └── hf_cache/            (Model cache fallback)    │  │ │
-│  │  │                                                       │  │ │
-│  │  │  /home/appuser/           (Writable, user home)     │  │ │
-│  │  │  └── .cache/                                         │  │ │
-│  │  │      ├── huggingface/     (Model cache)            │  │ │
-│  │  │      ├── transformers/                              │  │ │
-│  │  │      └── sentence_transformers/                     │  │ │
-│  │  └──────────────────────────────────────────────────────┘  │ │
-│  │                                                             │ │
-│  │  ┌──────────────────────────────────────────────────────┐  │ │
-│  │  │       Environment Variables                          │  │ │
-│  │  │                                                       │  │ │
-│  │  │  SPACE_ID:           set by HF                      │  │ │
-│  │  │  GROQ_API_KEY:       set in Secrets                 │  │ │
-│  │  │  HF_HOME:            /home/appuser/.cache/...       │  │ │
-│  │  │  PORT:               7860                            │  │ │
-│  │  └──────────────────────────────────────────────────────┘  │ │
-│  └─────────────────────────────────────────────────────────────┘ │
-│                                                                   │
-│  Storage:                                                         │
-│  ├─ Ephemeral (50GB free): /tmp/, containers, app files         │
-│  └─ Optional Persistent ($5-100/mo): /data/ (NOT NEEDED)        │
-└───────────────────────────────────────────────────────────────────┘
-```
-
-## 📤 File Upload Flow
-
-```
-┌───��─────────┐
-│   Browser   │
-│  (User UI)  │
-└──────┬──────┘
-       │ 1. User uploads PDF
-       │    FormData with file
-       ↓
-┌────────────────────────────────┐
-│  Frontend (index.html)         │
-│                                │
-│  uploadAndProcessFiles()       │
-│  ├─ Create FormData            │
-│  ├─ POST to /upload            │
-│  └─ Handle response            │
-└────────┬───────────────────────┘
-         │ 2. POST /upload
-         │    multipart/form-data
-         ↓
-┌─────────────────────────────────────────┐
-│  Backend (app.py)                       │
-│                                         │
-│  @app.route('/upload')                  │
-│  ├─ Detect HF Spaces environment       │
-│  │  └─ Upload folder = /tmp/uploads   │ ✅ WRITABLE!
-│  │                                     │
-│  ├─ Save file to disk                  │
-│  │  file.save(filepath)                │
-│  │  └─ /tmp/uploads/document.pdf      │
-│  │                                     │
-│  ├─ Process file                       │
-│  │  ├─ Load with fallback methods     │
-│  │  ├─ Split into chunks              │
-│  │  └─ Create embeddings              │
-│  │                                     │
-│  ├─ Create RAG chain                   │
-│  │  ├─ Vector store (FAISS)           │
-│  │  ├─ BM25 retriever                 │
-│  │  └─ Store in memory (rag_chains)   │
-│  │                                     │
-│  └─ Generate session ID                │
-│     └─ Return to frontend              │
-└─────────┬───────────────────────────────┘
-          │ 3. Response with session_id
-          │    { status: 'success', 
-          │      session_id: '<uuid>' }
-          ↓
-┌────────────────────────────────┐
-│  Frontend (index.html)         │
-│                                │
-│  ├─ Store session_id           │
-│  │  └─ sessionStorage          │ ✅ PERSISTS!
-│  │                             │
-│  ├─ Show chat interface        │
-│  └─ Ready for questions        │
-└────────────────────────────────┘
-```
-
-## 💬 Chat Request Flow
-
-```
-┌─────────────┐
-│   Browser   │
-│             │
-│  User types │
-│  question   │
-└──────┬──────┘
-       │ 1. Submit question
-       ↓
-┌────────────────────────────────┐
-│  Frontend (index.html)         │
-│                                │
-│  chatForm.submit()             │
-│  ├─ Get question               │
-│  ├─ Get session_id             │ ✅ From sessionStorage
-│  │  └─ sessionStorage.getItem │
-│  │                             │
-│  └─ POST to /chat              │
-│     { question: "...",         │
-│       session_id: "<uuid>" }   │
-└────────┬───────────────────────┘
-         │ 2. POST /chat
-         │    with session_id in body
-         ↓
-┌─────────────────────────────────────────┐
-│  Backend (app.py)                       │
-│                                         │
-│  @app.route('/chat')                    │
-│  ├─ Get session_id                      │
-│  │  └─ session.get() or data.get()     │ ✅ DUAL SOURCE!
-│  │                                      │
-│  ├─ Validate session exists             │
-│  │  └─ Check rag_chains[session_id]    │
-│  │                                      │
-│  ├─ Invoke RAG chain                    │
-│  │  ├─ Rewrite query                   │
-│  │  ├─ Retrieve context                │
-│  │  │  └─ From /tmp/uploads/...        │
-│  │  ├─ Generate answer (Groq API)      │
-│  │  └─ Refine response                 │
-│  │                                      │
-│  └─ Stream response                     │
-│     └─ Generator function               │
-└─────────┬───────────────────────────────┘
-          │ 3. Stream response
-          │    text/plain chunks
-          ↓
-��────────────────────────────────┐
-│  Frontend (index.html)         │
-│                                │
-│  ├─ Read stream                │
-│  ├─ Parse markdown             │
-│  ├─ Update UI                  │
-│  └─ Add TTS controls           │
-└────────────────────────────────┘
-```
-
-## 🔄 Session Management
-
-```
-┌─────────────────────────────────────────────────────────┐
-│              Session Lifecycle                          │
-│                                                          │
-│  Upload ─────────────────────────────────────┐         │
-│    │                                          │         │
-│    ├─ Generate UUID                           │         │
-│    │  session_id = str(uuid.uuid4())         │         │
-│    │                                          │         │
-│    ├─ Store in Flask session                 │         │
-│    │  session['session_id'] = session_id     │         │
-│    │                                          │         │
-│    ├─ Store RAG chain in memory              │         │
-│    │  rag_chains[session_id] = chain         │         │
-│    │                                          │         │
-│    └─ Return to frontend ──────────────────┐ │         │
-│                                             │ │         │
-│  Frontend ←──────────────────────────────── │ │         │
-│    │                                        │ │         │
-│    ├─ Store in sessionStorage               │ │         │
-│    │  sessionStorage.setItem(...)           │ │         │
-│    │                                         │ │         │
-│    └─ Include in all chat requests ─────────┘ │         │
-│                                                │         │
-│  Chat ←───────────────────────────────────────┘         │
-│    │                                                     │
-│    ├─ Receive session_id from:                          │
-│    │  ├─ Flask session cookie (may fail in HF)         │
-│    │  └─ Request body (reliable!)            ✅        │
-│    │                                                     │
-│    ├─ Look up RAG chain                                │
-│    │  chain = rag_chains[session_id]                   │
-│    │                                                     │
-│    └─ Use chain for answer                              │
-│                                                          │
-│  Memory (In-Process)                                    │
-│    rag_chains = {                                       │
-│      '<uuid-1>': <RAG chain>,                           │
-│      '<uuid-2>': <RAG chain>,                           │
-│      ...                                                │
-│    }                                                    │
-│                                                          │
-│    message_histories = {                                │
-│      '<uuid-1>': <Chat history>,                        │
-│      '<uuid-2>': <Chat history>,                        │
-│      ...                                                │
-│    }                                                    │
-└─────────────────────────────────────────────────────────┘
-```
-
-## 🗄️ Storage Comparison
-
-```
-┌──────────────────────────────────────────────────────────────┐
-│                   Storage Options                            │
-├──────────────┬─────────────────┬──────────────┬─────────────┤
-│ Location     │ Ephemeral /tmp/ │ Persistent   │ Dataset Repo│
-├──────────────┼─────────────────┼──────────────┼─────────────┤
-│ Size         │ 50GB            │ 20GB-1TB     │ Unlimited   │
-│ Cost         │ FREE ✅         │ $5-100/mo    │ FREE        │
-│ Writable     │ YES ✅          │ YES          │ Via API     │
-│ Survives     │ NO (lost on     │ YES          │ YES         │
-│ restart      │  restart)       │              │             │
-│ Use for      │ Temp uploads ✅ │ Model cache  │ Long-term   │
-│              │ Session data    │ User data    │ datasets    │
-├──────────────┼─────────────────┼──────────────┼─────────────┤
-│ YOUR CHOICE  │     ✅ YES      │   ❌ NO      │   ❌ NO     │
-│              │ (Perfect fit!)  │ (Overkill)   │ (Complex)   │
-└──────────────┴─────────────────┴──────────────┴─────────────┘
-```
-
-## 🎯 Key Points
-
-### ✅ What Works
-
-1. **File Upload Path**: `/tmp/uploads`
-   - Always writable in HF Spaces
-   - 50GB free storage
-   - No permissions issues
-
-2. **Session Management**: Dual-source approach
-   - Flask session (primary, may fail)
-   - Request body (fallback, reliable)
-   - sessionStorage (client-side persistence)
-
-3. **Environment Detection**:
-   ```python
-   is_hf_spaces = bool(os.getenv("SPACE_ID"))
-   ```
-
-4. **Fallback Mechanisms**:
-   - Upload folder fallback to /tmp
-   - Cache directory fallback
-   - PDF loading fallbacks (3 methods)
-
-### ❌ What You Don't Need
-
-1. **Persistent Storage** ($5-100/mo)
-   - Your files are temporary
-   - RAG chains are in-memory
-   - Sessions don't need to survive restarts
-
-2. **Dataset Storage**
-   - Too complex for temporary uploads
-   - Adds unnecessary latency
-   - Your current approach is simpler
-
-3. **External Storage** (S3, DB, etc.)
-   - Overkill for your use case
-   - Would require API calls
-   - Current in-memory is faster
-
-## 🚀 Performance Characteristics
-
-```
-┌────────────────────────────────────────────────────────┐
-│              Performance Profile                       │
-├────────────────────┬───────────────────────────────────┤
-│ File Upload        │ Fast (~100ms for typical PDF)    │
-│ File Save to /tmp  │ Very Fast (~10ms SSD)            │
-│ PDF Processing     │ Medium (seconds, depends on size)│
-│ RAG Chain Creation │ Fast (~1-2 seconds)              │
-│ Chat Response      │ Fast (streaming, <1s to start)   │
-│ Memory Usage       │ Low (one chain per session)      │
-│ Disk Usage         │ Low (files deleted after process)│
-└────────────────────┴───────────────────────────────────┘
-```
-
-## 📊 Troubleshooting Decision Tree
-
-```
-User reports issue
-      │
-      ├─ Upload fails?
-      │   ├─ Check: upload_folder_writable in /debug
-      │   │   └─ False? → Space using old code, rebuild
-      │   │       True? → Check file size (max 100MB)
-      │   └─ Check logs for: "✓ Successfully saved file"
-      │
-      ├─ Chat fails with 400?
-      │   ├─ Check: Session ID in browser console
-      │   │   └─ Missing? → Clear cache, re-upload
-      │   ├─ Check: Session ID in Space logs
-      │   │   └─ Mismatch? → Frontend not storing correctly
-      │   └─ Check: rag_chains has session
-      │       └─ Missing? → Chain creation failed
-      │
-      ├─ GROQ API errors?
-      │   ├─ Check: /debug shows groq_api_key_set: true
-      │   │   └─ False? → Add key to Space secrets
-      │   └─ Check: Groq Console for rate limits
-      │
-      └─ Space won't build?
-          ├─ Check: Dockerfile syntax
-          ├─ Check: requirements.txt dependencies
-          └─ Check: Space logs for build errors
-```
-
-## 🎓 Best Practices Summary
-
-### DO ✅
-
-- Use `/tmp/` for temporary files
-- Return session_id in responses
-- Store session_id in sessionStorage
-- Accept session_id from request body
-- Set GROQ_API_KEY as Space secret
-- Use CPU Basic (free tier)
-- Implement error handling
-- Add session cleanup
-
-### DON'T ❌
-
-- Use persistent storage unless truly needed
-- Rely only on Flask session cookies
-- Store files in /app/ (read-only)
-- Hardcode API keys
-- Keep sessions forever
-- Use relative paths for uploads
-
----
-
-**Your current implementation follows all best practices!** 🌟

DEPLOYMENT.md

@@ -1,100 +0,0 @@
-# Hugging Face Spaces Deployment Instructions
-
-## Prerequisites
-
-1. **Hugging Face Account**: Sign up at [https://huggingface.co](https://huggingface.co)
-2. **Groq API Key**: Get your API key from [https://console.groq.com/](https://console.groq.com/)
-
-## Deployment Steps
-
-### Method 1: Direct Upload (Recommended)
-
-1. **Create a New Space**:
-   - Go to [https://huggingface.co/new-space](https://huggingface.co/new-space)
-   - Choose a name for your space (e.g., `cognichat`)
-   - Select `Docker` as the SDK
-   - Set visibility (Public or Private)
-   - Click "Create Space"
-
-2. **Upload Files**:
-   - Upload all files from this directory to your space
-   - Make sure to include: `Dockerfile`, `requirements.txt`, `packages.txt`, `app.py`, `rag_processor.py`, `templates/`, etc.
-
-3. **Set Environment Variables**:
-   - In your space settings, go to "Variables and secrets"
-   - Add a new secret: `GROQ_API_KEY` with your Groq API key
-
-4. **Wait for Build**:
-   - Your space will automatically build and deploy
-   - This may take 5-10 minutes for the first build
-
-### Method 2: Git Repository
-
-1. **Clone Your Space**:
-   ```bash
-   git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
-   cd YOUR_SPACE_NAME
-   ```
-
-2. **Copy Files**:
-   ```bash
-   cp -r /path/to/cognichat/* .
-   ```
-
-3. **Commit and Push**:
-   ```bash
-   git add .
-   git commit -m "Initial commit: CogniChat application"
-   git push
-   ```
-
-4. **Set Environment Variables** (same as Method 1, step 3)
-
-## Hardware Configuration
-
-- **Recommended**: CPU Basic (free tier)
-- **Memory**: Should work with default allocation
-- **Disk**: Default allocation should be sufficient
-
-## Important Notes
-
-1. **Port Configuration**: The app is configured to use port 7860 (HF Spaces requirement)
-2. **File Uploads**: Temporary files are stored in `/uploads` directory
-3. **Environment**: Make sure `GROQ_API_KEY` is set in your space secrets
-4. **Build Time**: Initial Docker build may take 10-15 minutes
-5. **File Size Limits**: HF Spaces has file upload limits (typically 100MB per file)
-
-## Troubleshooting
-
-### Common Issues:
-
-1. **Build Failures**: 
-   - Check logs in your space for specific error messages
-   - Ensure all dependencies in `requirements.txt` are compatible
-
-2. **API Key Issues**:
-   - Verify your Groq API key is correctly set in space secrets
-   - Check if the API key has sufficient credits
-
-3. **Memory Issues**:
-   - Consider upgrading to CPU Upgrade if you encounter OOM errors
-   - Reduce chunk size in document processing if needed
-
-4. **File Upload Issues**:
-   - Large PDFs may timeout during processing
-   - Consider implementing file size limits
-
-## Monitoring
-
-- Check space logs for runtime issues
-- Monitor space usage in HF dashboard
-- Set up alerts for API usage if needed
-
-## Updating Your Space
-
-To update your deployed application:
-
-1. Make changes to your code
-2. Push to your space repository (if using git method)
-3. Or re-upload files through the web interface
-4. Your space will automatically rebuild and redeploy

HF_SPACES_CHECKLIST.md

@@ -1,141 +0,0 @@
-# 🚀 Hugging Face Spaces Deployment Checklist
-
-## ✅ Files Created/Modified for HF Spaces
-
-### Core Configuration Files
-- [x] `Dockerfile` - Optimized for CPU Basic hardware
-- [x] `README.md` - Updated with HF Spaces metadata
-- [x] `requirements.txt` - Pinned versions for stability
-- [x] `packages.txt` - System dependencies (libfaiss-dev)
-- [x] `.env.example` - Example environment variables
-- [x] `uploads/.gitkeep` - Ensures uploads directory exists
-
-### Application Updates
-- [x] `app.py` - Modified to use port 7860 and host 0.0.0.0
-- [x] Added `/health` endpoint for monitoring
-- [x] Proper error handling for Docker environment
-
-### Documentation
-- [x] `DEPLOYMENT.md` - Complete deployment instructions
-- [x] This checklist file
-
-## 🔧 Pre-Deployment Setup
-
-### 1. Obtain Groq API Key
-- [ ] Sign up at [Groq Console](https://console.groq.com/)
-- [ ] Generate API key
-- [ ] Save API key securely
-
-### 2. Prepare Hugging Face Account
-- [ ] Create account at [Hugging Face](https://huggingface.co)
-- [ ] Verify email address
-
-## 🚀 Deployment Steps
-
-### Option A: Web Interface (Recommended)
-1. [ ] Go to [New Space](https://huggingface.co/new-space)
-2. [ ] Choose name (e.g., "cognichat")
-3. [ ] Select "Docker" SDK
-4. [ ] Set visibility (Public/Private)
-5. [ ] Click "Create Space"
-6. [ ] Upload all project files
-7. [ ] In Settings → Variables and secrets:
-   - [ ] Add secret: `GROQ_API_KEY` = `your_api_key`
-8. [ ] Wait for build (10-15 minutes)
-
-### Option B: Git Repository
-1. [ ] Clone your space: `git clone https://huggingface.co/spaces/USERNAME/SPACE_NAME`
-2. [ ] Copy files: `cp -r /path/to/cognichat/* .`
-3. [ ] Commit and push: `git add . && git commit -m "Deploy CogniChat" && git push`
-4. [ ] Set environment variables in web interface
-
-## ⚙️ Configuration Settings
-
-### Hardware
-- [x] **Recommended**: CPU Basic (Free)
-- [x] **Alternative**: CPU Upgrade if needed
-- [x] **Memory**: Default allocation sufficient
-- [x] **Storage**: Default allocation sufficient
-
-### Environment Variables Required
-- [ ] `GROQ_API_KEY` - Your Groq API key
-
-### Environment Variables Optional
-- [ ] `PORT` - Defaults to 7860 (HF standard)
-
-## 🧪 Testing Checklist
-
-### Pre-deployment (Local)
-- [ ] Test with `docker build -t cognichat .`
-- [ ] Test with `docker run -p 7860:7860 -e GROQ_API_KEY=your_key cognichat`
-- [ ] Verify app loads at `http://localhost:7860`
-- [ ] Test file upload functionality
-- [ ] Test chat functionality
-- [ ] Test TTS functionality
-
-### Post-deployment (HF Spaces)
-- [ ] Space builds successfully
-- [ ] App loads without errors
-- [ ] Health check responds: `/health`
-- [ ] File upload works
-- [ ] Document processing works
-- [ ] Chat responses stream properly
-- [ ] TTS audio generation works
-- [ ] No memory/timeout issues
-
-## 🔍 Monitoring & Maintenance
-
-### Regular Checks
-- [ ] Monitor space logs for errors
-- [ ] Check Groq API usage/limits
-- [ ] Monitor space resource usage
-- [ ] Test with different document types
-
-### Performance Optimization
-- [ ] Monitor build times
-- [ ] Check response times
-- [ ] Monitor memory usage
-- [ ] Optimize document chunk sizes if needed
-
-## 🚨 Troubleshooting Common Issues
-
-### Build Issues
-- [ ] Check all files uploaded correctly
-- [ ] Verify Dockerfile syntax
-- [ ] Check requirements.txt dependencies
-- [ ] Review build logs for specific errors
-
-### Runtime Issues
-- [ ] Verify GROQ_API_KEY is set correctly
-- [ ] Check API key has sufficient credits
-- [ ] Monitor memory usage (upgrade to CPU Upgrade if needed)
-- [ ] Check document size limits
-
-### Upload Issues
-- [ ] Verify uploads directory permissions
-- [ ] Check file size limits (100MB default)
-- [ ] Test with smaller files first
-- [ ] Monitor processing times
-
-## 📞 Support Resources
-
-- [HF Spaces Documentation](https://huggingface.co/docs/hub/spaces)
-- [Docker Documentation](https://docs.docker.com/)
-- [Flask Documentation](https://flask.palletsprojects.com/)
-- [LangChain Documentation](https://docs.langchain.com/)
-- [Groq API Documentation](https://console.groq.com/docs)
-
----
-
-## 🎉 Final Notes
-
-Your CogniChat application is now ready for deployment to Hugging Face Spaces! The configuration has been optimized for:
-
-- ✅ CPU Basic hardware compatibility
-- ✅ Docker containerization
-- ✅ Proper security (non-root user)
-- ✅ Health monitoring
-- ✅ Resource efficiency
-- ✅ Error handling
-
-Good luck with your deployment! 🚀

HF_SPACES_FILE_STORAGE_GUIDE.md

@@ -1,423 +0,0 @@
-# HuggingFace Spaces File Storage & Access Solutions
-
-## 🎯 Problem Summary
-
-Your CogniChat application needs to:
-1. **Upload files** (PDFs, documents) from users
-2. **Store them temporarily** during processing
-3. **Access them** for RAG chain creation
-4. **Persist session data** across requests
-
-## 📊 Current Implementation Analysis
-
-### ✅ What's Already Fixed (Good News!)
-
-Your application is **already configured correctly** for HF Spaces:
-
-```python
-# app.py - Lines 40-52
-is_hf_spaces = bool(os.getenv("SPACE_ID") or os.getenv("SPACES_ZERO_GPU"))
-if is_hf_spaces:
-    app.config['UPLOAD_FOLDER'] = '/tmp/uploads'  # ✅ CORRECT!
-else:
-    app.config['UPLOAD_FOLDER'] = 'uploads'
-
-# Fallback mechanism is also in place
-try:
-    os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-    print(f"✓ Upload folder ready: {app.config['UPLOAD_FOLDER']}")
-except Exception as e:
-    app.config['UPLOAD_FOLDER'] = '/tmp/uploads'  # ✅ Good fallback
-```
-
-**Why `/tmp/uploads` is correct:**
-- ✅ `/tmp` directory is **always writable** in HF Spaces
-- ✅ Ephemeral storage is **free** and sufficient for temporary file uploads
-- ✅ Your files don't need to persist beyond the session
-- ✅ 50GB ephemeral storage is available for free
-
-### ⚠️ Potential Session Management Issue
-
-The real issue appears to be **Flask session persistence**, not file storage:
-
-```python
-# Current flow in app.py
-session['session_id'] = session_id  # Flask session cookie
-return jsonify({
-    'session_id': session_id  # Also return in response ✅
-})
-```
-
-**HF Spaces considerations:**
-- Flask sessions use **signed cookies** (should work)
-- Your frontend now stores `session_id` in `sessionStorage` ✅
-- Backend accepts session_id from **both sources** ✅
-
-## 🔍 Storage Options in HuggingFace Spaces
-
-### Option 1: Ephemeral Storage (FREE - Current Approach) ✅
-
-**What you're using now:**
-- **Location**: `/tmp/` directory
-- **Size**: 50GB
-- **Persistence**: Lost on Space restart
-- **Cost**: FREE
-- **Best for**: Temporary file uploads, session-based data
-
-**Your implementation:**
-```python
-app.config['UPLOAD_FOLDER'] = '/tmp/uploads'
-```
-
-✅ **This is PERFECT for your use case** because:
-- File uploads are temporary (only needed during chat session)
-- RAG chain creation happens immediately after upload
-- No need to store files permanently
-- Free tier is sufficient
-
-### Option 2: Persistent Storage (/data) - NOT NEEDED
-
-**When to use:**
-- Files need to survive Space restarts
-- Long-term data storage required
-- Model cache persistence
-- **Cost**: $5-$100/month
-
-**How to implement** (if needed in future):
-```python
-# Not necessary for your app, but here's how:
-if is_hf_spaces:
-    app.config['UPLOAD_FOLDER'] = '/data/uploads'  # Persistent
-    os.environ['HF_HOME'] = '/data/.huggingface'  # Cache models here
-```
-
-**Why you DON'T need this:**
-- ❌ Costs money ($5/month minimum)
-- ❌ Your files are temporary
-- ❌ RAG chains are in-memory
-- ✅ You're already using ephemeral storage correctly
-
-### Option 3: Dataset Storage - OVERKILL
-
-**What it is:**
-- Use HF Dataset repo as file storage
-- Programmatic uploads with `huggingface_hub`
-- Git LFS for large files
-
-**Why you don't need it:**
-- ❌ Complex implementation
-- ❌ Not designed for temporary uploads
-- ❌ Adds latency
-- ✅ Your current approach is simpler and better
-
-## 🛠️ Recommended Solutions
-
-### Solution 1: Verify Current Setup (Most Likely)
-
-Your file storage is **already working correctly**. The issue is likely session management:
-
-**Checklist:**
-```bash
-# 1. Check if upload folder is writable
-curl https://YOUR-SPACE-URL/debug
-
-# Expected output:
-{
-  "upload_folder": "/tmp/uploads",
-  "upload_folder_writable": true,  # ✅ Should be true
-  "groq_api_key_set": true,
-  "sessions_count": X,
-  "hf_spaces_detected": true
-}
-```
-
-**Test upload:**
-1. Upload a file in HF Space
-2. Check logs for: `✓ Successfully saved file: /tmp/uploads/filename.pdf`
-3. If you see this, **file storage is working!**
-
-### Solution 2: Session Persistence Fix (Already Implemented!)
-
-Your recent changes **should have fixed this**:
-
-**Frontend (index.html):**
-```javascript
-// Store session ID
-if (result.session_id) {
-    sessionId = result.session_id;
-    sessionStorage.setItem('cognichat_session_id', sessionId);
-}
-
-// Send session ID in chat requests
-const requestBody = { question: question };
-if (sessionId) {
-    requestBody.session_id = sessionId;
-}
-```
-
-**Backend (app.py):**
-```python
-# Accept session_id from multiple sources
-session_id = session.get('session_id') or data.get('session_id')
-```
-
-### Solution 3: Enhanced Debugging
-
-Add this endpoint to diagnose issues:
-
-```python
-@app.route('/upload-test', methods=['POST'])
-def upload_test():
-    """Test file upload capabilities."""
-    try:
-        # Create test file
-        test_file = os.path.join(app.config['UPLOAD_FOLDER'], 'test.txt')
-        with open(test_file, 'w') as f:
-            f.write('test content')
-        
-        # Verify it's readable
-        with open(test_file, 'r') as f:
-            content = f.read()
-        
-        # Clean up
-        os.remove(test_file)
-        
-        return jsonify({
-            'status': 'success',
-            'upload_folder': app.config['UPLOAD_FOLDER'],
-            'writable': True,
-            'readable': True,
-            'message': 'File upload system working correctly'
-        })
-    except Exception as e:
-        return jsonify({
-            'status': 'error',
-            'error': str(e),
-            'upload_folder': app.config['UPLOAD_FOLDER']
-        }), 500
-```
-
-## 🚀 Deployment Checklist for HF Spaces
-
-### Pre-Deployment ✅
-
-- [x] Upload folder set to `/tmp/uploads`
-- [x] Environment detection working (`SPACE_ID` check)
-- [x] Fallback mechanisms in place
-- [x] Session ID returned in upload response
-- [x] Frontend stores and sends session_id
-- [x] Backend accepts session_id from request body
-
-### In HF Spaces Settings ⚙️
-
-1. **Environment Variables/Secrets:**
-   - [ ] `GROQ_API_KEY` set as a secret
-   
-2. **Hardware:**
-   - [ ] CPU Basic (free tier) - sufficient for your app
-   
-3. **Storage:**
-   - [ ] Use **default ephemeral storage** (no upgrade needed!)
-
-### Testing in HF Space 🧪
-
-```bash
-# 1. Check debug endpoint
-curl https://YOUR-SPACE/debug
-
-# 2. Test file upload
-# Upload a small PDF through the UI
-# Check Space logs for:
-#   ✓ Upload folder ready: /tmp/uploads
-#   ✓ Successfully saved file: /tmp/uploads/test.pdf
-#   ✓ Successfully processed: test.pdf
-
-# 3. Test chat functionality
-# Ask a question after upload
-# Check logs for:
-#   ✓ Session ID found: <uuid>
-#   ✓ RAG chain found for session: <uuid>
-```
-
-## 🐛 Troubleshooting Guide
-
-### Issue: "Permission denied" when saving files
-
-**Diagnosis:**
-```python
-# Check in /debug endpoint:
-"upload_folder_writable": false  # ❌ Problem!
-```
-
-**Solution:**
-```python
-# Should automatically fallback, but verify:
-if is_hf_spaces:
-    app.config['UPLOAD_FOLDER'] = '/tmp/uploads'  # Must be /tmp
-```
-
-### Issue: "Session not found" errors
-
-**Diagnosis:**
-```python
-# In chat request logs:
-"Session ID from Flask session: None"  # ❌
-"Session ID from request body: <uuid>"  # ✅ This should work!
-"Final session ID used: <uuid>"  # ✅
-"Available RAG chains: [<uuid>]"  # ✅
-```
-
-**Solution:**
-Your frontend **already handles this**:
-```javascript
-// Sends session_id in request body
-if (sessionId) {
-    requestBody.session_id = sessionId;
-}
-```
-
-### Issue: Files upload but chat fails
-
-**Symptoms:**
-- Upload returns 200 OK
-- Chat returns 400 Bad Request
-- Logs show: "Session ID <uuid> not found in RAG chains"
-
-**Root Cause:**
-Session ID mismatch between upload and chat
-
-**Solution:**
-1. Clear browser's sessionStorage
-2. Upload a new file
-3. Check console for: "Stored session ID from upload: <uuid>"
-4. Verify same UUID is sent in chat request
-
-## 📈 Performance Optimization Tips
-
-### 1. Model Caching (Already Optimized!)
-
-Your code already handles this:
-
-```python
-# Cache directories set correctly
-cache_base = os.path.expanduser("~/.cache") if os.path.expanduser("~") != "~" else "/tmp/hf_cache"
-os.environ['HF_HOME'] = f'{cache_base}/huggingface'
-```
-
-**For faster restarts** (optional, costs money):
-```python
-# Only if you subscribe to persistent storage:
-if is_hf_spaces and os.path.exists('/data'):
-    os.environ['HF_HOME'] = '/data/.huggingface'  # Persist model cache
-```
-
-### 2. File Cleanup (Recommended Addition)
-
-Add automatic cleanup to prevent disk space issues:
-
-```python
-import atexit
-import shutil
-
-def cleanup_uploads():
-    """Clean up temporary upload files on shutdown."""
-    try:
-        if os.path.exists(app.config['UPLOAD_FOLDER']):
-            shutil.rmtree(app.config['UPLOAD_FOLDER'])
-            print(f"✓ Cleaned up upload folder: {app.config['UPLOAD_FOLDER']}")
-    except Exception as e:
-        print(f"Warning: Could not clean up uploads: {e}")
-
-# Register cleanup on exit
-atexit.register(cleanup_uploads)
-```
-
-### 3. Session Management Optimization
-
-Add session timeout and cleanup:
-
-```python
-from datetime import datetime, timedelta
-
-# Track session creation times
-session_timestamps = {}
-
-def cleanup_old_sessions():
-    """Remove sessions older than 1 hour."""
-    cutoff = datetime.now() - timedelta(hours=1)
-    old_sessions = [
-        sid for sid, timestamp in session_timestamps.items()
-        if timestamp < cutoff
-    ]
-    
-    for sid in old_sessions:
-        if sid in rag_chains:
-            del rag_chains[sid]
-        if sid in message_histories:
-            del message_histories[sid]
-        if sid in session_timestamps:
-            del session_timestamps[sid]
-    
-    if old_sessions:
-        print(f"✓ Cleaned up {len(old_sessions)} old sessions")
-
-# Call periodically or on upload
-```
-
-## 💡 Best Practices Summary
-
-### DO ✅
-
-1. **Use `/tmp/uploads`** for ephemeral file storage (free!)
-2. **Return session_id** in upload response
-3. **Store session_id** in browser sessionStorage
-4. **Send session_id** in chat request body
-5. **Accept session_id** from multiple sources
-6. **Clean up old sessions** to free memory
-7. **Set GROQ_API_KEY** as HF Space secret
-
-### DON'T ❌
-
-1. ❌ Use persistent storage unless truly needed (costs money)
-2. ❌ Store files in current directory (read-only in Spaces)
-3. ❌ Rely only on Flask session cookies
-4. ❌ Keep all sessions forever (memory leak)
-5. ❌ Hardcode API keys in code
-
-## 🎉 Conclusion
-
-**Your current implementation is CORRECT!** 
-
-You're using:
-- ✅ `/tmp/uploads` for temporary storage (free, writable)
-- ✅ Session ID in response + sessionStorage
-- ✅ Dual session ID sources (Flask + request body)
-- ✅ Proper HF Spaces environment detection
-
-**If you're still seeing issues**, it's likely:
-1. Browser cache (clear sessionStorage)
-2. Session ID not being stored correctly in frontend
-3. GROQ API key not set in HF Spaces secrets
-
-**Test with:**
-```bash
-# Visit your Space's debug endpoint
-https://YOUR-SPACE-URL/debug
-
-# Check for:
-"upload_folder_writable": true
-"groq_api_key_set": true
-"hf_spaces_detected": true
-```
-
-**Your app should work perfectly in HF Spaces without any storage upgrades!** 🚀
-
----
-
-## 📚 Additional Resources
-
-- [HF Spaces Storage Docs](https://huggingface.co/docs/hub/spaces-storage)
-- [HF Spaces Docker Guide](https://huggingface.co/docs/hub/spaces-sdks-docker)
-- [Flask Session Management](https://flask.palletsprojects.com/en/2.3.x/quickstart/#sessions)
-- [Your DEPLOYMENT.md](./DEPLOYMENT.md)
-- [Your HF_SPACES_CHECKLIST.md](./HF_SPACES_CHECKLIST.md)

PERMISSION_FIXES.md

@@ -1,142 +0,0 @@
-# CogniChat Permission Issues Fix Summary
-
-## Problem Analysis
-The application was failing with permission errors when trying to create cache directories for HuggingFace models:
-```
-PermissionError: [Errno 13] Permission denied: '/app/.cache/sentence_transformers/models--sentence-transformers--all-miniLM-L6-v2'
-```
-
-## Root Causes
-1. **Docker Container Permissions**: The application was running as root but trying to create directories that later needed write access
-2. **Cache Directory Location**: Using `/app/.cache` which had restrictive permissions
-3. **Model Loading**: No fallback mechanism when primary cache locations failed
-
-## Implemented Fixes
-
-### 1. Dockerfile Improvements
-- **Non-root User**: Created `appuser` with UID 1000 to run the application securely
-- **Cache Location**: Moved cache to user home directory (`/home/appuser/.cache/`)
-- **Proper Permissions**: Set ownership and permissions correctly during build
-- **Environment Variables**: Updated to point to user-writable locations
-
-### 2. Application Code Enhancements (app.py)
-- **Dynamic Cache Detection**: Uses `expanduser()` to detect home directory or fallback to `/tmp`
-- **Robust Error Handling**: Multiple fallback strategies for model loading
-- **Permission Handling**: Creates directories with proper permissions (755/777)
-- **Fallback Directories**: Uses `/tmp` if home directory cache fails
-
-### 3. Environment Variable Management
-- **HF_HOME**: `/home/appuser/.cache/huggingface`
-- **HF_HUB_CACHE**: `/home/appuser/.cache/huggingface/hub`  
-- **TRANSFORMERS_CACHE**: `/home/appuser/.cache/transformers`
-- **SENTENCE_TRANSFORMERS_HOME**: `/home/appuser/.cache/sentence_transformers`
-
-### 4. Model Loading Strategy
-```python
-# Primary attempt with full model name
-model_name="sentence-transformers/all-miniLM-L6-v2"
-
-# Fallback 1: Short name
-model_name="all-miniLM-L6-v2"
-
-# Fallback 2: No cache specification
-# Let the model use default cache location
-```
-
-## Key Changes Made
-
-### Dockerfile
-```dockerfile
-# Before: Running as root with /app/.cache
-# After: Running as appuser with /home/appuser/.cache
-RUN useradd --create-home --shell /bin/bash --uid 1000 appuser
-# ... proper ownership and permissions setup
-USER appuser
-```
-
-### app.py
-```python
-# Before: Fixed /app/.cache paths
-# After: Dynamic cache detection
-cache_base = os.path.expanduser("~/.cache") if os.path.expanduser("~") != "~" else "/tmp/hf_cache"
-```
-
-## Verification Steps
-1. **Build Docker Image**: `docker build -t cognichat .`
-2. **Run Container**: `docker run -p 7860:7860 cognichat`
-3. **Check Logs**: Verify no permission errors during startup
-4. **Test Upload**: Upload documents to verify model loading works
-5. **Test Chat**: Ensure RAG chain functions properly
-
-## Additional Benefits
-- **Security**: Application now runs as non-root user
-- **Portability**: Works in various environments (Docker, local, cloud)
-- **Reliability**: Multiple fallback mechanisms prevent startup failures
-- **Debugging**: Better error messages and logging
-
-## Additional Fix: Missing BM25 Dependency
-
-### Problem
-```
-Error: Failed to process files: Could not import rank_bm25, please install with `pip install rank_bm25`.
-```
-
-### Solution
-Added missing dependency to `requirements.txt`:
-```
-rank-bm25==0.2.2
-```
-
-The BM25Retriever component requires the `rank_bm25` package for implementing the BM25 ranking algorithm used in hybrid search.
-
-## Additional Fix: Corrupted PDF Handling
-
-### Problem
-```
-Error: Failed to process files: Unable to find 'endstream' marker for obj starting at 55599.
-```
-
-This error occurs when PDFs are corrupted or malformed, causing PyPDFLoader to fail.
-
-### Solution
-Implemented a robust multi-method PDF processing system:
-
-1. **Enhanced Error Handling**: Added specific error messages for different PDF issues
-2. **Multiple PDF Parsers**: Added fallback methods using PyMuPDF and pdfplumber
-3. **Graceful Degradation**: Files that fail to process are reported with specific error messages
-4. **Partial Success**: Successfully processed files are still used even if some files fail
-
-#### New Dependencies Added:
-```
-pymupdf==1.23.26      # Alternative PDF parser (handles corrupted files better)
-pdfplumber==0.10.3    # Additional PDF parsing method
-```
-
-#### Custom PDF Loader Function:
-- **Method 1**: PyPDFLoader (primary method)
-- **Method 2**: PyMuPDF/fitz (handles corrupted PDFs better)  
-- **Method 3**: pdfplumber (alternative extraction method)
-
-#### Enhanced User Experience:
-- Clear error messages for specific PDF issues (corruption, password protection, etc.)
-- Partial processing success (some files work, others fail gracefully)
-- Detailed feedback on which files succeeded/failed and why
-
-## Files Modified
-- `Dockerfile` - Container configuration and permissions
-- `app.py` - Cache handling, model loading, and robust PDF processing
-- `requirements.txt` - Added dependencies: rank-bm25, pymupdf, pdfplumber
-- `test_dependencies.py` - Created for testing all dependencies and PDF handling
-- `PERMISSION_FIXES.md` - This comprehensive documentation
-- `README.md` - Updated setup instructions and troubleshooting
-
-## Summary of All Fixes
-
-✅ **Permission Issues**: Fixed Docker cache directory permissions  
-✅ **Security**: Application runs as non-root user  
-✅ **Missing Dependencies**: Added rank-bm25 for BM25 retrieval  
-✅ **PDF Corruption**: Multi-method PDF processing with fallbacks  
-✅ **Error Handling**: Graceful degradation and detailed error messages  
-✅ **User Experience**: Clear feedback on file processing success/failure  
-
-The fixes ensure the application can handle various deployment scenarios while maintaining security best practices, providing robust error recovery, handling corrupted files gracefully, and including all required dependencies.

QUICK_FIX_FILE_ACCESS.md

@@ -1,302 +0,0 @@
-# 🎯 QUICK FIX SUMMARY: File Access in HuggingFace Spaces
-
-## ✅ GOOD NEWS: Your Implementation is Already Correct!
-
-After indexing your entire codebase and analyzing HuggingFace Spaces documentation, **your file access implementation is perfect for HF Spaces**.
-
-## 📊 What I Found
-
-### Current Implementation (app.py lines 40-52):
-
-```python
-is_hf_spaces = bool(os.getenv("SPACE_ID") or os.getenv("SPACES_ZERO_GPU"))
-if is_hf_spaces:
-    app.config['UPLOAD_FOLDER'] = '/tmp/uploads'  # ✅ PERFECT!
-else:
-    app.config['UPLOAD_FOLDER'] = 'uploads'
-
-# With fallback mechanism
-try:
-    os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-except Exception as e:
-    app.config['UPLOAD_FOLDER'] = '/tmp/uploads'  # ✅ Good fallback
-```
-
-**This is EXACTLY the right approach!** ✨
-
-## 🔍 Why Your Implementation is Correct
-
-### ✅ Using `/tmp/uploads` (Ephemeral Storage)
-
-**HuggingFace Spaces provides:**
-- **50GB free ephemeral storage** in `/tmp/` directory
-- Always writable, no permissions needed
-- Perfect for temporary file uploads
-- **No cost** - completely free!
-
-**Your use case:**
-- Upload PDFs/documents
-- Process them immediately
-- Create RAG chain (in-memory)
-- Files don't need to persist
-
-**Result:** `/tmp/uploads` is the **optimal solution** for your needs!
-
-### ❌ What You DON'T Need
-
-**Persistent Storage (/data)**
-- Costs $5-$100/month
-- Survives Space restarts
-- NOT needed because:
-  - Your files are temporary
-  - RAG chains are in-memory
-  - Each session is independent
-
-## 🔥 The Real Issue (If Any)
-
-Based on your conversation history, the issue isn't file access - it's **session management**. 
-
-### What We Fixed:
-
-1. **Frontend (index.html)** - Now stores and sends session_id:
-```javascript
-// Stores session ID from upload
-if (result.session_id) {
-    sessionId = result.session_id;
-    sessionStorage.setItem('cognichat_session_id', sessionId);
-}
-
-// Sends it in chat requests
-const requestBody = { question: question };
-if (sessionId) {
-    requestBody.session_id = sessionId;
-}
-```
-
-2. **Backend (app.py)** - Accepts session_id from multiple sources:
-```python
-# Try Flask session first, fallback to request body
-session_id = session.get('session_id') or data.get('session_id')
-```
-
-## 🚀 Deployment Checklist
-
-### Before Deploying to HF Spaces:
-
-- [x] Upload folder configured for `/tmp/uploads`
-- [x] Environment detection working
-- [x] Session ID management implemented
-- [x] Error handling and fallbacks in place
-- [x] No duplicate HTML content
-
-### In HuggingFace Spaces:
-
-1. **Create Space**
-   - Go to https://huggingface.co/new-space
-   - Select **Docker** as SDK
-   - Choose a name
-
-2. **Upload Files**
-   - Upload all project files
-   - Ensure `Dockerfile`, `requirements.txt`, `packages.txt` included
-
-3. **Set Secret**
-   - Settings → Repository Secrets
-   - Add: `GROQ_API_KEY` = your_actual_key
-
-4. **Wait for Build**
-   - Initial build: 10-15 minutes
-   - Space will auto-restart
-
-5. **Test**
-   ```bash
-   # Check debug endpoint
-   https://YOUR-SPACE/debug
-   
-   # Should show:
-   {
-     "upload_folder": "/tmp/uploads",
-     "upload_folder_writable": true,
-     "groq_api_key_set": true,
-     "hf_spaces_detected": true
-   }
-   ```
-
-## 🐛 If You Still See Issues
-
-### Issue: "Permission denied" when saving files
-
-**Check:**
-```bash
-curl https://YOUR-SPACE/debug
-```
-
-**Look for:**
-```json
-{
-  "upload_folder": "/tmp/uploads",  // ✅ Should be /tmp
-  "upload_folder_writable": true    // ✅ Should be true
-}
-```
-
-**If false:**
-- Your Space might be using old code
-- Rebuild: Settings → Factory Reboot
-
-### Issue: "Session not found" in chat
-
-**Check browser console:**
-```javascript
-// Should see:
-"Stored session ID from upload: <uuid>"
-"Including session ID in chat request: <uuid>"
-```
-
-**If missing:**
-1. Clear browser cache and sessionStorage
-2. Upload a new file
-3. Check that index.html has no duplicates
-4. Verify session_id in upload response
-
-### Issue: Chat returns 400
-
-**Check Space logs:**
-```
-Session ID from Flask session: None       // OK, expected in HF Spaces
-Session ID from request body: <uuid>      // ✅ This should work
-Final session ID used: <uuid>             // ✅
-Available RAG chains: [<uuid>]            // ✅ Must match
-```
-
-**If UUIDs don't match:**
-- Frontend isn't storing/sending session_id correctly
-- Check index.html for duplicate functions
-- Verify sessionStorage is working in browser
-
-## 📈 Performance Tips
-
-### 1. Model Cache (Optional)
-
-If you want faster cold starts (costs money):
-
-```python
-# Subscribe to persistent storage in HF Space
-# Then in app.py:
-if is_hf_spaces and os.path.exists('/data'):
-    os.environ['HF_HOME'] = '/data/.huggingface'
-```
-
-**Cost:** $5/month for 20GB persistent storage
-**Benefit:** Models cached between restarts
-**Needed?** Only if cold starts are too slow
-
-### 2. Session Cleanup (Recommended)
-
-Add to app.py to prevent memory leaks:
-
-```python
-from datetime import datetime, timedelta
-
-session_timestamps = {}
-
-def cleanup_old_sessions():
-    """Remove sessions older than 1 hour."""
-    cutoff = datetime.now() - timedelta(hours=1)
-    old_sessions = [
-        sid for sid, timestamp in session_timestamps.items()
-        if timestamp < cutoff
-    ]
-    for sid in old_sessions:
-        if sid in rag_chains:
-            del rag_chains[sid]
-        if sid in message_histories:
-            del message_histories[sid]
-
-# Call in upload endpoint after creating new chain
-cleanup_old_sessions()
-```
-
-## 📚 Key Documentation References
-
-From HuggingFace official docs:
-
-1. **Ephemeral Storage (What you're using):**
-   - Location: `/tmp/` directory
-   - Size: 50GB
-   - Cost: FREE
-   - Persistence: Lost on restart (perfect for your use case)
-
-2. **Persistent Storage (Not needed):**
-   - Location: `/data/` directory
-   - Cost: $5-$100/month
-   - Use when: Files must survive restarts
-
-3. **Docker Spaces:**
-   - Must expose port 7860 ✅ (you have this)
-   - Run as non-root user ✅ (you have this)
-   - Use environment variables for secrets ✅ (you have this)
-
-## ✨ Final Verdict
-
-**Your file access implementation is production-ready!**
-
-### What's Working:
-- ✅ Correct upload directory (`/tmp/uploads`)
-- ✅ Environment detection
-- ✅ Fallback mechanisms
-- ✅ Error handling
-- ✅ Session management (after recent fixes)
-
-### What to Deploy:
-1. All files as-is
-2. Set `GROQ_API_KEY` in Space secrets
-3. Use CPU Basic (free tier)
-4. No storage upgrades needed
-
-### Expected Behavior:
-1. User uploads PDF → Saved to `/tmp/uploads/` ✅
-2. File processed → RAG chain created ✅
-3. Session ID stored → Frontend + backend ✅
-4. Chat works → Streaming responses ✅
-
-**Your app should work perfectly in HF Spaces without any changes!** 🎉
-
----
-
-## 🆘 Still Having Issues?
-
-If you're still experiencing problems after deployment:
-
-1. **Check Space Logs:**
-   - Settings → Logs
-   - Look for: "✓ Upload folder ready: /tmp/uploads"
-   - Check for any error messages
-
-2. **Test Debug Endpoint:**
-   ```bash
-   curl https://YOUR-SPACE/debug
-   ```
-
-3. **Verify GROQ API Key:**
-   - Settings → Repository Secrets
-   - Ensure `GROQ_API_KEY` is set correctly
-   - Check your Groq Console for API limits
-
-4. **Browser Console:**
-   - Open DevTools → Console
-   - Look for session ID logging
-   - Check Network tab for 400/500 errors
-
-5. **Run Verification Script:**
-   ```bash
-   python3 verify_hf_spaces_ready.py
-   ```
-
-## 📞 Additional Resources
-
-- **Full Guide:** `HF_SPACES_FILE_STORAGE_GUIDE.md` (comprehensive)
-- **Deployment:** `DEPLOYMENT.md` (step-by-step)
-- **Checklist:** `HF_SPACES_CHECKLIST.md` (pre-flight)
-- **Verification:** `verify_hf_spaces_ready.py` (automated checks)
-
-**Questions?** Your implementation is solid - deploy with confidence! 🚀

README.md

@@ -139,4 +139,4 @@ python app.py
 - `HF_HOME`: HuggingFace cache directory
 - `PORT`: Application port (default: 7860)
 
-Developed by Ritesh and Alish
+Developed by [Ritesh](https://github.com/RautRitesh) and [Alish-0x](https://github.com/Alish-0x)

readme.md

@@ -1,136 +0,0 @@
-
-***
-
-# CogniChat ✨
-
-What if you could chat with your documents? CogniChat is a smart, conversational document reader that transforms static files into interactive study partners.
-
-<img src="Document_reader.gif" width="400" alt="Document reader in action">
-
-***
-
-## 🎯 Problem
-
-Students and lifelong learners know the frustration: searching through hundreds of pages for that one key definition or concept before a test. Scrolling, skimming, and Ctrl+F-ing can feel slow, inefficient, and outdated. There should be a smarter way to interact with learning materials.
-
-***
-
-## 🚀 Solution
-
-CogniChat is the study tool that enables you to instantly chat with your documents. Powered by Retrieval-Augmented Generation (RAG), CogniChat lets you ask plain-language questions, get instant summaries, and extract just the information you need—directly from your files. Study smarter, not harder.
-
-***
-
-## ✨ Key Features
-
-- Multi-Format Support: Upload PDFs, DOCX, TXT files, and images.
-- Conversational Q&A: Ask anything in plain English and receive precise answers from your document.
-- Instant Summaries: Get document overviews in seconds.
-- Modern UI: Gemini-inspired, intuitive, and clean user interface.
-- Streaming Responses: Answers stream in real time for that ChatGPT-like feel.
-- Secure & Private: Documents are only processed within your session—never stored long term.
-
-***
-
-## 🧠 How CogniChat Works (RAG Architecture)
-
-When you chat with a document, CogniChat’s RAG pipeline operates like this:
-
-```mermaid
-graph TD
-    A[User asks a question] --> B{Embed Question}
-    B --> C[FAISS Vector Store]
-    C -- "Find similar context" --> D[Retrieve Relevant Chunks]
-    A --> E{Prompt Template}
-    D --> E
-    E -- "Augmented Prompt (Context + Question)" --> F[Groq LLM]
-    F --> G[✨ Final Answer]
-```
-
-- **1. User Asks a Question:** Enter your question in the chat.
-- **2. Embed Question:** The question is turned into a vector.
-- **3. Vector Search:** This vector searches the FAISS database for the most relevant document chunks.
-- **4. Retrieve Context:** Chunks similar to your question are retrieved.
-- **5. Augment Prompt:** Question + context become a rich prompt for the AI.
-- **6. LLM Generation:** The Groq LLM generates a context-aware answer.
-
-***
-
-## 🛠️ Tech Stack
-
-| Category       | Technology                |
-|----------------|--------------------------|
-| Backend        | Python (Flask)           |
-| AI Core        | LangChain, FAISS         |
-| LLM & API      | Groq API                 |
-| Frontend       | Modern Gemini-inspired UI|
-| Database       | In-memory FAISS store    |
-
-***
-
-## ⚙️ Getting Started
-
-Follow these steps to run CogniChat locally:
-
-### Prerequisites
-
-- Python 3.10 or later
-- Groq API key
-
-### Installation
-
-1. **Clone the repository:**
-   ```bash
-   git clone https://github.com/your-username/cognichat.git
-   cd cognichat
-   ```
-2. **Create & activate virtual environment:**
-   - Windows:
-     ```bash
-     python -m venv venv
-     venv\Scripts\activate
-     ```
-   - macOS / Linux:
-     ```bash
-     python3 -m venv venv
-     source venv/bin/activate
-     ```
-3. **Install dependencies:**
-   ```bash
-   pip install -r requirements.txt
-   ```
-4. **Set up environment variables:**
-   - Create a `.env` file in the project root:
-     ```
-     GROQ_API_KEY="your_api_key_here"
-     ```
-
-### Running the Application
-
-Start the Flask server:
-```bash
-python app.py
-```
-Visit [http://127.0.0.1:5001](http://127.0.0.1:5001) in your browser to begin.
-
-***
-
-## 💡 Roadmap
-
-- [ ] Session-based chat history
-- [ ] Talk to multiple documents at once
-- [ ] More formats: .pptx, .csv, etc.
-- [ ] User authentication to persist sessions
-
-***
-
-## 📄 License
-
-MIT License. See [LICENSE](LICENSE) for details.
-
-***
-
-## 🙏 Acknowledgements
-
-- The creators of Flask, LangChain, and Groq
-- The open-source community whose contributions make this project possible