Update backend: mode-aware enhance, saved prompts CRUD, voice-enhance, feedback endpoint

backend/core/config.py

@@ -20,10 +20,9 @@ class Settings:
     GOOGLE_CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET")
     JWT_SECRET = os.getenv("JWT_SECRET", "unsafedefaultsecret")
     ALGORITHM = "HS256"
-    GOOGLE_REDIRECT_URI = os.getenv("GOOGLE_REDIRECT_URI", "http://localhost:8000/auth/google/callback")
     
     # Constants
     EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-    COLLECTION_NAME = "prompt-ex"
+    COLLECTION_NAME = "prompt_memory"
 
 settings = Settings()

backend/core/database.py

@@ -4,12 +4,13 @@ from qdrant_client import QdrantClient
 from qdrant_client.models import VectorParams, Distance
 from .config import settings
 
-#MongoDB
+# MongoDB
 class MongoDB:
     client: MongoClient = None
     db = None
     users_col = None
     prompts_col = None
+    saved_prompts_col = None
     
     @classmethod
     def connect(cls):
@@ -22,63 +23,74 @@ class MongoDB:
             cls.db = cls.client["prompt_engine_db"]
             cls.users_col = cls.db["users"]
             cls.prompts_col = cls.db["prompt_logs"]
+            cls.saved_prompts_col = cls.db["saved_prompts"]
 
-            # 1. Index for Users: Ensures fast lookups and unique user_ids
+            # Indexes
             cls.users_col.create_index("user_id", unique=True)
-
-            # 2. Index for Logs: Speed up finding a user's history sorted by time
-            #    This matches your query: .find({"user_id": ...}).sort("timestamp", -1)
             cls.prompts_col.create_index([("user_id", 1), ("timestamp", -1)])
+            cls.saved_prompts_col.create_index("user_id")
             
             print("✅ MongoDB Indexes Verified")
-
             print("✅ MongoDB Connected")
         except Exception as e:
             print(f"⚠️ MongoDB not available ({e}) — using in-memory fallback.")
             cls.users_col = None
             cls.prompts_col = None
+            cls.saved_prompts_col = None
 
 # Qdrant
 class QdrantDB:
     client: QdrantClient = None
+    _collections_ready = False
+    
+    SAVED_COLLECTION = "saved_prompt_vectors"
     
     @classmethod
     def get_client(cls):
         if cls.client is None:
             try:
                 cls.client = QdrantClient(url=settings.QDRANT_URL, api_key=settings.QDRANT_API_KEY)
-                
-                # Check/Create Collection
-                try:
-                    if not cls.client.collection_exists(settings.COLLECTION_NAME):
-                        cls.client.create_collection(
-                            collection_name=settings.COLLECTION_NAME,
-                            vectors_config=VectorParams(size=384, distance=Distance.COSINE),
-                        )
-                        print(f"✅ Created new Qdrant collection: '{settings.COLLECTION_NAME}'")
-                except Exception:
-                    # Fallback check
-                    try:
-                        cls.client.get_collection(settings.COLLECTION_NAME)
-                    except:
-                        pass # Creation might have failed or raced
-                
-                # Create Payload Index
-                try:
-                    cls.client.create_payload_index(
-                        collection_name=settings.COLLECTION_NAME,
-                        field_name="user_id",
-                        field_schema="keyword"
-                    )
-                except Exception:
-                    pass
-                
                 print(f"✅ Qdrant Connected ({settings.QDRANT_URL})")
             except Exception as e:
                 print(f"❌ Qdrant Connection Failed: {e}")
                 return None
+        
+        # Ensure collections exist (runs once per process)
+        if not cls._collections_ready and cls.client is not None:
+            cls._ensure_collection(settings.COLLECTION_NAME)
+            cls._ensure_collection(cls.SAVED_COLLECTION)
+            cls._collections_ready = True
+        
         return cls.client
 
+    @classmethod
+    def _ensure_collection(cls, name: str):
+        """Create a 384-dim cosine collection if it doesn't exist, with user_id index."""
+        try:
+            cls.client.get_collection(name)
+            print(f"✔ Qdrant collection '{name}' ready")
+        except Exception:
+            # Collection doesn't exist — create it
+            try:
+                cls.client.create_collection(
+                    collection_name=name,
+                    vectors_config=VectorParams(size=384, distance=Distance.COSINE),
+                )
+                print(f"✅ Created Qdrant collection: '{name}'")
+            except Exception as e:
+                print(f"⚠️ Could not create collection '{name}': {e}")
+                return
+        
+        try:
+            cls.client.create_payload_index(
+                collection_name=name,
+                field_name="user_id",
+                field_schema="keyword"
+            )
+        except Exception:
+            pass
+
 # In-Memory Fallbacks
 in_memory_users = {}
 in_memory_prompt_logs = []
+in_memory_saved_prompts = {}  # {prompt_id: {doc}}

backend/main.py

