first commit

app/config.py

@@ -1,57 +0,0 @@
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-class Settings(BaseSettings):
-    """Application settings loaded from environment variables."""
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # Google API Keys
-    # ───────────────────────────────────────────────────────────────────────────
-    pagespeed_api_key: str
-    gemini_api_key: str
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # Chat & RAG Configuration
-    # ───────────────────────────────────────────────────────────────────────────
-    groq_api_key: str
-    vectorstore_base_path: str = "./vectorstores"
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # Hugging Face Hub
-    # ───────────────────────────────────────────────────────────────────────────
-    huggingfacehub_api_token: str
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # MongoDB Configuration (Local)
-    # ───────────────────────────────────────────────────────────────────────────
-    mongo_uri: str = "mongodb://localhost:27017"
-    mongo_chat_db: str = "Education_chatbot"
-    mongo_chat_collection: str = "chat_histories"
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # FastAPI Server Configuration
-    # ───────────────────────────────────────────────────────────────────────────
-    host: str = "0.0.0.0"
-    port: int = 8000
-    debug: bool = False
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # App Metadata (unchanged)
-    # ───────────────────────────────────────────────────────────────────────────
-    app_name: str = "PageSpeed Insights Report Generator"
-    app_version: str = "1.0.0"
-    app_description: str = (
-        "Professional API for generating PageSpeed Insights reports "
-        "using Google's APIs and Gemini AI"
-    )
-
-    # ───────────────────────────────────────────────────────────────────────────
-    # Tell Pydantic to load from .env and ignore extras
-    # ───────────────────────────────────────────────────────────────────────────
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        extra="ignore",
-    )
-
-# Single shared Settings instance
-settings = Settings()

app/main.py

@@ -5,24 +5,16 @@ import time
 import logging
 import json
 from datetime import datetime
-from fastapi import FastAPI, HTTPException, Depends
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from contextlib import asynccontextmanager
 
-from app.config import settings
-from app.models import (
-    PageSpeedRequest,
-    PageSpeedDataResponse,
-    ReportRequest,
-    ReportResponse,
-    HealthResponse,
-    PriorityRequest,
-    PriorityResponse
-)
-from app.services import PageSpeedService
+from app.page_speed.config import settings
+from app.page_speed.models import HealthResponse
 from app.rag.routes import router as rag_router
 from app.seo import routes as seo_routes
+from app.page_speed import routes as page_speed_routes
 
 
 # ------------------------
@@ -67,6 +59,8 @@ app.include_router(rag_router)
 
 app.include_router(seo_routes.router)
 
+# Mount PageSpeed router
+app.include_router(page_speed_routes.router)
 
 # Add CORS middleware
 app.add_middleware(
@@ -77,12 +71,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Dependency to get PageSpeed service
-def get_pagespeed_service() -> PageSpeedService:
-    """Dependency to get a new PageSpeedService instance."""
-    return PageSpeedService()
-
-
 @app.get("/", response_model=dict)
 async def root():
     """Root endpoint with API information."""
@@ -113,124 +101,6 @@ async def health_check():
     )
 
 
-@app.post("/pagespeed", response_model=PageSpeedDataResponse)
-async def fetch_pagespeed(
-    request: PageSpeedRequest,
-    service: PageSpeedService = Depends(get_pagespeed_service)
-):
-    """
-    Fetch raw PageSpeed Insights data for a given URL.
-
-    Request body:
-    {
-      "url": "https://www.example.com"
-    }
-
-    Returns:
-    {
-      "success": true,
-      "url": "https://www.example.com",
-      "pagespeed_data": { ... },
-      "error": null
-    }
-    """
-    url_str = str(request.url)
-    logger.info("Received POST /pagespeed for URL: %s", url_str)
-    
-    try:
-        pagespeed_data = service.get_pagespeed_data(url_str)
-        logger.info("Returning PageSpeed data for %s", url_str)
-        return PageSpeedDataResponse(
-            success=True,
-            url=url_str,
-            pagespeed_data=pagespeed_data,
-            error=None
-        )
-    except Exception as e:
-        logger.error("Error in /pagespeed endpoint for URL %s: %s", url_str, e, exc_info=True)
-        return PageSpeedDataResponse(
-            success=False,
-            url=url_str,
-            pagespeed_data=None,
-            error=str(e)
-        )
-
-
-@app.post("/generate-report", response_model=ReportResponse)
-async def generate_report(
-    body: ReportRequest,
-    service: PageSpeedService = Depends(get_pagespeed_service)
-):
-    """
-    Generate a Gemini-based optimization report from previously-fetched PageSpeed JSON.
-
-    Request body:
-    {
-      "pagespeed_data": { …full PageSpeed JSON… }
-    }
-
-    Returns:
-    {
-      "success": true,
-      "report": "Gemini-generated analysis…",
-      "error": null
-    }
-    """
-    logger.info("Received POST /generate-report")
-
-    try:
-        pagespeed_data = body.pagespeed_data
-        logger.debug("PageSpeed JSON payload size: %d bytes", len(str(pagespeed_data)))
-        
-        report_text = service.generate_report_with_gemini(pagespeed_data)
-        logger.info("Returning Gemini report.")
-        return ReportResponse(
-            success=True,
-            report=report_text,
-            error=None
-        )
-    except Exception as e:
-        logger.error("Error in /generate-report endpoint: %s", e, exc_info=True)
-        return ReportResponse(
-            success=False,
-            report=None,
-            error=str(e)
-        )
-
-
-@app.post("/generate-priorities", response_model=PriorityResponse)
-async def generate_priorities(
-    request: PriorityRequest,
-    service: PageSpeedService = Depends(get_pagespeed_service)
-):
-    """
-    Generate a prioritized list of performance improvements from a Gemini report.
-
-    Request body:
-    {
-      "report": "Full Gemini-generated performance report..."
-    }
-
-    Returns:
-    {
-      "success": true,
-      "priorities": {
-        "High": ["Optimize TBT by reducing JS execution", ...],
-        "Medium": [...],
-        "Low": [...]
-      },
-      "error": null
-    }
-    """
-    logger.info("Received POST /generate-priorities")
-    try:
-        priorities = service.generate_priority(request.report)
-        return PriorityResponse(success=True, priorities=priorities)
-    except Exception as e:
-        logger.error("Error in /generate-priorities: %s", e, exc_info=True)
-        return PriorityResponse(success=False, priorities=None, error=str(e))
-
-
 @app.exception_handler(404)
 async def not_found_handler(request, exc):
     """Custom 404 handler."""
