Update main.py

main.py

@@ -1,896 +1,896 @@
-"""
-FastAPI Backend for NotebookPRO
-Handles RAG, LLM, file processing, and chat management
-"""
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import List, Optional, Dict, Any
-from pathlib import Path
-import json
-from datetime import datetime
-import uuid
-import sys
-import warnings
-import logging
-import os
-import shutil
-
-# Suppress warnings
-warnings.filterwarnings('ignore')
-os.environ['PYTHONWARNINGS'] = 'ignore'
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
-os.environ['TOKENIZERS_PARALLELISM'] = 'false'
-os.environ.setdefault('OMP_NUM_THREADS', '2')
-os.environ.setdefault('MKL_NUM_THREADS', '2')
-os.environ.setdefault('OPENBLAS_NUM_THREADS', '2')
-os.environ.setdefault('NUMEXPR_NUM_THREADS', '2')
-#logging.getLogger().setLevel(logging.ERROR)
-
-# Add project root to path
-sys.path.append(str(Path(__file__).parent.parent))
-
-import config
-from utils.document_processor import DocumentProcessor
-from utils.vector_db import VectorDatabase
-from utils.hybrid_retriever import HybridRetriever
-from utils.llm_generator import LLMGenerator
-from utils.config_manager import ConfigManager
-from utils.spaces_manager import SpacesManager
-from utils.studio_manager import StudioManager
-from utils.studio_generator import StudioGenerator
-
-# Initialize FastAPI
-app = FastAPI(title="NotebookPRO API", version="2.0.0")
-
-# CORS - Allow Flutter web to connect
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # In production, specify your Flutter web URL
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global instances
-config_manager = ConfigManager()
-spaces_manager = SpacesManager()
-studio_manager = StudioManager()
-studio_generator = None  # Will be initialized after LLM
-vector_db = None
-llm_generator = None
-current_space = None
-
-# ==================== Pydantic Models ====================
-
-class ChatMessage(BaseModel):
-    role: str
-    content: str
-    timestamp: str
-    sources: Optional[List[Dict[str, Any]]] = None
-
-class ChatRequest(BaseModel):
-    query: str
-    space_id: str
-    chat_id: Optional[str] = None
-    workflow: str = "chat"
-
-class ChatResponse(BaseModel):
-    response: str
-    sources: List[Dict[str, Any]]
-    chat_id: str
-    timestamp: str
-
-class SpaceCreate(BaseModel):
-    name: str
-
-class SpaceResponse(BaseModel):
-    id: str
-    name: str
-    created_at: str
-    file_count: int
-
-class ChatInfo(BaseModel):
-    id: str
-    title: str
-    preview: str
-    created_at: str
-    updated_at: str
-    message_count: int
-
-class ConfigResponse(BaseModel):
-    groq_api_key: Optional[str]
-    gemini_api_key: Optional[str]
-
-class ConfigUpdate(BaseModel):
-    groq_api_key: Optional[str] = None
-    gemini_api_key: Optional[str] = None
-
-class ChatToNotebookRequest(BaseModel):
-    space_id: str
-    question: str
-    answer: str
-    chat_id: Optional[str] = None
-    assistant_timestamp: Optional[str] = None
-    tags: List[str] = []
-    space_name: Optional[str] = None
-
-# ==================== Helper Functions ====================
-
-def get_data_dir():
-    """Get data directory path"""
-    return Path(__file__).parent.parent / "data"
-
-def get_space_dir(space_id: str):
-    """Get space-specific directory"""
-    return get_data_dir() / "spaces" / space_id
-
-def load_chats_for_space(space_id: str) -> List[Dict]:
-    """Load all chats for a space"""
-    chats_file = get_space_dir(space_id) / "chats.json"
-    if chats_file.exists():
-        with open(chats_file, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    return []
-
-def save_chats_for_space(space_id: str, chats: List[Dict]):
-    """Save chats for a space"""
-    chats_file = get_space_dir(space_id) / "chats.json"
-    chats_file.parent.mkdir(parents=True, exist_ok=True)
-    with open(chats_file, 'w', encoding='utf-8') as f:
-        json.dump(chats, f, indent=2, ensure_ascii=False)
-
-def get_chat_title(messages: List[Dict]) -> str:
-    """Generate chat title from first user message"""
-    for msg in messages:
-        if msg['role'] == 'user':
-            content = msg['content'][:50]
-            return content + "..." if len(msg['content']) > 50 else content
-    return "New Chat"
-
-def ensure_notebooks_for_existing_spaces() -> int:
-    """Ensure every existing space has an associated notebook metadata record."""
-    created_count = 0
-    spaces = spaces_manager.get_all_spaces()
-
-    for space in spaces:
-        space_id = space.get('id')
-        if not space_id:
-            continue
-
-        existing_notebook = studio_manager.get_space_notebook(space_id)
-        if existing_notebook:
-            continue
-
-        studio_manager.ensure_space_notebook(space_id, space.get('name', space_id))
-        created_count += 1
-
-    return created_count
-
-def rebuild_space_index_if_missing(space_id: str) -> int:
-    """Rebuild a space index from uploaded files if the current index is empty."""
-    if not vector_db:
-        return 0
-
-    try:
-        if vector_db.get_collection_count() > 0:
-            return 0
-    except Exception:
-        # If count check fails, continue with a best-effort rebuild.
-        pass
-
-    uploads_dir = get_space_dir(space_id) / "uploads"
-    if not uploads_dir.exists():
-        return 0
-
-    files = [
-        p for p in uploads_dir.iterdir()
-        if p.is_file() and p.suffix.lower() in {".pdf", ".docx", ".txt"}
-    ]
-    if not files:
-        return 0
-
-    processor = DocumentProcessor()
-    texts: List[str] = []
-    metadatas: List[Dict[str, Any]] = []
-    ids: List[str] = []
-
-    for file_path in files:
-        try:
-            file_data = processor.process_file(file_path)
-            chunks = processor.chunk_text(
-                file_data['content'],
-                chunk_size=512,
-                overlap=50,
-                semantic=True,
-            )
-            total_chunks = len(chunks)
-            for idx, chunk in enumerate(chunks):
-                texts.append(chunk)
-                metadatas.append({
-                    'filename': file_path.name,
-                    'chunk_index': idx,
-                    'total_chunks': total_chunks,
-                    'source_type': file_data['format'],
-                })
-                ids.append(f"{space_id}_rebuild_{len(ids)}_{uuid.uuid4().hex[:8]}")
-        except Exception as e:
-            print(f"Index rebuild skipped {file_path.name}: {e}")
-
-    if not texts:
-        return 0
-
-    batch_size = 5000
-    for i in range(0, len(texts), batch_size):
-        vector_db.add_documents(
-            texts[i:i + batch_size],
-            metadatas[i:i + batch_size],
-            ids[i:i + batch_size],
-        )
-
-    print(f"Rebuilt index for space '{space_id}' with {len(texts)} chunks")
-    return len(texts)
-
-def initialize_space(space_id: str):
-    """Initialize vector DB and components for a space"""
-    global vector_db, llm_generator, studio_generator, current_space
-
-    # Fast path: reuse already initialized components for the active space.
-    if current_space == space_id and vector_db is not None and llm_generator is not None:
-        return
-    
-    # Get API keys
-    import os
-    # Try the config manager first, but fallback to the .env file variables
-    groq_key = config_manager.get_api_key('groq') or os.getenv('GROQ_API_KEY')
-    gemini_key = config_manager.get_api_key('gemini') or os.getenv('GOOGLE_API_KEY') or os.getenv('GEMINI_API_KEY')
-    
-    if not groq_key and not gemini_key:
-        raise HTTPException(status_code=400, detail="No API keys configured. Please add Groq or Gemini API key.")
-    
-    # Initialize vector database for this space (space-local persistence path).
-    # Initialize Qdrant cloud database for this space
-    vector_db = VectorDatabase(
-        collection_name=f"space_{space_id}"
-    )
-
-    # Backward-compatibility: rebuild embeddings from uploaded files if index is empty.
-    rebuild_space_index_if_missing(space_id)
-    
-    # Initialize LLM generator - choose provider based on available keys
-    if groq_key:
-        llm_generator = LLMGenerator(provider="groq", api_key=groq_key)
-    else:
-        llm_generator = LLMGenerator(provider="gemini", api_key=gemini_key)
-    
-    # Initialize studio generator with LLM
-    studio_generator = StudioGenerator(llm_generator, studio_manager)
-    current_space = space_id
-
-@app.on_event("startup")
-async def startup_sync_notebooks():
-    """Auto-create missing notebooks for pre-existing spaces when backend starts."""
-    try:
-        created = ensure_notebooks_for_existing_spaces()
-        if created > 0:
-            print(f"Created {created} missing notebook(s) for existing spaces")
-    except Exception as e:
-        # Keep server startup resilient even if sync fails.
-        print(f"Notebook startup sync failed: {e}")
-
-# ==================== API Endpoints ====================
-
-@app.get("/")
-async def root():
-    """Health check"""
-    return {"status": "NotebookPRO API is running", "version": "2.0.0"}
-
-@app.get("/api/config", response_model=ConfigResponse)
-async def get_config():
-    """Get current API keys (masked)"""
-    groq_key = config_manager.get_api_key('groq')
-    gemini_key = config_manager.get_api_key('gemini')
-    
-    return ConfigResponse(
-        groq_api_key="***" + groq_key[-4:] if groq_key else None,
-        gemini_api_key="***" + gemini_key[-4:] if gemini_key else None
-    )
-
-@app.post("/api/config")
-async def update_config(config_update: ConfigUpdate):
-    """Update API keys"""
-    if config_update.groq_api_key:
-        config_manager.set_api_key('groq', config_update.groq_api_key)
-    if config_update.gemini_api_key:
-        config_manager.set_api_key('gemini', config_update.gemini_api_key)
-    
-    return {"status": "success", "message": "Configuration updated"}
-
-@app.get("/api/spaces", response_model=List[SpaceResponse])
-async def get_spaces():
-    """Get all spaces"""
-    # Self-healing check in case spaces were created externally while server is running.
-    ensure_notebooks_for_existing_spaces()
-    spaces = spaces_manager.get_all_spaces()
-    
-    result = []
-    for space in spaces:
-        space_id = space['id']
-        space_dir = get_space_dir(space_id)
-        processed_file = space_dir / "processed_files.json"
-        
-        file_count = 0
-        if processed_file.exists():
-            with open(processed_file, 'r') as f:
-                file_count = len(json.load(f))
-        
-        result.append(SpaceResponse(
-            id=space_id,
-            name=space['name'],
-            created_at=space['created_at'],
-            file_count=file_count
-        ))
-    
-    return result
-
-@app.post("/api/spaces", response_model=SpaceResponse)
-async def create_space(space_data: SpaceCreate):
-    """Create a new space"""
-    try:
-        space = spaces_manager.create_space(space_data.name)
-
-        # Create associated notebook metadata with the same name as the space.
-        studio_manager.ensure_space_notebook(space['id'], space['name'])
-        
-        return SpaceResponse(
-            id=space['id'],
-            name=space['name'],
-            created_at=space['created_at'],
-            file_count=0
-        )
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.delete("/api/spaces/{space_id}")
-async def delete_space(space_id: str):
-    """Delete a space"""
-    try:
-        spaces_manager.delete_space(space_id)
-        
-        # Delete space directory
-        space_dir = get_space_dir(space_id)
-        if space_dir.exists():
-            shutil.rmtree(space_dir)
-        
-        return {"status": "success", "message": f"Space {space_id} deleted"}
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error deleting space: {str(e)}")
-
-@app.get("/api/spaces/{space_id}/chats", response_model=List[ChatInfo])
-async def get_chats(space_id: str):
-    """Get all chats for a space"""
-    chats = load_chats_for_space(space_id)
-    
-    result = []
-    for chat in chats:
-        messages = chat.get('messages', [])
-        result.append(ChatInfo(
-            id=chat['id'],
-            title=get_chat_title(messages),
-            preview=messages[0]['content'][:100] if messages else "",
-            created_at=chat.get('created_at', ''),
-            updated_at=chat.get('updated_at', ''),
-            message_count=len(messages)
-        ))
-    
-    return result
-
-@app.get("/api/spaces/{space_id}/chats/{chat_id}")
-async def get_chat(space_id: str, chat_id: str):
-    """Get specific chat by ID"""
-    chats = load_chats_for_space(space_id)
-    
-    for chat in chats:
-        if chat['id'] == chat_id:
-            return chat
-    
-    raise HTTPException(status_code=404, detail="Chat not found")
-
-@app.delete("/api/spaces/{space_id}/chats/{chat_id}")
-async def delete_chat(space_id: str, chat_id: str):
-    """Delete a chat"""
-    chats = load_chats_for_space(space_id)
-    chats = [c for c in chats if c['id'] != chat_id]
-    save_chats_for_space(space_id, chats)
-    
-    return {"status": "success", "message": f"Chat {chat_id} deleted"}
-
-@app.post("/api/chat", response_model=ChatResponse)
-async def chat(request: ChatRequest):
-    """Process a chat message with RAG"""
-    try:
-        # Initialize space if needed
-        initialize_space(request.space_id)
-        
-        # Create hybrid retriever with 60% vector, 40% BM25
-        hybrid_retriever = HybridRetriever(vector_db, alpha=0.6)
-        
-        # Retrieve relevant documents
-        documents, metadatas, scores = hybrid_retriever.retrieve(
-            query=request.query,
-            n_results=5
-        )
-        
-        # Build context from retrieved documents
-        context_parts = []
-        sources = []
-        
-        for idx, (doc, meta, score) in enumerate(zip(documents, metadatas, scores), 1):
-            # Extract clean filename for source citation
-            filename = meta.get('filename', 'Unknown')
-            clean_name = filename.replace('.pdf', '').replace('.docx', '').replace('.txt', '')
-            context_parts.append(f"Source [{idx}] ({clean_name}):\n{doc}\n")
-            sources.append({
-                "content": doc[:200] + "..." if len(doc) > 200 else doc,
-                "metadata": meta,
-                "score": float(score)
-            })
-        
-        context = "\n".join(context_parts)
-        
-        # Use the advanced generate_response method which has the new NotebookLM-style prompt
-        response = llm_generator.generate_response(
-            prompt=request.query,
-            context=context,
-            use_case=request.workflow if request.workflow in ["summary", "explanation", "qa", "notes"] else "qa",
-            metadatas=metadatas,
-            temperature=0.3
-        )
-
-        # Create or update chat
-        chat_id = request.chat_id or str(uuid.uuid4())
-        chats = load_chats_for_space(request.space_id)
-        
-        # Find existing chat or create new
-        chat = None
-        for c in chats:
-            if c['id'] == chat_id:
-                chat = c
-                break
-        
-        if not chat:
-            chat = {
-                'id': chat_id,
-                'messages': [],
-                'created_at': datetime.now().isoformat(),
-                'updated_at': datetime.now().isoformat()
-            }
-            chats.append(chat)
-        
-        # Add messages
-        timestamp = datetime.now().isoformat()
-        chat['messages'].extend([
-            {'role': 'user', 'content': request.query, 'timestamp': timestamp},
-            {
-                'role': 'assistant',
-                'content': response,
-                'timestamp': timestamp,
-                'sources': sources
-            }
-        ])
-        chat['updated_at'] = timestamp
-        
-        # Save chats
-        save_chats_for_space(request.space_id, chats)
-        
-        return ChatResponse(
-            response=response,
-            sources=sources,
-            chat_id=chat_id,
-            timestamp=timestamp
-        )
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/spaces/{space_id}/upload")
-async def upload_files(space_id: str, files: List[UploadFile] = File(...)):
-    """Upload and process files for a space"""
-    try:
-        # Initialize space
-        initialize_space(space_id)
-        
-        # Save uploaded files temporarily
-        space_dir = get_space_dir(space_id)
-        uploads_dir = space_dir / "uploads"
-        uploads_dir.mkdir(parents=True, exist_ok=True)
-        
-        processor = DocumentProcessor()
-        all_chunks = []
-        processed_files = []
-        
-        for file in files:
-            # Save file
-            file_path = uploads_dir / file.filename
-            with open(file_path, "wb") as f:
-                content = await file.read()
-                f.write(content)
-            
-            # Process file and extract content
-            try:
-                file_data = processor.process_file(file_path)
-                content = file_data['content']
-                
-                # Chunk the content
-                chunks = processor.chunk_text(content, chunk_size=512, overlap=50, semantic=True)
-                
-                # Format chunks for vector database
-                formatted_chunks = []
-                for idx, chunk in enumerate(chunks):
-                    formatted_chunks.append({
-                        'content': chunk,
-                        'metadata': {
-                            'filename': file.filename,
-                            'chunk_index': idx,
-                            'total_chunks': len(chunks),
-                            'source_type': file_data['format']
-                        }
-                    })
-                
-                all_chunks.extend(formatted_chunks)
-                processed_files.append({
-                    'filename': file.filename,
-                    'chunks': len(chunks),
-                    'processed_at': datetime.now().isoformat()
-                })
-            except Exception as e:
-                # Log error but continue with other files
-                print(f"Error processing {file.filename}: {str(e)}")
-                continue
-        
-        # Add to vector database in batches to avoid size limits
-        if all_chunks:
-            # Extract texts, metadatas, and generate IDs
-            texts = [chunk['content'] for chunk in all_chunks]
-            metadatas = [chunk['metadata'] for chunk in all_chunks]
-            ids = [f"{space_id}_{idx}_{uuid.uuid4().hex[:8]}" for idx in range(len(all_chunks))]
-            
-            # Process in batches of 5000 to avoid ChromaDB batch size limit
-            batch_size = 5000
-            for i in range(0, len(texts), batch_size):
-                batch_texts = texts[i:i + batch_size]
-                batch_metadatas = metadatas[i:i + batch_size]
-                batch_ids = ids[i:i + batch_size]
-                
-                vector_db.add_documents(batch_texts, batch_metadatas, batch_ids)
-                print(f"Processed batch {i//batch_size + 1}/{(len(texts)-1)//batch_size + 1}")
-        
-        # Save processed files info
-        processed_file = space_dir / "processed_files.json"
-        existing = []
-        if processed_file.exists():
-            with open(processed_file, 'r') as f:
-                existing = json.load(f)
-        
-        existing.extend(processed_files)
-        with open(processed_file, 'w') as f:
-            json.dump(existing, f, indent=2)
-        
-        return {
-            "status": "success",
-            "files_processed": len(processed_files),
-            "total_chunks": len(all_chunks)
-        }
-    
-    except Exception as e:
-        raise e  # This strips the wrapper and forces FastAPI to log the raw stack trace
-
-@app.get("/api/spaces/{space_id}/files")
-async def get_files(space_id: str):
-    """Get processed files for a space"""
-    processed_file = get_space_dir(space_id) / "processed_files.json"
-    
-    if processed_file.exists():
-        with open(processed_file, 'r') as f:
-            return json.load(f)
-    
-    return []
-
-@app.delete("/api/spaces/{space_id}/files/{filename}")
-async def delete_file(space_id: str, filename: str):
-    """Delete a specific file from a space"""
-    try:
-        # Remove from processed_files.json
-        processed_file = get_space_dir(space_id) / "processed_files.json"
-        files_data = []
-        
-        if processed_file.exists():
-            with open(processed_file, 'r') as f:
-                files_data = json.load(f)
-            
-            # Filter out the file to delete
-            files_data = [f for f in files_data if f.get('filename') != filename]
-            
-            with open(processed_file, 'w') as f:
-                json.dump(files_data, f, indent=2)
-        
-        # Delete the actual file
-        file_path = get_space_dir(space_id) / "uploads" / filename
-        if file_path.exists():
-            file_path.unlink()
-        
-        # Remove from vector database (if initialized)
-        # Note: This removes all chunks with this filename from metadata
-        if vector_db:
-            try:
-                # Get all documents in the collection
-                collection = vector_db.collection
-                results = collection.get()
-                
-                # Find IDs of documents with matching filename
-                ids_to_delete = []
-                for idx, metadata in enumerate(results['metadatas']):
-                    if metadata and metadata.get('filename') == filename:
-                        ids_to_delete.append(results['ids'][idx])
-                
-                # Delete those documents
-                if ids_to_delete:
-                    collection.delete(ids=ids_to_delete)
-                    print(f"Deleted {len(ids_to_delete)} chunks for {filename}")
-            except Exception as e:
-                print(f"Error removing from vector DB: {e}")
-        
-        return {
-            "status": "success",
-            "message": f"File {filename} deleted"
-        }
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error deleting file: {str(e)}")
-
-
-# ==================== STUDIO API ROUTES ====================
-# Routes for Notebook, Flashcards, and Quiz features
-
-# Import studio models
-from models.studio_models import (
-    NotebookEntry, NotebookEntryCreate, NotebookEntryUpdate,
-    Flashcard, FlashcardCreate, FlashcardUpdate, FlashcardReview,
-    FlashcardGenerateRequest,
-    Quiz, QuizCreate, QuizGenerateRequest, QuizSubmission, QuizResult, QuizHistory,
-    MasteryLevel
-)
-
-# ===== NOTEBOOK ROUTES =====
-
-@app.post("/api/studio/notebook", response_model=NotebookEntry)
-async def create_notebook_entry(entry_data: NotebookEntryCreate):
-    """Create a new notebook entry"""
-    try:
-        entry = studio_manager.create_notebook_entry(entry_data)
-        return entry
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/notebook/space/{space_id}")
-async def get_space_notebook(space_id: str):
-    """Get or create notebook metadata for a space."""
-    try:
-        space = spaces_manager.get_space(space_id)
-        space_name = space['name'] if space else space_id
-        notebook = studio_manager.ensure_space_notebook(space_id, space_name)
-        return notebook
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/studio/notebook/from-chat", response_model=NotebookEntry)
-async def add_chat_to_notebook(request: ChatToNotebookRequest):
-    """Add a chat question/answer pair into a space notebook."""
-    try:
-        space = spaces_manager.get_space(request.space_id)
-        resolved_space_name = request.space_name or (space['name'] if space else request.space_id)
-
-        entry = studio_manager.create_notebook_entry_from_chat(
-            space_id=request.space_id,
-            question=request.question,
-            answer=request.answer,
-            chat_id=request.chat_id,
-            assistant_timestamp=request.assistant_timestamp,
-            tags=request.tags,
-            space_name=resolved_space_name
-        )
-        return entry
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/notebook", response_model=List[NotebookEntry])
-async def list_notebook_entries(space_id: Optional[str] = None):
-    """List all notebook entries, optionally filtered by space"""
-    try:
-        entries = studio_manager.list_notebook_entries(space_id)
-        return entries
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/notebook/{entry_id}", response_model=NotebookEntry)
-async def get_notebook_entry(entry_id: str):
-    """Get a single notebook entry"""
-    entry = studio_manager.get_notebook_entry(entry_id)
-    if not entry:
-        raise HTTPException(status_code=404, detail="Notebook entry not found")
-    return entry
-
-@app.put("/api/studio/notebook/{entry_id}", response_model=NotebookEntry)
-async def update_notebook_entry(entry_id: str, update_data: NotebookEntryUpdate):
-    """Update a notebook entry"""
-    entry = studio_manager.update_notebook_entry(entry_id, update_data)
-    if not entry:
-        raise HTTPException(status_code=404, detail="Notebook entry not found")
-    return entry
-
-@app.delete("/api/studio/notebook/{entry_id}")
-async def delete_notebook_entry(entry_id: str):
-    """Delete a notebook entry"""
-    success = studio_manager.delete_notebook_entry(entry_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="Notebook entry not found")
-    return {"status": "success", "message": "Notebook entry deleted"}
-
-
-# ===== FLASHCARD ROUTES =====
-
-@app.post("/api/studio/flashcards", response_model=Flashcard)
-async def create_flashcard(card_data: FlashcardCreate):
-    """Create a new flashcard"""
-    try:
-        card = studio_manager.create_flashcard(card_data)
-        return card
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/flashcards", response_model=List[Flashcard])
-async def list_flashcards(
-    space_id: Optional[str] = None,
-    mastery: Optional[MasteryLevel] = None
-):
-    """List all flashcards, optionally filtered"""
-    try:
-        cards = studio_manager.list_flashcards(space_id, mastery)
-        return cards
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/flashcards/{card_id}", response_model=Flashcard)
-async def get_flashcard(card_id: str):
-    """Get a single flashcard"""
-    card = studio_manager.get_flashcard(card_id)
-    if not card:
-        raise HTTPException(status_code=404, detail="Flashcard not found")
-    return card
-
-@app.put("/api/studio/flashcards/{card_id}", response_model=Flashcard)
-async def update_flashcard(card_id: str, update_data: FlashcardUpdate):
-    """Update a flashcard"""
-    card = studio_manager.update_flashcard(card_id, update_data)
-    if not card:
-        raise HTTPException(status_code=404, detail="Flashcard not found")
-    return card
-
-@app.post("/api/studio/flashcards/{card_id}/review", response_model=Flashcard)
-async def review_flashcard(card_id: str, review: FlashcardReview):
-    """Record a flashcard review"""
-    card = studio_manager.review_flashcard(card_id, review)
-    if not card:
-        raise HTTPException(status_code=404, detail="Flashcard not found")
-    return card
-
-@app.delete("/api/studio/flashcards/{card_id}")
-async def delete_flashcard(card_id: str):
-    """Delete a flashcard"""
-    success = studio_manager.delete_flashcard(card_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="Flashcard not found")
-    return {"status": "success", "message": "Flashcard deleted"}
-
-@app.post("/api/studio/flashcards/generate", response_model=List[Flashcard])
-async def generate_flashcards(request: FlashcardGenerateRequest):
-    """Generate flashcards from content using LLM"""
-    global studio_generator
-    
-    if not studio_generator:
-        raise HTTPException(status_code=503, detail="LLM not initialized")
-    
-    try:
-        cards = await studio_generator.generate_flashcards(request)
-        return cards
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ===== QUIZ ROUTES =====
-
-@app.post("/api/studio/quizzes", response_model=Quiz)
-async def create_quiz(quiz_data: QuizCreate):
-    """Create a new quiz"""
-    try:
-        quiz = studio_manager.create_quiz(quiz_data)
-        return quiz
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/quizzes", response_model=List[Quiz])
-async def list_quizzes(space_id: Optional[str] = None):
-    """List all quizzes, optionally filtered by space"""
-    try:
-        quizzes = studio_manager.list_quizzes(space_id)
-        return quizzes
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/quizzes/{quiz_id}", response_model=Quiz)
-async def get_quiz(quiz_id: str):
-    """Get a quiz by ID"""
-    quiz = studio_manager.get_quiz(quiz_id)
-    if not quiz:
-        raise HTTPException(status_code=404, detail="Quiz not found")
-    return quiz
-
-@app.delete("/api/studio/quizzes/{quiz_id}")
-async def delete_quiz(quiz_id: str):
-    """Delete a quiz"""
-    success = studio_manager.delete_quiz(quiz_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="Quiz not found")
-    return {"status": "success", "message": "Quiz deleted"}
-
-@app.post("/api/studio/quizzes/generate", response_model=Quiz)
-async def generate_quiz(request: QuizGenerateRequest):
-    """Generate a quiz from content using LLM"""
-    global studio_generator
-    
-    if not studio_generator:
-        raise HTTPException(status_code=503, detail="LLM not initialized")
-    
-    try:
-        quiz = await studio_generator.generate_quiz(request)
-        if not quiz:
-            raise HTTPException(status_code=500, detail="Failed to generate quiz")
-        return quiz
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/studio/quizzes/{quiz_id}/submit", response_model=QuizResult)
-async def submit_quiz(quiz_id: str, submission: QuizSubmission):
-    """Submit quiz answers and get results"""
-    try:
-        result = studio_manager.submit_quiz(quiz_id, submission.answers)
-        if not result:
-            raise HTTPException(status_code=404, detail="Quiz not found")
-        return result
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/studio/quizzes/{quiz_id}/history", response_model=QuizHistory)
-async def get_quiz_history(quiz_id: str):
-    """Get quiz attempt history"""
-    try:
-        history = studio_manager.get_quiz_history(quiz_id)
-        if not history:
-            raise HTTPException(status_code=404, detail="Quiz not found")
-        return history
-    except HTTPException as he:
-        # If the error is already an HTTPException (like the missing API key error), pass it through directly
-        raise he 
-    except Exception as e:
-        # For all other crashes, print the actual traceback to the terminal so you can see what broke
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
-
-# ==================== Run Server ====================
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="error")
+"""
+FastAPI Backend for NotebookPRO
+Handles RAG, LLM, file processing, and chat management
+"""
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+import json
+from datetime import datetime
+import uuid
+import sys
+import warnings
+import logging
+import os
+import shutil
+
+# Suppress warnings
+warnings.filterwarnings('ignore')
+os.environ['PYTHONWARNINGS'] = 'ignore'
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+os.environ['TOKENIZERS_PARALLELISM'] = 'false'
+os.environ.setdefault('OMP_NUM_THREADS', '2')
+os.environ.setdefault('MKL_NUM_THREADS', '2')
+os.environ.setdefault('OPENBLAS_NUM_THREADS', '2')
+os.environ.setdefault('NUMEXPR_NUM_THREADS', '2')
+#logging.getLogger().setLevel(logging.ERROR)
+
+# Add project root to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+import config
+from utils.document_processor import DocumentProcessor
+from utils.vector_db import VectorDatabase
+from utils.hybrid_retriever import HybridRetriever
+from utils.llm_generator import LLMGenerator
+from utils.config_manager import ConfigManager
+from utils.spaces_manager import SpacesManager
+from utils.studio_manager import StudioManager
+from utils.studio_generator import StudioGenerator
+
+# Initialize FastAPI
+app = FastAPI(title="NotebookPRO API", version="2.0.0")
+
+# CORS - Allow Flutter web to connect
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your Flutter web URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global instances
+config_manager = ConfigManager()
+spaces_manager = SpacesManager()
+studio_manager = StudioManager()
+studio_generator = None  # Will be initialized after LLM
+vector_db = None
+llm_generator = None
+current_space = None
+
+# ==================== Pydantic Models ====================
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+    timestamp: str
+    sources: Optional[List[Dict[str, Any]]] = None
+
+class ChatRequest(BaseModel):
+    query: str
+    space_id: str
+    chat_id: Optional[str] = None
+    workflow: str = "chat"
+
+class ChatResponse(BaseModel):
+    response: str
+    sources: List[Dict[str, Any]]
+    chat_id: str
+    timestamp: str
+
+class SpaceCreate(BaseModel):
+    name: str
+
+class SpaceResponse(BaseModel):
+    id: str
+    name: str
+    created_at: str
+    file_count: int
+
+class ChatInfo(BaseModel):
+    id: str
+    title: str
+    preview: str
+    created_at: str
+    updated_at: str
+    message_count: int
+
+class ConfigResponse(BaseModel):
+    groq_api_key: Optional[str]
+    gemini_api_key: Optional[str]
+
+class ConfigUpdate(BaseModel):
+    groq_api_key: Optional[str] = None
+    gemini_api_key: Optional[str] = None
+
+class ChatToNotebookRequest(BaseModel):
+    space_id: str
+    question: str
+    answer: str
+    chat_id: Optional[str] = None
+    assistant_timestamp: Optional[str] = None
+    tags: List[str] = []
+    space_name: Optional[str] = None
+
+# ==================== Helper Functions ====================
+
+def get_data_dir():
+    """Get data directory path"""
+    return Path(__file__).parent.parent / "data"
+
+def get_space_dir(space_id: str):
+    """Get space-specific directory"""
+    return get_data_dir() / "spaces" / space_id
+
+def load_chats_for_space(space_id: str) -> List[Dict]:
+    """Load all chats for a space"""
+    chats_file = get_space_dir(space_id) / "chats.json"
+    if chats_file.exists():
+        with open(chats_file, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return []
+
+def save_chats_for_space(space_id: str, chats: List[Dict]):
+    """Save chats for a space"""
+    chats_file = get_space_dir(space_id) / "chats.json"
+    chats_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(chats_file, 'w', encoding='utf-8') as f:
+        json.dump(chats, f, indent=2, ensure_ascii=False)
+
+def get_chat_title(messages: List[Dict]) -> str:
+    """Generate chat title from first user message"""
+    for msg in messages:
+        if msg['role'] == 'user':
+            content = msg['content'][:50]
+            return content + "..." if len(msg['content']) > 50 else content
+    return "New Chat"
+
+def ensure_notebooks_for_existing_spaces() -> int:
+    """Ensure every existing space has an associated notebook metadata record."""
+    created_count = 0
+    spaces = spaces_manager.get_all_spaces()
+
+    for space in spaces:
+        space_id = space.get('id')
+        if not space_id:
+            continue
+
+        existing_notebook = studio_manager.get_space_notebook(space_id)
+        if existing_notebook:
+            continue
+
+        studio_manager.ensure_space_notebook(space_id, space.get('name', space_id))
+        created_count += 1
+
+    return created_count
+
+def rebuild_space_index_if_missing(space_id: str) -> int:
+    """Rebuild a space index from uploaded files if the current index is empty."""
+    if not vector_db:
+        return 0
+
+    try:
+        if vector_db.get_collection_count() > 0:
+            return 0
+    except Exception:
+        # If count check fails, continue with a best-effort rebuild.
+        pass
+
+    uploads_dir = get_space_dir(space_id) / "uploads"
+    if not uploads_dir.exists():
+        return 0
+
+    files = [
+        p for p in uploads_dir.iterdir()
+        if p.is_file() and p.suffix.lower() in {".pdf", ".docx", ".txt"}
+    ]
+    if not files:
+        return 0
+
+    processor = DocumentProcessor()
+    texts: List[str] = []
+    metadatas: List[Dict[str, Any]] = []
+    ids: List[str] = []
+
+    for file_path in files:
+        try:
+            file_data = processor.process_file(file_path)
+            chunks = processor.chunk_text(
+                file_data['content'],
+                chunk_size=512,
+                overlap=50,
+                semantic=True,
+            )
+            total_chunks = len(chunks)
+            for idx, chunk in enumerate(chunks):
+                texts.append(chunk)
+                metadatas.append({
+                    'filename': file_path.name,
+                    'chunk_index': idx,
+                    'total_chunks': total_chunks,
+                    'source_type': file_data['format'],
+                })
+                ids.append(f"{space_id}_rebuild_{len(ids)}_{uuid.uuid4().hex[:8]}")
+        except Exception as e:
+            print(f"Index rebuild skipped {file_path.name}: {e}")
+
+    if not texts:
+        return 0
+
+    batch_size = 100
+    for i in range(0, len(texts), batch_size):
+        vector_db.add_documents(
+            texts[i:i + batch_size],
+            metadatas[i:i + batch_size],
+            ids[i:i + batch_size],
+        )
+
+    print(f"Rebuilt index for space '{space_id}' with {len(texts)} chunks")
+    return len(texts)
+
+def initialize_space(space_id: str):
+    """Initialize vector DB and components for a space"""
+    global vector_db, llm_generator, studio_generator, current_space
+
+    # Fast path: reuse already initialized components for the active space.
+    if current_space == space_id and vector_db is not None and llm_generator is not None:
+        return
+    
+    # Get API keys
+    import os
+    # Try the config manager first, but fallback to the .env file variables
+    groq_key = config_manager.get_api_key('groq') or os.getenv('GROQ_API_KEY')
+    gemini_key = config_manager.get_api_key('gemini') or os.getenv('GOOGLE_API_KEY') or os.getenv('GEMINI_API_KEY')
+    
+    if not groq_key and not gemini_key:
+        raise HTTPException(status_code=400, detail="No API keys configured. Please add Groq or Gemini API key.")
+    
+    # Initialize vector database for this space (space-local persistence path).
+    # Initialize Qdrant cloud database for this space
+    vector_db = VectorDatabase(
+        collection_name=f"space_{space_id}"
+    )
+
+    # Backward-compatibility: rebuild embeddings from uploaded files if index is empty.
+    rebuild_space_index_if_missing(space_id)
+    
+    # Initialize LLM generator - choose provider based on available keys
+    if groq_key:
+        llm_generator = LLMGenerator(provider="groq", api_key=groq_key)
+    else:
+        llm_generator = LLMGenerator(provider="gemini", api_key=gemini_key)
+    
+    # Initialize studio generator with LLM
+    studio_generator = StudioGenerator(llm_generator, studio_manager)
+    current_space = space_id
+
+@app.on_event("startup")
+async def startup_sync_notebooks():
+    """Auto-create missing notebooks for pre-existing spaces when backend starts."""
+    try:
+        created = ensure_notebooks_for_existing_spaces()
+        if created > 0:
+            print(f"Created {created} missing notebook(s) for existing spaces")
+    except Exception as e:
+        # Keep server startup resilient even if sync fails.
+        print(f"Notebook startup sync failed: {e}")
+
+# ==================== API Endpoints ====================
+
+@app.get("/")
+async def root():
+    """Health check"""
+    return {"status": "NotebookPRO API is running", "version": "2.0.0"}
+
+@app.get("/api/config", response_model=ConfigResponse)
+async def get_config():
+    """Get current API keys (masked)"""
+    groq_key = config_manager.get_api_key('groq')
+    gemini_key = config_manager.get_api_key('gemini')
+    
+    return ConfigResponse(
+        groq_api_key="***" + groq_key[-4:] if groq_key else None,
+        gemini_api_key="***" + gemini_key[-4:] if gemini_key else None
+    )
+
+@app.post("/api/config")
+async def update_config(config_update: ConfigUpdate):
+    """Update API keys"""
+    if config_update.groq_api_key:
+        config_manager.set_api_key('groq', config_update.groq_api_key)
+    if config_update.gemini_api_key:
+        config_manager.set_api_key('gemini', config_update.gemini_api_key)
+    
+    return {"status": "success", "message": "Configuration updated"}
+
+@app.get("/api/spaces", response_model=List[SpaceResponse])
+async def get_spaces():
+    """Get all spaces"""
+    # Self-healing check in case spaces were created externally while server is running.
+    ensure_notebooks_for_existing_spaces()
+    spaces = spaces_manager.get_all_spaces()
+    
+    result = []
+    for space in spaces:
+        space_id = space['id']
+        space_dir = get_space_dir(space_id)
+        processed_file = space_dir / "processed_files.json"
+        
+        file_count = 0
+        if processed_file.exists():
+            with open(processed_file, 'r') as f:
+                file_count = len(json.load(f))
+        
+        result.append(SpaceResponse(
+            id=space_id,
+            name=space['name'],
+            created_at=space['created_at'],
+            file_count=file_count
+        ))
+    
+    return result
+
+@app.post("/api/spaces", response_model=SpaceResponse)
+async def create_space(space_data: SpaceCreate):
+    """Create a new space"""
+    try:
+        space = spaces_manager.create_space(space_data.name)
+
+        # Create associated notebook metadata with the same name as the space.
+        studio_manager.ensure_space_notebook(space['id'], space['name'])
+        
+        return SpaceResponse(
+            id=space['id'],
+            name=space['name'],
+            created_at=space['created_at'],
+            file_count=0
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.delete("/api/spaces/{space_id}")
+async def delete_space(space_id: str):
+    """Delete a space"""
+    try:
+        spaces_manager.delete_space(space_id)
+        
+        # Delete space directory
+        space_dir = get_space_dir(space_id)
+        if space_dir.exists():
+            shutil.rmtree(space_dir)
+        
+        return {"status": "success", "message": f"Space {space_id} deleted"}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error deleting space: {str(e)}")
+
+@app.get("/api/spaces/{space_id}/chats", response_model=List[ChatInfo])
+async def get_chats(space_id: str):
+    """Get all chats for a space"""
+    chats = load_chats_for_space(space_id)
+    
+    result = []
+    for chat in chats:
+        messages = chat.get('messages', [])
+        result.append(ChatInfo(
+            id=chat['id'],
+            title=get_chat_title(messages),
+            preview=messages[0]['content'][:100] if messages else "",
+            created_at=chat.get('created_at', ''),
+            updated_at=chat.get('updated_at', ''),
+            message_count=len(messages)
+        ))
+    
+    return result
+
+@app.get("/api/spaces/{space_id}/chats/{chat_id}")
+async def get_chat(space_id: str, chat_id: str):
+    """Get specific chat by ID"""
+    chats = load_chats_for_space(space_id)
+    
+    for chat in chats:
+        if chat['id'] == chat_id:
+            return chat
+    
+    raise HTTPException(status_code=404, detail="Chat not found")
+
+@app.delete("/api/spaces/{space_id}/chats/{chat_id}")
+async def delete_chat(space_id: str, chat_id: str):
+    """Delete a chat"""
+    chats = load_chats_for_space(space_id)
+    chats = [c for c in chats if c['id'] != chat_id]
+    save_chats_for_space(space_id, chats)
+    
+    return {"status": "success", "message": f"Chat {chat_id} deleted"}
+
+@app.post("/api/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Process a chat message with RAG"""
+    try:
+        # Initialize space if needed
+        initialize_space(request.space_id)
+        
+        # Create hybrid retriever with 60% vector, 40% BM25
+        hybrid_retriever = HybridRetriever(vector_db, alpha=0.6)
+        
+        # Retrieve relevant documents
+        documents, metadatas, scores = hybrid_retriever.retrieve(
+            query=request.query,
+            n_results=5
+        )
+        
+        # Build context from retrieved documents
+        context_parts = []
+        sources = []
+        
+        for idx, (doc, meta, score) in enumerate(zip(documents, metadatas, scores), 1):
+            # Extract clean filename for source citation
+            filename = meta.get('filename', 'Unknown')
+            clean_name = filename.replace('.pdf', '').replace('.docx', '').replace('.txt', '')
+            context_parts.append(f"Source [{idx}] ({clean_name}):\n{doc}\n")
+            sources.append({
+                "content": doc[:200] + "..." if len(doc) > 200 else doc,
+                "metadata": meta,
+                "score": float(score)
+            })
+        
+        context = "\n".join(context_parts)
+        
+        # Use the advanced generate_response method which has the new NotebookLM-style prompt
+        response = llm_generator.generate_response(
+            prompt=request.query,
+            context=context,
+            use_case=request.workflow if request.workflow in ["summary", "explanation", "qa", "notes"] else "qa",
+            metadatas=metadatas,
+            temperature=0.3
+        )
+
+        # Create or update chat
+        chat_id = request.chat_id or str(uuid.uuid4())
+        chats = load_chats_for_space(request.space_id)
+        
+        # Find existing chat or create new
+        chat = None
+        for c in chats:
+            if c['id'] == chat_id:
+                chat = c
+                break
+        
+        if not chat:
+            chat = {
+                'id': chat_id,
+                'messages': [],
+                'created_at': datetime.now().isoformat(),
+                'updated_at': datetime.now().isoformat()
+            }
+            chats.append(chat)
+        
+        # Add messages
+        timestamp = datetime.now().isoformat()
+        chat['messages'].extend([
+            {'role': 'user', 'content': request.query, 'timestamp': timestamp},
+            {
+                'role': 'assistant',
+                'content': response,
+                'timestamp': timestamp,
+                'sources': sources
+            }
+        ])
+        chat['updated_at'] = timestamp
+        
+        # Save chats
+        save_chats_for_space(request.space_id, chats)
+        
+        return ChatResponse(
+            response=response,
+            sources=sources,
+            chat_id=chat_id,
+            timestamp=timestamp
+        )
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/spaces/{space_id}/upload")
+async def upload_files(space_id: str, files: List[UploadFile] = File(...)):
+    """Upload and process files for a space"""
+    try:
+        # Initialize space
+        initialize_space(space_id)
+        
+        # Save uploaded files temporarily
+        space_dir = get_space_dir(space_id)
+        uploads_dir = space_dir / "uploads"
+        uploads_dir.mkdir(parents=True, exist_ok=True)
+        
+        processor = DocumentProcessor()
+        all_chunks = []
+        processed_files = []
+        
+        for file in files:
+            # Save file
+            file_path = uploads_dir / file.filename
+            with open(file_path, "wb") as f:
+                content = await file.read()
+                f.write(content)
+            
+            # Process file and extract content
+            try:
+                file_data = processor.process_file(file_path)
+                content = file_data['content']
+                
+                # Chunk the content
+                chunks = processor.chunk_text(content, chunk_size=512, overlap=50, semantic=True)
+                
+                # Format chunks for vector database
+                formatted_chunks = []
+                for idx, chunk in enumerate(chunks):
+                    formatted_chunks.append({
+                        'content': chunk,
+                        'metadata': {
+                            'filename': file.filename,
+                            'chunk_index': idx,
+                            'total_chunks': len(chunks),
+                            'source_type': file_data['format']
+                        }
+                    })
+                
+                all_chunks.extend(formatted_chunks)
+                processed_files.append({
+                    'filename': file.filename,
+                    'chunks': len(chunks),
+                    'processed_at': datetime.now().isoformat()
+                })
+            except Exception as e:
+                # Log error but continue with other files
+                print(f"Error processing {file.filename}: {str(e)}")
+                continue
+        
+        # Add to vector database in batches to avoid size limits
+        if all_chunks:
+            # Extract texts, metadatas, and generate IDs
+            texts = [chunk['content'] for chunk in all_chunks]
+            metadatas = [chunk['metadata'] for chunk in all_chunks]
+            ids = [f"{space_id}_{idx}_{uuid.uuid4().hex[:8]}" for idx in range(len(all_chunks))]
+            
+            # Process in batches of 5000 to avoid ChromaDB batch size limit
+            batch_size = 5000
+            for i in range(0, len(texts), batch_size):
+                batch_texts = texts[i:i + batch_size]
+                batch_metadatas = metadatas[i:i + batch_size]
+                batch_ids = ids[i:i + batch_size]
+                
+                vector_db.add_documents(batch_texts, batch_metadatas, batch_ids)
+                print(f"Processed batch {i//batch_size + 1}/{(len(texts)-1)//batch_size + 1}")
+        
+        # Save processed files info
+        processed_file = space_dir / "processed_files.json"
+        existing = []
+        if processed_file.exists():
+            with open(processed_file, 'r') as f:
+                existing = json.load(f)
+        
+        existing.extend(processed_files)
+        with open(processed_file, 'w') as f:
+            json.dump(existing, f, indent=2)
+        
+        return {
+            "status": "success",
+            "files_processed": len(processed_files),
+            "total_chunks": len(all_chunks)
+        }
+    
+    except Exception as e:
+        raise e  # This strips the wrapper and forces FastAPI to log the raw stack trace
+
+@app.get("/api/spaces/{space_id}/files")
+async def get_files(space_id: str):
+    """Get processed files for a space"""
+    processed_file = get_space_dir(space_id) / "processed_files.json"
+    
+    if processed_file.exists():
+        with open(processed_file, 'r') as f:
+            return json.load(f)
+    
+    return []
+
+@app.delete("/api/spaces/{space_id}/files/{filename}")
+async def delete_file(space_id: str, filename: str):
+    """Delete a specific file from a space"""
+    try:
+        # Remove from processed_files.json
+        processed_file = get_space_dir(space_id) / "processed_files.json"
+        files_data = []
+        
+        if processed_file.exists():
+            with open(processed_file, 'r') as f:
+                files_data = json.load(f)
+            
+            # Filter out the file to delete
+            files_data = [f for f in files_data if f.get('filename') != filename]
+            
+            with open(processed_file, 'w') as f:
+                json.dump(files_data, f, indent=2)
+        
+        # Delete the actual file
+        file_path = get_space_dir(space_id) / "uploads" / filename
+        if file_path.exists():
+            file_path.unlink()
+        
+        # Remove from vector database (if initialized)
+        # Note: This removes all chunks with this filename from metadata
+        if vector_db:
+            try:
+                # Get all documents in the collection
+                collection = vector_db.collection
+                results = collection.get()
+                
+                # Find IDs of documents with matching filename
+                ids_to_delete = []
+                for idx, metadata in enumerate(results['metadatas']):
+                    if metadata and metadata.get('filename') == filename:
+                        ids_to_delete.append(results['ids'][idx])
+                
+                # Delete those documents
+                if ids_to_delete:
+                    collection.delete(ids=ids_to_delete)
+                    print(f"Deleted {len(ids_to_delete)} chunks for {filename}")
+            except Exception as e:
+                print(f"Error removing from vector DB: {e}")
+        
+        return {
+            "status": "success",
+            "message": f"File {filename} deleted"
+        }
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error deleting file: {str(e)}")
+
+
+# ==================== STUDIO API ROUTES ====================
+# Routes for Notebook, Flashcards, and Quiz features
+
+# Import studio models
+from models.studio_models import (
+    NotebookEntry, NotebookEntryCreate, NotebookEntryUpdate,
+    Flashcard, FlashcardCreate, FlashcardUpdate, FlashcardReview,
+    FlashcardGenerateRequest,
+    Quiz, QuizCreate, QuizGenerateRequest, QuizSubmission, QuizResult, QuizHistory,
+    MasteryLevel
+)
+
+# ===== NOTEBOOK ROUTES =====
+
+@app.post("/api/studio/notebook", response_model=NotebookEntry)
+async def create_notebook_entry(entry_data: NotebookEntryCreate):
+    """Create a new notebook entry"""
+    try:
+        entry = studio_manager.create_notebook_entry(entry_data)
+        return entry
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/notebook/space/{space_id}")
+async def get_space_notebook(space_id: str):
+    """Get or create notebook metadata for a space."""
+    try:
+        space = spaces_manager.get_space(space_id)
+        space_name = space['name'] if space else space_id
+        notebook = studio_manager.ensure_space_notebook(space_id, space_name)
+        return notebook
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/studio/notebook/from-chat", response_model=NotebookEntry)
+async def add_chat_to_notebook(request: ChatToNotebookRequest):
+    """Add a chat question/answer pair into a space notebook."""
+    try:
+        space = spaces_manager.get_space(request.space_id)
+        resolved_space_name = request.space_name or (space['name'] if space else request.space_id)
+
+        entry = studio_manager.create_notebook_entry_from_chat(
+            space_id=request.space_id,
+            question=request.question,
+            answer=request.answer,
+            chat_id=request.chat_id,
+            assistant_timestamp=request.assistant_timestamp,
+            tags=request.tags,
+            space_name=resolved_space_name
+        )
+        return entry
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/notebook", response_model=List[NotebookEntry])
+async def list_notebook_entries(space_id: Optional[str] = None):
+    """List all notebook entries, optionally filtered by space"""
+    try:
+        entries = studio_manager.list_notebook_entries(space_id)
+        return entries
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/notebook/{entry_id}", response_model=NotebookEntry)
+async def get_notebook_entry(entry_id: str):
+    """Get a single notebook entry"""
+    entry = studio_manager.get_notebook_entry(entry_id)
+    if not entry:
+        raise HTTPException(status_code=404, detail="Notebook entry not found")
+    return entry
+
+@app.put("/api/studio/notebook/{entry_id}", response_model=NotebookEntry)
+async def update_notebook_entry(entry_id: str, update_data: NotebookEntryUpdate):
+    """Update a notebook entry"""
+    entry = studio_manager.update_notebook_entry(entry_id, update_data)
+    if not entry:
+        raise HTTPException(status_code=404, detail="Notebook entry not found")
+    return entry
+
+@app.delete("/api/studio/notebook/{entry_id}")
+async def delete_notebook_entry(entry_id: str):
+    """Delete a notebook entry"""
+    success = studio_manager.delete_notebook_entry(entry_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Notebook entry not found")
+    return {"status": "success", "message": "Notebook entry deleted"}
+
+
+# ===== FLASHCARD ROUTES =====
+
+@app.post("/api/studio/flashcards", response_model=Flashcard)
+async def create_flashcard(card_data: FlashcardCreate):
+    """Create a new flashcard"""
+    try:
+        card = studio_manager.create_flashcard(card_data)
+        return card
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/flashcards", response_model=List[Flashcard])
+async def list_flashcards(
+    space_id: Optional[str] = None,
+    mastery: Optional[MasteryLevel] = None
+):
+    """List all flashcards, optionally filtered"""
+    try:
+        cards = studio_manager.list_flashcards(space_id, mastery)
+        return cards
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/flashcards/{card_id}", response_model=Flashcard)
+async def get_flashcard(card_id: str):
+    """Get a single flashcard"""
+    card = studio_manager.get_flashcard(card_id)
+    if not card:
+        raise HTTPException(status_code=404, detail="Flashcard not found")
+    return card
+
+@app.put("/api/studio/flashcards/{card_id}", response_model=Flashcard)
+async def update_flashcard(card_id: str, update_data: FlashcardUpdate):
+    """Update a flashcard"""
+    card = studio_manager.update_flashcard(card_id, update_data)
+    if not card:
+        raise HTTPException(status_code=404, detail="Flashcard not found")
+    return card
+
+@app.post("/api/studio/flashcards/{card_id}/review", response_model=Flashcard)
+async def review_flashcard(card_id: str, review: FlashcardReview):
+    """Record a flashcard review"""
+    card = studio_manager.review_flashcard(card_id, review)
+    if not card:
+        raise HTTPException(status_code=404, detail="Flashcard not found")
+    return card
+
+@app.delete("/api/studio/flashcards/{card_id}")
+async def delete_flashcard(card_id: str):
+    """Delete a flashcard"""
+    success = studio_manager.delete_flashcard(card_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Flashcard not found")
+    return {"status": "success", "message": "Flashcard deleted"}
+
+@app.post("/api/studio/flashcards/generate", response_model=List[Flashcard])
+async def generate_flashcards(request: FlashcardGenerateRequest):
+    """Generate flashcards from content using LLM"""
+    global studio_generator
+    
+    if not studio_generator:
+        raise HTTPException(status_code=503, detail="LLM not initialized")
+    
+    try:
+        cards = await studio_generator.generate_flashcards(request)
+        return cards
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ===== QUIZ ROUTES =====
+
+@app.post("/api/studio/quizzes", response_model=Quiz)
+async def create_quiz(quiz_data: QuizCreate):
+    """Create a new quiz"""
+    try:
+        quiz = studio_manager.create_quiz(quiz_data)
+        return quiz
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/quizzes", response_model=List[Quiz])
+async def list_quizzes(space_id: Optional[str] = None):
+    """List all quizzes, optionally filtered by space"""
+    try:
+        quizzes = studio_manager.list_quizzes(space_id)
+        return quizzes
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/quizzes/{quiz_id}", response_model=Quiz)
+async def get_quiz(quiz_id: str):
+    """Get a quiz by ID"""
+    quiz = studio_manager.get_quiz(quiz_id)
+    if not quiz:
+        raise HTTPException(status_code=404, detail="Quiz not found")
+    return quiz
+
+@app.delete("/api/studio/quizzes/{quiz_id}")
+async def delete_quiz(quiz_id: str):
+    """Delete a quiz"""
+    success = studio_manager.delete_quiz(quiz_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Quiz not found")
+    return {"status": "success", "message": "Quiz deleted"}
+
+@app.post("/api/studio/quizzes/generate", response_model=Quiz)
+async def generate_quiz(request: QuizGenerateRequest):
+    """Generate a quiz from content using LLM"""
+    global studio_generator
+    
+    if not studio_generator:
+        raise HTTPException(status_code=503, detail="LLM not initialized")
+    
+    try:
+        quiz = await studio_generator.generate_quiz(request)
+        if not quiz:
+            raise HTTPException(status_code=500, detail="Failed to generate quiz")
+        return quiz
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/studio/quizzes/{quiz_id}/submit", response_model=QuizResult)
+async def submit_quiz(quiz_id: str, submission: QuizSubmission):
+    """Submit quiz answers and get results"""
+    try:
+        result = studio_manager.submit_quiz(quiz_id, submission.answers)
+        if not result:
+            raise HTTPException(status_code=404, detail="Quiz not found")
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/studio/quizzes/{quiz_id}/history", response_model=QuizHistory)
+async def get_quiz_history(quiz_id: str):
+    """Get quiz attempt history"""
+    try:
+        history = studio_manager.get_quiz_history(quiz_id)
+        if not history:
+            raise HTTPException(status_code=404, detail="Quiz not found")
+        return history
+    except HTTPException as he:
+        # If the error is already an HTTPException (like the missing API key error), pass it through directly
+        raise he 
+    except Exception as e:
+        # For all other crashes, print the actual traceback to the terminal so you can see what broke
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== Run Server ====================
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="error")