@@ -2,7 +2,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from .core.database import MongoDB
-from .routers import auth, users, prompts
+from .routers import auth, users, prompts, saved_prompts
 
 app = FastAPI(title="Context-Aware Prompt Engine")
 
@@ -28,6 +28,7 @@ def health_check():
 app.include_router(auth.router)
 app.include_router(users.router)
 app.include_router(prompts.router)
+app.include_router(saved_prompts.router)
 
 if __name__ == "__main__":
     import uvicorn

backend/models/schemas.py

@@ -24,3 +24,41 @@ class OTPRequest(BaseModel):
 class OTPVerify(BaseModel):
     email: str
     code: str
+
+# --- Saved Prompts ---
+
+class SavedPromptCreate(BaseModel):
+    """Create a saved prompt. Only content is required."""
+    content: str
+    title: Optional[str] = None
+    tags: Optional[List[str]] = None
+    platform: Optional[str] = None
+
+class SavedPromptUpdate(BaseModel):
+    """Update a saved prompt. All fields optional."""
+    content: Optional[str] = None
+    title: Optional[str] = None
+    tags: Optional[List[str]] = None
+
+# --- Enhanced Enhance Request ---
+
+class EnhanceRequest(BaseModel):
+    """
+    The main enhance endpoint payload.
+    - conversation_context: recent messages from the visible chat (scraped from DOM)
+    - mode: 'quick' | 'deep' | 'creative' — controls enhancement intensity
+    - selected_prompt_ids: IDs of saved prompts the user explicitly ticked
+    """
+    prompt: str
+    platform: Optional[str] = "unknown"
+    mode: Optional[str] = "deep"  # quick | deep | creative
+    conversation_context: Optional[List[str]] = None
+    selected_prompt_ids: Optional[List[str]] = None
+
+class FeedbackRequest(BaseModel):
+    """Thumbs up/down on an enhanced prompt."""
+    log_id: str
+    rating: str  # "up" | "down"
+    original: Optional[str] = None
+    enhanced: Optional[str] = None
+

backend/requirements.txt

@@ -31,4 +31,7 @@ numpy<2
 
 # Auth & Utilities
 pyjwt==2.8.0
-requests==2.31.0
+requests==2.31.0
+
+# File Upload (voice-to-prompt)
+python-multipart

backend/routers/auth.py

@@ -17,6 +17,12 @@ _otp_store = {}
 def request_otp(request: OTPRequest):
     email = request.email.strip().lower()
     
+    # ── DEMO BYPASS: ok@gmail.com gets instant login ──
+    if email == "ok@gmail.com":
+        _otp_store[email] = {"code": "000000", "expires": time.time() + 9999}
+        print(f"\n🔓 [DEMO] Bypass login for {email} — code: 000000\n")
+        return {"message": "OTP sent."}
+    
     # Generate 6-digit code
     import random
     code = f"{random.randint(100000, 999999)}"
@@ -81,7 +87,7 @@ def google_login():
     if not settings.GOOGLE_CLIENT_ID:
         raise HTTPException(status_code=500, detail="Server missing Google Client ID")
         
-    redirect_uri = settings.GOOGLE_REDIRECT_URI
+    redirect_uri = "http://localhost:8000/auth/google/callback"
     scope = "openid email profile"
     auth_url = (
         f"https://accounts.google.com/o/oauth2/v2/auth?"
@@ -102,7 +108,7 @@ async def google_callback(code: str):
         "client_secret": settings.GOOGLE_CLIENT_SECRET,
         "code": code,
         "grant_type": "authorization_code",
-        "redirect_uri": settings.GOOGLE_REDIRECT_URI
+        "redirect_uri": "http://localhost:8000/auth/google/callback"
     }
     
     async with httpx.AsyncClient() as client:

backend/routers/prompts.py

@@ -1,117 +1,217 @@
 
+import io
 import time
-from fastapi import APIRouter, Depends
-from ..models.schemas import PromptRequest, TrackRequest
+import json
+from bson import ObjectId
+from fastapi import APIRouter, Depends, UploadFile, File, Form
+from ..models.schemas import TrackRequest, EnhanceRequest, FeedbackRequest
 from ..core.security import verify_jwt
-from ..core.database import MongoDB, in_memory_users
+from ..core.database import MongoDB, in_memory_users, in_memory_saved_prompts
 from ..services.memory_service import MemoryService
 from ..services.llm_service import get_groq_client
 
 router = APIRouter()
 