@@ -244,7 +114,6 @@ async def not_found_handler(request, exc):
         }
     )
 
-
 @app.exception_handler(500)
 async def internal_error_handler(request, exc):
     """Custom 500 handler."""

app/page_speed/config.py

@@ -0,0 +1,39 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from urllib.parse import quote_plus
+
+class Settings(BaseSettings):
+    # Google API Keys
+    pagespeed_api_key: str
+    gemini_api_key: str
+
+    # Chat & RAG Configuration
+    groq_api_key: str
+    vectorstore_base_path: str = "./vectorstores"
+
+    # Hugging Face
+    huggingfacehub_api_token: str
+
+    # MongoDB Config
+    mongo_password: str
+    mongo_chat_db: str = "MAAS"
+    mongo_chat_collection: str = "chat_histories"
+
+    # FastAPI Server Config
+    host: str = "0.0.0.0"
+    port: int = 8000
+    debug: bool = False
+
+    # MongoDB Atlas URI (Dynamically Constructed)
+    @property
+    def mongo_uri(self):
+        encoded_pwd = quote_plus(self.mongo_password)
+        return f"mongodb+srv://Hammad:{encoded_pwd}@cluster0.oi9z5ig.mongodb.net/{self.mongo_chat_db}?retryWrites=true&w=majority"
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore"
+    )
+
+# Global settings instance
+settings = Settings()

app/{models.py → page_speed/models.py}

@@ -109,4 +109,14 @@ class PriorityRequest(BaseModel):
 class PriorityResponse(BaseModel):
     success: bool
     priorities: Optional[Dict[str, List[str]]] = None
-    error: Optional[str] = None
+    error: Optional[str] = None
+
+class AnalyzeRequest(BaseModel):
+    url: HttpUrl
+
+class AnalyzeResponse(BaseModel):
+    success: bool
+    url: HttpUrl
+    report: str | None
+    priorities: dict | None
+    error: str | None

app/page_speed/routes.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter, Depends
+from app.page_speed.models import (
+    AnalyzeRequest,
+    AnalyzeResponse
+)
+
+import logging
+
+from app.page_speed.services import PageSpeedService 
+
+router = APIRouter(prefix="/pagespeed", tags=["PageSpeed"])
+
+"""
+PageSpeed Insights API routes for analyzing URLs and generating reports.
+"""
+
+logger = logging.getLogger("app.page_speed.routes")
+logger.setLevel(logging.INFO)
+
+
+def get_pagespeed_service() -> PageSpeedService:
+    """Dependency to get a new PageSpeedService instance."""
+    return PageSpeedService()
+
+
+@router.post("/analyze-url", response_model=AnalyzeResponse)
+async def analyze_url(
+    request: AnalyzeRequest,
+    service: PageSpeedService = Depends(get_pagespeed_service)
+):
+    """
+    One-stop endpoint to fetch PageSpeed data, generate report, and derive priorities.
+
+    - Takes a single 'url' field in the body.
+    - Returns pagespeed_data, human-friendly report, and priority lists.
+    """
+    url_str = str(request.url)
+    logger.info("Received POST /analyze-url for URL: %s", url_str)
+
+    try:
+        # 1. Fetch raw PageSpeed Insights data
+        pagespeed_data = service.get_pagespeed_data(url_str)
+        logger.debug("Fetched PageSpeed data (bytes=%d)", len(str(pagespeed_data)))
+
+        # 2. Generate text report via Gemini
+        report_text = service.generate_report_with_gemini(pagespeed_data)
+        logger.debug("Generated report text (chars=%d)", len(report_text))
+
+        # 3. Produce prioritized improvements
+        priorities = service.generate_priority(report_text)
+        logger.info("Analysis complete for %s", url_str)
+
+        return AnalyzeResponse(
+            success=True,
+            url=url_str,
+            report=report_text,
+            priorities=priorities,
+            error=None
+        )
+    except Exception as e:
+        logger.error("Error in /analyze-url: %s", e, exc_info=True)
+        return AnalyzeResponse(
+            success=False,
+            url=url_str,
+            report=None,
+            priorities=None,
+            error=str(e)
+        )

app/{services.py → page_speed/services.py}

@@ -6,7 +6,7 @@ import requests
 import logging
 import google.generativeai as genai
 from typing import Dict, Any
