Adding local files to new repository

.dockerignore

@@ -0,0 +1,28 @@
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Git
+.git
+.gitignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs & Temp
+*.log
+uploaded_files/
+temp_unzip_*/
+
+# Local DBs (Don't copy local DBs into image, use volumes instead)
+omni_agent.db
+fake_ecommerce.db

.gitignore

@@ -0,0 +1,27 @@
+# --- Security (Inhein kabhi upload mat karna) ---
+.env
+.env.local
+
+# --- Python Garbage ---
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# --- Virtual Environment (Heavy folders) ---
+venv/
+env/
+.venv/
+
+# --- Local Databases (Railway par naya banega) ---
+omni_agent.db
+fake_ecommerce.db
+*.sqlite3
+
+# --- OS Junk ---
+.DS_Store
+Thumbs.db
+
+# --- Logs ---
+*.log
+uploaded_files/

Dockerfile

@@ -0,0 +1,32 @@
+# 1. Base Image (Lightweight Python)
+FROM  python:3.10-slim
+
+# 2. Set Environment Variables
+# Prevents Python from writing pyc files to disc
+ENV PYTHONDONTWRITEBYTECODE 1
+# Prevents Python from buffering stdout and stderr (logs show up immediately)
+ENV PYTHONUNBUFFERED 1
+
+# 3. Install System Dependencies
+# 'build-essential' is often needed for compiling python packages like numpy/cryptography
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# 4. Set Work Directory
+WORKDIR /app
+
+# 5. Install Dependencies (Layer Caching Strategy)
+# We copy requirements FIRST. If requirements don't change, Docker uses cached layer here.
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# 6. Copy Application Code
+COPY . .
+
+# 7. Expose Port
+EXPOSE 8000
+
+# 8. Run Command
+# We use host 0.0.0.0 so it is accessible outside the container
+CMD ["uvicorn", "backend.src.main:app", "--host", "0.0.0.0", "--port", "8000"]

Procfile

@@ -0,0 +1 @@
+web: uvicorn backend.src.main:app --host 0.0.0.0 --port $PORT

backend/src/api/routes/auth.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from pydantic import BaseModel, EmailStr
+
+from backend.src.db.session import get_db
+from backend.src.models.user import User
+from backend.src.utils.auth import get_password_hash, verify_password, create_access_token
+
+router = APIRouter()
+
+# --- Schemas ---
+class UserCreate(BaseModel):
+    email: EmailStr
+    password: str
+    full_name: str | None = None
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+# --- 1. Registration Endpoint ---
+@router.post("/auth/register", response_model=Token)
+async def register(user_in: UserCreate, db: AsyncSession = Depends(get_db)):
+    # Check agar email pehle se exist karta hai
+    result = await db.execute(select(User).where(User.email == user_in.email))
+    existing_user = result.scalars().first()
+    
+    if existing_user:
+        raise HTTPException(
+            status_code=400,
+            detail="Email already registered"
+        )
+    
+    # Naya User Banao
+    new_user = User(
+        email=user_in.email,
+        hashed_password=get_password_hash(user_in.password),
+        full_name=user_in.full_name
+    )
+    db.add(new_user)
+    await db.commit()
+    await db.refresh(new_user)
+    
+    # Direct Login Token do
+    access_token = create_access_token(data={"sub": str(new_user.id)})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+# --- 2. Login Endpoint ---
+@router.post("/auth/login", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
+    # User dhoondo
+    result = await db.execute(select(User).where(User.email == form_data.username)) # OAuth2 form mein email 'username' field mein hota hai
+    user = result.scalars().first()
+    
+    # Password check karo
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Token generate karo
+    access_token = create_access_token(data={"sub": str(user.id)})
+    return {"access_token": access_token, "token_type": "bearer"}

backend/src/api/routes/chat.py

@@ -0,0 +1,50 @@
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from backend.src.db.session import get_db
+from backend.src.schemas.chat import ChatRequest, ChatResponse
+from backend.src.services.chat_service import process_chat
+from backend.src.core.config import settings
+
+# --- Security Imports ---
+from backend.src.api.routes.deps import get_current_user
+from backend.src.models.user import User
+
+router = APIRouter()
+
+@router.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(
+    request: ChatRequest, 
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user) # <-- User Logged in hai
+):
+    """
+    Protected Chat Endpoint.
+    Only accessible with a valid JWT Token.
+    """
+    try:
+        # User ki ID token se aayegi (Secure)
+        # Session ID user maintain kar sakta hai taake alag-alag chats yaad rahein
+        user_id = str(current_user.id)
+        session_id = request.session_id or user_id # Fallback
+        
+        # --- FIX IS HERE: 'user_id' pass kiya ja raha hai ---
+        response_text = await process_chat(
+            message=request.message,
+            session_id=session_id,
+            user_id=user_id, # <--- Ye hum bhool gaye thay
+            db=db
+        )
+        
+        return ChatResponse(
+            response=response_text,
+            session_id=session_id,
+            # 'provider' ab chat_service se aayega, humein yahan hardcode nahi karna
+            provider="omni_agent" 
+        )
+        
+    except Exception as e:
+        print(f"Error in chat endpoint: {e}")
+        import traceback
+        traceback.print_exc() # Poora error print karega
+        raise HTTPException(status_code=500, detail=str(e))

backend/src/api/routes/deps.py

@@ -0,0 +1,45 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import jwt, JWTError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+
+from backend.src.core.config import settings
+from backend.src.db.session import get_db
+from backend.src.models.user import User
+from backend.src.utils.auth import ALGORITHM
+
+# Ye Swagger UI ko batata hai ke Token kahan se lena hai (/auth/login se)
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/auth/login")
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme), 
+    db: AsyncSession = Depends(get_db)
+) -> User:
+    """
+    Ye function har protected route se pehle chalega.
+    Ye Token ko verify karega aur Database se User nikal kar dega.
+    """
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    
+    try:
+        # Token Decode karo
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[ALGORITHM])
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+        
+    # Database mein User check karo
+    result = await db.execute(select(User).where(User.id == int(user_id)))
+    user = result.scalars().first()
+    
+    if user is None:
+        raise credentials_exception
+        
+    return user

backend/src/api/routes/ingestion.py

@@ -0,0 +1,148 @@
+
+import os
+import shutil
+from fastapi import APIRouter, UploadFile, File, HTTPException, Form, BackgroundTasks, Depends
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+
+# --- Security Imports ---
+from backend.src.api.routes.deps import get_current_user
+from backend.src.models.user import User
+
+# --- Internal Services & DB Imports ---
+from backend.src.services.ingestion.file_processor import process_file
+from backend.src.services.ingestion.crawler import SmartCrawler 
+from backend.src.services.ingestion.zip_processor import SmartZipProcessor
+from backend.src.db.session import get_db, AsyncSessionLocal
+from backend.src.models.ingestion import IngestionJob, JobStatus, IngestionType
+
+# --- CONFIG ---
+MAX_ZIP_SIZE_MB = 100
+MAX_ZIP_SIZE_BYTES = MAX_ZIP_SIZE_MB * 1024 * 1024
+
+router = APIRouter()
+UPLOAD_DIRECTORY = "./uploaded_files"
+
+# ==========================================
+# FILE UPLOAD (Protected)
+# ==========================================
+@router.post("/ingest/upload")
+async def upload_and_process_file(
+    session_id: str = Form(...),
+    file: UploadFile = File(...),
+    current_user: User = Depends(get_current_user) # <--- 🔒 TALA LAGA DIYA
+):
+    # (Function logic same rahegi, bas ab current_user mil jayega)
+    if not os.path.exists(UPLOAD_DIRECTORY):
+        os.makedirs(UPLOAD_DIRECTORY)
+
+    file_path = os.path.join(UPLOAD_DIRECTORY, file.filename)
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        chunks_added = await process_file(file_path, session_id)
+        if chunks_added <= 0:
+            raise HTTPException(status_code=400, detail="Could not process file.")
+        
+        return {
+            "message": "File processed successfully",
+            "filename": file.filename,
+            "chunks_added": chunks_added,
+            "session_id": session_id
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+# ==========================================
+# WEB CRAWLER (Protected)
+# ==========================================
+class WebIngestRequest(BaseModel):
+    url: str
+    session_id: str
+    crawl_type: str = "single_page"
+
+async def run_crawler_task(job_id, url, session_id, crawl_type, db_factory):
+    async with db_factory() as db:
+        crawler = SmartCrawler(job_id, url, session_id, crawl_type, db)
+        await crawler.start()
+
+@router.post("/ingest/url")
+async def start_web_ingestion(
+    request: WebIngestRequest,
+    background_tasks: BackgroundTasks,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user) # <--- 🔒 TALA LAGA DIYA
+):
+    # (Function logic same rahegi)
+    new_job = IngestionJob(
+        session_id=request.session_id,
+        ingestion_type=IngestionType.URL,
+        source_name=request.url,
+        status=JobStatus.PENDING
+    )
+    db.add(new_job)
+    await db.commit()
+    await db.refresh(new_job)
+
+    background_tasks.add_task(run_crawler_task, new_job.id, request.url, request.session_id, request.crawl_type, AsyncSessionLocal)
+    return {"message": "Ingestion job started", "job_id": new_job.id}
+
+@router.get("/ingest/status/{job_id}")
+async def check_job_status(
+    job_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user) # <--- 🔒 TALA LAGA DIYA
+):
+    # (Function logic same rahegi)
+    result = await db.execute(select(IngestionJob).where(IngestionJob.id == job_id))
+    job = result.scalars().first()
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return job
+
+# ==========================================
+# BULK ZIP UPLOAD (Protected)
+# ==========================================
+async def run_zip_task(job_id, zip_path, session_id, db_factory):
+    async with db_factory() as db:
+        processor = SmartZipProcessor(job_id, zip_path, session_id, db)
+        await processor.start()
+
+@router.post("/ingest/upload-zip")
+async def upload_and_process_zip(
+    session_id: str = Form(...),
+    file: UploadFile = File(...),
+    background_tasks: BackgroundTasks = BackgroundTasks(),
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user) # <--- 🔒 TALA LAGA DIYA
+):
+    # (Function logic same rahegi)
+    if not file.filename.endswith(".zip"):
+        raise HTTPException(status_code=400, detail="Only .zip files are allowed.")
+    if file.size > MAX_ZIP_SIZE_BYTES:
+        raise HTTPException(status_code=413, detail=f"File too large. Max size is {MAX_ZIP_SIZE_MB} MB.")
+
+    zip_dir = os.path.join(UPLOAD_DIRECTORY, "zips")
+    os.makedirs(zip_dir, exist_ok=True)
+    file_path = os.path.join(zip_dir, f"job_{session_id}_{file.filename}")
+    
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+
+    new_job = IngestionJob(
+        session_id=session_id,
+        ingestion_type=IngestionType.ZIP,
+        source_name=file.filename,
+        status=JobStatus.PENDING
+    )
+    db.add(new_job)
+    await db.commit()
+    await db.refresh(new_job)
+
+    background_tasks.add_task(run_zip_task, new_job.id, file_path, session_id, AsyncSessionLocal)
+    return {"message": "Zip processing started", "job_id": new_job.id}

backend/src/api/routes/settings.py