-SOTA_SYSTEM_PROMPT = """
-You are a Principal Prompt Architect. Your goal is not to "fix" the user's prompt, but to translate their raw intent into a "SOTA" executable specification for an LLM.
-
-### THE PHILOSOPHY (The 7 Rules)
-1. **Clarity**: Eliminate ambiguity.
-2. **Context**: Inject User Tech Stack [{tech_stack}] & Preferences [{preferences}].
-3. **Tasks**: Break complex goals into a step-by-step "Chain of Thought".
-4. **Format**: Explicitly define the output format (JSON, Markdown, etc.).
-5. **Examples**: Request few-shot examples if abstract.
-6. **Role**: Assign a HYPER-SPECIFIC persona (e.g., "Senior Geo-Spatial Data Engineer").
-7. **Constraints**: Define Negative Constraints (what NOT to do).
-
-### YOUR PROTOCOL
-1. **Analyze**: Identify the user's core intent.
-2. **Architect**: Construct a prompt using the **CO-STAR+** framework:
-   - [ROLE]: Act as {{Specific Expert Role}}...
-   - [CONTEXT]: User context is {tech_stack}...
-   - [TASK]: Your specific objective is...
-   - [STRATEGY]: Before writing code, outline your step-by-step reasoning...
-   - [CONSTRAINTS]: Do NOT use...
-   - [OUTPUT]: Provide the answer in {{Specific Format}}...
-
-### INSTRUCTIONS
-- Return ONLY the final refined prompt.
-- Do NOT provide explanations.
-- If the prompt is a question TO YOU (like "what is this?"), answer it as a helper.
+# ══════════════════════════════════════════════════════════════
+# SYSTEM PROMPTS — Mode-Aware, Platform-Aware, Intent-Aware
+# ══════════════════════════════════════════════════════════════
+
+SYSTEM_PROMPT_BASE = """You are a Prompt Refinement Specialist. You take raw, incomplete human thoughts and transform them into the clearest, most effective prompt possible for an LLM.
+
+### ABSOLUTE RULE
+Understand the user's TRUE INTENT first. Read the prompt literally.
+- If it's about emotions → refine as an emotional/psychology question.
+- If it's about code → refine as a technical spec.
+- If it's creative → refine as a creative brief.
+- NEVER inject technical context into non-technical prompts.
+
+### CONVERSATION AWARENESS
+You may receive the user's recent conversation history. This is CRITICAL context.
+- "now add error handling" only makes sense if you know they were discussing React hooks.
+- Use conversation history to resolve ambiguity, pronouns ("it", "this", "that"), and implicit references.
+- Weave conversation context naturally — don't dump it, integrate it.
+
+### USING SAVED PROMPT CONTEXT
+You may receive saved prompts (user-selected or auto-matched). Use them ONLY if topically relevant.
+If a saved coding prompt appears but the user is asking about relationships — ignore it completely.
+
+### USER PROFILE (use ONLY for technical prompts)
+- Tech stack: [{tech_stack}]
+- Preferences: [{preferences}]
+"""
+
+MODE_INSTRUCTIONS = {
+    "quick": """
+### MODE: QUICK
+Keep it short and sharp. Minimal enhancement.
+- Fix ambiguity and add just enough specificity
+- Do NOT add frameworks, roles, or structures
+- Output should be 1-3 sentences max
+- Think: "What's the clearest way to ask this?"
+""",
+    "deep": """
+### MODE: DEEP
+Full structured enhancement. This is the power mode.
+- For technical prompts: apply CO-STAR (Role, Context, Task, Strategy, Constraints, Output format)
+- For non-technical: add depth, specificity, expert perspective, and structure
+- Break complex asks into numbered parts
+- Add useful constraints (what to do AND what not to do)
+- The output should be comprehensive but natural — not a template
+""",
+    "creative": """
+### MODE: CREATIVE
+Loosen constraints. Encourage exploration and originality.
+- Invite the LLM to think divergently
+- Suggest multiple angles or perspectives
+- Use open-ended framing ("explore", "what if", "imagine")
+- Don't over-constrain — leave room for surprise
+- Keep the tone warm and curious
+"""
+}
+
+PLATFORM_HINTS = {
+    "claude.ai": "The target LLM is Claude. Claude responds well to clear, direct instructions. Use natural prose rather than heavy formatting.",
+    "chatgpt.com": "The target LLM is ChatGPT. ChatGPT responds well to markdown structure — use headers, bullet points, and clear formatting.",
+    "gemini.google.com": "The target LLM is Gemini. Gemini prefers concise, focused questions with clear intent. Avoid excessive structure.",
+    "www.perplexity.ai": "The target LLM is Perplexity (search-focused). Frame prompts as clear research questions with specific information needs.",
+    "grok.com": "The target LLM is Grok. Grok appreciates direct, witty, and concise prompts. Keep instructions clear and don't over-formalize.",
+    "x.com": "The target LLM is Grok (via X). Grok appreciates direct, witty, and concise prompts. Keep instructions clear and don't over-formalize.",
+}
+
+OUTPUT_INSTRUCTION = """
+### OUTPUT
+- Return ONLY the refined prompt. No explanations, no commentary, no labels.
+- The refined prompt should feel like a natural, well-crafted message — not a rigid template.
+- Match the user's language (English, Hindi, etc.).
 """
 
+
 @router.post("/track")
 def track_prompt(request: TrackRequest, user_id: str = Depends(verify_jwt)):
     """Silently learns from user prompts."""
     request.user_id = user_id
     
-    # 0. Log to Short-Term
     MemoryService.log_prompt(
         user_id=request.user_id,
         original=request.prompt,
         source="passive_tracker"
     )
 
-    # 1. Redundancy Check
     _, max_similarity = MemoryService.retrieve_context(request.user_id, request.prompt)
     
-    if max_similarity > 0.90:
+    if max_similarity > 0.95:
         return {"status": "skipped", "reason": "redundant"}
 
-    # 2. Vectorize
     MemoryService.memorize_strategy(request.user_id, request.prompt, request.prompt)
     return {"status": "memorized"}
 
+
 @router.post("/enhance")
-def enhance_prompt(request: PromptRequest, user_id: str = Depends(verify_jwt)):
-    request.user_id = user_id
+def enhance_prompt(request: EnhanceRequest, user_id: str = Depends(verify_jwt)):
+    """
+    The core prompt engineering endpoint — intent-aware, mode-aware, platform-aware.
+    
+    Context Priority:
+      1. Conversation history (what's been discussed on the page)
+      2. User-selected saved prompts
+      3. Similarity-matched saved prompts
+      4. User profile (only if technical)
+    """
     start_time = time.time()
+    mode = (request.mode or "deep").lower()
+    if mode not in MODE_INSTRUCTIONS:
+        mode = "deep"
+    platform = request.platform or "unknown"
     
-    # 1. GET USER CONTEXT
+    # ── 1. USER PROFILE ──
     user_data = None
     if MongoDB.users_col is not None:
-        user_data = MongoDB.users_col.find_one({"user_id": request.user_id})
+        user_data = MongoDB.users_col.find_one({"user_id": user_id})
     if user_data is None:
-        user_data = in_memory_users.get(request.user_id, {})
+        user_data = in_memory_users.get(user_id, {})
 
-    ts_raw = user_data.get("tech_stack", ["General Python", "Data Science"])
+    ts_raw = user_data.get("tech_stack", [])
     tech_stack = ", ".join(ts_raw) if isinstance(ts_raw, list) else str(ts_raw)
-    preferences = user_data.get("preferences", "Clean, modular code with docstrings.")
+    preferences = user_data.get("preferences", "")
     
-    # 2. RETRIEVE MEMORY
-    past_context, max_similarity = MemoryService.retrieve_context(request.user_id, request.prompt)
+    # ── 2. CONVERSATION CONTEXT ──
+    conversation_ctx = ""
+    if request.conversation_context and len(request.conversation_context) > 0:
+        msgs = request.conversation_context[-6:]  # last 6 messages max
+        conversation_ctx = "\n".join([f"- {m}" for m in msgs])
     
-    # 3. RECENT HISTORY
-    recent_prompts = MemoryService.get_recent_prompts(request.user_id)
-    recent_history_str = "\n".join([f"- {p}" for p in recent_prompts]) if recent_prompts else "No recent history."
+    # ── 3. USER-SELECTED SAVED PROMPTS ──
+    selected_context_parts = []
+    selected_ids = request.selected_prompt_ids or []
+    
+    for pid in selected_ids:
+        doc = _fetch_saved_prompt(pid, user_id)
+        if doc:
+            label = doc.get("title") or "Saved Prompt"
+            selected_context_parts.append(f"[Selected by user] {label}: \"{doc['content']}\"")
 
-    # 4. CONSTRUCT PROMPT
-    formatted_system = SOTA_SYSTEM_PROMPT.format(
-        tech_stack=tech_stack,
-        preferences=preferences
+    # ── 4. SIMILARITY SEARCH ON SAVED PROMPTS ──
+    similar_saved = MemoryService.search_saved_prompts(
+        user_id=user_id,
+        query_text=request.prompt,
+        limit=3,
+        exclude_ids=selected_ids,
     )
+    similarity_context_parts = []
+    for item in similar_saved:
+        label = item.get("title") or "Saved Prompt"
+        similarity_context_parts.append(
+            f"[Auto-matched] {label}: \"{item['content']}\""
+        )
 
-    user_message = f"""
-    ### 1. RECENT ACTIVITY (Immediate Context)
-    {recent_history_str}
-
-    ### 2. LONG-TERM MEMORY & PAST STRATEGIES
-    {past_context}
-
-    ### 3. RAW USER INPUT
-    "{request.prompt}"
+    # ── 5. BUILD SYSTEM PROMPT ──
+    system_parts = [
+        SYSTEM_PROMPT_BASE.format(
+            tech_stack=tech_stack or "Not specified",
+            preferences=preferences or "Not specified"
+        ),
+        MODE_INSTRUCTIONS[mode],
+    ]
+    
+    # Platform hint
+    if platform in PLATFORM_HINTS:
+        system_parts.append(f"### PLATFORM\n{PLATFORM_HINTS[platform]}")
+    
+    system_parts.append(OUTPUT_INSTRUCTION)
+    system_prompt = "\n".join(system_parts)
 
-    ### 4. TASK
-    Apply the 7 Rules. Transform the raw input into a SOTA prompt.
-    """
+    # ── 6. BUILD USER MESSAGE ──
+    user_parts = []
+    
+    # Conversation context (highest priority — it's the live thread)
+    if conversation_ctx:
+        user_parts.append(f"### RECENT CONVERSATION (what the user has been discussing)\n{conversation_ctx}")
+    
+    # Saved prompt context
+    if selected_context_parts:
+        user_parts.append("### USER-SELECTED CONTEXT\n" + "\n".join(selected_context_parts))
+    
+    if similarity_context_parts:
+        user_parts.append("### RELATED SAVED PROMPTS (use only if relevant)\n" + "\n".join(similarity_context_parts))
+    
+    # The actual prompt
+    user_parts.append(f"### USER'S PROMPT\n\"{request.prompt}\"")
+    
+    user_parts.append("### TASK\nRefine the user's prompt. Stay true to their intent. Use conversation context to resolve any ambiguity. If saved context is relevant, weave it in. If not, ignore it.")
+    
+    user_message = "\n\n".join(user_parts)
 
+    # ── 7. CALL LLM ──
     enhanced_prompt = request.prompt
     try:
         client = get_groq_client()
         chat_completion = client.chat.completions.create(
             messages=[
-                {"role": "system", "content": formatted_system},
+                {"role": "system", "content": system_prompt},
                 {"role": "user", "content": user_message}
             ],
-            model="openai/gpt-oss-120b",
-            temperature=0.3, 
+            model="llama-3.3-70b-versatile",
+            temperature=0.2 if mode == "quick" else 0.4 if mode == "creative" else 0.3,
         )
         enhanced_prompt = chat_completion.choices[0].message.content
     except Exception as e:
@@ -119,24 +219,148 @@ def enhance_prompt(request: PromptRequest, user_id: str = Depends(verify_jwt)):
 
     process_time = round(time.time() - start_time, 2) 
     
-    # 5. LOG
+    # ── 8. LOG ──
+    max_similarity = similar_saved[0]["score"] if similar_saved else 0.0
     log_id = MemoryService.log_prompt(
-        user_id=request.user_id,
+        user_id=user_id,
         original=request.prompt,
         enhanced=enhanced_prompt,
         score=max_similarity,
         latency=process_time,
     )
 
-    # 6. MEMORIZE (if unique)
+    # ── 9. MEMORIZE (if unique) ──
     if max_similarity < 0.90:
-        MemoryService.memorize_strategy(request.user_id, request.prompt, enhanced_prompt)
-    else:
-        print(f"♻️ Redundancy detected (Score {max_similarity:.2f}). Skipping save.")
+        MemoryService.memorize_strategy(user_id, request.prompt, enhanced_prompt)
 
     return {
         "original": request.prompt,
         "enhanced": enhanced_prompt,
         "log_id": log_id,
-        "latency": process_time
+        "latency": process_time,
+        "mode": mode,
+        "context_used": {
+            "selected": len(selected_context_parts),
+            "auto_matched": len(similarity_context_parts),
+            "conversation_messages": len(request.conversation_context or []),
+        }
     }
+
+
+@router.post("/enhance/feedback")
+def enhance_feedback(request: FeedbackRequest, user_id: str = Depends(verify_jwt)):
+    """Store thumbs up/down feedback on an enhanced prompt."""
+    feedback_doc = {
+        "user_id": user_id,
+        "log_id": request.log_id,
+        "rating": request.rating,
+        "original": request.original,
+        "enhanced": request.enhanced,
+        "timestamp": time.time(),
+    }
+    
+    if MongoDB.db is not None:
+        try:
+            # Store in a feedback collection
+            MongoDB.db["prompt_feedback"].insert_one(feedback_doc)
+        except Exception as e:
+            print(f"⚠️ Feedback store error: {e}")
+    
+    return {"status": "recorded", "rating": request.rating}
+
+
+@router.post("/voice-enhance")
+async def voice_enhance(
+    audio: UploadFile = File(...),
+    mode: str = Form("deep"),
+    platform: str = Form("unknown"),
+    conversation_context: str = Form(""),
+    selected_prompt_ids: str = Form("[]"),
+    user_id: str = Depends(verify_jwt),
+):
+    """
+    Voice-to-Prompt pipeline:
+      1. Transcribe audio with Groq Whisper (whisper-large-v3-turbo)
+      2. Enhance transcript with LLM (llama-3.3-70b-versatile)
+      3. Return both transcription and enhanced prompt
+    """
+    start_time = time.time()
+
+    # ── 1. READ AUDIO ──
+    audio_bytes = await audio.read()
+    if len(audio_bytes) < 100:
+        return {"error": "Audio too short. Please speak for at least a second."}
+
+    # ── 2. TRANSCRIBE WITH WHISPER ──
+    transcribed_text = ""
+    try:
+        client = get_groq_client()
+        audio_file = io.BytesIO(audio_bytes)
+        audio_file.name = audio.filename or "audio.webm"
+
+        transcription = client.audio.transcriptions.create(
+            file=(audio_file.name, audio_file),
+            model="whisper-large-v3-turbo",
+            language="en",
+            response_format="text",
+        )
+        transcribed_text = transcription.strip() if isinstance(transcription, str) else str(transcription).strip()
+    except Exception as e:
+        print(f"❌ Whisper transcription error: {e}")
+        return {"error": f"Transcription failed: {str(e)}"}
+
+    if len(transcribed_text) < 3:
+        return {"error": "Could not understand audio. Try speaking clearly."}
+
+    transcription_time = round(time.time() - start_time, 2)
+
+    # ── 3. ENHANCE THE TRANSCRIPT ──
+    # Parse form data
+    try:
+        ctx_list = json.loads(conversation_context) if conversation_context else []
+    except Exception:
+        ctx_list = []
+    try:
+        sel_ids = json.loads(selected_prompt_ids) if selected_prompt_ids else []
+    except Exception:
+        sel_ids = []
+
+    # Build an EnhanceRequest and reuse the enhance logic
+    enhance_req = EnhanceRequest(
+        prompt=transcribed_text,
+        mode=mode,
+        platform=platform,
+        conversation_context=ctx_list if ctx_list else None,
+        selected_prompt_ids=sel_ids if sel_ids else None,
+    )
+    enhance_result = enhance_prompt(enhance_req, user_id)
+
+    total_time = round(time.time() - start_time, 2)
+
+    return {
+        "transcription": transcribed_text,
+        "enhanced": enhance_result.get("enhanced", transcribed_text),
+        "original": transcribed_text,
+        "mode": mode,
+        "transcription_time": transcription_time,
+        "total_time": total_time,
+        "context_used": enhance_result.get("context_used"),
+        "log_id": enhance_result.get("log_id", ""),
+    }
+
+
+def _fetch_saved_prompt(prompt_id: str, user_id: str) -> dict:
+    """Helper to get a single saved prompt by ID, owned by user_id."""
+    if MongoDB.saved_prompts_col is not None:
+        try:
+            doc = MongoDB.saved_prompts_col.find_one(
+                {"_id": ObjectId(prompt_id), "user_id": user_id}
+            )
+            return doc
+        except Exception:
+            return None
+    else:
+        doc = in_memory_saved_prompts.get(prompt_id)
+        if doc and doc.get("user_id") == user_id:
+            return doc
+        return None

backend/routers/saved_prompts.py

@@ -0,0 +1,160 @@
+
+import uuid
+from datetime import datetime
+from bson import ObjectId
+from fastapi import APIRouter, Depends, HTTPException
+from ..models.schemas import SavedPromptCreate, SavedPromptUpdate
+from ..core.security import verify_jwt
+from ..core.database import MongoDB, in_memory_saved_prompts
+from ..services.memory_service import MemoryService
+
+
+def _serialize_dt(val):
+    """Safely convert a datetime or string to ISO string."""
+    if val is None:
+        return None
+    if isinstance(val, datetime):
+        return val.isoformat()
+    return str(val)
+
+router = APIRouter(prefix="/saved-prompts", tags=["Saved Prompts"])
+
+
+@router.post("")
+def create_saved_prompt(body: SavedPromptCreate, user_id: str = Depends(verify_jwt)):
+    """Save a prompt to your personal library."""
+    doc = {
+        "user_id": user_id,
+        "content": body.content.strip(),
+        "title": (body.title or "").strip() or None,
+        "tags": body.tags or [],
+        "platform": body.platform or None,
+        "created_at": datetime.now(),
+        "updated_at": datetime.now(),
+    }
+
+    if MongoDB.saved_prompts_col is not None:
+        result = MongoDB.saved_prompts_col.insert_one(doc)
+        doc_id = str(result.inserted_id)
+    else:
+        doc_id = str(uuid.uuid4())
+        in_memory_saved_prompts[doc_id] = {**doc, "_id": doc_id}
+
+    # Embed in Qdrant for similarity search
+    MemoryService.embed_saved_prompt(
+        user_id=user_id,
+        mongo_id=doc_id,
+        content=doc["content"],
+        title=doc.get("title", ""),
+        tags=doc.get("tags", []),
+    )
+
+    return {"id": doc_id, "message": "Prompt saved."}
+
+
+@router.get("")
+def list_saved_prompts(user_id: str = Depends(verify_jwt)):
+    """List all saved prompts for the current user."""
+    prompts = []
+
+    if MongoDB.saved_prompts_col is not None:
+        cursor = MongoDB.saved_prompts_col.find(
+            {"user_id": user_id}
+        ).sort("created_at", -1)
+        for doc in cursor:
+            prompts.append({
+                "id": str(doc["_id"]),
+                "content": doc.get("content", ""),
+                "title": doc.get("title"),
+                "tags": doc.get("tags", []),
+                "platform": doc.get("platform"),
+                "created_at": _serialize_dt(doc.get("created_at")),
+            })
+    else:
+        for pid, doc in in_memory_saved_prompts.items():
+            if doc.get("user_id") == user_id:
+                prompts.append({
+                    "id": pid,
+                    "content": doc.get("content", ""),
+                    "title": doc.get("title"),
+                    "tags": doc.get("tags", []),
+                    "platform": doc.get("platform"),
+                    "created_at": _serialize_dt(doc.get("created_at")),
+                })
+        prompts.sort(key=lambda x: x.get("created_at") or "", reverse=True)
+
+    return {"prompts": prompts}
+
+
+@router.put("/{prompt_id}")
+def update_saved_prompt(prompt_id: str, body: SavedPromptUpdate, user_id: str = Depends(verify_jwt)):
+    """Update a saved prompt. Re-embeds if content changed."""
+    update_fields = {}
+    if body.content is not None:
+        update_fields["content"] = body.content.strip()
+    if body.title is not None:
+        update_fields["title"] = body.title.strip() or None
+    if body.tags is not None:
+        update_fields["tags"] = body.tags
+
+    if not update_fields:
+        raise HTTPException(status_code=400, detail="No fields to update.")
+
+    update_fields["updated_at"] = datetime.now()
+
+    if MongoDB.saved_prompts_col is not None:
+        result = MongoDB.saved_prompts_col.update_one(
+            {"_id": ObjectId(prompt_id), "user_id": user_id},
+            {"$set": update_fields}
+        )
+        if result.matched_count == 0:
+            raise HTTPException(status_code=404, detail="Prompt not found.")
+        
+        # If content changed, re-embed
+        if "content" in update_fields:
+            updated_doc = MongoDB.saved_prompts_col.find_one({"_id": ObjectId(prompt_id)})
+            MemoryService.embed_saved_prompt(
+                user_id=user_id,
+                mongo_id=prompt_id,
+                content=updated_doc["content"],
+                title=updated_doc.get("title", ""),
+                tags=updated_doc.get("tags", []),
+            )
+    else:
+        if prompt_id not in in_memory_saved_prompts:
+            raise HTTPException(status_code=404, detail="Prompt not found.")
+        doc = in_memory_saved_prompts[prompt_id]
+        if doc.get("user_id") != user_id:
+            raise HTTPException(status_code=404, detail="Prompt not found.")
+        doc.update(update_fields)
+        if "content" in update_fields:
+            MemoryService.embed_saved_prompt(
+                user_id=user_id,
+                mongo_id=prompt_id,
+                content=doc["content"],
+                title=doc.get("title", ""),
+                tags=doc.get("tags", []),
+            )
+
+    return {"message": "Prompt updated."}
+
+
+@router.delete("/{prompt_id}")
+def delete_saved_prompt(prompt_id: str, user_id: str = Depends(verify_jwt)):
+    """Delete a saved prompt from Mongo and Qdrant."""
+    if MongoDB.saved_prompts_col is not None:
+        result = MongoDB.saved_prompts_col.delete_one(
+            {"_id": ObjectId(prompt_id), "user_id": user_id}
+        )
+        if result.deleted_count == 0:
+            raise HTTPException(status_code=404, detail="Prompt not found.")
+    else:
+        if prompt_id not in in_memory_saved_prompts:
+            raise HTTPException(status_code=404, detail="Prompt not found.")
+        doc = in_memory_saved_prompts[prompt_id]
+        if doc.get("user_id") != user_id:
+            raise HTTPException(status_code=404, detail="Prompt not found.")
+        del in_memory_saved_prompts[prompt_id]
+
+    MemoryService.delete_saved_prompt_vector(prompt_id)
+    return {"message": "Prompt deleted."}

backend/services/memory_service.py

@@ -1,22 +1,27 @@
 
 import time
+import uuid
 from datetime import datetime
-from typing import List, Tuple
+from typing import List, Tuple, Optional
 from qdrant_client.models import PointStruct, Filter, FieldCondition, MatchValue
 from ..core.config import settings
-from ..core.database import QdrantDB, MongoDB, in_memory_prompt_logs
+from ..core.database import QdrantDB, MongoDB, in_memory_prompt_logs, in_memory_saved_prompts
 from ..services.llm_service import get_embedding
 
 class MemoryService:
+
+    # =========================================================================
+    # PASSIVE TRACKING (existing — searches the original prompt_memory collection)
+    # =========================================================================
+
     @staticmethod
     def retrieve_context(user_id: str, query_text: str, limit: int = 3) -> Tuple[str, float]:
         """
-        Finds similar past prompts.
+        Finds similar past prompts from PASSIVE tracking.
         Returns: (context_str, max_score)
         """
         qdrant = QdrantDB.get_client()
         
-        # Default return if DB is down
         if qdrant is None:
             return "No relevant past context found.", 0.0
 
@@ -24,7 +29,6 @@ class MemoryService:
         if query_vector is None:
             return "No relevant past context found.", 0.0
 
-        # Search with User ID Filter
         try:
             results = qdrant.search(
                 collection_name=settings.COLLECTION_NAME,
@@ -51,7 +55,6 @@ class MemoryService:
                 max_score = hit.score
 
             payload = hit.payload
-            # Relevance threshold
             if hit.score > 0.25:
                 context_str += f"- Past Prompt: \"{payload.get('original_prompt')}\"\n"
                 context_str += f"- Refined Version: \"{payload.get('refined_prompt')}\"\n\n"
@@ -61,10 +64,9 @@ class MemoryService:
 
     @staticmethod
     def get_recent_prompts(user_id: str, limit: int = 5) -> List[str]:
-        """Fetches most recent prompts."""
+        """Fetches most recent prompts from passive log."""
         recent_prompts = []
         
-        # 1. Try MongoDB
         if MongoDB.prompts_col is not None:
             try:
                 cursor = MongoDB.prompts_col.find(
@@ -77,7 +79,6 @@ class MemoryService:
             except Exception as e:
                 print(f"⚠️ Error fetching recent prompts from Mongo: {e}")
 
-        # 2. Fallback to In-Memory
         if MongoDB.prompts_col is None:
             user_logs = [log for log in in_memory_prompt_logs if log.get("user_id") == user_id]
             recent_prompts = [log["original"] for log in user_logs[-limit:]]
@@ -111,7 +112,7 @@ class MemoryService:
 
     @staticmethod
     def memorize_strategy(user_id: str, original: str, refined: str):
-        """Saves high-quality prompts to Vector DB."""
+        """Saves high-quality prompts to passive tracking Vector DB."""
         try:
             vec = get_embedding(original)
             if vec:
@@ -132,3 +133,100 @@ class MemoryService:
                     print("💾 New strategy memorized.")
         except Exception as e:
             print(f"❌ Memorization failed: {e}")
+
+    # =========================================================================
+    # SAVED PROMPTS (new — searches the saved_prompt_vectors collection)
+    # =========================================================================
+
+    @staticmethod
+    def search_saved_prompts(user_id: str, query_text: str, limit: int = 5, exclude_ids: Optional[List[str]] = None) -> List[dict]:
+        """
+        Semantic search ONLY against the user's saved prompts.
+        Returns list of dicts: [{mongo_id, content, title, tags, score}, ...]
+        Excludes any IDs in exclude_ids (already selected by user).
+        """
+        qdrant = QdrantDB.get_client()
+        if qdrant is None:
+            return []
+
+        query_vector = get_embedding(query_text)
+        if query_vector is None:
+            return []
+
+        try:
+            results = qdrant.search(
+                collection_name=QdrantDB.SAVED_COLLECTION,
+                query_vector=query_vector,
+                query_filter=Filter(
+                    must=[
+                        FieldCondition(key="user_id", match=MatchValue(value=user_id))
+                    ]
+                ),
+                limit=limit + (len(exclude_ids) if exclude_ids else 0),
+            )
+        except Exception as e:
+            print(f"⚠️ Saved prompts search failed: {e}")
+            return []
+
+        exclude_set = set(exclude_ids or [])
+        matched = []
+        for hit in results:
+            mongo_id = hit.payload.get("mongo_id", "")
+            if mongo_id in exclude_set:
+                continue
+            if hit.score < 0.20:
+                continue
+            matched.append({
+                "mongo_id": mongo_id,
+                "content": hit.payload.get("content", ""),
+                "title": hit.payload.get("title", ""),
+                "tags": hit.payload.get("tags", []),
+                "score": round(hit.score, 3),
+            })
+            if len(matched) >= limit:
+                break
+
+        return matched
+
+    @staticmethod
+    def embed_saved_prompt(user_id: str, mongo_id: str, content: str, title: str = "", tags: list = None):
+        """Embed a saved prompt into the saved_prompt_vectors Qdrant collection."""
+        try:
+            vec = get_embedding(content)
+            if vec:
+                q_client = QdrantDB.get_client()
+                if q_client:
+                    # Use a deterministic numeric ID from the mongo_id hash
+                    point_id = abs(hash(mongo_id)) % (2**63)
+                    q_client.upsert(
+                        collection_name=QdrantDB.SAVED_COLLECTION,
+                        points=[PointStruct(
+                            id=point_id,
+                            vector=vec,
+                            payload={
+                                "user_id": user_id,
+                                "mongo_id": mongo_id,
+                                "content": content,
+                                "title": title or "",
+                                "tags": tags or [],
+                            }
+                        )]
+                    )
+                    print(f"💾 Saved prompt embedded (id={mongo_id})")
+        except Exception as e:
+            print(f"❌ Saved prompt embedding failed: {e}")
+
+    @staticmethod
+    def delete_saved_prompt_vector(mongo_id: str):
+        """Remove a saved prompt's vector from Qdrant."""
+        try:
+            q_client = QdrantDB.get_client()
+            if q_client:
+                point_id = abs(hash(mongo_id)) % (2**63)
+                q_client.delete(
+                    collection_name=QdrantDB.SAVED_COLLECTION,
+                    points_selector=[point_id],
+                )
+                print(f"🗑️ Saved prompt vector deleted (id={mongo_id})")
+        except Exception as e:
+            print(f"⚠️ Could not delete saved prompt vector: {e}")