-from app.config import settings
+from app.page_speed.config import settings
 
 # Create a module-level logger
 logger = logging.getLogger(__name__)
@@ -116,106 +116,78 @@ class PageSpeedService:
     
     def _create_analysis_prompt(self, pagespeed_data: Dict[Any, Any]) -> str:
         """
-        Create the specialized prompt for Gemini analysis.
+        Create the specialized prompt for Gemini analysis in a human-readable format.
 
         Args:
             pagespeed_data (Dict[Any, Any]): PageSpeed Insights data
 
         Returns:
-            str: Formatted prompt for Gemini
+            str: Human-readable, user-friendly report prompt
         """
         logger.debug("Building Gemini analysis prompt from PageSpeed data.")
         return f"""
+<<<<<<< HEAD:app/services.py
     You are an **Expert Web Performance Optimization Consultant**. The following JSON `{pagespeed_data}` contains exactly these keys (all required):
+=======
+    You are an **Expert Web Performance Optimization Consultant**. The following JSON `{{pagespeed_data}}` includes detailed website performance metrics from Google PageSpeed Insights.
+>>>>>>> 574c6ac (Update endpoints):app/page_speed/services.py
+
+    Your task is to analyze this data and generate a human-friendly performance **report in plain English**. The report will be read by a **non-technical business owner**, so keep it understandable while explaining technical concepts briefly when necessary.
+
+    ### Format of Your Response:
+    Respond with a **natural language summary (not JSON)**. It should read like a report, not like code or technical output.
+
+    ---
+
+    ### Your report must include the following sections:
+
+    1. **Overall Performance Summary**
+    - Explain how fast the website feels to users.
+    - Mention the overall category (FAST, AVERAGE, SLOW) and what that means.
+    - If origin data differs from page data, point it out.
+
+    2. **Key Metrics Breakdown**
+    - For each metric (`CLS`, `TTFB`, `FCP`, `INP`, `LCP`, `TBT`):
+        - Provide the value and performance category (e.g., "good", "needs improvement").
+        - Briefly explain what the metric means and how it impacts the user experience.
+        - Use simple analogies if possible. (Example: “CLS measures layout shift – like if buttons jump around while loading.”)
+
+    3. **Top Issues**
+    - List and explain the top 3–5 performance problems in plain language.
+    - Avoid jargon. Example: “Too many large images are slowing down the page.”
+
+    4. **Improvement Opportunities**
+    - Suggest high-impact actions to improve speed (e.g., compress images, lazy load below-the-fold content).
+    - Prioritize based on effort (low/medium/high) and expected time savings.
+    - Mention technical fixes where helpful, but **always** explain what they do and **why they help**.
+
+    5. **Detailed Audit Notes**
+    - Mention any specific URLs or files causing problems (e.g., slow scripts, unoptimized images).
+    - For each, explain the issue and estimated time it adds to loading.
+    - Be clear and concise.
+
+    6. **Recommended Action Plan**
+    - Provide a to-do list of concrete fixes with estimated effort levels.
+    - If possible, include tips tailored to platforms (e.g., for WordPress or Next.js).
+
+    7. **Ongoing Monitoring Advice**
+    - Recommend how often they should check performance.
+    ---
+
+    ### Important:
+    - Do **not** output JSON or code blocks unless specifically required.
+    - Use a tone that's **professional, helpful, and non-technical**.
+    - Help the reader understand what needs fixing and why it matters for their website and users.
+
+    Example phrasing:
+    > "Your site currently loads in about 3.2 seconds for most users, which is considered average. Improving this can reduce bounce rates and improve conversions."
+
+    Be specific and practical. Use values directly from `{{pagespeed_data}}` such as `numeric_value`, `percentile`, and `category` fields.
+
+    ### PageSpeed Data:
+    {json.dumps(pagespeed_data, indent=2)}
+        """
 