@@ -0,0 +1,299 @@
+
+import json
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from sqlalchemy import create_engine, inspect
+from pymongo import MongoClient
+from pydantic import BaseModel
+from typing import Dict, List, Any, Tuple
+
+# --- Internal Imports ---
+from backend.src.db.session import get_db
+from backend.src.models.user import User
+from backend.src.models.integration import UserIntegration
+from backend.src.api.routes.deps import get_current_user
+
+# --- Connectors ---
+from backend.src.services.connectors.sanity_connector import SanityConnector
+
+# --- AI & LLM ---
+from backend.src.services.llm.factory import get_llm_model
+from langchain_core.messages import HumanMessage
+
+router = APIRouter()
+
+# ==========================================
+# DATA MODELS
+# ==========================================
+class IntegrationUpdateRequest(BaseModel):
+    provider: str
+    credentials: Dict[str, Any]
+
+class RefreshSchemaRequest(BaseModel):
+    provider: str 
+
+class ConnectedServiceResponse(BaseModel):
+    provider: str
+    is_active: bool
+    description: str | None = None
+    last_updated: str | None = None
+
+class UserSettingsResponse(BaseModel):
+    user_email: str
+    connected_services: List[ConnectedServiceResponse]
+
+# --- NEW: Bot Profile Model ---
+class BotSettingsRequest(BaseModel):
+    bot_name: str
+    bot_instruction: str
+
+# ==========================================
+# THE DYNAMIC PROFILER (No Bias) 🧠
+# ==========================================
+
+async def generate_data_profile(schema_map: dict, provider: str) -> str:
+    """
+    Ye function bina kisi bias ke, sirf data structure dekh kar keywords nikalta hai.
+    """
+    try:
+        if not schema_map: return f"Connected to {provider}."
+        
+        llm = get_llm_model() 
+        schema_str = json.dumps(schema_map)[:3500] 
+        
+        prompt = f"""
+        Act as a Database Architect. Your job is to analyze the provided Database Schema and generate a 'Semantic Description' for an AI Router.
+
+        --- INPUT SCHEMA ({provider}) ---
+        {schema_str}
+
+        --- INSTRUCTIONS ---
+        1. Analyze the Table Names (or Collections/Types) and Field Names deeply.
+        2. Identify the core "Business Concepts" represented in this data.
+        3. Construct a dense, keyword-rich summary that describes EXACTLY what is in this database.
+        4. **STRICT RULE:** Do NOT use generic words like "solution" or "platform". Use specific nouns found in the schema (e.g., "invoices", "appointments", "inventory", "cement", "users").
+        5. Do NOT guess. Only describe what you see in the schema keys.
+
+        --- OUTPUT FORMAT ---
+        Write a single paragraph (approx 30 words) describing the data contents.
+        Description:
+        """
+        
+        response = await llm.ainvoke([HumanMessage(content=prompt)])
+        return response.content.strip()
+    except Exception as e:
+        print(f"⚠️ Profiling failed: {e}")
+        return f"Contains data from {provider}."
+
+async def perform_discovery(provider: str, credentials: Dict[str, Any]) -> Tuple[Dict, str]:
+    """
+    Common discovery function for Connect and Refresh.
+    """
+    schema_map = {}
+    description = None
+    
+    try:
+        # --- CASE A: SANITY ---
+        if provider == 'sanity':
+            connector = SanityConnector(credentials=credentials)
+            if connector.connect():
+                schema_map = connector.fetch_schema_structure()
+                description = await generate_data_profile(schema_map, 'Sanity CMS')
+
+        # --- CASE B: SQL DATABASE ---
+        elif provider == 'sql':
+            db_url = credentials.get('connection_string') or credentials.get('url')
+            if db_url:
+                engine = create_engine(db_url)
+                inspector = inspect(engine)
+                tables = inspector.get_table_names()
+                
+                schema_map = {"tables": tables}
+                if len(tables) < 15:
+                    for t in tables:
+                        try:
+                            cols = [c['name'] for c in inspector.get_columns(t)]
+                            schema_map[t] = cols
+                        except: pass
+                
+                description = await generate_data_profile(schema_map, 'SQL Database')
+
+        # --- CASE C: MONGODB ---
+        elif provider == 'mongodb':
+            mongo_uri = credentials.get('connection_string') or credentials.get('url')
+            if mongo_uri:
+                client = MongoClient(mongo_uri)
+                db_name = client.get_database().name
+                collections = client[db_name].list_collection_names()
+                
+                schema_map = {"collections": collections}
+                for col in collections[:5]: 
+                    one_doc = client[db_name][col].find_one()
+                    if one_doc:
+                        keys = [k for k in list(one_doc.keys()) if not k.startswith('_')]
+                        schema_map[col] = keys
+
+                description = await generate_data_profile(schema_map, 'MongoDB NoSQL')
+
+        # --- CASE D: QDRANT / OTHERS ---
+        elif provider == 'qdrant':
+            description = "Contains uploaded documents, policies, and knowledge base."
+        
+        return schema_map, description
+
+    except Exception as e:
+        print(f"❌ Discovery Error for {provider}: {e}")
+        return {}, f"Connected to {provider} (Auto-discovery failed: {str(e)})"
+
+# ==========================================
+# 1. SAVE / CONNECT INTEGRATION
+# ==========================================
+@router.post("/settings/integration", status_code=status.HTTP_201_CREATED)
+async def save_or_update_integration(
+    data: IntegrationUpdateRequest,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    try:
+        query = select(UserIntegration).where(
+            UserIntegration.user_id == str(current_user.id),
+            UserIntegration.provider == data.provider
+        )
+        result = await db.execute(query)
+        existing_integration = result.scalars().first()
+
+        credentials_json = json.dumps(data.credentials)
+        schema_map, description = await perform_discovery(data.provider, data.credentials)
+
+        if existing_integration:
+            existing_integration.credentials = credentials_json
+            existing_integration.is_active = True
+            if schema_map: existing_integration.schema_map = schema_map
+            if description: existing_integration.profile_description = description
+            message = f"Integration for {data.provider} updated."
+        else:
+            new_integration = UserIntegration(
+                user_id=str(current_user.id),
+                provider=data.provider,
+                is_active=True,
+                schema_map=schema_map,
+                profile_description=description
+            )
+            new_integration.credentials = credentials_json
+            db.add(new_integration)
+            message = f"Integration for {data.provider} connected."
+
+        await db.commit()
+        return {
+            "message": message, 
+            "provider": data.provider, 
+            "profile": description
+        }
+
+    except Exception as e:
+        await db.rollback()
+        print(f"❌ Error saving integration: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==========================================
+# 2. REFRESH SCHEMA
+# ==========================================
+@router.post("/settings/integration/refresh")
+async def refresh_integration_schema(
+    data: RefreshSchemaRequest,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    print(f"🔄 Refreshing schema for {data.provider} (User: {current_user.id})")
+    
+    try:
+        stmt = select(UserIntegration).where(
+            UserIntegration.user_id == str(current_user.id),
+            UserIntegration.provider == data.provider
+        )
+        result = await db.execute(stmt)
+        integration = result.scalars().first()
+
+        if not integration:
+            raise HTTPException(status_code=404, detail="Integration not found. Please connect first.")
+
+        creds_str = integration.credentials 
+        creds_dict = json.loads(creds_str)
+
+        new_schema, new_description = await perform_discovery(data.provider, creds_dict)
+
+        if new_schema:
+            integration.schema_map = dict(new_schema)
+        
+        if new_description:
+            integration.profile_description = new_description
+            
+        await db.commit()
+        
+        return {
+            "message": "Schema and profile refreshed successfully!", 
+            "provider": data.provider,
+            "new_profile": new_description
+        }
+
+    except Exception as e:
+        print(f"❌ Refresh Failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==========================================
+# 3. UPDATE BOT PROFILE (NEW ✅)
+# ==========================================
+@router.post("/settings/bot-profile")
+async def update_bot_profile(
+    data: BotSettingsRequest,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    User yahan apne chatbot ka Naam aur Role set karega.
+    """
+    try:
+        current_user.bot_name = data.bot_name
+        current_user.bot_instruction = data.bot_instruction
+        
+        db.add(current_user)
+        await db.commit()
+        
+        return {
+            "message": "Bot profile updated successfully!", 
+            "bot_name": data.bot_name,
+            "bot_instruction": data.bot_instruction
+        }
+    except Exception as e:
+        print(f"❌ Bot Profile Update Failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==========================================
+# 4. GET USER INTEGRATIONS
+# ==========================================
+@router.get("/settings/integrations", response_model=UserSettingsResponse)
+async def get_user_integrations(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    query = select(UserIntegration).where(
+        UserIntegration.user_id == str(current_user.id)
+    )
+    result = await db.execute(query)
+    integrations = result.scalars().all()
+    
+    connected_services = [
+        ConnectedServiceResponse(
+            provider=i.provider, 
+            is_active=i.is_active,
+            description=i.profile_description, 
+            last_updated=str(i.updated_at) if i.updated_at else str(i.created_at)
+        )
+        for i in integrations
+    ]
+    
+    return {
+        "user_email": current_user.email,
+        "connected_services": connected_services
+    }

backend/src/core/config.py

@@ -0,0 +1,76 @@
+
+import os
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from functools import lru_cache
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    # ------------------- CORE PROJECT SETTINGS -------------------
+    PROJECT_NAME: str = "OmniAgent Core"
+    VERSION: str = "1.0.0"
+    API_V1_STR: str = "/api/v1"
+    
+    # ------------------- SECURITY (NEW) -------------------
+    # Ye bohot zaroori hai JWT tokens ke liye
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "super-secret-key-change-me")
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    # ------------------- NETWORK / HOSTING -------------------
+    QDRANT_HOST: str = os.getenv("QDRANT_HOST", "localhost")
+    QDRANT_PORT: int = 6333
+    
+    MONGO_HOST: str = os.getenv("MONGO_HOST", "localhost")
+    MONGO_PORT: int = int(os.getenv("MONGO_PORT", 27018))
+    MONGO_USER: str = os.getenv("MONGO_INITDB_ROOT_USERNAME", "admin")
+    MONGO_PASS: str = os.getenv("MONGO_INITDB_ROOT_PASSWORD", "super_secret_admin_pass")
+
+    # ------------------- DATABASES -------------------
+    _DATABASE_URL: str = os.getenv("POSTGRES_URL", "sqlite+aiosqlite:///./omni_agent.db")
+
+    @property
+    def DATABASE_URL(self) -> str:
+        url = self._DATABASE_URL
+        if url and "?" in url:
+            url = url.split("?")[0]
+        if url and url.startswith("postgres://"):
+            url = url.replace("postgres://", "postgresql+asyncpg://", 1)
+        elif url and url.startswith("postgresql://") and "+asyncpg" not in url:
+            url = url.replace("postgresql://", "postgresql+asyncpg://", 1)
+
+              # --- DEBUG PRINT (Ye add karein) ---
+        print(f"🕵️ DEBUG: Connecting to DB URL: {url}") 
+        # (Security Warning: Ye console mein password dikhayega, baad mein hata dena)
+        return url
+
+    @property
+    def QDRANT_URL(self) -> str:
+        if self.QDRANT_HOST.startswith("http"):
+            return self.QDRANT_HOST
+        return f"http://{self.QDRANT_HOST}:{self.QDRANT_PORT}"
+
+    QDRANT_COLLECTION_NAME: str = "omni_agent_main_collection"
+    QDRANT_API_KEY: str | None = None
+
+    # ------------------- RAG / EMBEDDINGS -------------------
+    EMBEDDING_PROVIDER: str = "local"
+    EMBEDDING_MODEL_NAME: str = "sentence-transformers/all-MiniLM-L6-v2"
+
+    # ------------------- AI MODELS -------------------
+    LLM_PROVIDER: str = "generic" 
+    LLM_MODEL_NAME: str = "gpt-3.5-turbo"
+    LLM_BASE_URL: str | None = None 
+    LLM_API_KEY: str | None = None
+    
+    GROQ_API_KEY: str | None = None
+    GOOGLE_API_KEY: str | None = None
+    OPENAI_API_KEY: str | None = None
+
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore", env_file_encoding='utf-8')
+
+@lru_cache()
+def get_settings():
+    return Settings()
+
+settings = get_settings()

backend/src/db/base.py

@@ -0,0 +1,5 @@
+# backend/src/db/base.py
+from sqlalchemy.ext.declarative import declarative_base
+
+# Saare models is Base class se inherit karenge
+Base = declarative_base()

backend/src/db/session.py

@@ -0,0 +1,36 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy import create_engine
+from backend.src.core.config import settings
+
+# Connection Arguments
+connect_args = {}
+if "sqlite" in settings.DATABASE_URL:
+    connect_args = {"check_same_thread": False}
+
+# --- ROBUST ENGINE CREATION (The Fix) ---
+# Ye settings Neon/Serverless ke liye best hain
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=False,
+    connect_args=connect_args,
+    pool_size=5,  # 5 connections ka pool rakho
+    max_overflow=10, # Agar zaroorat pade to 10 aur bana lo
+    pool_recycle=300, # Har 5 minute (300s) mein purane connections ko refresh karo (Sleep issue fix)
+    pool_pre_ping=True, # Har query se pehle check karo ke connection zinda hai ya nahi
+)
+
+# Session Maker
+AsyncSessionLocal = async_sessionmaker(
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autoflush=False,
+)
+
+# Dependency Injection
+async def get_db():
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

backend/src/init_db.py

@@ -0,0 +1,27 @@
+import asyncio
+from backend.src.db.session import engine
+from backend.src.db.base import Base
+
+# --- Import ALL Models here ---
+# Ye zaroori hai taake SQLAlchemy ko pata chale ke kaunse tables banane hain
+from backend.src.models.chat import ChatHistory
+from backend.src.models.ingestion import IngestionJob
+from backend.src.models.integration import UserIntegration # <--- Isme naya column hai
+from backend.src.models.user import User
+
+async def init_database():
+    print("🚀 Connecting to the database...")
+    async with engine.begin() as conn:
+        # --- CRITICAL FOR SCHEMA UPDATE ---
+        # Hum purane tables DROP kar rahe hain taake naya 'profile_description' column add ho sake.
+        # Note: Isse purana data udd jayega (Dev environment ke liye theek hai).
+        print("🗑️ Dropping old tables to apply new Schema...")
+        await conn.run_sync(Base.metadata.drop_all) 
+        
+        print("⚙️ Creating new tables (Users, Chats, Integrations, Jobs)...")
+        await conn.run_sync(Base.metadata.create_all)
+        print("✅ Database tables created successfully!")
+
+if __name__ == "__main__":
+    print("Starting database initialization...")
+    asyncio.run(init_database())

backend/src/main.py

@@ -0,0 +1,53 @@
+import os
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles # <--- New Import
+from fastapi.middleware.cors import CORSMiddleware
+from backend.src.core.config import settings
+
+# --- API Route Imports ---
+from backend.src.api.routes import chat, ingestion, auth, settings as settings_route
+
+# 1. App Initialize karein
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    version=settings.VERSION,
+    description="OmniAgent Core API - The Intelligent Employee"
+)
+
+# 2. CORS Setup (Security)
+# Frontend ko Backend se baat karne ki ijazat dena
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # Production mein hum isay specific domain karenge
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 3. Mount Static Files (Chat Widget ke liye) 🎨
+# Ye check karta hai ke 'static' folder hai ya nahi, agar nahi to banata hai
+if not os.path.exists("static"):
+    os.makedirs("static")
+
+# Is line ka matlab hai: Jo bhi file 'static' folder mein hogi, wo '/static/filename' par milegi
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# 4. Health Check Route
+@app.get("/")
+async def root():
+    return {
+        "message": "Welcome to OmniAgent Core 🚀", 
+        "status": "active",
+        "widget_url": "/static/widget.js" # Widget ka link bhi bata diya
+    }
+
+# 5. API Router Includes
+app.include_router(auth.router, prefix=settings.API_V1_STR, tags=["Authentication"])
+app.include_router(settings_route.router, prefix=settings.API_V1_STR, tags=["User Settings"])
+app.include_router(chat.router, prefix=settings.API_V1_STR, tags=["Chat"])
+app.include_router(ingestion.router, prefix=settings.API_V1_STR, tags=["Ingestion"])
+
+if __name__ == "__main__":
+    import uvicorn
+    # Server Run command (Debugging ke liye)
+    uvicorn.run("backend.src.main:app", host="0.0.0.0", port=8000, reload=True)

backend/src/models/chat.py

@@ -0,0 +1,17 @@
+# backend/src/models/chat.py
+from sqlalchemy import Column, Integer, String, Text, DateTime, Boolean
+from sqlalchemy.sql import func
+from backend.src.db.base import Base
+
+class ChatHistory(Base):
+    __tablename__ = "chat_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    session_id = Column(String, index=True) # User ka Session ID
+    human_message = Column(Text) # User ne kya kaha
+    ai_message = Column(Text) # Bot ne kya jawab diya
+    timestamp = Column(DateTime(timezone=True), server_default=func.now()) # Kab baat hui
+    
+    # Metadata (Optional: Konsa tool use hua, kitne tokens lage)
+    provider = Column(String) 
+    tokens_used = Column(Integer, default=0)

backend/src/models/ingestion.py

@@ -0,0 +1,40 @@
+from sqlalchemy import Column, Integer, String, Text, DateTime, Enum, JSON # <--- JSON import karein
+from sqlalchemy.sql import func
+import enum
+from backend.src.db.base import Base
+
+class JobStatus(str, enum.Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    
+class IngestionType(str, enum.Enum):
+    URL = "url"
+    ZIP = "zip"
+    FILE = "file" # (Future use ke liye)
+
+class IngestionJob(Base):
+    __tablename__ = "ingestion_jobs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    session_id = Column(String, index=True)
+    
+    # --- NEW COLUMNS ---
+    ingestion_type = Column(String, default=IngestionType.URL) # Taake pata chale ye URL hai ya Zip
+    source_name = Column(String, nullable=False) # Ye URL ya Zip file ka naam hoga
+    
+    status = Column(String, default=JobStatus.PENDING)
+    
+    # Progress Tracking
+    items_processed = Column(Integer, default=0)
+    total_items = Column(Integer, default=0)
+    
+    # Detailed Logging
+    details = Column(JSON, default=[]) # <--- Har file ka result yahan aayega
+    
+    error_message = Column(Text, nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+    # 'url', 'crawl_type' waghaira columns hata diye taake table generic rahe

backend/src/models/integration.py

@@ -0,0 +1,34 @@
+
+from sqlalchemy import Column, Integer, String, Text, Boolean, JSON, DateTime
+from sqlalchemy.sql import func
+from backend.src.db.base import Base
+from backend.src.utils.security import SecurityUtils
+
+class UserIntegration(Base):
+    __tablename__ = "user_integrations"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String, index=True) 
+    
+    provider = Column(String, nullable=False) # e.g., 'sanity', 'sql', 'mongodb'
+    
+    # Store encrypted credentials
+    _credentials = Column("credentials", Text, nullable=False)
+    
+    # The Map (Technical Structure)
+    schema_map = Column(JSON, default={})
+
+    # --- NEW COLUMN: The semantic description of the data ---
+    profile_description = Column(Text, nullable=True) 
+    
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+
+    @property
+    def credentials(self):
+        return SecurityUtils.decrypt(self._credentials)
+
+    @credentials.setter
+    def credentials(self, value):
+        self._credentials = SecurityUtils.encrypt(value)

backend/src/models/user.py

@@ -0,0 +1,19 @@
+from sqlalchemy import Column, Integer, String, DateTime, Boolean, Text # Text add kiya
+from sqlalchemy.sql import func
+from backend.src.db.base import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    full_name = Column(String, nullable=True)
+    is_active = Column(Boolean, default=True)
+    
+    # --- NEW: Bot Customization ---
+    bot_name = Column(String, default="Support Agent")
+    bot_instruction = Column(Text, default="You are a helpful customer support agent. Only answer questions related to the provided data.")
+    
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())

backend/src/schemas/chat.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from typing import Optional
+
+# User jab sawal bhejegaecho $GOOGLE_API_KEY
+class ChatRequest(BaseModel):
+    message: str
+    # Isay Optional bana diya. Default value None hai.
+    session_id: Optional[str] = None 
+
+# Server jab jawab dega
+class ChatResponse(BaseModel):
+    response: str
+    # Yahan bhi Optional, kyunki guest ke paas ID nahi hogi
+    session_id: Optional[str] = None 
+    provider: str

backend/src/services/chat_service.py

@@ -0,0 +1,598 @@
+
+# import json
+# from sqlalchemy.ext.asyncio import AsyncSession
+# from sqlalchemy.future import select
+
+# # --- Model Imports ---
+# from backend.src.models.chat import ChatHistory
+# from backend.src.models.integration import UserIntegration
+
+# # --- Dynamic Factory & Tool Imports ---
+# from backend.src.services.llm.factory import get_llm_model
+# from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+# from backend.src.services.security.pii_scrubber import PIIScrubber
+
+# # --- Agents ---
+# from backend.src.services.tools.secure_agent import get_secure_agent 
+# from backend.src.services.tools.nosql_agent import get_nosql_agent 
+# from backend.src.services.tools.cms_agent import get_cms_agent
+
+# # --- Router ---
+# from backend.src.services.routing.semantic_router import SemanticRouter
+
+# # --- LangChain Core ---
+# from langchain_core.messages import HumanMessage, AIMessage
+# from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+# # ==========================================
+# # HELPER FUNCTIONS (UPDATED STRICT LOGIC)
+# # ==========================================
+
+# async def get_user_integrations(user_id: str, db: AsyncSession) -> dict:
+#     if not user_id: return {}
+    
+#     query = select(UserIntegration).where(UserIntegration.user_id == user_id, UserIntegration.is_active == True)
+#     result = await db.execute(query)
+#     integrations = result.scalars().all()
+    
+#     settings = {}
+#     for i in integrations:
+#         try:
+#             creds = json.loads(i.credentials)
+#             creds['provider'] = i.provider
+#             creds['schema_map'] = i.schema_map if i.schema_map else {}
+            
+#             # --- 🔥 FIX: NO DEFAULT DESCRIPTION ---
+#             # Agar DB mein description NULL hai, to NULL hi rehne do.
+#             # Hum isay Router mein add hi nahi karenge.
+#             creds['description'] = i.profile_description 
+            
+#             settings[i.provider] = creds
+#         except (json.JSONDecodeError, TypeError):
+#             continue
+#     return settings
+
+# async def save_chat_to_db(db: AsyncSession, session_id: str, human_msg: str, ai_msg: str, provider: str):
+#     if not session_id: return
+#     safe_human = PIIScrubber.scrub(human_msg)
+#     safe_ai = PIIScrubber.scrub(ai_msg)
+#     new_chat = ChatHistory(
+#         session_id=session_id, human_message=safe_human, ai_message=safe_ai, provider=provider
+#     )
+#     db.add(new_chat)
+#     await db.commit()
+
+# async def get_chat_history(session_id: str, db: AsyncSession):
+#     if not session_id: return []
+#     query = select(ChatHistory).where(ChatHistory.session_id == session_id).order_by(ChatHistory.timestamp.asc())
+#     result = await db.execute(query)
+#     return result.scalars().all()
+
+# OMNI_SUPPORT_PROMPT = "You are OmniAgent. Answer based on the provided context or chat history."
+
+# # ==========================================
+# # MAIN CHAT LOGIC
+# # ==========================================
+# async def process_chat(message: str, session_id: str, user_id: str, db: AsyncSession):
+    
+#     # 1. User Settings
+#     user_settings = await get_user_integrations(user_id, db)
+    
+#     # 2. LLM Check
+#     llm_creds = user_settings.get('groq') or user_settings.get('openai')
+#     if not llm_creds:
+#         return "Please configure your AI Model in Settings."
+
+#     # 3. Build Tool Map for Router (STRICT FILTERING)
+#     tools_map = {}
+#     for provider, config in user_settings.items():
+#         if provider in ['sanity', 'sql', 'mongodb']:
+#             # 🔥 Check: Agar Description hai, tabhi Router mein daalo
+#             if config.get('description'):
+#                 tools_map[provider] = config['description']
+#             else:
+#                 print(f"⚠️ [Router] Skipping {provider} - No Description found.")
+
+#     # 4. SEMANTIC DECISION
+#     selected_provider = None
+#     if tools_map:
+#         router = SemanticRouter()
+#         selected_provider = router.route(message, tools_map)
+#     else:
+#         print("⚠️ [Router] No active tools with descriptions found.")
+    
+#     response_text = ""
+#     provider_name = "general_chat"
+
+#     # 5. Route to Winner
+#     if selected_provider:
+#         print(f"👉 [Router] Selected Tool: {selected_provider.upper()}")
+#         try:
+#             if selected_provider == 'sanity':
+#                 schema = user_settings['sanity'].get('schema_map', {})
+#                 agent = get_cms_agent(user_id=user_id, schema_map=schema, llm_credentials=llm_creds)
+#                 res = await agent.ainvoke({"input": message})
+#                 response_text = str(res.get('output', ''))
+#                 provider_name = "cms_agent"
+
+#             elif selected_provider == 'sql':
+#                 role = "admin" if user_id == '99' else "customer"
+#                 agent = get_secure_agent(int(user_id), role, user_settings['sql'], llm_credentials=llm_creds)
+#                 res = await agent.ainvoke({"input": message})
+#                 response_text = str(res.get('output', ''))
+#                 provider_name = "sql_agent"
+
+#             elif selected_provider == 'mongodb':
+#                 agent = get_nosql_agent(user_id, user_settings['mongodb'], llm_credentials=llm_creds)
+#                 res = await agent.ainvoke({"input": message})
+#                 response_text = str(res.get('output', ''))
+#                 provider_name = "nosql_agent"
+
+#             # Anti-Hallucination
+#             if not response_text or "error" in response_text.lower():
+#                 response_text = "" # Trigger Fallback
+
+#         except Exception as e:
+#             print(f"❌ [Router] Execution Failed: {e}")
+#             response_text = "" 
+
+#     # 6. Fallback / RAG
+#     if not response_text:
+#         print("👉 [Router] Fallback to RAG/General Chat...")
+#         try:
+#             llm = get_llm_model(credentials=llm_creds)
+            
+#             context = ""
+#             if 'qdrant' in user_settings:
+#                 try:
+#                     vector_store = get_vector_store(credentials=user_settings['qdrant'])
+#                     docs = await vector_store.asimilarity_search(message, k=3)
+#                     if docs:
+#                         context = "\n\n".join([d.page_content for d in docs])
+#                 except Exception as e:
+#                     print(f"⚠️ RAG Warning: {e}")
+            
+#             system_instruction = OMNI_SUPPORT_PROMPT
+#             if context: system_instruction = f"Context:\n{context}"
+
+#             history = await get_chat_history(session_id, db)
+#             formatted_history = []
+#             for chat in history:
+#                 formatted_history.append(HumanMessage(content=chat.human_message))
+#                 if chat.ai_message: formatted_history.append(AIMessage(content=chat.ai_message))
+
+#             prompt = ChatPromptTemplate.from_messages([
+#                 ("system", system_instruction),
+#                 MessagesPlaceholder(variable_name="chat_history"),
+#                 ("human", "{question}")
+#             ])
+#             chain = prompt | llm
+            
+#             ai_response = await chain.ainvoke({"chat_history": formatted_history, "question": message})
+#             response_text = ai_response.content
+#             provider_name = "rag_fallback"
+
+#         except Exception as e:
+#             response_text = "I am currently unable to process your request."
+
+#     await save_chat_to_db(db, session_id, message, response_text, provider_name)
+#     return response_text
+import json
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+
+# --- Model Imports ---
+from backend.src.models.chat import ChatHistory
+from backend.src.models.integration import UserIntegration
+from backend.src.models.user import User  # Added User model for Bot Persona
+
+# --- Dynamic Factory & Tool Imports ---
+from backend.src.services.llm.factory import get_llm_model
+from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+from backend.src.services.security.pii_scrubber import PIIScrubber
+
+# --- Agents ---
+from backend.src.services.tools.secure_agent import get_secure_agent 
+from backend.src.services.tools.nosql_agent import get_nosql_agent 
+from backend.src.services.tools.cms_agent import get_cms_agent
+
+# --- Router ---
+from backend.src.services.routing.semantic_router import SemanticRouter
+
+# --- LangChain Core ---
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+# ==========================================
+# HELPER FUNCTIONS
+# ==========================================
+
+async def get_user_integrations(user_id: str, db: AsyncSession) -> dict:
+    """Fetches active integrations and filters valid descriptions."""
+    if not user_id: return {}
+    
+    query = select(UserIntegration).where(UserIntegration.user_id == user_id, UserIntegration.is_active == True)
+    result = await db.execute(query)
+    integrations = result.scalars().all()
+    
+    settings = {}
+    for i in integrations:
+        try:
+            creds = json.loads(i.credentials)
+            creds['provider'] = i.provider
+            creds['schema_map'] = i.schema_map if i.schema_map else {}
+            
+            # --- STRICT CHECK ---
+            if i.profile_description:
+                creds['description'] = i.profile_description
+            
+            settings[i.provider] = creds
+        except (json.JSONDecodeError, TypeError):
+            continue
+    return settings
+
+async def save_chat_to_db(db: AsyncSession, session_id: str, human_msg: str, ai_msg: str, provider: str):
+    """Saves chat history with PII redaction."""
+    if not session_id: return
+    safe_human = PIIScrubber.scrub(human_msg)
+    safe_ai = PIIScrubber.scrub(ai_msg)
+    new_chat = ChatHistory(
+        session_id=session_id, human_message=safe_human, ai_message=safe_ai, provider=provider
+    )
+    db.add(new_chat)
+    await db.commit()
+
+async def get_chat_history(session_id: str, db: AsyncSession):
+    """Retrieves past conversation history."""
+    if not session_id: return []
+    query = select(ChatHistory).where(ChatHistory.session_id == session_id).order_by(ChatHistory.timestamp.asc())
+    result = await db.execute(query)
+    return result.scalars().all()
+
+async def get_bot_persona(user_id: str, db: AsyncSession):
+    """Fetches custom Bot Name and Instructions from User table."""
+    try:
+        # User ID ko int mein convert karke query karein
+        stmt = select(User).where(User.id == int(user_id))
+        result = await db.execute(stmt)
+        user = result.scalars().first()
+        
+        if user:
+            return {
+                "name": getattr(user, "bot_name", "OmniAgent"),
+                "instruction": getattr(user, "bot_instruction", "You are a helpful AI assistant.")
+            }
+    except Exception as e:
+        print(f"⚠️ Error fetching persona: {e}")
+        pass
+    
+    # Fallback Default Persona
+    return {"name": "OmniAgent", "instruction": "You are a helpful AI assistant."}
+
+# ==========================================
+# MAIN CHAT LOGIC
+# ==========================================
+async def process_chat(message: str, session_id: str, user_id: str, db: AsyncSession):
+    
+    # 1. Fetch User Settings & Persona
+    user_settings = await get_user_integrations(user_id, db)
+    bot_persona = await get_bot_persona(user_id, db) # <--- Persona Load kiya
+    
+    # 2. LLM Check
+    llm_creds = user_settings.get('groq') or user_settings.get('openai')
+    if not llm_creds:
+        return "Please configure your AI Model in Settings."
+
+    # 3. Build Tool Map for Router
+    tools_map = {}
+    for provider, config in user_settings.items():
+        if provider in ['sanity', 'sql', 'mongodb']:
+            if config.get('description'):
+                tools_map[provider] = config['description']
+
+    # 4. SEMANTIC DECISION (Router)
+    selected_provider = None
+    if tools_map:
+        router = SemanticRouter() # Singleton Instance
+        selected_provider = router.route(message, tools_map)
+    
+    response_text = ""
+    provider_name = "general_chat"
+
+    # 5. Route to Winner
+    if selected_provider:
+        print(f"👉 [Router] Selected Tool: {selected_provider.upper()}")
+        try:
+            if selected_provider == 'sanity':
+                schema = user_settings['sanity'].get('schema_map', {})
+                agent = get_cms_agent(user_id=user_id, schema_map=schema, llm_credentials=llm_creds)
+                res = await agent.ainvoke({"input": message})
+                response_text = str(res.get('output', ''))
+                provider_name = "cms_agent"
+
+            elif selected_provider == 'sql':
+                role = "admin" if user_id == '99' else "customer"
+                agent = get_secure_agent(int(user_id), role, user_settings['sql'], llm_credentials=llm_creds)
+                res = await agent.ainvoke({"input": message})
+                response_text = str(res.get('output', ''))
+                provider_name = "sql_agent"
+
+            elif selected_provider == 'mongodb':
+                agent = get_nosql_agent(user_id, user_settings['mongodb'], llm_credentials=llm_creds)
+                res = await agent.ainvoke({"input": message})
+                response_text = str(res.get('output', ''))
+                provider_name = "nosql_agent"
+
+            # Anti-Hallucination
+            if not response_text or "error" in response_text.lower():
+                print(f"⚠️ [Router] Tool {selected_provider} failed. Triggering Fallback.")
+                response_text = "" 
+
+        except Exception as e:
+            print(f"❌ [Router] Execution Failed: {e}")
+            response_text = "" 
+
+    # 6. Fallback / RAG (Using Custom Persona)
+    if not response_text:
+        print("👉 [Router] Fallback to RAG/General Chat...")
+        try:
+            llm = get_llm_model(credentials=llm_creds)
+            
+            # Context from Vector DB
+            context = ""
+            if 'qdrant' in user_settings:
+                try:
+                    vector_store = get_vector_store(credentials=user_settings['qdrant'])
+                    docs = await vector_store.asimilarity_search(message, k=3)
+                    if docs:
+                        context = "\n\n".join([d.page_content for d in docs])
+                except Exception as e:
+                    print(f"⚠️ RAG Warning: {e}")
+            
+            # --- 🔥 DYNAMIC SYSTEM PROMPT ---
+            system_instruction = f"""
+            IDENTITY: You are '{bot_persona['name']}'.
+            MISSION: {bot_persona['instruction']}
+            
+            CONTEXT FROM KNOWLEDGE BASE:
+            {context if context else "No specific documents found."}
+            
+            Answer the user's question based on the context above or your general knowledge if permitted by your mission.
+            """
+
+            # History Load
+            history = await get_chat_history(session_id, db)
+            formatted_history = []
+            for chat in history:
+                formatted_history.append(HumanMessage(content=chat.human_message))
+                if chat.ai_message: formatted_history.append(AIMessage(content=chat.ai_message))
+
+            # LLM Call
+            prompt = ChatPromptTemplate.from_messages([
+                ("system", system_instruction),
+                MessagesPlaceholder(variable_name="chat_history"),
+                ("human", "{question}")
+            ])
+            chain = prompt | llm
+            
+            ai_response = await chain.ainvoke({"chat_history": formatted_history, "question": message})
+            response_text = ai_response.content
+            provider_name = "rag_fallback"
+
+        except Exception as e:
+            print(f"❌ Fallback Error: {e}")
+            response_text = "I am currently unable to process your request. Please check your AI configuration."
+
+    # 7. Save to DB
+    await save_chat_to_db(db, session_id, message, response_text, provider_name)
+    return response_text
+# import json
+# from sqlalchemy.ext.asyncio import AsyncSession
+# from sqlalchemy.future import select
+
+# # --- Model Imports ---
+# from backend.src.models.chat import ChatHistory
+# from backend.src.models.integration import UserIntegration
+# from backend.src.models.user import User  # Added User model for Bot Persona
+
+# # --- Dynamic Factory & Tool Imports ---
+# from backend.src.services.llm.factory import get_llm_model
+# from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+# from backend.src.services.security.pii_scrubber import PIIScrubber
+
+# # --- Agents ---
+# from backend.src.services.tools.secure_agent import get_secure_agent 
+# from backend.src.services.tools.nosql_agent import get_nosql_agent 
+# from backend.src.services.tools.cms_agent import get_cms_agent
+
+# # --- Router ---
+# from backend.src.services.routing.semantic_router import SemanticRouter
+
+# # --- LangChain Core ---
+# from langchain_core.messages import HumanMessage, AIMessage
+# from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+# # ==========================================
+# # HELPER FUNCTIONS
+# # ==========================================
+
+# async def get_user_integrations(user_id: str, db: AsyncSession) -> dict:
+#     """Fetches active integrations and filters valid descriptions."""
+#     if not user_id: return {}
+    
+#     query = select(UserIntegration).where(UserIntegration.user_id == user_id, UserIntegration.is_active == True)
+#     result = await db.execute(query)
+#     integrations = result.scalars().all()
+    
+#     settings = {}
+#     for i in integrations:
+#         try:
+#             creds = json.loads(i.credentials)
+#             creds['provider'] = i.provider
+#             creds['schema_map'] = i.schema_map if i.schema_map else {}
+            
+#             # --- STRICT CHECK ---
+#             # Agar Description NULL hai to dictionary mein mat daalo
+#             # Taake Router confuse na ho
+#             if i.profile_description:
+#                 creds['description'] = i.profile_description
+            
+#             settings[i.provider] = creds
+#         except (json.JSONDecodeError, TypeError):
+#             continue
+#     return settings
+
+# async def save_chat_to_db(db: AsyncSession, session_id: str, human_msg: str, ai_msg: str, provider: str):
+#     """Saves chat history with PII redaction."""
+#     if not session_id: return
+#     safe_human = PIIScrubber.scrub(human_msg)
+#     safe_ai = PIIScrubber.scrub(ai_msg)
+#     new_chat = ChatHistory(
+#         session_id=session_id, human_message=safe_human, ai_message=safe_ai, provider=provider
+#     )
+#     db.add(new_chat)
+#     await db.commit()
+
+# async def get_chat_history(session_id: str, db: AsyncSession):
+#     """Retrieves past conversation history."""
+#     if not session_id: return []
+#     query = select(ChatHistory).where(ChatHistory.session_id == session_id).order_by(ChatHistory.timestamp.asc())
+#     result = await db.execute(query)
+#     return result.scalars().all()
+
+# async def get_bot_persona(user_id: str, db: AsyncSession):
+#     """Fetches custom Bot Name and Instructions from User table."""
+#     try:
+#         result = await db.execute(select(User).where(User.id == int(user_id)))
+#         user = result.scalars().first()
+#         if user:
+#             return {
+#                 "name": getattr(user, "bot_name", "OmniAgent"),
+#                 "instruction": getattr(user, "bot_instruction", "You are a helpful AI assistant.")
+#             }
+#     except Exception:
+#         pass
+#     return {"name": "OmniAgent", "instruction": "You are a helpful AI assistant."}
+
+# # ==========================================
+# # MAIN CHAT LOGIC
+# # ==========================================
+# async def process_chat(message: str, session_id: str, user_id: str, db: AsyncSession):
+    
+#     # 1. Fetch User Settings & Persona
+#     user_settings = await get_user_integrations(user_id, db)
+#     bot_persona = await get_bot_persona(user_id, db)
+    
+#     # 2. LLM Check
+#     llm_creds = user_settings.get('groq') or user_settings.get('openai')
+#     if not llm_creds:
+#         return "Please configure your AI Model in Settings."
+
+#     # 3. Build Tool Map for Router (STRICT FILTERING)
+#     tools_map = {}
+#     for provider, config in user_settings.items():
+#         if provider in ['sanity', 'sql', 'mongodb']:
+#             # Sirf tab add karo agar description exist karti hai
+#             if config.get('description'):
+#                 tools_map[provider] = config['description']
+#             else:
+#                 print(f"⚠️ [Router] Skipping {provider} - No Description found.")
+
+#     # 4. SEMANTIC DECISION (Router)
+#     selected_provider = None
+#     if tools_map:
+#         router = SemanticRouter() # Singleton Instance
+#         selected_provider = router.route(message, tools_map)
+#     else:
+#         print("⚠️ [Router] No active tools with descriptions found.")
+    
+#     response_text = ""
+#     provider_name = "general_chat"
+
+#     # 5. Route to Winner (Tool Execution)
+#     if selected_provider:
+#         print(f"👉 [Router] Selected Tool: {selected_provider.upper()}")
+#         try:
+#             if selected_provider == 'sanity':
+#                 schema = user_settings['sanity'].get('schema_map', {})
+#                 agent = get_cms_agent(user_id=user_id, schema_map=schema, llm_credentials=llm_creds)
+#                 res = await agent.ainvoke({"input": message})
+#                 response_text = str(res.get('output', ''))
+#                 provider_name = "cms_agent"
+
+#             elif selected_provider == 'sql':
+#                 role = "admin" if user_id == '99' else "customer"
+#                 agent = get_secure_agent(int(user_id), role, user_settings['sql'], llm_credentials=llm_creds)
+#                 res = await agent.ainvoke({"input": message})
+#                 response_text = str(res.get('output', ''))
+#                 provider_name = "sql_agent"
+
+#             elif selected_provider == 'mongodb':
+#                 agent = get_nosql_agent(user_id, user_settings['mongodb'], llm_credentials=llm_creds)
+#                 res = await agent.ainvoke({"input": message})
+#                 response_text = str(res.get('output', ''))
+#                 provider_name = "nosql_agent"
+
+#             # Anti-Hallucination Check
+#             if not response_text or "error" in response_text.lower():
+#                 print(f"⚠️ [Router] Tool {selected_provider} failed/empty. Triggering Fallback.")
+#                 response_text = "" # Clears response to trigger fallback below
+
+#         except Exception as e:
+#             print(f"❌ [Router] Execution Failed: {e}")
+#             response_text = "" 
+
+#     # 6. Fallback / RAG (General Chat)
+#     if not response_text:
+#         print("👉 [Router] Fallback to RAG/General Chat...")
+#         try:
+#             llm = get_llm_model(credentials=llm_creds)
+            
+#             # Context from Vector DB
+#             context = ""
+#             if 'qdrant' in user_settings:
+#                 try:
+#                     vector_store = get_vector_store(credentials=user_settings['qdrant'])
+#                     docs = await vector_store.asimilarity_search(message, k=3)
+#                     if docs:
+#                         context = "\n\n".join([d.page_content for d in docs])
+#                 except Exception as e:
+#                     print(f"⚠️ RAG Warning: {e}")
+            
+#             # --- DYNAMIC SYSTEM PROMPT (PERSONA) ---
+#             system_instruction = f"""
+#             IDENTITY: You are '{bot_persona['name']}'.
+#             MISSION: {bot_persona['instruction']}
+            
+#             CONTEXT FROM KNOWLEDGE BASE:
+#             {context if context else "No specific documents found."}
+            
+#             Answer the user's question based on the context above or your general knowledge if permitted by your mission.
+#             """
+
+#             # History Load
+#             history = await get_chat_history(session_id, db)
+#             formatted_history = []
+#             for chat in history:
+#                 formatted_history.append(HumanMessage(content=chat.human_message))
+#                 if chat.ai_message: formatted_history.append(AIMessage(content=chat.ai_message))
+
+#             # LLM Call
+#             prompt = ChatPromptTemplate.from_messages([
+#                 ("system", system_instruction),
+#                 MessagesPlaceholder(variable_name="chat_history"),
+#                 ("human", "{question}")
+#             ])
+#             chain = prompt | llm
+            
+#             ai_response = await chain.ainvoke({"chat_history": formatted_history, "question": message})
+#             response_text = ai_response.content
+#             provider_name = "rag_fallback"
+
+#         except Exception as e:
+#             print(f"❌ Fallback Error: {e}")
+#             response_text = "I am currently unable to process your request. Please check your AI configuration."
+
+#     # 7. Save to DB
+#     await save_chat_to_db(db, session_id, message, response_text, provider_name)
+#     return response_text

backend/src/services/connectors/base.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+class NoSQLConnector(ABC):
+    """
+    Abstract Base Class for Universal NoSQL Connectivity.
+    Any database (Mongo, DynamoDB, Firebase) must implement these methods.
+    """
+
+    @abstractmethod
+    def connect(self):
+        """Establish connection to the database."""
+        pass
+
+    @abstractmethod
+    def disconnect(self):
+        """Close the connection."""
+        pass
+
+    @abstractmethod
+    def get_schema_summary(self) -> str:
+        """
+        Returns a string description of collections and fields.
+        Crucial for the LLM to understand what to query.
+        """
+        pass
+
+    @abstractmethod
+    def find_one(self, collection: str, query: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Retrieve a single document matching the query."""
+        pass
+
+    @abstractmethod
+    def find_many(self, collection: str, query: Dict[str, Any], limit: int = 5) -> List[Dict[str, Any]]:
+        """Retrieve multiple documents matching the query."""
+        pass

backend/src/services/connectors/cms_base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List
+
+class CMSBaseConnector(ABC):
+    """
+    Abstract Interface for Headless CMS Integrations.
+    """
+
+    @abstractmethod
+    def connect(self, credentials: Dict[str, str]) -> bool:
+        """
+        Validate credentials and establish connection.
+        Returns True if successful.
+        """
+        pass
+
+    @abstractmethod
+    def fetch_schema_structure(self) -> Dict[str, List[str]]:
+        """
+        Introspects the CMS to find available Types and Fields.
+        Example Return: {'product': ['title', 'price'], 'author': ['name']}
+        """
+        pass
+
+    @abstractmethod
+    def execute_query(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Executes a raw query (GROQ, GraphQL) and returns JSON data.
+        """
+        pass

backend/src/services/connectors/mongo_connector.py

@@ -0,0 +1,85 @@
+
+import pymongo
+from typing import List, Dict, Any, Optional
+from backend.src.services.connectors.base import NoSQLConnector
+
+class MongoConnector(NoSQLConnector):
+    def __init__(self, credentials: Dict[str, str]):
+        """
+        Initializes with user-specific credentials.
+        """
+        # User ki di hui connection string use karega
+        # e.g., "mongodb+srv://user:pass@cluster..."
+        self.uri = credentials.get("url")
+        if not self.uri:
+            raise ValueError("MongoDB connection URL ('url') is missing in credentials.")
+            
+        # Database ka naam URL se nikalne ki koshish (agar / ke baad hai)
+        # Ya credentials se direct le lo
+        self.db_name = credentials.get("database_name", self.uri.split("/")[-1].split("?")[0])
+        
+        self.client = None
+        self.db = None
+        
+        # SSL/TLS arguments for cloud databases like Atlas
+        self.connect_args = {
+            'tls': True,
+            'tlsAllowInvalidCertificates': True # Development ke liye OK, Production mein False hona chahiye
+        }
+
+    def connect(self):
+        if not self.client:
+            print(f"🔌 [NoSQL] Connecting to MongoDB Cluster...")
+            try:
+                # Use serverSelectionTimeoutMS to fail fast if connection is bad
+                self.client = pymongo.MongoClient(self.uri, serverSelectionTimeoutMS=5000, **self.connect_args)
+                # Ye line check karegi ke connection waqayi bana ya nahi
+                self.client.server_info() 
+                self.db = self.client[self.db_name]
+                print("✅ [NoSQL] MongoDB Connection Successful.")
+            except pymongo.errors.ConnectionFailure as e:
+                print(f"❌ [NoSQL] MongoDB Connection Failed: {e}")
+                raise e
+
+    def disconnect(self):
+        if self.client:
+            self.client.close()
+            self.client = None
+            print("🔌 [NoSQL] Disconnected from MongoDB.")
+
+    def get_schema_summary(self) -> str:
+        self.connect()
+        summary = []
+        try:
+            collections = self.db.list_collection_names()
+            for col_name in collections:
+                sample = self.db[col_name].find_one()
+                if sample:
+                    if '_id' in sample: del sample['_id']
+                    keys = list(sample.keys())
+                    summary.append(f"Collection: '{col_name}' -> Fields: {keys}")
+        except Exception as e:
+            return f"Error fetching schema: {e}"
+        return "\n".join(summary)
+
+    def find_one(self, collection: str, query: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        self.connect()
+        try:
+            result = self.db[collection].find_one(query)
+            if result and '_id' in result:
+                result['_id'] = str(result['_id'])
+            return result
+        except Exception as e:
+            return None
+
+    def find_many(self, collection: str, query: Dict[str, Any], limit: int = 5) -> List[Dict[str, Any]]:
+        self.connect()
+        try:
+            cursor = self.db[collection].find(query).limit(limit)
+            results = [doc for doc in cursor]
+            for doc in results:
+                if '_id' in doc:
+                    doc['_id'] = str(doc['_id'])
+            return results
+        except Exception as e:
+            return []

backend/src/services/connectors/sanity_connector.py

@@ -0,0 +1,133 @@
+
+import requests
+import json
+from urllib.parse import quote
+from typing import Dict, List, Any
+from backend.src.services.connectors.cms_base import CMSBaseConnector
+
+class SanityConnector(CMSBaseConnector):
+    def __init__(self, credentials: Dict[str, str]):
+        self.project_id = credentials.get("project_id")
+        self.dataset = credentials.get("dataset")
+        self.token = credentials.get("token") # Read-only token
+        self.api_version = "v2021-10-21"
+        
+        if not all([self.project_id, self.dataset, self.token]):
+            raise ValueError("Sanity credentials (project_id, dataset, token) are required.")
+            
+        # Build the base URL for API calls
+        self.base_url = f"https://{self.project_id}.api.sanity.io/{self.api_version}/data/query/{self.dataset}"
+        self.headers = {"Authorization": f"Bearer {self.token}"}
+        
+        self.is_connected = False
+
+    def connect(self, credentials: Dict[str, str] = None) -> bool:
+        """Tests the connection by making a simple, non-data-intensive query."""
+        if not self.is_connected:
+            print(f"🔌 [Sanity] Connecting to Project ID: {self.project_id}...")
+            try:
+                # Test query to check credentials
+                test_query = '*[_type == "sanity.imageAsset"][0...1]'
+                response = requests.get(self.base_url, headers=self.headers, params={'query': test_query})
+                
+                if response.status_code == 200:
+                    self.is_connected = True
+                    print("✅ [Sanity] Connection Successful.")
+                    return True
+                else:
+                    print(f"❌ [Sanity] Connection Failed. Status: {response.status_code}, Response: {response.text}")
+                    return False
+            except Exception as e:
+                print(f"❌ [Sanity] Connection Failed: {e}")
+                return False
+        return True
+
+    def fetch_schema_structure(self) -> Dict[str, Any]:
+        """
+        🕵️‍♂️ DEEP DISCOVERY: Fetches 1 sample of EVERY type to map the full nesting.
+        """
+        if not self.is_connected: self.connect()
+        
+        print("🕵️‍♂️ Starting Deep Schema Discovery...")
+        
+        # Step 1: Get all unique document types (filtering out system types)
+        types_query = "array::unique(*[!(_id in path('_.**')) && !(_type match 'sanity.*')]._type)"
+        
+        try:
+            response = requests.get(self.base_url, headers=self.headers, params={'query': types_query})
+            if response.status_code != 200:
+                print(f"❌ Failed to fetch types: {response.text}")
+                return {}
+                
+            user_types = response.json().get('result', [])
+            print(f"📋 Found Types: {user_types}")
+
+            schema_map = {}
+            
+            # Step 2: Loop through each type and fetch ONE full document
+            for doc_type in user_types:
+                # Query: "Give me the first item of this type"
+                sample_query = f"*[_type == '{doc_type}'][0]"
+                sample_response = requests.get(self.base_url, headers=self.headers, params={'query': sample_query})
+                sample_doc = sample_response.json().get('result')
+                
+                if sample_doc:
+                    # Step 3: Recursively extract structure
+                    structure = self._extract_structure(sample_doc)
+                    schema_map[doc_type] = structure
+            
+            print(f"✅ Full Database Map Created.")
+            return schema_map
+
+        except Exception as e:
+            print(f"❌ Schema Discovery Error: {e}")
+            return {}
+
+    def _extract_structure(self, doc: Any, depth=0) -> Any:
+        """
+        Helper to map nested fields.
+        Real Data: {"store": {"price": 20}} -> Map: {"store": {"price": "Number"}}
+        """
+        if depth > 3: return "..." # Stop infinite recursion
+        
+        if isinstance(doc, dict):
+            structure = {}
+            for key, value in doc.items():
+                if key.startswith("_"): continue # Skip internal fields
+                structure[key] = self._extract_structure(value, depth + 1)
+            return structure
+            
+        elif isinstance(doc, list):
+            # If list has items, check the first one to know what's inside
+            if len(doc) > 0:
+                return [self._extract_structure(doc[0], depth + 1)]
+            return "List[]"
+            
+        elif isinstance(doc, (int, float)):
+            return "Number"
+        elif isinstance(doc, bool):
+            return "Boolean"
+        
+        return "String"
+
+    def execute_query(self, query: str) -> List[Dict[str, Any]]:
+        """Executes a GROQ query against the Sanity HTTP API."""
+        if not self.is_connected: self.connect()
+        
+        print(f"🚀 [Sanity] Executing GROQ Query: {query}")
+        try:
+            # URL-encode the query to handle special characters
+            encoded_query = quote(query)
+            
+            response = requests.get(f"{self.base_url}?query={encoded_query}", headers=self.headers)
+            
+            if response.status_code == 200:
+                results = response.json().get('result')
+                if results is None: return []
+                return results if isinstance(results, list) else [results]
+            else:
+                print(f"❌ [Sanity] Query Failed. Status: {response.status_code}, Details: {response.text}")
+                return []
+        except Exception as e:
+            print(f"❌ [Sanity] Query execution error: {e}")
+            return []

backend/src/services/embeddings/factory.py

@@ -0,0 +1,48 @@
+# backend/src/services/embeddings/factory.py
+from langchain_community.embeddings import (
+    SentenceTransformerEmbeddings,
+    OpenAIEmbeddings,
+)
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from backend.src.core.config import settings
+from functools import lru_cache
+from langchain_huggingface import HuggingFaceEmbeddings
+
+# Ye function cache karega, taake model baar baar load na ho
+@lru_cache()
+def get_embedding_model():
+    """
+    Ye hamari "Embedding Factory" hai.
+    Ye config file ko padhti hai aur sahi embedding model load karti hai.
+    Modular design ka ye sabse ahem hissa hai.
+    """
+    provider = settings.EMBEDDING_PROVIDER.lower()
+    model_name = settings.EMBEDDING_MODEL_NAME
+
+    print(f"INFO: Loading embedding model from provider: '{provider}' using model '{model_name}'")
+
+    if provider == "local":
+        # Ye model local computer par chalta hai. Koi API key nahi chahiye.
+        return HuggingFaceEmbeddings(
+            model_name=model_name,
+            # cache_folder="./models_cache" # Uncomment if you want to specify a cache folder
+        )
+
+    elif provider == "openai":
+        if not settings.OPENAI_API_KEY:
+            raise ValueError("OpenAI API key not found in .env file")
+        return OpenAIEmbeddings(
+            model=model_name, 
+            openai_api_key=settings.OPENAI_API_KEY
+        )
+
+    elif provider == "google":
+        if not settings.GOOGLE_API_KEY:
+            raise ValueError("Google API key not found in .env file")
+        return GoogleGenerativeAIEmbeddings(
+            model=model_name,
+            google_api_key=settings.GOOGLE_API_KEY,
+            task_type="retrieval_document" 
+        )
+    else:
+        raise ValueError(f"Unsupported embedding provider: {provider}")

backend/src/services/ingestion/crawler.py

@@ -0,0 +1,169 @@
+import asyncio
+import requests
+import numpy as np
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin
+from sqlalchemy.ext.asyncio import AsyncSession
+from backend.src.models.ingestion import IngestionJob, JobStatus
+from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+from qdrant_client.http import models
+
+# --- NEW IMPORT ---
+from backend.src.services.ingestion.guardrail_factory import predict_with_model
+
+# --- CONFIGURATION ---
+MAX_PAGES_LIMIT = 50 
+
+class SmartCrawler:
+    def __init__(self, job_id: int, url: str, session_id: str, crawl_type: str, db: AsyncSession):
+        self.job_id = job_id
+        self.root_url = url
+        self.session_id = session_id
+        self.crawl_type = crawl_type
+        self.db = db
+        self.visited = set()
+        self.vector_store = get_vector_store()
+        # YAHAN SE MODEL LOAD HATA DIYA
+
+    async def log_status(self, status: str, processed=0, total=0, error=None):
+        try:
+            job = await self.db.get(IngestionJob, self.job_id)
+            if job:
+                job.status = status
+                job.pages_processed = processed
+                job.total_pages_found = total
+                if error:
+                    job.error_message = str(error)
+                await self.db.commit()
+        except Exception as e:
+            print(f"DB Log Error: {e}")
+
+    async def is_ai_unsafe(self, text: str, url: str) -> bool: # <--- Async bana diya
+        """
+        Non-blocking AI Check using Factory.
+        """
+        sample_text = text[:300] + " ... " + text[len(text)//2 : len(text)//2 + 300]
+        label = "This is an e-commerce product page with price, buy button, or shopping cart."
+        
+        # --- FIX: Call Factory Async Function ---
+        # Ab ye server ko block nahi karega
+        scores = await predict_with_model(sample_text, label)
+        
+        # Softmax Calculation
+        probs = np.exp(scores) / np.sum(np.exp(scores))
+        entailment_score = probs[1]
+        
+        print("\n" + "="*60)
+        print(f"🤖 AI ANALYSIS REPORT for: {url}")
+        print("-" * 60)
+        print(f"📊 Scores -> Contradiction: {probs[0]:.2f}, Entailment: {probs[1]:.2f}, Neutral: {probs[2]:.2f}")
+        print(f"🎯 Target Score (Entailment): {entailment_score:.4f} (Threshold: 0.5)")
+        
+        if entailment_score > 0.5:
+            print(f"⛔ DECISION: BLOCKED")
+            print("="*60 + "\n")
+            return True
+        else:
+            print(f"✅ DECISION: ALLOWED")
+            print("="*60 + "\n")
+            return False
+
+    async def fetch_page(self, url: str):
+        try:
+            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+            return await asyncio.to_thread(requests.get, url, headers=headers, timeout=10)
+        except Exception:
+            return None
+
+    async def clean_existing_data(self):
+        print(f"INFO: Cleaning old data for source: {self.root_url}")
+        try:
+            self.vector_store.client.delete(
+                collection_name=self.vector_store.collection_name,
+                points_selector=models.FilterSelector(
+                    filter=models.Filter(
+                        must=[
+                            models.FieldCondition(
+                                key="metadata.source",
+                                match=models.MatchValue(value=self.root_url)
+                            )
+                        ]
+                    )
+                )
+            )
+        except Exception as e:
+            print(f"Warning: Clean data failed: {e}")
+
+    async def process_page(self, url: str, soup: BeautifulSoup) -> bool:
+        for script in soup(["script", "style", "nav", "footer", "iframe", "noscript", "svg"]):
+            script.extract()
+            
+        text = soup.get_text(separator=" ", strip=True)
+        
+        if len(text) < 200: 
+            print(f"⚠️ Skipping {url} (Not enough text: {len(text)} chars)")
+            return False
+
+        # --- AWAIT HERE ---
+        # Ab hum 'await' use kar rahe hain taake ye background mein chale
+        if await self.is_ai_unsafe(text, url):
+            return False
+
+        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        docs = [Document(page_content=text, metadata={
+            "source": self.root_url, 
+            "specific_url": url,
+            "session_id": self.session_id,
+            "type": "web_scrape"
+        })]
+        split_docs = splitter.split_documents(docs)
+
+        await self.vector_store.aadd_documents(split_docs)
+        return True
+
+    async def start(self):
+        try:
+            await self.log_status(JobStatus.PROCESSING)
+            await self.clean_existing_data()
+
+            queue = [self.root_url]
+            self.visited.add(self.root_url)
+            total_processed = 0
+
+            while queue and total_processed < MAX_PAGES_LIMIT:
+                current_url = queue.pop(0)
+                
+                response = await self.fetch_page(current_url)
+                if not response or response.status_code != 200:
+                    continue
+
+                soup = BeautifulSoup(response.content, 'html.parser')
+
+                success = await self.process_page(current_url, soup)
+                
+                if not success:
+                    if current_url == self.root_url:
+                        await self.log_status(JobStatus.FAILED, error="Root URL blocked. Identified as E-commerce.")
+                        return
+                    continue
+
+                total_processed += 1
+                
+                if self.crawl_type == "full_site":
+                    for link in soup.find_all('a', href=True):
+                        full_link = urljoin(self.root_url, link['href'])
+                        if self.root_url in full_link and full_link not in self.visited:
+                            self.visited.add(full_link)
+                            queue.append(full_link)
+
+                await self.log_status(JobStatus.PROCESSING, processed=total_processed, total=len(queue)+total_processed)
+                await asyncio.sleep(0.5) 
+
+            await self.log_status(JobStatus.COMPLETED, processed=total_processed)
+            print(f"SUCCESS: Crawling finished. Processed {total_processed} pages.")
+
+        except Exception as e:
+            print(f"ERROR: Crawling failed: {e}")
+            await self.log_status(JobStatus.FAILED, error=str(e))

backend/src/services/ingestion/file_processor.py

@@ -0,0 +1,94 @@
+# backend/src/services/ingestion/file_processor.py
+import os
+import asyncio
+# Specific Stable Loaders
+from langchain_community.document_loaders import (
+    TextLoader,
+    PyPDFLoader,
+    CSVLoader,
+    Docx2txtLoader,
+    UnstructuredMarkdownLoader
+)
+# Fallback loader (agar upar walon mein se koi na ho)
+from langchain_community.document_loaders import UnstructuredFileLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+
+def get_loader(file_path: str):
+    """
+    Factory function jo file extension ke hisaab se
+    sabse stable loader return karta hai.
+    """
+    ext = os.path.splitext(file_path)[1].lower()
+
+    if ext == ".txt":
+        # TextLoader sabse fast aur safe hai
+        return TextLoader(file_path, encoding="utf-8")
+    
+    elif ext == ".pdf":
+        # PyPDFLoader pure python hai, hang nahi hota
+        return PyPDFLoader(file_path)
+    
+    elif ext == ".csv":
+        return CSVLoader(file_path, encoding="utf-8")
+    
+    elif ext in [".doc", ".docx"]:
+        # Docx2txtLoader light hai
+        return Docx2txtLoader(file_path)
+    
+    elif ext == ".md":
+        # Markdown ko hum TextLoader se bhi parh sakte hain agar Unstructured tang kare
+        return TextLoader(file_path, encoding="utf-8")
+    
+    else:
+        # Agar koi ajeeb format ho, tab hum Heavy 'Unstructured' loader try karenge
+        print(f"INFO: Unknown format '{ext}', attempting to use UnstructuredFileLoader...")
+        return UnstructuredFileLoader(file_path)
+
+async def process_file(file_path: str, session_id: str):
+    """
+    Processes a single uploaded file and adds it to the Vector DB.
+    Supports: TXT, PDF, CSV, DOCX, MD and others.
+    """
+    print(f"INFO: [Ingestion] Starting processing for file: {file_path}")
+    
+    try:
+        # 1. Sahi Loader select karein
+        loader = get_loader(file_path)
+        
+        # 2. File Load karein (Thread mein taake server block na ho)
+        # Note: 'aload()' har loader ke paas nahi hota, isliye hum standard 'load()' ko async wrap karte hain
+        docs = await asyncio.to_thread(loader.load)
+        
+    except Exception as e:
+        print(f"ERROR: [Ingestion] Failed to load file {file_path}: {e}")
+        return 0
+    
+    if not docs:
+        print(f"WARNING: [Ingestion] Could not extract any content from {file_path}")
+        return 0
+
+    # 3. Document ko chunks mein todein
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        length_function=len
+    )
+    split_docs = text_splitter.split_documents(docs)
+    
+    # Metadata update (Source tracking ke liye)
+    for doc in split_docs:
+        doc.metadata["session_id"] = session_id
+        doc.metadata["file_name"] = os.path.basename(file_path)
+        # Extension bhi store kar lete hain filter karne ke liye
+        doc.metadata["file_type"] = os.path.splitext(file_path)[1].lower()
+
+    # 4. Qdrant mein upload karein
+    try:
+        vector_store = get_vector_store()
+        await vector_store.aadd_documents(split_docs)
+        print(f"SUCCESS: [Ingestion] Processed {len(split_docs)} chunks from {file_path}")
+        return len(split_docs)
+    except Exception as e:
+        print(f"ERROR: [Ingestion] Failed to upload to Qdrant: {e}")
+        return 0

backend/src/services/ingestion/guardrail_factory.py

@@ -0,0 +1,28 @@
+from sentence_transformers import CrossEncoder
+from functools import lru_cache
+import asyncio
+
+# Global Cache
+_model_instance = None
+
+def get_guardrail_model():
+    """
+    Model ko sirf ek baar load karega.
+    """
+    global _model_instance
+    if _model_instance is None:
+        print("⏳ INFO: Loading AI Guardrail Model into RAM (First Time Only)...")
+        # 'nli-distilroberta-base' thoda heavy hai, agar PC slow hai to 'cross-encoder/ms-marco-TinyBERT-L-2' use karein
+        _model_instance = CrossEncoder('cross-encoder/nli-distilroberta-base')
+        print("✅ INFO: AI Guardrail Model Loaded!")
+    return _model_instance
+
+async def predict_with_model(text, label):
+    """
+    Prediction ko background thread mein chalata hai taake server hang na ho.
+    """
+    model = get_guardrail_model()
+    
+    # Ye line magic hai: Heavy kaam ko alag thread mein bhej do
+    scores = await asyncio.to_thread(model.predict, [(text, label)])
+    return scores[0]

backend/src/services/ingestion/web_processor.py

@@ -0,0 +1,53 @@
+import asyncio
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+
+async def process_url(url: str, session_id: str):
+    """
+    Ek URL se data scrape karta hai, chunks banata hai aur Qdrant mein save karta hai.
+    """
+    print(f"INFO: [Ingestion] Starting scraping for URL: {url}")
+    
+    try:
+        # 1. Load Data from URL
+        # Hum loader ko async thread mein chalayenge taake server block na ho
+        def load_data():
+            loader = WebBaseLoader(url)
+            return loader.load()
+        
+        docs = await asyncio.to_thread(load_data)
+        
+        if not docs:
+            print(f"WARNING: [Ingestion] No content found at {url}")
+            return 0
+            
+        print(f"INFO: [Ingestion] Successfully fetched content. Length: {len(docs[0].page_content)} chars.")
+
+    except Exception as e:
+        print(f"ERROR: [Ingestion] Failed to scrape URL {url}: {e}")
+        raise e # Error upar bhejenge taake API user ko bata sake
+
+    # 2. Split Text into Chunks
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        length_function=len
+    )
+    split_docs = text_splitter.split_documents(docs)
+    
+    # 3. Add Metadata (Bohat Zaroori)
+    for doc in split_docs:
+        doc.metadata["session_id"] = session_id
+        doc.metadata["source"] = url # Taake pata chale ye data kahan se aaya
+        doc.metadata["type"] = "web_scrape"
+
+    # 4. Save to Qdrant
+    try:
+        vector_store = get_vector_store()
+        await vector_store.aadd_documents(split_docs)
+        print(f"SUCCESS: [Ingestion] Processed {len(split_docs)} chunks from {url}")
+        return len(split_docs)
+    except Exception as e:
+        print(f"ERROR: [Ingestion] Failed to upload to Qdrant: {e}")
+        return 0

backend/src/services/ingestion/zip_processor.py

@@ -0,0 +1,132 @@
+import zipfile
+import os
+import shutil
+import asyncio
+from sqlalchemy.ext.asyncio import AsyncSession
+from backend.src.models.ingestion import IngestionJob, JobStatus
+from backend.src.services.ingestion.file_processor import process_file
+from backend.src.services.vector_store.qdrant_adapter import get_vector_store
+from qdrant_client.http import models
+
+# --- CONFIGURATION ---
+SUPPORTED_EXTENSIONS = ['.pdf', '.txt', '.md', '.docx', '.csv']
+MAX_FILES_IN_ZIP = 500
+
+class SmartZipProcessor:
+    def __init__(self, job_id: int, zip_path: str, session_id: str, db: AsyncSession):
+        self.job_id = job_id
+        self.zip_path = zip_path
+        self.session_id = session_id
+        self.db = db
+        self.vector_store = get_vector_store()
+        self.temp_dir = f"./temp_unzip_{job_id}"
+        self.report = []
+
+    async def log_status(self, status: str, processed=0, total=0, error=None):
+        """Database mein job status update karta hai"""
+        try:
+            job = await self.db.get(IngestionJob, self.job_id)
+            if job:
+                job.status = status
+                job.items_processed = processed
+                job.total_items = total
+                job.details = self.report # Report bhi save karo
+                if error:
+                    job.error_message = str(error)
+                await self.db.commit()
+        except Exception as e:
+            print(f"DB Log Error: {e}")
+
+    async def clean_existing_data(self):
+        """Update Logic: Is session ka purana data saaf karo"""
+        print(f"INFO: Cleaning old data for session_id: {self.session_id}")
+        try:
+            self.vector_store.client.delete(
+                collection_name=self.vector_store.collection_name,
+                points_selector=models.FilterSelector(
+                    filter=models.Filter(
+                        must=[
+                            models.FieldCondition(
+                                key="metadata.session_id",
+                                match=models.MatchValue(value=self.session_id)
+                            )
+                        ]
+                    )
+                )
+            )
+        except Exception as e:
+            print(f"Warning: Clean data failed (maybe first upload): {e}")
+
+    def inspect_zip(self) -> list:
+        """Zip ko bina extract kiye check karta hai"""
+        with zipfile.ZipFile(self.zip_path, 'r') as zf:
+            file_list = zf.infolist()
+            
+            # Guardrail 1: File Count
+            if len(file_list) > MAX_FILES_IN_ZIP:
+                raise ValueError(f"Zip contains too many files ({len(file_list)}). Max allowed is {MAX_FILES_IN_ZIP}.")
+            
+            # Sirf "Files" return karo, folders nahi
+            return [f for f in file_list if not f.is_dir()]
+
+    def extract_zip(self):
+        """Zip ko temp folder mein extract karta hai"""
+        os.makedirs(self.temp_dir, exist_ok=True)
+        with zipfile.ZipFile(self.zip_path, 'r') as zf:
+            zf.extractall(self.temp_dir)
+
+    def cleanup(self):
+        """Temp files/folders delete karta hai"""
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+        if os.path.exists(self.zip_path):
+            os.remove(self.zip_path)
+
+    async def start(self):
+        """Main Processing Loop"""
+        try:
+            # Step 1: Inspect
+            files_to_process = self.inspect_zip()
+            total_files = len(files_to_process)
+            await self.log_status(JobStatus.PROCESSING, total=total_files)
+
+            # Step 2: Clean old data (Atomic Update)
+            await self.clean_existing_data()
+
+            # Step 3: Extract
+            self.extract_zip()
+
+            # Step 4: Process each file
+            processed_count = 0
+            for file_info in files_to_process:
+                file_path = os.path.join(self.temp_dir, file_info.filename)
+                
+                # Guardrail 2: Supported Extension
+                ext = os.path.splitext(file_path)[1].lower()
+                if ext not in SUPPORTED_EXTENSIONS:
+                    self.report.append({"file": file_info.filename, "status": "skipped", "reason": "unsupported_type"})
+                    continue
+                
+                # Process the file
+                try:
+                    # process_file (jo humne pehle banaya tha) ko call karo
+                    chunks_added = await process_file(file_path, self.session_id)
+                    if chunks_added > 0:
+                        self.report.append({"file": file_info.filename, "status": "success", "chunks": chunks_added})
+                    else:
+                        raise ValueError("No content extracted")
+                except Exception as e:
+                    self.report.append({"file": file_info.filename, "status": "failed", "reason": str(e)})
+                
+                processed_count += 1
+                await self.log_status(JobStatus.PROCESSING, processed=processed_count, total=total_files)
+                await asyncio.sleep(0.1) # Thoda saans lene do
+
+            await self.log_status(JobStatus.COMPLETED, processed=processed_count, total=total_files)
+            print(f"SUCCESS: Zip processing finished. Processed {processed_count}/{total_files} files.")
+
+        except Exception as e:
+            print(f"ERROR: Zip processing failed: {e}")
+            await self.log_status(JobStatus.FAILED, error=str(e))
+        finally:
+            self.cleanup()

backend/src/services/llm/factory.py

@@ -0,0 +1,66 @@
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_openai import ChatOpenAI
+from backend.src.core.config import settings
+
+def get_llm_model(credentials: dict = None):
+    """
+    True Universal Factory (Fixed).
+    Ab ye provider ke hisaab se sahi 'base_url' set karega.
+    """
+    
+    # --- Default settings (Fallback) ---
+    llm_provider = settings.LLM_PROVIDER.lower()
+    llm_model_name = settings.LLM_MODEL_NAME
+    llm_base_url = settings.LLM_BASE_URL
+    llm_api_key = settings.LLM_API_KEY
+    google_api_key = settings.GOOGLE_API_KEY
+
+    # --- User-specific settings (Override) ---
+    if credentials:
+        # User ki settings use karo
+        llm_provider = credentials.get("provider", llm_provider).lower()
+        llm_model_name = credentials.get("model_name", llm_model_name)
+        llm_base_url = credentials.get("base_url", llm_base_url)
+        llm_api_key = credentials.get("api_key", llm_api_key)
+        
+        # Google ke liye
+        if llm_provider == "google":
+            google_api_key = llm_api_key
+            
+    # --- MAGIC FIX: Set Base URL for known providers ---
+    if llm_provider == "groq" and not llm_base_url:
+        llm_base_url = "https://api.groq.com/openai/v1"
+        # Groq key .env se le lo agar user ne nahi di (fallback)
+        llm_api_key = llm_api_key or settings.GROQ_API_KEY
+        
+    print(f"🤖 Loading AI Model: {llm_provider} -> {llm_model_name}")
+
+    # --- BLOCK 1: GOOGLE GEMINI ---
+    if llm_provider == "google":
+        if not google_api_key:
+            raise ValueError("Google API key not found.")
+        return ChatGoogleGenerativeAI(
+            model=llm_model_name,
+            google_api_key=google_api_key,
+            temperature=0.7,
+            convert_system_message_to_human=True
+        )
+
+    # --- BLOCK 2: UNIVERSAL OPENAI-COMPATIBLE ---
+    # Ye block Groq, OpenAI, Ollama, etc. sabko handle karega
+    else:
+        if not llm_api_key and "localhost" not in (llm_base_url or ""):
+             print("⚠️ WARNING: No API Key provided for LLM. Trying global fallback.")
+             # Fallback to global keys
+             if settings.OPENAI_API_KEY and llm_provider == "openai":
+                 llm_api_key = settings.OPENAI_API_KEY
+             
+        print(f"   -> Endpoint URL: {llm_base_url or 'Default OpenAI'}")
+        
+        return ChatOpenAI(
+            model_name=llm_model_name,
+            api_key=llm_api_key or "dummy-key",
+            openai_api_base=llm_base_url,
+            temperature=0.7
+        )

backend/src/services/routing/semantic_router.py

@@ -0,0 +1,52 @@
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+class SemanticRouter:
+    _instance = None
+    _model = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(SemanticRouter, cls).__new__(cls)
+            print("🧠 [Router] Loading Multilingual Embedding Model...")
+            # --- CHANGE IS HERE ---
+            # Ye model Hindi/Urdu/English sab samajhta hai
+            cls._model = SentenceTransformer('sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2')
+            print("✅ [Router] Multilingual Model Loaded.")
+        return cls._instance
+
+    def route(self, query: str, tools_map: dict) -> str | None:
+        if not tools_map:
+            return None
+
+        tool_names = list(tools_map.keys())
+        descriptions = list(tools_map.values())
+
+        # Encode (Query + Descriptions)
+        all_texts = [query] + descriptions
+        embeddings = self._model.encode(all_texts)
+
+        query_vec = embeddings[0].reshape(1, -1)
+        tool_vecs = embeddings[1:]
+
+        # Scores Calculate karo
+        scores = cosine_similarity(query_vec, tool_vecs)[0]
+
+        # Debugging Print
+        print(f"\n📊 [Router Logic] Query: '{query}'")
+        for name, score in zip(tool_names, scores):
+            print(f"   🔹 {name}: {score:.4f}")
+
+        best_idx = np.argmax(scores)
+        best_score = scores[best_idx]
+        best_tool = tool_names[best_idx]
+
+        # --- THRESHOLD ADJUSTMENT ---
+        # Hinglish/Multilingual matching ke liye score thoda kam aata hai.
+        # Hum 0.05 rakhenge taake agar halka sa bhi match ho to pakad le.
+        if best_score < 0.05:
+            print(f"⛔ [Router] Score too low ({best_score:.4f} < 0.05). Fallback.")
+            return None
+        
+        return best_tool

backend/src/services/security/pii_scrubber.py

@@ -0,0 +1,67 @@
+import re
+from typing import Tuple
+
+class SecurityException(Exception):
+    """Custom exception for security violations like prompt injection."""
+    pass
+
+class PIIScrubber:
+    # Pre-compiling Regex patterns for performance
+    
+    # Email: Standard pattern
+    EMAIL_REGEX = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b')
+    
+    # Phone: Matches +1-555-555-5555, (555) 555-5555, 555 555 5555
+    # Logic: Look for digits with common separators, length approx 10-15
+    PHONE_REGEX = re.compile(r'\b(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b')
+    
+    # Credit Card: Matches 13-16 digits, with potential dashes or spaces
+    # Logic: Look for groups of 4 digits or continuous strings
+    CREDIT_CARD_REGEX = re.compile(r'\b(?:\d{4}[-\s]?){3}\d{4}\b|\b\d{13,16}\b')
+    
+    # IPv4 Address: 0.0.0.0 to 255.255.255.255
+    IP_REGEX = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')
+
+    # Basic Injection Keywords (Lowercased for case-insensitive check)
+    INJECTION_KEYWORDS = [
+        "ignore all previous instructions",
+        "ignore previous instructions",
+        "system override",
+        "delete database",
+        "drop table",
+        "you are now",
+        "bypass security"
+    ]
+
+    @staticmethod
+    def scrub(text: str) -> str:
+        """
+        Sanitizes the input text by replacing PII with placeholders.
+        """
+        if not text:
+            return ""
+
+        # Apply redactions sequentially
+        scrubbed_text = text
+        scrubbed_text = PIIScrubber.EMAIL_REGEX.sub("[EMAIL_REDACTED]", scrubbed_text)
+        scrubbed_text = PIIScrubber.PHONE_REGEX.sub("[PHONE_REDACTED]", scrubbed_text)
+        scrubbed_text = PIIScrubber.CREDIT_CARD_REGEX.sub("[CC_REDACTED]", scrubbed_text)
+        scrubbed_text = PIIScrubber.IP_REGEX.sub("[IP_REDACTED]", scrubbed_text)
+
+        return scrubbed_text
+
+    @staticmethod
+    def check_for_injection(text: str) -> Tuple[bool, str]:
+        """
+        Checks for basic Prompt Injection attempts.
+        Returns: (is_safe: bool, reason: str)
+        """
+        if not text:
+            return True, ""
+
+        lower_text = text.lower()
+        for keyword in PIIScrubber.INJECTION_KEYWORDS:
+            if keyword in lower_text:
+                return False, f"Malicious keyword detected: '{keyword}'"
+        
+        return True, ""

backend/src/services/tools/cms_agent.py

@@ -0,0 +1,67 @@
+
+import json
+from langchain.agents import create_agent
+from backend.src.services.llm.factory import get_llm_model
+from backend.src.services.tools.cms_tool import CMSQueryTool
+from typing import Optional, Dict
+
+# --- THE CMS EXPERT PROMPT (ANTI-YAP VERSION 🤐) ---
+CMS_SYSTEM_PROMPT = """You are a Sanity GROQ Query Generator.
+Your goal is to query the database based on the user's request.
+
+--- KNOWLEDGE BASE (SCHEMA) ---
+{schema_map}
+
+--- RULES (READ CAREFULLY) ---
+1. **NO EXPLANATIONS:** Do NOT say "Here is the query" or "I will search for...".
+2. **JUST THE QUERY:** Directly call the 'cms_query_tool' with the GROQ string.
+3. **USE THE SCHEMA:** Look at the schema map above. If `price` is inside `variants`, use `variants[].price`.
+4. **SYNTAX:** `*[_type == "product" && title match "Blue*"]`
+
+--- ERROR HANDLING ---
+If the query fails or returns empty, just say: "No products found matching your criteria."
+Do NOT make up fake products from Amazon or other websites.
+
+User Input: {input}
+"""
+
+# --- AGENT ADAPTER ---
+class AgentAdapter:
+    def __init__(self, agent):
+        self.agent = agent
+    
+    async def ainvoke(self, input_dict):
+        # Hum input ko thoda modify karke bhejenge taake AI focus kare
+        user_text = input_dict.get("input", "")
+        # Force instruction appended to user query
+        strict_input = f"{user_text} (Return ONLY the GROQ query tool call. Do not explain.)"
+        
+        payload = {"messages": [("user", strict_input)]}
+        result = await self.agent.ainvoke(payload)
+        last_message = result["messages"][-1]
+        return {"output": last_message.content}
+
+# --- DYNAMIC AGENT FACTORY ---
+def get_cms_agent(
+    user_id: str, 
+    schema_map: dict,
+    llm_credentials: Optional[Dict[str, str]] = None
+):
+    # 1. Load User's LLM
+    llm = get_llm_model(credentials=llm_credentials)
+    
+    # 2. Initialize Tool
+    tool = CMSQueryTool(user_id=str(user_id))
+    tools = [tool]
+
+    # Convert schema to string
+    schema_str = json.dumps(schema_map, indent=2)
+
+    # 3. Create Agent
+    agent_runnable = create_agent(
+        model=llm,
+        tools=tools,
+        system_prompt=CMS_SYSTEM_PROMPT.format(schema_map=schema_str, input="{input}")
+    )
+    
+    return AgentAdapter(agent_runnable)

backend/src/services/tools/cms_tool.py

@@ -0,0 +1,74 @@
+
+import json
+import ast
+from typing import Type
+from pydantic import BaseModel, Field
+from langchain_core.tools import BaseTool
+from sqlalchemy.future import select
+
+# Imports for DB access & Connector
+from backend.src.db.session import AsyncSessionLocal 
+from backend.src.models.integration import UserIntegration
+# Ab hum Mock nahi, Real use karenge
+from backend.src.services.connectors.sanity_connector import SanityConnector
+
+class CMSQueryInput(BaseModel):
+    query: str = Field(..., description="The query string (GROQ/GraphQL) to execute.")
+
+class CMSQueryTool(BaseTool):
+    name: str = "cms_query_tool"
+    description: str = """
+    Use this tool to fetch products, offers, or content from the CMS.
+    Input should be a specific query string (e.g., GROQ for Sanity).
+    """
+    args_schema: Type[BaseModel] = CMSQueryInput
+    user_id: str
+
+    def _run(self, query: str) -> str:
+        raise NotImplementedError("Use _arun for async execution")
+
+    async def _arun(self, query: str) -> str:
+        print(f"🛒 [CMS Tool] Processing Query: {query}")
+        
+        try:
+            async with AsyncSessionLocal() as db:
+                # 1. Fetch Integration
+                stmt = select(UserIntegration).where(
+                    UserIntegration.user_id == self.user_id,
+                    UserIntegration.provider == 'sanity', # Specifically find Sanity
+                    UserIntegration.is_active == True
+                )
+                result = await db.execute(stmt)
+                integration = result.scalars().first()
+                
+                if not integration:
+                    return "Error: No active Sanity integration found. Please connect first."
+
+                # 2. Decrypt & Parse Credentials
+                creds_dict = {}
+                try:
+                    creds_str = integration.credentials
+                    creds_dict = json.loads(creds_str)
+                except Exception as e:
+                    print(f"❌ [CMS Tool] Credential parsing failed: {e}")
+                    return "Error: Invalid Sanity credentials format in database."
+
+                # 3. Connect & Execute (FIX IS HERE)
+                # Pass the credentials to the connector
+                connector = SanityConnector(credentials=creds_dict)
+                
+                if not connector.connect():
+                    return "Error: Could not connect to Sanity. Please check your credentials."
+
+                data = connector.execute_query(query)
+                
+                if not data:
+                    return "No data found matching your query."
+                
+                return json.dumps(data, indent=2)
+
+        except Exception as e:
+            print(f"❌ [CMS Tool] CRITICAL ERROR: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"Error executing CMS query: {str(e)}"

backend/src/services/tools/nosql_agent.py

@@ -0,0 +1,65 @@
+
+from langchain.agents import create_agent
+from backend.src.services.llm.factory import get_llm_model
+from backend.src.services.tools.nosql_tool import NoSQLQueryTool
+from typing import Optional, Dict
+
+# --- THE CONSTITUTION (Same as before) ---
+NOSQL_SYSTEM_PROMPT = """You are a User Data Assistant with access to a NoSQL Database.
+Your job is to retrieve user profile details and activity logs using the 'nosql_database_tool'.
+
+--- CRITICAL RULES FOR QUERYING ---
+1. **DO NOT** include 'user_id' or '_id' in the 'query_json'. 
+   - The tool AUTOMATICALLY applies the security filter for the current user.
+   - If you want to fetch the user's profile, just send an empty query: "{{}}"
+   
+2. **DO NOT** try to select specific fields in the query_json.
+   - Incorrect: {{"fields": ["email"]}} 
+   - Correct: {{}} (Fetch the whole document, then you extract the email).
+
+3. You are acting on behalf of User ID: {user_id}.
+
+--- AVAILABLE COLLECTIONS ---
+1. 'users': Contains profile info (name, email, membership_tier).
+2. 'activity_logs': Contains login history and actions.
+
+--- EXAMPLES ---
+- User: "Show my profile" -> Tool Input: collection='users', query_json='{{}}'
+- User: "Show my login history" -> Tool Input: collection='activity_logs', query_json='{{"action": "login"}}'
+"""
+
+class AgentAdapter:
+    """Wrapper for V1 Agent compatibility"""
+    def __init__(self, agent):
+        self.agent = agent
+    
+    async def ainvoke(self, input_dict):
+        user_text = input_dict.get("input", "")
+        payload = {"messages": [("user", user_text)]}
+        result = await self.agent.ainvoke(payload)
+        last_message = result["messages"][-1]
+        return {"output": last_message.content}
+
+# --- DYNAMIC AGENT FACTORY (UPDATED) ---
+def get_nosql_agent(
+    user_id: str,
+    llm_credentials: Optional[Dict[str, str]] = None # <--- Added this
+):
+    """
+    Creates a NoSQL Agent using the user's specific LLM credentials.
+    """
+    # 1. Load User's LLM
+    llm = get_llm_model(credentials=llm_credentials)
+    
+    # 2. Initialize the tool
+    tool = NoSQLQueryTool(user_id=str(user_id))
+    tools = [tool]
+
+    # 3. Create Agent
+    agent_runnable = create_agent(
+        model=llm,
+        tools=tools,
+        system_prompt=NOSQL_SYSTEM_PROMPT.format(user_id=user_id)
+    )
+    
+    return AgentAdapter(agent_runnable)

backend/src/services/tools/nosql_tool.py

@@ -0,0 +1,61 @@
+
+import json
+import asyncio
+from typing import Type
+from pydantic import BaseModel, Field
+from langchain_core.tools import BaseTool
+from backend.src.services.connectors.mongo_connector import MongoConnector
+from typing import Dict, Optional
+
+# --- NoSQLQueryInput Schema (Same as before) ---
+class NoSQLQueryInput(BaseModel):
+    collection: str = Field(..., description="The name of the collection to query (e.g., 'users', 'activity_logs').")
+    query_json: str = Field(..., description="A valid JSON string representing the query filter.")
+
+class NoSQLQueryTool(BaseTool):
+    name: str = "nosql_database_tool"
+    description: str = """
+    Use this tool to query the NoSQL User Database. 
+    Useful for retrieving User Profiles and Activity Logs.
+    """
+    args_schema: Type[BaseModel] = NoSQLQueryInput
+    
+    # --- DYNAMIC INJECTION ---
+    user_id: str
+    db_credentials: Dict[str, str] # User's Mongo URL will come here
+
+    def _run(self, collection: str, query_json: str) -> str:
+        # 1. Initialize connector WITH User Credentials
+        # Note: Future-proofing to select connector based on provider
+        connector = MongoConnector(credentials=self.db_credentials)
+        
+        try:
+            # 2. Parse Query
+            query_dict = json.loads(query_json.replace("'", '"')) 
+            
+            # 3. Security Checks (Injection & RBAC)
+            query_str = str(query_dict)
+            if "$where" in query_str or "$function" in query_str:
+                return "⛔ SECURITY ALERT: Malicious operators detected."
+
+            # Force user_id filter
+            query_dict['user_id'] = self.user_id
+            
+            print(f"🔎 [NoSQL Tool] Executing Query on '{collection}': {query_dict}")
+
+            # 4. Execute
+            results = connector.find_many(collection, query_dict, limit=5)
+            
+            if not results:
+                return "No records found matching your request."
+            
+            return f"Found {len(results)} records:\n{json.dumps(results, indent=2, default=str)}"
+
+        except json.JSONDecodeError:
+            return "❌ Error: Invalid JSON query format."
+        except Exception as e:
+            return f"❌ System Error: {str(e)}"
+
+    async def _arun(self, collection: str, query_json: str):
+        """Async wrapper for the tool."""
+        return await asyncio.to_thread(self._run, collection, query_json)

backend/src/services/tools/secure_agent.py

@@ -0,0 +1,57 @@
+
+from langchain.agents import create_agent
+from backend.src.services.llm.factory import get_llm_model
+from backend.src.services.tools.sql_tool import get_sql_toolkit # Updated Import
+from typing import Optional, Dict
+
+# --- PROMPTS (Same as before) ---
+ADMIN_PREFIX = "You are a PostgreSQL expert... full access..."
+CUSTOMER_PREFIX = """You are a SQL helper for User ID: {user_id}.
+CRITICAL: For every query, you MUST add a "WHERE user_id = {user_id}" clause.
+Never show data of other users.
+Always present data in a clean MARKDOWN TABLE.
+"""
+
+# --- AGENT ADAPTER (Same as before) ---
+class AgentAdapter:
+    def __init__(self, agent):
+        self.agent = agent
+    
+    async def ainvoke(self, input_dict):
+        user_text = input_dict.get("input", "")
+        payload = {"messages": [("user", user_text)]}
+        result = await self.agent.ainvoke(payload)
+        last_message = result["messages"][-1]
+        return {"output": last_message.content}
+
+# --- DYNAMIC AGENT FACTORY ---
+def get_secure_agent(
+    user_id: int, 
+    role: str,
+    db_credentials: Dict[str, str],
+    llm_credentials: Optional[Dict[str, str]] = None
+):
+    """
+    Creates a Secure SQL Agent using the specific user's databases and LLM.
+    """
+    # 1. Load User's LLM (via factory)
+    llm = get_llm_model(credentials=llm_credentials)
+    
+    # 2. Get User-specific SQL Toolkit
+    toolkit = get_sql_toolkit(db_credentials, llm_credentials)
+    tools = toolkit.get_tools() # Toolkit se tools nikalo
+
+    # 3. Select the right security prompt
+    if role == "admin":
+        system_prefix = ADMIN_PREFIX
+    else:
+        system_prefix = CUSTOMER_PREFIX.format(user_id=user_id)
+
+    # 4. Create the Agent (New V1 'create_agent' syntax)
+    agent_runnable = create_agent(
+        model=llm,
+        tools=tools,
+        system_prompt=system_prefix
+    )
+    
+    return AgentAdapter(agent_runnable)

backend/src/services/tools/sql_tool.py

@@ -0,0 +1,45 @@
+
+from langchain_community.utilities import SQLDatabase
+from langchain_community.agent_toolkits import SQLDatabaseToolkit
+from backend.src.services.llm.factory import get_llm_model
+from typing import Optional, Dict
+
+# --- DYNAMIC FUNCTIONS ---
+
+def get_database_connection(db_credentials: Dict[str, str]) -> SQLDatabase:
+    """
+    User ki di hui connection string se connect karta hai.
+    """
+    db_uri = db_credentials.get("url")
+    if not db_uri:
+        raise ValueError("SQL Database URL not found in user's settings.")
+
+    # --- FIX for SQLAlchemy Async Driver ---
+    # Ensure the URL is compatible with the synchronous SQLDatabase object
+    if "+asyncpg" in db_uri:
+        db_uri = db_uri.replace("+asyncpg", "") # Sync object needs sync driver
+    
+    print(f"INFO: [SQL Tool] Connecting to user's SQL DB: {db_uri[:30]}...")
+
+    db = SQLDatabase.from_uri(
+        db_uri,
+        sample_rows_in_table_info=2 # 2 samples kafi hain
+    )
+    return db
+
+def get_sql_toolkit(
+    db_credentials: Dict[str, str], 
+    llm_credentials: Optional[Dict[str, str]] = None
+) -> SQLDatabaseToolkit:
+    """
+    User ke DB aur User ke LLM se Toolkit banata hai.
+    """
+    # 1. Connect to User's DB
+    db = get_database_connection(db_credentials)
+    
+    # 2. Load User's LLM
+    llm = get_llm_model(credentials=llm_credentials)
+    
+    # 3. Create Toolkit
+    toolkit = SQLDatabaseToolkit(db=db, llm=llm)
+    return toolkit

backend/src/services/vector_store/qdrant_adapter.py

@@ -0,0 +1,78 @@
+
+import qdrant_client
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+from langchain_qdrant import QdrantVectorStore
+from backend.src.core.config import settings
+from backend.src.services.embeddings.factory import get_embedding_model
+from typing import Optional, Dict
+
+# @lru_cache() HATA DIYA - We can't cache user-specific connections
+def get_vector_store(credentials: Optional[Dict[str, str]] = None):
+    """
+    Dynamic Vector Store Connector.
+    1. Agar 'credentials' hain, to unhein use karega (User's Cloud Qdrant).
+    2. Agar nahi, to global settings use karega (Fallback/Admin).
+    """
+    embedding_model = get_embedding_model() # Ye local hai, isko keys nahi chahiye
+    
+    # --- DYNAMIC CONFIGURATION LOGIC ---
+    if credentials:
+        # User-specific Cloud settings
+        qdrant_url = credentials.get("url")
+        qdrant_api_key = credentials.get("api_key")
+        collection_name = credentials.get("collection_name", "user_default_collection")
+    else:
+        # Global fallback settings
+        qdrant_url = settings.QDRANT_URL
+        qdrant_api_key = settings.QDRANT_API_KEY
+        collection_name = settings.QDRANT_COLLECTION_NAME
+
+    if not qdrant_url:
+        raise ValueError("Qdrant URL is not configured for this user or globally.")
+
+    print(f"INFO: [VectorDB] Connecting to Qdrant at '{qdrant_url}'...")
+    
+    # 1. Qdrant Client banayen (User ki keys ke sath)
+    client = QdrantClient(
+        url=qdrant_url,
+        api_key=qdrant_api_key,
+    )
+
+    # 2. CHECK: Kya Collection exist karti hai?
+    # Hum 'try-except' use karenge taake connection errors bhi pakde jayen
+    try:
+        # collection_exists is deprecated, use get_collection instead
+        client.get_collection(collection_name=collection_name)
+        print(f"INFO: [VectorDB] Collection '{collection_name}' already exists.")
+    except Exception as e:
+        # Agar error "Not found" hai, to collection banayenge
+        if "404" in str(e) or "Not found" in str(e):
+            print(f"INFO: Collection '{collection_name}' not found. Creating it now...")
+            
+            # Embedding size pata karna
+            dummy_embedding = embedding_model.embed_query("test")
+            vector_size = len(dummy_embedding)
+            
+            client.create_collection(
+                collection_name=collection_name,
+                vectors_config=models.VectorParams(
+                    size=vector_size,
+                    distance=models.Distance.COSINE
+                )
+            )
+            print(f"SUCCESS: Created collection '{collection_name}' with vector size {vector_size}.")
+        else:
+            # Koi aur error (e.g., connection refused)
+            raise ConnectionError(f"Failed to connect or access Qdrant: {e}")
+
+    # 3. Vector Store object bana kar return karein
+    vector_store = QdrantVectorStore(
+        client=client,
+        collection_name=collection_name,
+        embedding=embedding_model,
+        content_payload_key="page_content",
+        metadata_payload_key="metadata"
+    )
+
+    return vector_store

backend/src/utils/auth.py

@@ -0,0 +1,30 @@
+from passlib.context import CryptContext
+from datetime import datetime, timedelta
+from jose import jwt
+from backend.src.core.config import settings
+
+# Password Hasher (Bcrypt)
+pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+
+# JWT Configuration
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+def verify_password(plain_password, hashed_password):
+    """Check karein ke user ka password sahi hai ya nahi"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    """Password ko encrypt karein taake DB mein plain text save na ho"""
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict):
+    """User ke liye Login Token (Badge) banayein"""
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    
+    # Secret Key config se lenge (Ensure karein ke config mein ho)
+    secret_key = settings.SECRET_KEY
+    encoded_jwt = jwt.encode(to_encode, secret_key, algorithm=ALGORITHM)
+    return encoded_jwt

backend/src/utils/security.py

@@ -0,0 +1,29 @@
+from cryptography.fernet import Fernet
+import base64
+
+# --- FIX: A Valid, Consistent 32-byte Base64 Key ---
+# Ye key change nahi hogi, to decryption hamesha chalega.
+DEFAULT_KEY = b'8_sW7x9y2z4A5b6C8d9E0f1G2h3I4j5K6l7M8n9O0pQ='
+
+class SecurityUtils:
+    @staticmethod
+    def get_cipher():
+        # Production mein ye .env se aana chahiye
+        # Development ke liye hum hardcoded valid key use kar rahe hain
+        return Fernet(DEFAULT_KEY)
+
+    @staticmethod
+    def encrypt(data: str) -> str:
+        if not data: return ""
+        cipher = SecurityUtils.get_cipher()
+        return cipher.encrypt(data.encode()).decode()
+
+    @staticmethod
+    def decrypt(token: str) -> str:
+        if not token: return ""
+        cipher = SecurityUtils.get_cipher()
+        try:
+            return cipher.decrypt(token.encode()).decode()
+        except Exception as e:
+            print(f"🔐 Decryption Failed: {e}")
+            raise ValueError("Invalid Key or Corrupted Data")

dummy_cms_data.json

@@ -0,0 +1,37 @@
+[
+  {
+    "_id": "p1",
+    "_type": "product",
+    "title": "Classic Blue Denim Jacket",
+    "price": 59.99,
+    "inStock": true,
+    "colors": ["Blue", "Black"],
+    "description": "A timeless classic denim jacket for all seasons."
+  },
+  {
+    "_id": "p2",
+    "_type": "product",
+    "title": "Urban Running Shoes",
+    "price": 89.50,
+    "inStock": true,
+    "colors": ["White", "Grey"],
+    "description": "High performance running shoes with foam technology."
+  },
+  {
+    "_id": "p3",
+    "_type": "product",
+    "title": "Graphic Tee - Retro",
+    "price": 25.00,
+    "inStock": false,
+    "colors": ["Red"],
+    "description": "100% Cotton tee with retro print."
+  },
+  {
+    "_id": "offer1",
+    "_type": "offer",
+    "code": "SUMMER20",
+    "discount_percentage": 20,
+    "active": true,
+    "description": "Get 20% off on all summer wear."
+  }
+]

requirements.txt

@@ -0,0 +1,194 @@
+accelerate==1.12.0
+aiofiles==25.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.2
+aiosignal==1.4.0
+aiosqlite==0.21.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+anyio==4.12.0
+argon2-cffi==25.1.0
+argon2-cffi-bindings==25.1.0
+asyncpg==0.31.0
+attrs==25.4.0
+backoff==2.2.1
+bcrypt==5.0.0
+beautifulsoup4==4.14.3
+cachetools==6.2.2
+certifi==2025.11.12
+cffi==2.0.0
+charset-normalizer==3.4.4
+click==8.3.1
+colorama==0.4.6
+coloredlogs==15.0.1
+contourpy==1.3.3
+cryptography==46.0.3
+cycler==0.12.1
+dataclasses-json==0.6.7
+Deprecated==1.3.1
+distro==1.9.0
+dnspython==2.8.0
+docx2txt==0.9
+ecdsa==0.19.1
+effdet==0.4.1
+email-validator==2.3.0
+emoji==2.15.0
+et_xmlfile==2.0.0
+fastapi==0.124.0
+filelock==3.20.0
+filetype==1.2.0
+flatbuffers==25.9.23
+fonttools==4.61.0
+frozenlist==1.8.0
+fsspec==2025.12.0
+google-api-core==2.28.1
+google-auth==2.43.0
+google-cloud-vision==3.11.0
+google-genai==1.54.0
+googleapis-common-protos==1.72.0
+greenlet==3.3.0
+groq==0.37.1
+grpcio==1.76.0
+grpcio-status==1.76.0
+h11==0.16.0
+h2==4.3.0
+hpack==4.1.0
+html5lib==1.1
+httpcore==1.0.9
+httptools==0.7.1
+httpx==0.28.1
+httpx-sse==0.4.3
+huggingface-hub==0.36.0
+humanfriendly==10.0
+hyperframe==6.1.0
+idna==3.11
+Jinja2==3.1.6
+jiter==0.12.0
+joblib==1.5.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+kiwisolver==1.4.9
+langchain==1.1.3
+langchain-classic==1.0.0
+langchain-community==0.4.1
+langchain-core==1.1.3
+langchain-google-genai==4.0.0
+langchain-groq==1.1.0
+langchain-huggingface==1.1.0
+langchain-openai==1.1.1
+langchain-qdrant==1.1.0
+langchain-text-splitters==1.0.0
+langdetect==1.0.9
+langgraph==1.0.4
+langgraph-checkpoint==3.0.1
+langgraph-prebuilt==1.0.5
+langgraph-sdk==0.2.15
+langsmith==0.4.57
+lxml==6.0.2
+Markdown==3.10
+MarkupSafe==3.0.3
+marshmallow==3.26.1
+matplotlib==3.10.7
+ml_dtypes==0.5.4
+mpmath==1.3.0
+msoffcrypto-tool==5.4.2
+multidict==6.7.0
+mypy_extensions==1.1.0
+networkx==3.6.1
+nltk==3.9.2
+numpy==2.2.6
+olefile==0.47
+omegaconf==2.3.0
+onnx==1.20.0
+onnxruntime==1.23.2
+openai==2.9.0
+opencv-python==4.12.0.88
+openpyxl==3.1.5
+orjson==3.11.5
+ormsgpack==1.12.0
+packaging==25.0
+pandas==2.3.3
+passlib==1.7.4
+pdf2image==1.17.0
+pdfminer.six==20251107
+pi_heif==1.1.1
+pikepdf==10.0.2
+pillow==12.0.0
+portalocker==3.2.0
+propcache==0.4.1
+proto-plus==1.26.1
+protobuf==6.33.2
+psutil==7.1.3
+psycopg2-binary==2.9.11
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pycocotools==2.0.10
+pycparser==2.23
+pydantic==2.12.5
+pydantic-settings==2.12.0
+pydantic_core==2.41.5
+pymongo==4.15.5
+pypandoc==1.16.2
+pyparsing==3.2.5
+pypdf==6.4.1
+pypdfium2==5.1.0
+pyreadline3==3.5.4
+python-dateutil==2.9.0.post0
+python-docx==1.2.0
+python-dotenv==1.2.1
+python-iso639==2025.11.16
+python-jose==3.5.0
+python-magic==0.4.27
+python-multipart==0.0.20
+python-oxmsg==0.0.2
+python-pptx==1.0.2
+pytz==2025.2
+pywin32==311
+PyYAML==6.0.3
+qdrant-client==1.16.1
+RapidFuzz==3.14.3
+regex==2025.11.3
+requests==2.32.5
+requests-toolbelt==1.0.0
+rsa==4.9.1
+safetensors==0.7.0
+scikit-learn==1.7.2
+scipy==1.16.3
+sentence-transformers==5.1.2
+setuptools==80.9.0
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.8
+SQLAlchemy==2.0.45
+starlette==0.50.0
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+timm==1.0.22
+tokenizers==0.22.1
+torch==2.9.1
+torchvision==0.24.1
+tqdm==4.67.1
+transformers==4.57.3
+typing-inspect==0.9.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+unstructured==0.18.21
+unstructured-client==0.42.4
+unstructured.pytesseract==0.3.15
+unstructured_inference==1.1.2
+urllib3==2.6.1
+uuid_utils==0.12.0
+uvicorn==0.38.0
+watchfiles==1.1.1
+webencodings==0.5.1
+websockets==15.0.1
+wrapt==2.0.1
+xlrd==2.0.2
+xlsxwriter==3.2.9
+xxhash==3.6.0
+yarl==1.22.0
+zstandard==0.25.0

static/widget.js

@@ -0,0 +1,153 @@
+(function() {
+    // ----------------------------------------------------
+    // 1. CONFIGURATION: Script Tag se values uthana
+    // ----------------------------------------------------
+    const scriptTag = document.currentScript;
+    
+    const USER_ID = scriptTag.getAttribute("data-user-id"); 
+    const API_URL = scriptTag.getAttribute("data-api-url");
+    const THEME_COLOR = scriptTag.getAttribute("data-theme-color") || "#007bff";
+
+    if (!USER_ID || !API_URL) {
+        console.error("OmniAgent Widget Error: data-user-id or data-api-url is missing!");
+        return;
+    }
+
+    // Modern way to generate unique ID (Fixing substr deprecated warning)
+    const CHAT_SESSION_ID = "omni_session_" + Math.random().toString(36).slice(2, 11); 
+
+    // ----------------------------------------------------
+    // 2. STYLES: UI Design aur Position
+    // ----------------------------------------------------
+    const style = document.createElement('style');
+    style.innerHTML = `
+        #omni-widget-container {
+            position: fixed; bottom: 20px; right: 20px; z-index: 9999; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            transition: all 0.3s;
+        }
+        #omni-chat-btn {
+            background: ${THEME_COLOR}; color: white; border: none; padding: 15px; border-radius: 50%;
+            cursor: pointer; box-shadow: 0 4px 12px rgba(0,0,0,0.4); width: 60px; height: 60px; font-size: 24px;
+            display: flex; align-items: center; justify-content: center;
+        }
+        #omni-chat-window {
+            display: none; width: 350px; height: 500px; background: white; border-radius: 10px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.5); flex-direction: column; overflow: hidden;
+            margin-bottom: 15px; transform-origin: bottom right; animation: fadeIn 0.3s ease-out;
+        }
+        #omni-header { 
+            background: ${THEME_COLOR}; color: white; padding: 15px; font-weight: 600; display: flex; 
+            justify-content: space-between; align-items: center; border-radius: 10px 10px 0 0; 
+        }
+        #omni-messages { flex: 1; padding: 10px; overflow-y: auto; background: #f0f0f0; }
+        #omni-input-area { display: flex; border-top: 1px solid #ddd; }
+        #omni-input { flex: 1; padding: 12px; border: none; outline: none; font-size: 14px; }
+        #omni-send { background: white; border: none; color: ${THEME_COLOR}; font-weight: bold; cursor: pointer; padding: 0 15px; font-size: 18px; }
+        .omni-msg { margin: 8px 0; padding: 10px 15px; border-radius: 15px; max-width: 80%; font-size: 14px; line-height: 1.4; }
+        .omni-msg.user { background: ${THEME_COLOR}; color: white; margin-left: auto; border-bottom-right-radius: 2px; }
+        .omni-msg.bot { background: #e8e8e8; color: #333; margin-right: auto; border-bottom-left-radius: 2px; }
+        
+        @keyframes fadeIn { from { opacity: 0; transform: scale(0.9); } to { opacity: 1; transform: scale(1); } }
+    `;
+    document.head.appendChild(style);
+
+    // ----------------------------------------------------
+    // 3. HTML Structure Banao
+    // ----------------------------------------------------
+    const container = document.createElement('div');
+    container.id = 'omni-widget-container';
+
+    const chatWindow = document.createElement('div');
+    chatWindow.id = 'omni-chat-window';
+    chatWindow.innerHTML = `
+        <div id="omni-header">
+            <span>Customer Support</span>
+            <span style="cursor:pointer; font-size: 18px;" onclick="window.toggleOmniChat()">—</span>
+        </div>
+        <div id="omni-messages"></div>
+        <div id="omni-input-area">
+            <input type="text" id="omni-input" placeholder="Type your query..." />
+            <button id="omni-send">➤</button>
+        </div>
+    `;
+
+    const chatBtn = document.createElement('button');
+    chatBtn.id = 'omni-chat-btn';
+    chatBtn.innerHTML = '💬';
+    
+    // onClick ko addEventListener se theek kiya
+    chatBtn.addEventListener('click', toggleOmniChat); 
+
+    container.appendChild(chatWindow);
+    container.appendChild(chatBtn);
+    document.body.appendChild(container);
+
+    // ----------------------------------------------------
+    // 4. Logic Functions (Modern Event Listeners)
+    // ----------------------------------------------------
+    
+    const inputField = document.getElementById('omni-input');
+    const sendButton = document.getElementById('omni-send');
+
+    window.toggleOmniChat = function() {
+        const win = document.getElementById('omni-chat-window');
+        const isVisible = win.style.display === 'flex';
+        win.style.display = isVisible ? 'none' : 'flex';
+        if (!isVisible) {
+            inputField.focus();
+        }
+    };
+
+    function addMessage(text, sender) {
+        const msgs = document.getElementById('omni-messages');
+        const div = document.createElement('div');
+        div.className = `omni-msg ${sender}`;
+        div.innerHTML = text.replace(/(https?:\/\/[^\s]+)/g, '<a href="$1" target="_blank" style="color:white; text-decoration:underline;">$1</a>');
+        msgs.appendChild(div);
+        msgs.scrollTop = msgs.scrollHeight;
+    }
+
+    async function sendMessage() {
+        const originalBtnText = sendButton.innerHTML;
+        const text = inputField.value.trim();
+        if (!text) return;
+
+        addMessage(text, 'user');
+        inputField.value = '';
+        inputField.disabled = true;
+        sendButton.innerHTML = '...';
+        sendButton.disabled = true;
+
+        try {
+            // Backend API Call
+            const response = await fetch(`${API_URL}/api/v1/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    message: text,
+                    session_id: CHAT_SESSION_ID,
+                    user_id: USER_ID 
+                })
+            });
+            const data = await response.json();
+            addMessage(data.response, 'bot'); 
+        } catch (error) {
+            addMessage("Error: Could not connect to the Agent.", 'bot');
+            console.error("OmniAgent API Error:", error);
+        } finally {
+            inputField.disabled = false;
+            sendButton.innerHTML = originalBtnText;
+            sendButton.disabled = false;
+            inputField.focus();
+        }
+    }
+
+    // Modern Event Listeners (Fixing deprecated 'onkeypress')
+    sendButton.addEventListener('click', sendMessage);
+    inputField.addEventListener('keypress', (e) => { 
+        if(e.key === 'Enter') {
+            sendMessage(); 
+            e.preventDefault(); // Enter key ka default action roko
+        }
+    });
+})();