-    ```
-    {{
-    "url": string,  // analyzed page URL
-    "origin": string,  // origin domain
-    "loading_experience": {{  // Chrome UX data for URL
-        "overall_category": "FAST"|"AVERAGE"|"SLOW",
-        "metrics": {{
-        "CLS": {{ "percentile": number, "category": string }},
-        "TTFB": {{ "percentile": number, "category": string }},
-        "FCP": {{ "percentile": number, "category": string }},
-        "INP": {{ "percentile": number, "category": string }}
-        }}
-    }},
-    "origin_loading_experience": {{  // Chrome UX data for origin
-        "overall_category": "FAST"|"AVERAGE"|"SLOW"
-    }},
-    "lighthouse_audits": [  // only audits with score <1 or notApplicable
-        {{
-        "id": string,  // audit identifier
-        "numeric_value": number,  // ms or unit value
-        "score": number|null,  // 0–1 or null if N/A
-        "description": string,  // audit title/description
-        "details": {{  // optional details for resource URLs
-            "items": [ {{ "url": string }} ]
-        }},
-        "metric_savings_ms"?: number  // if available
-        }}
-    ]
-    }}
-    ```
-
-    Your job: output **exactly** the following JSON report—no extra keys, no prose outside these structures:
-
-    ```json
-    {{
-    "overall_score": integer,
-    "grade": "A"|"B"|"C"|"D"|"F",
-    "summary": {{
-        "CLS": {{ "value": number, "category": string }},
-        "TTFB": {{ "value": number, "category": string }},
-        "FCP": {{ "value": number, "category": string }},
-        "INP": {{ "value": number, "category": string }},
-        "LCP": {{ "value": number, "score": number }},
-        "TBT": {{ "value": number, "score": number }}
-    }},
-    "top_issues": [string],
-    "top_opportunities": [string],
-    "audits": [
-        {{
-        "id": string,
-        "value": number,
-        "score": number|null,
-        "resource_url"?: string,  // first offending URL from details.items
-        "status": "critical"|"needs_improvement"|"good",
-        "recommendation": string,
-        "expected_gain_s": number
-        }}
-    ],
-    "action_plan": [
-        {{
-        "id": string,
-        "fix": string,
-        "platform_tip"?: string,  // e.g. Next.js `next/image` or WordPress-specific advice
-        "effort": "low"|"medium"|"high"
-        }}
-    ],
-    "monitoring": {{
-        "frequency": string,
-        "methods": [string],
-        "ci_snippet"?: string  // optional GitHub Action or Lighthouse CI config
-    }}
-    }}``` 
-    **Requirements:**
-    - **Strict Mapping:** Every field derives from `{{PSI_DATA}}` (use JSON paths like `lighthouseResult.audits[...].numeric_value`).
-    - **No Extra Text:** Only the JSON above.
-    - **Tie to JSON Paths:** Include resource URLs via `details.items[0].url`.
-    - **Exact Code Snippets:** Provide `<link rel="preload"...>` or `<script defer>` snippets.
-    - **Quantify Impact:** Use `metric_savings_ms` for each audit to calculate `expected_gain_s`.
-    - **Threshold Targets:** State target values, e.g. "Reduce LCP to ≤1200 ms".
-    - **Platform‑Specific Tips:** If known, include stack advice, e.g. Next.js `next/image` or WordPress plugins.
-    - **Monitoring CI:** Optionally include a GitHub Action snippet:
-    ```yaml
-    - uses: treosh/lighthouse-ci-action@v5
-        with:
-        configPath: .lighthouserc.json
-    ```
-    - **Deterministic Scoring & Priority:** Same as before.
-    """
 
     
     def analyze_url(self, url: str) -> Dict[str, Any]:
@@ -295,16 +267,15 @@ Classification Rules:
 2. **Measurable Target:** Include the numeric goal (e.g., "Reduce LCP to ≤1200 ms").
 3. **Resource Context:** Embed the resource URL or file name when relevant.
 4. **Expected Savings:** Append expected savings in seconds (from `metric_savings_ms`).
-5. **Effort Estimate:** Add an effort estimate (e.g., "Effort: Medium (≈2 hrs)").
-6. **Code Snippet:** Provide a ready‑to‑copy snippet if applicable (e.g., `<img loading="lazy" src=...>`).
-7. **Category Tag:** Prefix with optimization domain `[Image]`, `[CSS]`, `[JS]`, `[Server]`.
-8. **Impact Score:** Append a simple impact rating (e.g., "Impact: ⭐⭐⭐☆☆" or "% of total savings").
-9. **Platform Tip:** If known, include stack‑specific advice (e.g., Next.js `next/image`).
-10. **Priority Classification:**
+5. **Code Snippet:** Provide a ready‑to‑copy snippet if applicable (e.g., `<img loading="lazy" src=...>`).
+6. **Category Tag:** Prefix with optimization domain `[Image]`, `[CSS]`, `[JS]`, `[Server]`.
+7. **Platform Tip:** If known, include stack‑specific advice (e.g., Next.js `next/image`).
+8. **Priority Classification:**
    - High: Savings ≥ 1.5 seconds or score < 0.25
    - Medium: Savings between 0.5 and 1.49 seconds or score 0.25 to 0.50
    - Low: Savings < 0.5 seconds or score between 0.51 and 1.0
    - Unknown: No savings or score data available
+9. Explain in easy english, avoiding technical jargon and explaination for technical terms.
 
 Important:
 - Respond with *only* a valid JSON object.

app/rag/chat_history.py

@@ -1,10 +1,12 @@
+import os
 import time
 from typing import List, Dict, Any
 from pymongo import ReturnDocument
 
-from app.config import settings
+from app.page_speed.config import settings
 from .db import mongo_client, chat_collection_name
 from .embeddings import get_llm
+from .utils import get_vectorstore_path  # make sure this util is available
 from langchain.prompts import ChatPromptTemplate
 from .logging_config import logger
 
@@ -78,3 +80,22 @@ class ChatHistoryManager:
         )
         logger.info("Summarized chat %s down to one message", chat_id)
         return True
+
+    @staticmethod
+    def vectorstore_exists(user_id: str) -> bool:
+        """
+        Check if a vectorstore directory already exists for this user.
+        """
+        path = get_vectorstore_path(user_id)
+        exists = os.path.isdir(path)
+        logger.debug("Vectorstore path %s exists: %s", path, exists)
+        return exists
+
+    @staticmethod
+    def chat_exists(chat_id: str) -> bool:
+        """
+        Check if a chat session already exists in Mongo for this chat_id.
+        """
+        found = coll.count_documents({"session_id": chat_id}, limit=1) > 0
+        logger.debug("Chat session %s exists: %s", chat_id, found)
+        return found

app/rag/db.py

@@ -1,5 +1,5 @@
 from pymongo import MongoClient
-from app.config import settings
+from app.page_speed.config import settings
 
 # ──────────────────────────────────────────────────────────────────────────────
 # MongoDB Initialization

app/rag/embeddings.py

@@ -1,7 +1,6 @@
 import os
 from langchain_community.embeddings import HuggingFaceBgeEmbeddings
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.prompts import ChatPromptTemplate
 from dotenv import load_dotenv
 
 load_dotenv()  # now os.getenv(...) will pick up values from your .env file

app/rag/prompt_library.py

@@ -1,7 +1,5 @@
 from langchain.prompts import ChatPromptTemplate
 
-
-
 # ──────────────────────────────────────────────────────────────────────────────
 # 1. Prompt Template for PAGE Speed Insights RAG Chatbot
 # ──────────────────────────────────────────────────────────────────────────────

app/rag/routes.py

@@ -1,125 +1,117 @@
 import os
 import uuid
 from fastapi import APIRouter, HTTPException
-from typing import Optional
 
-from .schemas import (
-    IngestRequest,
-    IngestResponse,
-    CreateChatResponse,
-    ChatRequest,
-    ChatResponse
-)
+from .schemas import SetupRequest, ChatRequest, SetupResponse, ChatResponse
 from .utils import (
     text_splitter,
     embeddings,
-    get_vectorstore_path,
     save_vectorstore_to_disk,
     upsert_vectorstore_metadata,
-    build_or_load_vectorstore,
-    build_rag_chain,
-    initialize_chat_history
+    get_vectorstore_path,
+    build_rag_chain
 )
-from .logging_config import logger
-
 from .chat_history import ChatHistoryManager
 from .logging_config import logger
 
 router = APIRouter(prefix="/rag", tags=["rag"])
 
-@router.post("/ingest/{user_id}", response_model=IngestResponse)
-async def ingest_documents(user_id: str, body: IngestRequest):
+@router.post("/initialization/{onboarding_id}", response_model=SetupResponse)
+async def setup_rag_session(onboarding_id: str, body: SetupRequest):
     """
-    Ingest a list of text documents into a FAISS vectorstore for this user.
-    Steps:
-      1. Concatenate all documents into one string.
-      2. Split into chunks using RecursiveCharacterTextSplitter.
-      3. Create a FAISS vectorstore from those chunks.
-      4. Save the vectorstore to disk under ./vectorstores/{user_id}/faiss_index.
-      5. Upsert metadata in Mongo (user_id -> vectorstore_path).
+    Single endpoint to ingest documents and create a chat session.
+    - If vectorstore exists for user_id, skip ingestion.
+    - Always create a new chat_id for this session.
     """
-    logger.info("Ingestion requested for user_id=%s. Number of docs=%d", user_id, len(body.documents))
-    try:
-        # 1. Join all provided documents
+    # 1. Handle vectorstore existence
+    vectorstore_path = get_vectorstore_path(onboarding_id)
+    if os.path.isdir(vectorstore_path):
+        logger.info(
+            "Vectorstore exists for onboarding_id=%s at %s; skipping ingestion",
+            onboarding_id, vectorstore_path
+        )
+        vs_path = vectorstore_path
+    else:
+        if not body.documents:
+            logger.error(
+                "Vectorstore missing for onboarding_id=%s and no documents provided", onboarding_id
+            )
+            raise HTTPException(
+                status_code=400,
+                detail="Vectorstore does not exist; please provide documents to ingest."
+            )
+        # Ingest new vectorstore
         all_text = "\n\n".join(body.documents)
-
-        # 2. Split into chunks
         text_chunks = text_splitter.split_text(all_text)
-        logger.info("Split into %d chunks", len(text_chunks))
-
-        # 3. Build FAISS vectorstore
+        logger.info("Split into %d chunks for ingestion", len(text_chunks))
         from langchain.vectorstores import FAISS as _FAISS
         vs = _FAISS.from_texts(texts=text_chunks, embedding=embeddings)
-
-        # 4. Save to disk
-        faiss_path = save_vectorstore_to_disk(vs, user_id)
-        logger.info("Saved FAISS index to %s", faiss_path)
-
-        # 5. Upsert metadata
-        upsert_vectorstore_metadata(user_id, faiss_path)
-        logger.info("Upserted vectorstore metadata for user_id=%s", user_id)
-
-        return IngestResponse(
-            success=True,
-            message="Vectorstore created successfully.",
-            user_id=user_id,
-            vectorstore_path=faiss_path
+        vs_path = save_vectorstore_to_disk(vs, onboarding_id)
+        logger.info("Saved FAISS index to %s", vs_path)
+        upsert_vectorstore_metadata(onboarding_id, vs_path)
+        logger.info(
+            "Upserted vectorstore metadata for onboarding_id=%s", onboarding_id
         )
-    except Exception as e:
-        logger.error("Error during ingestion for user_id=%s: %s", user_id, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Ingestion failed: {e}")
 
-@router.post("/chat/create/{user_id}", response_model=CreateChatResponse)
-async def create_chat_session(user_id: str):
+    # Create new chat session
+    chat_id = str(uuid.uuid4())
+    ChatHistoryManager.create_session(chat_id)
+    logger.info(
+        "Created new chat session %s for onboarding_id=%s",
+        chat_id, onboarding_id
+    )
+
+    return SetupResponse(
+        success=True,
+        message="RAG setup completed.",
+        onboarding_id=onboarding_id,
+        chat_id=chat_id,
+        vectorstore_path=vs_path
+    )
+
+@router.post("/chat/{onboarding_id}/{chat_id}", response_model=ChatResponse)
+async def chat_with_user(onboarding_id: str, chat_id: str, prompt_type: str, body: ChatRequest):
     """
-    Create a new chat session for this user:
-      - Generate a chat_id (UUID).
-      - Initialize an empty MongoDBChatMessageHistory for that chat_id.
-      - Return the chat_id so the client can use it in subsequent calls.
+    Chat endpoint that uses an existing chat session and vectorstore.
+    - Validates that the vectorstore exists for onboarding_id.
+    - Validates that the chat session exists.
     """
-    logger.info("Creating new chat session for user_id=%s", user_id)
-    try:
-        chat_id = str(uuid.uuid4())
-
-        # Initialize chat history (this writes an empty session to Mongo)
-        _ = initialize_chat_history(chat_id)
-        logger.info("Created chat history in Mongo for chat_id=%s", chat_id)
-
-        return CreateChatResponse(
-            success=True,
-            message="Chat session created.",
-            user_id=user_id,
-            chat_id=chat_id
+    # 0. Validate vectorstore
+    vectorstore_path = get_vectorstore_path(onboarding_id)
+    if not os.path.isdir(vectorstore_path):
+        logger.error("Vectorstore not found for onboarding_id=%s", onboarding_id)
+        raise HTTPException(
+            status_code=400,
+            detail="Vectorstore not found for this onboarding_id. Please run /setup first."
         )
-    except Exception as e:
-        logger.error("Error creating chat for user_id=%s: %s", user_id, e, exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Failed to create chat session: {e}")
 
+    # 1. Ensure chat session exists
+    if not ChatHistoryManager.chat_exists(chat_id):
+        logger.error("Chat session %s not found for onboarding_id=%s", chat_id, onboarding_id)
+        raise HTTPException(
+            status_code=404,
+            detail=f"Chat session {chat_id} does not exist."
+        )
 
-@router.post("/chat/{user_id}/{chat_id}", response_model=ChatResponse)
-async def chat_with_user(user_id: str, chat_id: str, prompt_type:str, body: ChatRequest):
     question = body.question.strip()
-    logger.info("Chat request user=%s chat=%s question=%s", user_id, chat_id, question)
+    logger.info("Chat request onboarding_id=%s chat=%s question=%s", onboarding_id, chat_id, question)
 
     try:
-        # 1) Ensure session exists
-        ChatHistoryManager.create_session(chat_id)
-
-        # 2) Summarize long histories
+        # Summarize long histories
         ChatHistoryManager.summarize_if_needed(chat_id, threshold=10)
 
-        # 3) Record the user message
+        # Record the user message
         ChatHistoryManager.add_message(chat_id, role="human", content=question)
 
-        # 4) Build and invoke the RAG chain
-        chain = build_rag_chain(user_id, chat_id , prompt_type)
+        # Build and invoke the RAG chain
+        chain = build_rag_chain(onboarding_id, chat_id, prompt_type)
         history = ChatHistoryManager.get_messages(chat_id)
         result = chain.invoke({"question": question, "chat_history": history})
         answer = result.get("answer") or result.get("output_text")
         if not answer:
             raise Exception("No answer returned from chain")
 
-        # 5) Record the AI response
+        # Record the AI response
         ChatHistoryManager.add_message(chat_id, role="ai", content=answer)
 
         return ChatResponse(
@@ -127,17 +119,17 @@ async def chat_with_user(user_id: str, chat_id: str, prompt_type:str, body: Chat
             answer=answer,
             error=None,
             chat_id=chat_id,
-            user_id=user_id
+            onboarding_id=onboarding_id
         )
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("Error chatting user=%s chat=%s: %s", user_id, chat_id, e, exc_info=True)
+        logger.error("Error chatting onboarding_id=%s chat=%s: %s", onboarding_id, chat_id, e, exc_info=True)
         return ChatResponse(
             success=False,
             answer=None,
             error=str(e),
             chat_id=chat_id,
-            user_id=user_id
+            onboarding_id=onboarding_id
         )

app/rag/schemas.py

@@ -1,33 +1,6 @@
 from pydantic import BaseModel, Field
 from typing import List, Optional
 
-class IngestRequest(BaseModel):
-    """
-    Request body for ingesting documents into a user's FAISS vector store.
-    """
-    documents: List[str] = Field(
-        ...,
-        description="A list of text documents (strings) to ingest into the vector store."
-    )
-
-class IngestResponse(BaseModel):
-    """
-    Response after ingesting documents for a user.
-    """
-    success: bool
-    message: str
-    user_id: str
-    vectorstore_path: Optional[str] = None
-
-class CreateChatResponse(BaseModel):
-    """
-    Response after creating a new chat session for a user.
-    """
-    success: bool
-    message: str
-    user_id: str
-    chat_id: Optional[str] = None
-
 class ChatRequest(BaseModel):
     """
     Body for sending a user message to an existing chat session.
@@ -42,4 +15,14 @@ class ChatResponse(BaseModel):
     answer: Optional[str] = None
     error: Optional[str] = None
     chat_id: str
-    user_id: str
+    onboarding_id: str
+
+class SetupRequest(BaseModel):
+    documents: List[str]
+    
+class SetupResponse(BaseModel):
+    success: bool
+    message: str
+    onboarding_id: str
+    chat_id: str
+    vectorstore_path: str

app/rag/utils.py

@@ -7,7 +7,7 @@ from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
 from langchain.memory import ConversationBufferMemory                # ← IMPORT THIS
 from langchain.chains import ConversationalRetrievalChain
 
-from app.config import settings
+from app.page_speed.config import settings
 from .db import vectorstore_meta_coll, chat_collection_name
 from .embeddings import embeddings, text_splitter, get_llm
 from .logging_config import logger
@@ -23,7 +23,7 @@ def get_vectorstore_path(user_id: str) -> str:
     """
     base_dir = settings.vectorstore_base_path
     user_dir = os.path.join(base_dir, user_id)
-    os.makedirs(user_dir, exist_ok=True)
+    # os.makedirs(user_dir, exist_ok=True)
     return user_dir
 
 # ──────────────────────────────────────────────────────────────────────────────

app/seo/models.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+from typing import Any, Dict
+
+class SEORequest(BaseModel):
+    seo_data: Dict[str, Any]

app/seo/routes.py

@@ -1,38 +1,27 @@
 from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from typing import Any, Dict
 from .seo_service import SEOService
-
+from .models import SEORequest
 
 router = APIRouter(prefix="/seo", tags=["SEO"])
 
 seo_service = SEOService()
 
-
-class SEORequest(BaseModel):
-    seo_data: Dict[str, Any]
-
-class SEOPriorityRequest(BaseModel):
-    report: str
-
-@router.post("/generate-report")
-def generate_seo_report(request: SEORequest):
+@router.post("/generate-full-report")
+def generate_full_seo_analysis(request: SEORequest):
     """
-    Generate SEO report via Gemini.
+    Generate full SEO analysis: report + prioritized suggestions.
     """
     try:
+        # Step 1: Generate SEO report (as a string)
         report = seo_service.generate_seo_report(request.seo_data)
-        return {"success": True, "report": report}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-    
-@router.post("/generate-priority")
-def generate_seo_priority(request: SEOPriorityRequest):
-    """
-    Generate prioritized SEO suggestions from the report.
-    """
-    try:
-        priority_suggestions = seo_service.generate_seo_priority(request.report)
-        return {"success": True, "priority_suggestions": priority_suggestions}
+
+        # Step 2: Generate prioritized SEO suggestions from the report
+        priority_suggestions = seo_service.generate_seo_priority(report)
+
+        return {
+            "success": True,
+            "report": report,
+            "priority_suggestions": priority_suggestions
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

app/seo/seo_service.py

@@ -6,15 +6,11 @@ import requests
 import logging
 import google.generativeai as genai
 from typing import Dict, Any
-from app.config import settings
+from app.page_speed.config import settings
 
 # Create a module-level logger
 glogger = logging.getLogger(__name__)
 
-
-
-
-
 class SEOService:
     """
     Service class for generating SEO reports via Gemini.
@@ -67,127 +63,105 @@ class SEOService:
         Build the advanced prompt for SEO analysis based on the updated specialized template.
         """
         return f"""
-You are an **Expert SEO Consultant** with deep expertise in on‑page, technical, and off‑page SEO.
-
-The following JSON `{{SEO_DATA}}` contains exactly these keys (all required):
-
-{json.dumps(seo_data, indent=2)}
-
-Your task is to output **exactly** the following JSON report—no additional text, no extra keys, no commentary:
+You are an **Expert SEO Consultant** with advanced knowledge of on-page, technical, and off-page SEO.
 
-```json
-{{
-  "overall_score": integer,
-  "grade": "A"|"B"|"C"|"D"|"F",
-  "top_strengths": [string],
-  "top_issues": [string],
-  "metrics": [
-    {{
-      "name": string,
-      "value": string|number|boolean|array,
-      "benchmark": string,
-      "score": integer,
-      "status": "good"|"needs_improvement"|"critical",
-      "why_it_matters": string,
-      "recommendation": string
-    }}
-  ],
-  "action_plan": [
-    {{
-      "metric": string,
-      "fix": string,
-      "effort_level": "low"|"medium"|"high"
-    }}
-  ],
-  "monitoring": {{
-    "frequency": string,
-    "methods": [string]
-  }},
-  "technical_seo": "data_unavailable" | {{
-    "core_web_vitals": {{
-      "LCP": string,
-      "FID": string,
-      "CLS": string
-    }},
-    "page_speed_score": integer,
-    "lazy_loading": boolean,
-    "security_headers": [string]
-  }},
-  "schema_markup": "data_unavailable" | {{
-    "structured_data_types": [string],
-    "valid": boolean
-  }},
-  "backlink_profile": "data_unavailable" | {{
-    "referring_domains": integer,
-    "toxic_links": integer,
-    "recommendations": string
-  }},
-  "trend_comparison": "data_unavailable" | {{
-    "previous_score": integer,
-    "change": "increase"|"decrease"|"no_change",
-    "comment": string
-  }}
-}}
+Your task is to analyze this data and return a detailed SEO audit report as a **multi-line string** (not as JSON). Keep it structured, clear, and easy to read — for example, using sections, bullet points, and indentation.
 
-Instructions:
+Include these sections in your output:
 
-Do not include any text before or after the JSON.
+---
 
-Evaluate SEO performance holistically across all provided data:
+**Overall Summary**
+- Overall SEO Score: (0–100)
+- Grade: A, B, C, D, or F
+- Top Strengths: List the top 3–5 strong areas
+- Top Issues: List the top 3–5 weak/problematic areas
 
-On‑Page SEO (titles, meta, headings, content, images, links)
+---
 
-Technical SEO (robots.txt, sitemap.xml, indexability, mobile‑friendly, HTTPS, URL structure)
+**Metric Breakdown**
+For each key metric in the data:
+- Metric Name
+- Value: ...
+- Benchmark: ...
+- Score: ...
+- Status: good / needs improvement / critical
+- Why It Matters: Explain simply
+- Recommendation: What to fix or improve
 
-Off‑Page SEO (backlink_profile)
+---
 
-Use deterministic scoring based on internal benchmarks:
+**Action Plan**
+List 5 weakest metrics and how to fix them:
+- Metric: ...
+  - Fix: ...
+  - Effort Level: low / medium / high
 
-SEO Score: ≤50=critical, 51–70=needs_improvement, >70=good
+---
 
-Meta Title length: 50–60 chars=good, <50 or >60=needs_improvement
+**Monitoring Strategy**
+- Frequency: weekly or monthly (based on severity of issues)
+- Methods: Tools or techniques to track progress
 
-H1 Tags: exactly 1=good, >1=needs_improvement, 0=critical
+---
 
-Heading Structure errors: any=critical
+**Technical SEO**
+If data is available, include:
+- Core Web Vitals (LCP, FID, CLS)
+- Page Speed Score
+- Lazy Loading Enabled
+- Security Headers Present
 
-Image Alt Tags ratio: ≥90% good, 50–89% needs_improvement, <50% critical
+If not available, just write “Technical SEO data not available.”
 
-sitemapXmlCheck: missing=critical
+---
 
-robotsTxtCheck: missing=critical
+**Schema Markup**
+If available:
+- Types Detected
+- Is Valid: Yes/No  
+Else: “Schema markup data not available.”
 
-indexabilityCheck: false=critical
+---
 
-internalLinksCount: <5=needs_improvement
+**Backlink Profile**
+If available:
+- Referring Domains
+- Toxic Links
+- Recommendations to improve off-page SEO
 
-externalLinksCount: <2=needs_improvement
+---
 
-Advanced sections (technical_seo, schema_markup, backlink_profile, trend_comparison):
+**Trend Comparison**
+If available:
+- Previous Score
+- Score Change (increase, decrease, or no change)
+- Comment
 
-If the input data lacks these metrics, set the field value to "data_unavailable".
+---
 
-Otherwise, populate with real values (e.g., core web vitals, page speed score, backlink counts).
+### ⚙️ Scoring Rules Summary (for reference):
 
-The action_plan must list the 5 weakest metrics by score, across all sections.
+- SEO Score: ≤50 = critical, 51–70 = needs improvement, >70 = good
+- Meta Title: 50–60 chars = good, else needs improvement
+- H1 Tags: exactly 1 = good, 0 or >1 = needs improvement/critical
+- Heading Errors: any = critical
+- Image Alt Tags: ≥90% = good, 50–89% = needs improvement, <50% = critical
+- sitemapXmlCheck / robotsTxtCheck: missing = critical
+- indexabilityCheck: false = critical
+- internalLinksCount: <5 = needs improvement
+- externalLinksCount: <2 = needs improvement
 
-Set "monitoring.frequency" to:
+Use these rules to calculate metric status and overall grade:
+- 90–100 → A
+- 80–89 → B
+- 70–79 → C
+- 60–69 → D
+- <60 → F
 
-"weekly" if any metric status is "critical" or "needs_improvement".
+SEO data provided in JSON format:
+{seo_data}
 
-"monthly" if all metrics are "good".
-
-Grading scale:
-
-90–100: A
-
-80–89: B
-
-70–79: C
-
-60–69: D
-
-<60: F    
 """
 
     def generate_seo_priority(self, report: str) -> Dict[str, Any]:
@@ -233,19 +207,19 @@ Classification Rules:
 2. **Benchmark Comparison:** Include both the **current value** and the **ideal benchmark**  
    (e.g. `"Current: 15 keywords, Ideal: 1–3% density"`).
 3. **Impact Estimate:** Quantify expected SEO impact (e.g. `"+12% CTR"` or `"+0.5 page rank score"`).
-4. **Effort Estimate:** Add an effort estimate (e.g. `"Effort: Low (≈1 hr)"`).
-5. **Code Snippet:** Provide a ready‑to‑copy example if applicable  
+4. **Code Snippet:** Provide a ready‑to‑copy example if applicable  
    (e.g. `<meta name="description" content="...">`).
-6. **Category Tag:** Prefix with SEO domain—  
+5. **Category Tag:** Prefix with SEO domain—  
    `[On-Page]`, `[Technical]`, `[Off-Page]`, `[Local]`, `[Schema]`.
-7. **Impact Score:** Append a simple impact rating (e.g. `"Impact: ⭐⭐⭐☆☆"`).
-8. **Platform Tip:** If applicable, include CMS or framework advice  
+6. **Platform Tip:** If applicable, include CMS or framework advice  
    (e.g. `"WordPress: use Yoast SEO"`, `"Next.js: use next/head"`).
-9. **Priority Classification:**  
+7. **Priority Classification:**  
 - **High:** Any metric with score `"critical"` or < 60, or impact ≥ 10%.  
 - **Medium:** Score 60–79 or impact 5–9%.  
 - **Low:** Score 80–100 or impact < 5%.  
 - **Unknown:** No score or impact data available.
+8. Explain in easy english, avoiding technical jargon and explaination for technical terms.
+
 
 Important:
 - Respond with *only* a valid JSON object.