Base 1.0

.dockerignore

@@ -0,0 +1,24 @@
+# Git files
+.git
+.gitignore
+
+# Python virtual environment
+venv/
+env/
+.venv/
+
+# Python cache
+__pycache__/
+*.pyc
+
+# IDE and OS files
+.vscode/
+.idea/
+*.DS_Store
+
+# Local secrets and environment variables
+.env
+
+# Application cache (if you don't want it in the image)
+cache/
+

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+env/
+.venv/
+.env
+*.egg-info/
+dist/
+build/
+
+/cache/
+*.faiss
+default.sqlite
+
+sessions

AGENTS.md

@@ -0,0 +1,18 @@
+# Agent Instructions
+
+You are a proactive web browsing agent.
+
+## Browsing Guidelines
+
+- **Search is just the start**: When you search for something, don't just stop at the search results.
+- **Navigate**: You MUST click on relevant results to find the actual information.
+- **Use `get_links`**: On a search results page or any page, use the `get_links` action to see clickable items.
+- **Click Links**: Use the `click` action with the text of the link (or selector) to navigate.
+- **Deep Research**: Go 2-3 levels deep if necessary. Don't be lazy.
+
+## Example Flow
+1. `browser(action="navigate", url="google.com")`
+2. `browser(action="type", selector="search box", text="query")` + `press("Enter")`
+3. `browser(action="get_links")` -> Returns list of results
+4. `browser(action="click", selector="Link Text of Result 1")`
+5. `browser(action="get_text")` -> Read page content

Dockerfile

@@ -0,0 +1,58 @@
+# Use the official Python image with Playwright pre-installed
+# This base image includes Ubuntu 22.04 (Jammy) and necessary system deps for browsers
+FROM mcr.microsoft.com/playwright/python:v1.41.0-jammy
+
+# Set non-interactive mode for apt
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Create a user to run the application (HF Spaces uses user 1000)
+RUN useradd -m -u 1000 user
+
+# Set working directory
+WORKDIR /app
+
+# Switch to root to install dependencies and system packages if needed
+USER root
+
+# Install system dependencies if any additional ones are needed (e.g. for some python packages)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    software-properties-common \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright browsers (already in base image, but ensure they are available for the user)
+# The base image puts them in specific locations. 
+# We run `playwright install chromium` just to be safe and ensure links are set up if needed by the python lib
+RUN playwright install chromium
+
+# Copy application code
+COPY . .
+
+# Adjust permissions for the user
+RUN chown -R user:user /app
+
+# Create necessary directories for the app (data, cache) and ensure permission
+# HF Spaces likes /data for persistent storage if configured, but we map it in code.
+# Here we just make sure our app directories are writable
+RUN mkdir -p /app/data /app/memory /tmp/cache /tmp/hf && \
+    chown -R user:user /app/data /app/memory /tmp/cache /tmp/hf
+
+# Switch to the non-root user
+USER user
+
+# Expose the port
+EXPOSE 7860
+
+# Define environment variables
+ENV PYTHONUNBUFFERED=1
+ENV HOME=/home/user
+
+# Start the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: NPS ChatAgentBot
-emoji: 📊
-colorFrom: purple
-colorTo: blue
+title: NPS-AI
+emoji: 👀
+colorFrom: indigo
+colorTo: yellow
 sdk: docker
 pinned: false
 ---

STARTUP.md

@@ -0,0 +1,83 @@
+# Startup Instructions for NPS-AI
+
+This guide explains how to set up and run the NPS-AI project, including the FastAPI chatbot and the autonomous browser agent.
+
+## Prerequisites
+
+- **Python 3.10+**
+- **Ollama** (for local agent inference)
+- **Mistral API Key** (for chatbot RAG)
+
+## 1. Environment Setup
+
+1.  **Clone the repository** (if not already done).
+2.  **Create a `.env` file** in the project root:
+    ```bash
+    cp .env.example .env  # If .env.example exists
+    # OR create manually:
+    touch .env
+    ```
+3.  **Configure Environment Variables** in `.env`:
+    ```ini
+    MISTRAL_API_KEY=your_mistral_api_key_here
+    # Optional Admin Credentials for file management
+    ADMIN_USERNAME=admin
+    ADMIN_PASSWORD=admin
+    ```
+
+## 2. Install Dependencies
+
+Install the required Python packages:
+
+```bash
+pip install -r requirements.txt
+```
+
+Verify that `playwright` browsers are installed (required for the agent):
+
+```bash
+playwright install
+```
+
+## 3. Ollama Setup (For Agent)
+
+The agent uses a local Ollama model (`kimi-k2.5:cloud` by default in `nps_agent.py`). Ensure Ollama is running and the model is pulled:
+
+1.  **Start Ollama**:
+    ```bash
+    ollama serve
+    ```
+2.  **Pull the Model**:
+    ```bash
+    ollama pull kimi-k2.5:cloud
+    ```
+    *(Note: If you use a different model, update `model_name` in `nps_agent.py`)*
+
+## 4. Running the Application
+
+### Option A: Run the Full Application (Chatbot + Agent API)
+
+Start the FastAPI server:
+
+```bash
+python app.py
+```
+
+- **URL**: `http://localhost:7860`
+- **Chatbot Interface**: Accessible at the root URL (configured via static files in `frontend`).
+- **Agent Endpoint**: `POST /agent/run`
+
+### Option B: Run the Agent Standalone
+
+To test the agent directly specifically:
+
+```bash
+python nps_agent.py
+```
+*(This will prompt for a task input in the terminal)*
+
+## Troubleshooting
+
+- **Import Errors**: Ensure you are in the virtual environment (`source .venv/bin/activate` or similar).
+- **Browser Issues**: Run `playwright install` again.
+- **LLM Connection**: Check if Ollama is running on port 11434 (`http://localhost:11434`).

app.log

@@ -0,0 +1,15 @@
+2026-02-19 21:53:16,697 - __main__ - INFO - No persistent storage '/data' found. Using local 'data' folder and '/tmp/cache'.
+/home/yaduug/Desktop/Dev/NPS-AI/app.py:136: PydanticDeprecatedSince20: Support for class-based `config` is deprecated, use ConfigDict instead. Deprecated in Pydantic V2.0 to be removed in V3.0. See Pydantic V2 Migration Guide at https://errors.pydantic.dev/2.12/migration/
+  class ScikitLearnTfidfRetriever(BaseRetriever):
+INFO:     Started server process [1629794]
+INFO:     Waiting for application startup.
+2026-02-19 21:53:16,719 - __main__ - INFO - 🚀 Initializing RAG system...
+2026-02-19 21:53:16,719 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: BAAI/bge-base-en-v1.5
+2026-02-19 21:53:22,747 - __main__ - INFO - ✅ Loading vector store from cache: /tmp/cache/vectorstore_91a2d81fdd09516b836d2bb886c10c28.faiss
+2026-02-19 21:53:22,754 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2026-02-19 21:53:22,770 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2026-02-19 21:53:22,811 - __main__ - INFO - ✅ RAG system initialized successfully.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://0.0.0.0:7860 (Press CTRL+C to quit)
+2026-02-19 21:53:45,327 - __main__ - INFO - Translated 'GNDU kahan hai?' (Hindi) -> 'Where is GNDU?' (English)
+INFO:     127.0.0.1:33394 - "POST /ask HTTP/1.1" 200 OK

app.py

@@ -0,0 +1,597 @@
+import os, logging
+import glob
+import logging
+import re
+import hashlib
+import numpy as np
+import asyncio
+from typing import List, Optional, Any
+import shutil
+import secrets
+from contextlib import asynccontextmanager
+from nps_agent import run_nps_task
+
+# --- Pydantic & FastAPI ---
+from pydantic import BaseModel, Field
+import uvicorn
+from fastapi import FastAPI, HTTPException, APIRouter, UploadFile, File, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+
+# --- LangChain & RAG Core ---
+from PyPDF2 import PdfReader
+
+try:
+    from docx import Document as DocxDocument
+except ImportError:
+    DocxDocument = None
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_classic.retrievers import EnsembleRetriever
+from langchain_classic.chains.combine_documents import (
+    create_stuff_documents_chain,
+)
+from langchain_classic.chains import create_retrieval_chain
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.language_models import LLM
+from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.prompts import PromptTemplate
+
+# --- Scikit-Learn for TF-IDF ---
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# --- Mistral AI ---
+from mistralai import Mistral as MistralClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# --- Global Variables & Configuration ---
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Define the original, read-only data folder from the repo
+REPO_DATA_FOLDER = "data"
+
+# Use persistent storage if available (on Hugging Face Spaces)
+if os.path.exists("/data"):
+    logger.info("Persistent storage '/data' found. Using it for PDFs and cache.")
+    DATA_FOLDER = "/data/pdf_storage"
+    CACHE_DIR = "/data/cache"
+else:
+    logger.info(
+        "No persistent storage '/data' found. Using local 'data' folder and '/tmp/cache'."
+    )
+    DATA_FOLDER = REPO_DATA_FOLDER
+    CACHE_DIR = "/tmp/cache"
+
+os.makedirs(DATA_FOLDER, exist_ok=True)
+os.makedirs(CACHE_DIR, exist_ok=True)
+retrieval_chain = None
+
+HF_CACHE = "/tmp/hf"
+os.environ["HF_HOME"] = HF_CACHE
+os.environ["HF_DATASETS_CACHE"] = HF_CACHE
+os.environ["HF_MODULES_CACHE"] = HF_CACHE
+
+retrieval_chain = None
+
+db_path = "/data/default.sqlite" if os.path.exists("/data") else "default.sqlite"
+
+
+# --- Pydantic Models ---
+
+# --- Pydantic Models ---
+class QuestionRequest(BaseModel):
+    question: str = Field(..., min_length=1)
+    mode: str = Field("chat", description="Mode of operation: 'chat' or 'agent'")
+    language: str = Field("English", description="Language of the question and expected answer")
+
+
+class AgentRequest(BaseModel):
+    task: str = Field(..., min_length=5, description="The task for the browser agent to perform")
+
+
+class AnswerResponse(BaseModel):
+    answer: str
+    sources: List[str]
+
+
+# --- Greeting Handler ---
+GREETING_RESPONSES = {
+    "hi": "Hello! How can I assist you?",
+    "hello": "Hello! How can I help you today?",
+    "bye": "Bye-bye! See you soon.",
+    "ty": "Your Welcome!",
+}
+
+# --- Enhanced Prompt ---
+UNIVERSITY_ASSISTANT_PROMPT = PromptTemplate.from_template(
+    """
+You are a meticulous Guru Nanak Dev University Academic Assistant.
+Your task is to provide accurate, specific, and concise answers based ONLY on the provided Context.
+**Instructions:**
+1.  **Analyze the Context:** Carefully read the user's question and the provided context to synthesize an answer.
+2.  **Extract Specifics:** If asked for a fee, number, or date, provide the EXACT information.
+3.  **Cite Sources:** After your answer, cite the source document and page number: `(Source: Prospectus.pdf, Page: 15)`.
+4.  **Handle Missing Information:** If the info is not in the context, state: "Based on the provided documents, I could not find specific information about this topic."
+---
+**Context:**
+{context}
+---
+**Question:**
+{input}
+**Answer (with citations):**
+"""
+)
+
+
+# --- Custom Scikit-Learn TF-IDF Retriever ---
+class ScikitLearnTfidfRetriever(BaseRetriever):
+    docs: List[Document]
+    tfidf_vectorizer: TfidfVectorizer
+    tfidf_matrix: Any
+    k: int = 15
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def _get_relevant_documents(self, query: str) -> List[Document]:
+        query_vector = self.tfidf_vectorizer.transform([query])
+        similarity_scores = cosine_similarity(query_vector, self.tfidf_matrix).flatten()
+        top_k_indices = np.argsort(similarity_scores)[-self.k :][::-1]
+        return [self.docs[i] for i in top_k_indices]
+
+    async def _aget_relevant_documents(
+        self, query: str, *, run_manager=None
+    ) -> List[Document]:
+        return self._get_relevant_documents(query)
+
+
+# --- MistralLLM Class ---
+class MistralLLM(LLM):
+    client: Any = None
+    model: str = "mistral-small-latest"
+    temperature: float = 0.0
+    api_key: str = ""
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = "mistral-small-latest",
+        temperature: float = 0.0,
+    ):
+        super().__init__()
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.client = MistralClient(api_key=self.api_key)
+
+    @property
+    def _llm_type(self) -> str:
+        return "mistral"
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        messages = [{"role": "user", "content": prompt}]
+        response = self.client.chat.complete(
+            model=self.model, messages=messages, temperature=self.temperature
+        )
+        return response.choices[0].message.content.strip()
+
+
+# --- Caching and Data Processing Functions ---
+def get_data_hash(folder_path=DATA_FOLDER) -> str:
+    """Generates a hash based on the filenames and modification times of supported files."""
+    hasher = hashlib.md5()
+    if not os.path.exists(folder_path):
+        return "no_data"
+
+    supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+    files_to_hash = []
+    for ext in supported_extensions:
+        files_to_hash.extend(glob.glob(os.path.join(folder_path, f"*{ext}")))
+
+    for file_path in sorted(files_to_hash):
+        try:
+            stat = os.stat(file_path)
+            file_info = f"{os.path.basename(file_path)}-{stat.st_mtime}-{stat.st_size}"
+            hasher.update(file_info.encode("utf-8"))
+        except FileNotFoundError:
+            continue  # File might have been deleted during the process
+        
+    return hasher.hexdigest()
+
+
+def get_documents_from_files(folder_path=DATA_FOLDER) -> List[Document]:
+    docs = []
+    supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+
+    for file_path in glob.glob(os.path.join(folder_path, "*")):
+        file_name = os.path.basename(file_path)
+        file_ext = os.path.splitext(file_name)[1].lower()
+
+        if file_ext not in supported_extensions:
+            continue
+
+        if file_ext == ".pdf":
+            pdf_reader = PdfReader(file_path)
+            for i, page in enumerate(pdf_reader.pages):
+                text = page.extract_text() or ""
+                docs.append(
+                    Document(
+                        page_content=text, metadata={"source": file_name, "page": i + 1}
+                    )
+                )
+        elif file_ext in [".txt", ".md"]:
+            with open(file_path, "r", encoding="utf-8") as f:
+                text = f.read()
+                docs.append(
+                    Document(
+                        page_content=text, metadata={"source": file_name, "page": 1}
+                    )
+                )
+        elif file_ext == ".docx":
+            if DocxDocument is None:
+                logger.warning(
+                    "Skipping .docx file because 'python-docx' is not installed. Please install it with 'pip install python-docx'."
+                )
+                continue
+            try:
+                doc = DocxDocument(file_path)
+                text = "\n".join([para.text for para in doc.paragraphs])
+                docs.append(
+                    Document(
+                        page_content=text, metadata={"source": file_name, "page": 1}
+                    )
+                )
+            except Exception as e:
+                logger.error(f"Error processing .docx file {file_name}: {e}")
+
+    return docs
+
+
+async def initialize_rag_system():
+    global retrieval_chain
+    logger.info("🚀 Initializing RAG system...")
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    data_hash = get_data_hash()
+    cache_path = os.path.join(CACHE_DIR, f"vectorstore_{data_hash}.faiss")
+
+    embeddings = HuggingFaceEmbeddings(
+        model_name="BAAI/bge-base-en-v1.5",
+        model_kwargs={"device": "cpu"},
+        encode_kwargs={"normalize_embeddings": True},
+    )
+
+    if os.path.exists(cache_path):
+        logger.info(f"✅ Loading vector store from cache: {cache_path}")
+        vectorstore = FAISS.load_local(
+            cache_path, embeddings, allow_dangerous_deserialization=True
+        )
+        documents = get_documents_from_files()
+        text_chunks = RecursiveCharacterTextSplitter(
+            chunk_size=1000, chunk_overlap=150
+        ).split_documents(documents)
+    else:
+        logger.warning(
+            "No cache found or data has changed. Building new vector store..."
+        )
+        documents = get_documents_from_files()
+        if not documents:
+            logger.warning(
+                "No documents found in /data folder. RAG system will be inactive."
+            )
+            retrieval_chain = None  # Ensure chain is None
+            return
+
+        text_chunks = RecursiveCharacterTextSplitter(
+            chunk_size=1000, chunk_overlap=150
+        ).split_documents(documents)
+
+        logger.info(
+            f"Embedding {len(text_chunks)} chunks... (This will be slow on the first run)"
+        )
+        vectorstore = FAISS.from_documents(documents=text_chunks, embedding=embeddings)
+
+        logger.info(f"💾 Saving new vector store to cache: {cache_path}")
+        vectorstore.save_local(cache_path)
+
+    # --- Chain Setup ---
+    mistral_api_key = os.getenv("MISTRAL_API_KEY")
+    if not mistral_api_key:
+        raise ValueError("MISTRAL_API_KEY not found")
+
+    llm = MistralLLM(api_key=mistral_api_key)
+
+    question_answer_chain = create_stuff_documents_chain(
+        llm, UNIVERSITY_ASSISTANT_PROMPT
+    )
+
+    faiss_retriever = vectorstore.as_retriever(
+        search_type="similarity", search_kwargs={"k": 15}
+    )
+
+    tfidf_vectorizer = TfidfVectorizer(stop_words="english")
+
+    if not text_chunks:
+        logger.warning("No text chunks to process for TF-IDF.")
+        tfidf_retriever = ScikitLearnTfidfRetriever(
+            docs=[],
+            tfidf_vectorizer=tfidf_vectorizer,
+            tfidf_matrix=tfidf_vectorizer.fit_transform([]),
+            k=15,
+        )
+    else:
+        tfidf_matrix = tfidf_vectorizer.fit_transform(
+            [doc.page_content for doc in text_chunks]
+        )
+        tfidf_retriever = ScikitLearnTfidfRetriever(
+            docs=text_chunks,
+            tfidf_vectorizer=tfidf_vectorizer,
+            tfidf_matrix=tfidf_matrix,
+            k=15,
+        )
+
+    ensemble_retriever = EnsembleRetriever(
+        retrievers=[tfidf_retriever, faiss_retriever], weights=[0.5, 0.5]
+    )
+
+    retrieval_chain = create_retrieval_chain(ensemble_retriever, question_answer_chain)
+
+    logger.info("✅ RAG system initialized successfully.")
+
+
+def extract_sources_from_docs(docs: List[Document]) -> List[str]:
+    """Extracts unique source and page numbers from a list of documents."""
+    return sorted(
+        list(
+            set(
+                f"({doc.metadata.get('source', 'N/A')}, Page: {doc.metadata.get('page', 'N/A')})"
+                for doc in docs
+            )
+        )
+    )
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup event
+    # On Hugging Face, copy initial files from the read-only repo folder to persistent storage
+    if DATA_FOLDER != REPO_DATA_FOLDER and os.path.exists(REPO_DATA_FOLDER):
+        supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+        if not any(
+            any(f.endswith(ext) for ext in supported_extensions)
+            for f in os.listdir(DATA_FOLDER)
+        ):
+            logger.info(
+                f"Copying initial files from '{REPO_DATA_FOLDER}' to '{DATA_FOLDER}'..."
+            )
+            for filename in os.listdir(REPO_DATA_FOLDER):
+                if any(filename.endswith(ext) for ext in supported_extensions):
+                    src_path = os.path.join(REPO_DATA_FOLDER, filename)
+                    dest_path = os.path.join(DATA_FOLDER, filename)
+                    if not os.path.exists(dest_path):
+                        shutil.copy(src_path, dest_path)
+
+    await initialize_rag_system()
+    yield
+    # Shutdown event (if needed in future)
+
+
+# --- FastAPI Application ---
+app = FastAPI(title="GNDU Assistant (Cached)", version="4.0.0", lifespan=lifespan)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+security = HTTPBasic()
+
+
+def get_current_username(credentials: HTTPBasicCredentials = Depends(security)):
+    correct_username = secrets.compare_digest(
+        credentials.username, os.environ.get("ADMIN_USERNAME", "admin")
+    )
+    correct_password = secrets.compare_digest(
+        credentials.password, os.environ.get("ADMIN_PASSWORD", "admin")
+    )
+    if not (correct_username and correct_password):
+        raise HTTPException(
+            status_code=401,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+    return credentials.username
+
+
+admin_router = APIRouter()
+
+
+@admin_router.get("/files")
+async def get_files(_: str = Depends(get_current_username)):
+    """Lists all supported files in the data directory."""
+    if not os.path.exists(DATA_FOLDER):
+        return []
+    supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+    files = sorted(
+        [
+            f
+            for f in os.listdir(DATA_FOLDER)
+            if any(f.endswith(ext) for ext in supported_extensions)
+        ]
+    )
+    return files
+
+
+@admin_router.post("/files")
+async def upload_file(
+    file: UploadFile = File(...), _: str = Depends(get_current_username)
+):
+    """Uploads a new PDF file."""
+    file_path = os.path.join(DATA_FOLDER, file.filename)
+    if os.path.exists(file_path):
+        raise HTTPException(
+            status_code=409, detail="File with this name already exists."
+        )
+
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    finally:
+        file.file.close()
+
+    await initialize_rag_system()
+
+    return {"filename": file.filename}
+
+
+@admin_router.delete("/files/{filename}")
+async def delete_file(filename: str, _: str = Depends(get_current_username)):
+    """Deletes a PDF file."""
+    if ".." in filename:
+        raise HTTPException(status_code=400, detail="Invalid filename.")
+
+    file_path = os.path.join(DATA_FOLDER, filename)
+
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found.")
+
+    os.remove(file_path)
+
+    await initialize_rag_system()
+
+    return {"message": f"File '{filename}' deleted successfully."}
+
+
+app.include_router(admin_router, prefix="/admin")
+
+
+async def translate_text(text: str, target_language: str, api_key: str) -> str:
+    """Translates text to the target language using Mistral."""
+    if target_language.lower() == "english":
+        return text
+
+    client = MistralClient(api_key=api_key)
+    prompt = f"Translate the following text to {target_language}. Return ONLY the translated text, no unique prefix/suffix.\n\nText: {text}"
+    
+    try:
+        messages = [{"role": "user", "content": prompt}]
+        response = await client.chat.complete_async(
+            model="mistral-small-latest", messages=messages, temperature=0.0
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        logger.error(f"Translation failed: {e}")
+        return text  # Fallback to original text
+
+@app.post("/ask", response_model=AnswerResponse)
+async def ask_question(request: QuestionRequest):
+    normalized_question = request.question.strip().lower()
+    mistral_api_key = os.getenv("MISTRAL_API_KEY")
+    
+    # 1. Translate Query to English if needed
+    english_question = request.question
+    if request.language.lower() != "english":
+        try:
+             # Use a simple synchronous call for now if async is tricky with the client version, 
+             # but let's try to stick to the pattern. 
+             # IMPORTANT check: MistralClient in this code might be sync or async. 
+             # The existing MistralLLM uses sync `client.chat.complete`.
+             # We will use sync here for safety to match MistralLLM usage, or wrap in run_in_executor if needed.
+             # For simplicity in this step, let's use the same sync client pattern as MistralLLM.
+            
+            client = MistralClient(api_key=mistral_api_key)
+            trans_prompt = f"Translate the following text to English. Return ONLY the translated text.\n\nText: {request.question}"
+            trans_resp = client.chat.complete(
+                model="mistral-small-latest", messages=[{"role": "user", "content": trans_prompt}], temperature=0.0
+            )
+            english_question = trans_resp.choices[0].message.content.strip()
+            logger.info(f"Translated '{request.question}' ({request.language}) -> '{english_question}' (English)")
+        except Exception as e:
+            logger.error(f"Query translation failed: {e}")
+
+    # 2. Process Request
+    answer_text = ""
+    sources_list = []
+
+    if request.mode == "agent":
+        try:
+            logger.info(f"🚀 Executing Agent Task: {english_question}")
+            answer_text = await run_nps_task(english_question)
+            sources_list = ["Autonomus Agent"]
+        except Exception as e:
+            logger.error(f"Error running agent task: {e}")
+            raise HTTPException(status_code=500, detail=f"Agent Error: {str(e)}")
+
+    elif normalized_question in GREETING_RESPONSES:
+         answer_text = GREETING_RESPONSES[normalized_question]
+         sources_list = ["Conversational Greeting"]
+         
+    else:
+        # RAG Logic
+        if not retrieval_chain:
+            raise HTTPException(
+                status_code=503,
+                detail="RAG system is not initialized. Please add PDF files to the /data folder and restart.",
+            )
+
+        try:
+            # Modify the input to specificy the output language in the prompt if it's RAG
+            # Actually, RAG prompt expects 'input' and 'context'. 
+            # We will rely on post-translation for consistency across Agent/Chat
+            result = await retrieval_chain.ainvoke({"input": english_question})
+            answer_text = result.get("answer", "No answer could be generated.")
+            sources_list = extract_sources_from_docs(result.get("context", []))
+
+        except Exception as e:
+            logger.error(f"Error during RAG chain invocation: {e}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    # 3. Translate Answer back to Target Language
+    if request.language.lower() != "english":
+        try:
+            client = MistralClient(api_key=mistral_api_key)
+            back_prompt = f"Translate the following text to {request.language}. Return ONLY the translated text.\n\nText: {answer_text}"
+            back_resp = client.chat.complete(
+                model="mistral-small-latest", messages=[{"role": "user", "content": back_prompt}], temperature=0.0
+            )
+            answer_text = back_resp.choices[0].message.content.strip()
+        except Exception as e:
+            logger.error(f"Answer translation failed: {e}")
+
+    return AnswerResponse(answer=answer_text, sources=sources_list)
+
+
+@app.post("/agent/run")
+async def run_agent(request: AgentRequest):
+    """
+    Executes a task using the NPS Nanobot Agent.
+    """
+    try:
+        logger.info(f"🚀 Received agent task: {request.task}")
+        result = await run_nps_task(request.task)
+        return {"result": result}
+    except Exception as e:
+        logger.error(f"Error running agent task: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+app.mount("/", StaticFiles(directory="frontend", html=True), name="static")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

data/NPS_Rules.txt

@@ -0,0 +1,21 @@
+
+National Pension System (NPS) Information
+
+1. What is NPS?
+The National Pension System (NPS) is a voluntary, long-term retirement savings scheme designed to enable systematic savings during your working life. It is regulated by the Pension Fund Regulatory and Development Authority (PFRDA).
+
+2. Eligibility
+- Any citizen of India, whether resident or non-resident (NRI).
+- Individuals between 18 – 70 years of age can join.
+
+3. Types of Accounts
+- Tier I Account: This is the non-withdrawable permanent retirement account into which the accumulations are deposited and invested as per the option of the subscriber.
+- Tier II Account: This is a voluntary withdrawable account which is allowed only when there is an active Tier I account in the name of the subscriber. The withdrawals are permitted from this account as per the needs of the subscriber as and when required.
+
+4. Tax Benefits
+- Exclusive Tax Benefit: Investment up to ₹50,000 under Section 80CCD(1B) is available over and above the limit of ₹1.5 Lakhs under Section 80C.
+- Tax benefits are also available on employer contributions (for corporate sector).
+
+5. Exit and Withdrawal
+- Minimum 40% of the corpus must be utilized to purchase an annuity plan at the time of exit (superannuation/60 years).
+- Up to 60% of the corpus can be withdrawn as a tax-free lump sum.

data/Secrets.txt

@@ -0,0 +1 @@
+GITHUB TOKEN FOR Victus: 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

frontend/admin.html

@@ -0,0 +1,186 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>NPS Admin Panel</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">
+    <style>
+        body {
+            background-color: #f8f9fa;
+        }
+
+        .container {
+            margin-top: 50px;
+        }
+
+        #status {
+            margin-top: 15px;
+        }
+
+        .home-link {
+            margin-top: 20px;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <div class="card">
+            <div class="card-header">
+                <h1>🏛️ NPS Admin Panel</h1>
+            </div>
+            <div class="card-body">
+                <h2>Existing Files</h2>
+                <ul id="file-list" class="list-group mb-3"></ul>
+                <div id="status"></div>
+
+                <h2 class="mt-4">Upload New File</h2>
+                <form id="upload-form" enctype="multipart/form-data">
+                    <div class="input-group mb-3">
+                        <input type="file" class="form-control" id="file-input" name="file" accept=".pdf,.txt,.md,.docx"
+                            required>
+                        <button class="btn btn-primary" type="submit" id="upload-button">Upload</button>
+                    </div>
+                </form>
+
+                <a href="/" class="btn btn-secondary home-link">Back to Chat</a>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script>
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            const fileList = document.getElementById('file-list');
+            const uploadForm = document.getElementById('upload-form');
+            const fileInput = document.getElementById('file-input');
+            const status = document.getElementById('status');
+            let credentials = null;
+
+            const getCredentials = () => {
+                const username = prompt("Enter username:");
+                const password = prompt("Enter password:");
+                if (username && password) {
+                    credentials = btoa(`${username}:${password}`);
+                    return true;
+                }
+                return false;
+            };
+
+            const fetchWithAuth = async (url, options = {}) => {
+                if (!credentials) {
+                    if (!getCredentials()) {
+                        status.innerHTML = '<div class="alert alert-danger">Authentication required.</div>';
+                        return null;
+                    }
+                }
+
+                const headers = { ...options.headers, 'Authorization': `Basic ${credentials}` };
+                let response = await fetch(url, { ...options, headers });
+
+                if (response.status === 401) {
+                    status.innerHTML = '<div class="alert alert-danger">Authentication failed. Please try again.</div>';
+                    credentials = null; // Reset credentials
+                    if (getCredentials()) {
+                        const newHeaders = { ...options.headers, 'Authorization': `Basic ${credentials}` };
+                        response = await fetch(url, { ...options, headers: newHeaders });
+                    } else {
+                        status.innerHTML = '<div class="alert alert-danger">Authentication required.</div>';
+                        return null;
+                    }
+                }
+                return response;
+            };
+
+            const fetchFiles = async () => {
+                status.innerHTML = '<div class="alert alert-info">Loading files...</div>';
+                try {
+                    const response = await fetchWithAuth('/admin/files');
+                    if (!response) return;
+
+                    if (response.ok) {
+                        const files = await response.json();
+                        fileList.innerHTML = '';
+                        if (files.length === 0) {
+                            fileList.innerHTML = '<li class="list-group-item">No files found.</li>';
+                        } else {
+                            files.forEach(file => {
+                                const li = document.createElement('li');
+                                li.className = 'list-group-item d-flex justify-content-between align-items-center';
+                                li.textContent = file;
+                                const deleteBtn = document.createElement('button');
+                                deleteBtn.textContent = 'Delete';
+                                deleteBtn.className = 'btn btn-danger btn-sm';
+                                deleteBtn.onclick = () => deleteFile(file);
+                                li.appendChild(deleteBtn);
+                                fileList.appendChild(li);
+                            });
+                        }
+                        status.innerHTML = '';
+                    } else {
+                        status.innerHTML = '<div class="alert alert-danger">Error loading files.</div>';
+                    }
+                } catch (error) {
+                    status.innerHTML = '<div class="alert alert-danger">Error loading files.</div>';
+                    console.error('Error fetching files:', error);
+                }
+            };
+
+            const deleteFile = async (filename) => {
+                if (!confirm(`Are you sure you want to delete ${filename}?`)) return;
+                status.innerHTML = `<div class="alert alert-info">Deleting ${filename}...</div>`;
+                try {
+                    const response = await fetchWithAuth(`/admin/files/${filename}`, { method: 'DELETE' });
+                    if (!response) return;
+
+                    if (response.ok) {
+                        status.innerHTML = `<div class="alert alert-success">File '${filename}' deleted.</div>`;
+                        fetchFiles();
+                    } else {
+                        const error = await response.json();
+                        throw new Error(error.detail || 'Failed to delete file.');
+                    }
+                } catch (error) {
+                    status.innerHTML = `<div class="alert alert-danger">Error deleting file: ${error.message}</div>`;
+                    console.error('Error deleting file:', error);
+                }
+            };
+
+            uploadForm.addEventListener('submit', async (event) => {
+                event.preventDefault();
+                const file = fileInput.files[0];
+                if (!file) return;
+
+                const formData = new FormData();
+                formData.append('file', file);
+                status.innerHTML = `<div class="alert alert-info">Uploading ${file.name}...</div>`;
+
+                try {
+                    const response = await fetchWithAuth('/admin/files', {
+                        method: 'POST',
+                        body: formData,
+                    });
+                    if (!response) return;
+
+                    if (response.ok) {
+                        status.innerHTML = `<div class="alert alert-success">File '${file.name}' uploaded successfully.</div>`;
+                        fileInput.value = '';
+                        fetchFiles();
+                    } else {
+                        const error = await response.json();
+                        throw new Error(error.detail || 'Failed to upload file.');
+                    }
+                } catch (error) {
+                    status.innerHTML = `<div class="alert alert-danger">Error uploading file: ${error.message}</div>`;
+                    console.error('Error uploading file:', error);
+                }
+            });
+
+            fetchFiles();
+        });
+    </script>
+</body>
+
+</html>

frontend/index.html

@@ -0,0 +1,763 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>NPS Informational Assistant</title>
+  <link rel="icon"
+    href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>🏛️</text></svg>">
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/marked/9.1.6/marked.min.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-tomorrow.min.css">
+  <style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+
+    :root {
+      --primary: linear-gradient(135deg, #1e3c72, #2a5298);
+      --secondary: #e67e22;
+      --background: #0f172a;
+      --surface: #1e293b;
+      --surface-light: #334155;
+      --text: #f8fafc;
+      --text-muted: #94a3b8;
+      --assistant-bg: linear-gradient(135deg, #334155, #475569);
+      --user-bg: linear-gradient(135deg, #1e3c72, #2a5298);
+      --border: #333344;
+      --accent: #60a5fa;
+      --success: #10b981;
+      --error: #ef4444;
+      --glass-bg: rgba(26, 26, 36, 0.7);
+      --glass-border: rgba(255, 255, 255, 0.1);
+    }
+
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    html {
+      scroll-behavior: smooth;
+    }
+
+    body {
+      font-family: 'Inter', sans-serif;
+      background: var(--background);
+      background-image:
+        radial-gradient(circle at 15% 25%, rgba(30, 60, 114, 0.15) 0%, transparent 40%),
+        radial-gradient(circle at 85% 75%, rgba(230, 126, 34, 0.08) 0%, transparent 40%);
+      color: var(--text);
+      min-height: 100vh;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      padding: 10px;
+    }
+
+    .container {
+      width: 100%;
+      max-width: 900px;
+      height: calc(100vh - 40px);
+      max-height: 850px;
+      background: var(--glass-bg);
+      backdrop-filter: blur(25px);
+      border: 1px solid var(--glass-border);
+      border-radius: 24px;
+      box-shadow: 0 32px 64px rgba(0, 0, 0, 0.4);
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+      position: relative;
+      animation: fadeIn 0.5s ease-out;
+    }
+
+    @keyframes fadeIn {
+      from {
+        opacity: 0;
+        transform: scale(0.95);
+      }
+
+      to {
+        opacity: 1;
+        transform: scale(1);
+      }
+    }
+
+    header {
+      background: var(--primary);
+      padding: 20px 24px;
+      text-align: center;
+      position: relative;
+      overflow: hidden;
+      flex-shrink: 0;
+    }
+
+    header h1 {
+      font-size: 1.6rem;
+      font-weight: 700;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 12px;
+    }
+
+    .status-indicator {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      margin-top: 8px;
+      font-size: 0.85rem;
+      opacity: 0.9;
+    }
+
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--success);
+      animation: pulse 2s infinite cubic-bezier(0.4, 0, 0.6, 1);
+    }
+
+    @keyframes pulse {
+      50% {
+        opacity: 0.6;
+        transform: scale(0.9);
+      }
+    }
+
+    /* Toggle Switch */
+    .mode-toggle-container {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 12px;
+      margin-top: 16px;
+    }
+
+    .mode-label {
+      font-size: 0.9rem;
+      color: rgba(255, 255, 255, 0.8);
+      font-weight: 500;
+    }
+
+    .language-select {
+      background: rgba(255, 255, 255, 0.1);
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      color: white;
+      padding: 5px 10px;
+      border-radius: 15px;
+      outline: none;
+      font-family: 'Inter', sans-serif;
+      font-size: 0.9rem;
+      cursor: pointer;
+      transition: all 0.3s ease;
+    }
+
+    .language-select:hover {
+      background: rgba(255, 255, 255, 0.2);
+    }
+
+    .language-select option {
+      background: var(--surface);
+      color: var(--text);
+    }
+
+    .switch {
+      position: relative;
+      display: inline-block;
+      width: 50px;
+      height: 26px;
+    }
+
+    .switch input {
+      opacity: 0;
+      width: 0;
+      height: 0;
+    }
+
+    .slider {
+      position: absolute;
+      cursor: pointer;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background-color: rgba(255, 255, 255, 0.2);
+      -webkit-transition: .4s;
+      transition: .4s;
+      border-radius: 34px;
+    }
+
+    .slider:before {
+      position: absolute;
+      content: "";
+      height: 20px;
+      width: 20px;
+      left: 3px;
+      bottom: 3px;
+      background-color: white;
+      -webkit-transition: .4s;
+      transition: .4s;
+      border-radius: 50%;
+    }
+
+    input:checked+.slider {
+      background-color: var(--accent);
+    }
+
+    input:focus+.slider {
+      box-shadow: 0 0 1px var(--accent);
+    }
+
+    input:checked+.slider:before {
+      -webkit-transform: translateX(24px);
+      -ms-transform: translateX(24px);
+      transform: translateX(24px);
+    }
+
+    .chat-container {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      background: var(--surface);
+      position: relative;
+      min-height: 0;
+    }
+
+    #chat-box {
+      flex: 1;
+      overflow-y: auto;
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      padding: 24px;
+      padding-bottom: 120px;
+    }
+
+    #chat-box::-webkit-scrollbar {
+      width: 6px;
+    }
+
+    #chat-box::-webkit-scrollbar-track {
+      background: transparent;
+    }
+
+    #chat-box::-webkit-scrollbar-thumb {
+      background: var(--border);
+      border-radius: 3px;
+    }
+
+    #chat-box::-webkit-scrollbar-thumb:hover {
+      background: var(--accent);
+    }
+
+    .message-wrapper {
+      display: flex;
+      gap: 12px;
+      max-width: 85%;
+      animation: slideIn 0.4s ease-out;
+    }
+
+    @keyframes slideIn {
+      from {
+        opacity: 0;
+        transform: translateY(15px);
+      }
+
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .user-message-wrapper {
+      align-self: flex-end;
+      flex-direction: row-reverse;
+    }
+
+    .assistant-message-wrapper {
+      align-self: flex-start;
+    }
+
+    .assistant-avatar {
+      width: 40px;
+      height: 40px;
+      border-radius: 50%;
+      background: var(--accent);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      flex-shrink: 0;
+      font-size: 1.5rem;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+    }
+
+    .message {
+      padding: 14px 20px;
+      border-radius: 20px;
+      line-height: 1.6;
+      position: relative;
+      box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+    }
+
+    .assistant-message {
+      background: var(--assistant-bg);
+      border-bottom-left-radius: 8px;
+    }
+
+    .user-message {
+      background: var(--user-bg);
+      border-bottom-right-radius: 8px;
+      color: white;
+    }
+
+    .message-content :is(h1, h2, h3) {
+      margin-bottom: 12px;
+      color: var(--accent);
+      border-bottom: 1px solid var(--border);
+      padding-bottom: 8px;
+    }
+
+    .message-content :is(ul, ol) {
+      margin-left: 20px;
+      margin-bottom: 12px;
+    }
+
+    .message-content li {
+      margin-bottom: 6px;
+    }
+
+    .message-content p {
+      margin-bottom: 12px;
+    }
+
+    .message-content p:last-child {
+      margin-bottom: 0;
+    }
+
+    .message-content code {
+      background: rgba(0, 0, 0, 0.3);
+      padding: 3px 6px;
+      border-radius: 4px;
+      font-size: 0.9em;
+      font-family: 'Courier New', Courier, monospace;
+    }
+
+    .message-content pre {
+      background: rgba(0, 0, 0, 0.4);
+      padding: 16px;
+      border-radius: 8px;
+      overflow-x: auto;
+      margin: 12px 0;
+      border-left: 4px solid var(--accent);
+    }
+
+    .message-content blockquote {
+      border-left: 4px solid var(--accent);
+      padding-left: 16px;
+      margin: 12px 0;
+      font-style: italic;
+      opacity: 0.9;
+    }
+
+    .loading-message .message-content {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+    }
+
+    .typing-indicator {
+      display: flex;
+      gap: 5px;
+    }
+
+    .typing-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--accent);
+      animation: typing 1.4s infinite ease-in-out;
+    }
+
+    .typing-dot:nth-child(2) {
+      animation-delay: 0.2s;
+    }
+
+    .typing-dot:nth-child(3) {
+      animation-delay: 0.4s;
+    }
+
+    @keyframes typing {
+
+      0%,
+      80%,
+      100% {
+        transform: scale(0);
+      }
+
+      40% {
+        transform: scale(1.0);
+      }
+    }
+
+    .input-section {
+      position: absolute;
+      bottom: 0;
+      left: 0;
+      right: 0;
+      background: linear-gradient(to top, rgba(26, 26, 36, 1), rgba(26, 26, 36, 0.8));
+      padding: 24px;
+      padding-top: 16px;
+      border-top: 1px solid var(--border);
+      backdrop-filter: blur(10px);
+    }
+
+    .input-container {
+      background: var(--surface-light);
+      border-radius: 24px;
+      padding: 6px;
+      border: 1px solid var(--border);
+      transition: all 0.3s ease;
+    }
+
+    .input-container:focus-within {
+      border-color: var(--accent);
+      box-shadow: 0 0 0 3px rgba(96, 165, 250, 0.25);
+    }
+
+    .input-form {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+    }
+
+    #user-input {
+      flex: 1;
+      background: transparent;
+      border: none;
+      padding: 12px 16px;
+      color: var(--text);
+      font-size: 1rem;
+      outline: none;
+      resize: none;
+      min-height: 24px;
+      max-height: 120px;
+    }
+
+    #user-input::placeholder {
+      color: var(--text-muted);
+    }
+
+    .send-button {
+      background: var(--primary);
+      border: none;
+      border-radius: 18px;
+      width: 48px;
+      height: 48px;
+      color: white;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      flex-shrink: 0;
+    }
+
+    .send-button:hover:not(:disabled) {
+      transform: scale(1.05);
+      box-shadow: 0 8px 25px rgba(0, 90, 156, 0.4);
+    }
+
+    .send-button:disabled {
+      opacity: 0.6;
+      cursor: not-allowed;
+    }
+
+    .send-icon {
+      width: 20px;
+      height: 20px;
+      transition: transform 0.3s ease;
+    }
+
+    .send-button:hover:not(:disabled) .send-icon {
+      transform: rotate(45deg) scale(1.1);
+    }
+
+    footer {
+      padding: 12px 24px;
+      text-align: center;
+      font-size: 0.8rem;
+      color: var(--text-muted);
+      border-top: 1px solid var(--border);
+      background: var(--surface);
+      flex-shrink: 0;
+    }
+
+    .error-message {
+      background: linear-gradient(135deg, #b91c1c, #ef4444);
+      border-color: #fca5a5;
+    }
+
+    @media (max-width: 768px) {
+      body {
+        padding: 0;
+      }
+
+      .container {
+        height: 100vh;
+        max-height: 100vh;
+        border-radius: 0;
+        box-shadow: none;
+        border: none;
+      }
+
+      header h1 {
+        font-size: 1.3rem;
+      }
+
+      #chat-box {
+        padding: 16px;
+        padding-bottom: 120px;
+      }
+
+      .message-wrapper {
+        max-width: 90%;
+      }
+
+      .assistant-avatar {
+        width: 32px;
+        height: 32px;
+        font-size: 1.2rem;
+      }
+
+      .message {
+        padding: 12px 16px;
+      }
+
+      .input-section {
+        padding: 12px;
+      }
+
+      .input-container {
+        border-radius: 20px;
+      }
+
+      .send-button {
+        width: 44px;
+        height: 44px;
+      }
+    }
+  </style>
+</head>
+
+<body>
+  <div class="container">
+    <header>
+      <h1>🏛️ NPS Informational Assistant</h1>
+      <div class="status-indicator">
+        <div class="status-dot"></div>
+        <span>Online and ready to help</span>
+      </div>
+      <div class="mode-toggle-container">
+        <select id="language-select" class="language-select">
+          <option value="English">English</option>
+          <option value="Hindi">Hindi (हिंदी)</option>
+          <option value="Bengali">Bengali (বাংলা)</option>
+          <option value="Telugu">Telugu (తెలుగు)</option>
+          <option value="Marathi">Marathi (मराठी)</option>
+          <option value="Tamil">Tamil (தமிழ்)</option>
+          <option value="Urdu">Urdu (اردو)</option>
+          <option value="Gujarati">Gujarati (ગુજરાતી)</option>
+          <option value="Kannada">Kannada (ಕನ್ನಡ)</option>
+          <option value="Malayalam">Malayalam (മലയാളം)</option>
+          <option value="Odia">Odia (ଓଡ଼ିଆ)</option>
+          <option value="Punjabi">Punjabi (ਪੰਜਾਬੀ)</option>
+          <option value="Assamese">Assamese (অসমীয়া)</option>
+        </select>
+        <span class="mode-label">Chat</span>
+        <label class="switch">
+          <input type="checkbox" id="mode-toggle">
+          <span class="slider"></span>
+        </label>
+        <span class="mode-label">Agent</span>
+      </div>
+    </header>
+
+    <main class="chat-container">
+      <div id="chat-box">
+      </div>
+
+      <div class="input-section">
+        <div class="input-container">
+          <form class="input-form" id="question-form">
+            <textarea id="user-input" placeholder="Ask anything about NPS..." rows="1" autocomplete="off"
+              required></textarea>
+            <button type="submit" class="send-button" id="send-btn" aria-label="Send message">
+              <svg class="send-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"
+                stroke-linecap="round" stroke-linejoin="round">
+                <path d="M22 2L11 13" />
+                <path d="M22 2L15 22L11 13L2 9L22 2Z" />
+              </svg>
+            </button>
+          </form>
+        </div>
+      </div>
+    </main>
+
+    <footer>
+      <p>Powered by AI | <a href="/admin.html" style="color: var(--text-muted);">Admin</a></p>
+    </footer>
+  </div>
+
+  <script>
+
+
+    document.addEventListener('DOMContentLoaded', () => {
+      // Configuration for marked library
+      if (typeof marked !== 'undefined') {
+        marked.setOptions({
+          breaks: true,
+          gfm: true,
+          highlight: function (code, lang) {
+            if (typeof Prism !== 'undefined' && Prism.languages[lang]) {
+              return Prism.highlight(code, Prism.languages[lang], lang);
+            }
+            return code;
+          }
+        });
+      }
+
+      const API_BASE_URL = ''; // Keep empty to use the same origin
+      const chatBox = document.getElementById('chat-box');
+      const questionForm = document.getElementById('question-form');
+      const userInput = document.getElementById('user-input');
+      const sendBtn = document.getElementById('send-btn');
+      const modeToggle = document.getElementById('mode-toggle');
+      const languageSelect = document.getElementById('language-select');
+
+      userInput.addEventListener('input', function () {
+        this.style.height = 'auto';
+        this.style.height = Math.min(this.scrollHeight, 120) + 'px';
+      });
+
+      userInput.addEventListener('keydown', function (e) {
+        if (e.key === 'Enter' && !e.shiftKey) {
+          e.preventDefault();
+          sendBtn.click();
+        }
+      });
+
+      const addMessage = (content, sender, isError = false) => {
+        const wrapper = document.createElement('div');
+        wrapper.classList.add('message-wrapper', `${sender}-message-wrapper`);
+
+        let messageHTML = '';
+
+        if (sender === 'assistant') {
+          messageHTML += `<div class="assistant-avatar">🏛️</div>`;
+        }
+
+        const messageDiv = document.createElement('div');
+        messageDiv.classList.add('message', `${sender}-message`);
+        if (isError) {
+          messageDiv.classList.add('error-message');
+        }
+
+        const contentDiv = document.createElement('div');
+        contentDiv.classList.add('message-content');
+        // Safely handle marked parsing
+        if (sender === 'assistant' && typeof marked !== 'undefined') {
+          contentDiv.innerHTML = marked.parse(content);
+        } else {
+          contentDiv.textContent = content;
+        }
+
+        messageDiv.appendChild(contentDiv);
+
+        wrapper.innerHTML = messageHTML;
+        wrapper.appendChild(messageDiv);
+
+        chatBox.appendChild(wrapper);
+        chatBox.scrollTop = chatBox.scrollHeight;
+      };
+
+      const showLoadingIndicator = () => {
+        const wrapper = document.createElement('div');
+        wrapper.classList.add('message-wrapper', 'assistant-message-wrapper');
+        wrapper.id = 'loading-indicator';
+
+        wrapper.innerHTML = `
+          <div class="assistant-avatar">🏛️</div>
+          <div class="message assistant-message loading-message">
+            <div class="message-content">
+              <div class="typing-indicator">
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+              </div>
+            </div>
+          </div>
+        `;
+        chatBox.appendChild(wrapper);
+        chatBox.scrollTop = chatBox.scrollHeight;
+      };
+
+      const handleQuestionSubmit = async (event) => {
+        event.preventDefault();
+        const question = userInput.value.trim();
+        if (!question) return;
+
+        const mode = modeToggle.checked ? 'agent' : 'chat';
+        const language = languageSelect.value;
+
+        addMessage(question, 'user');
+        userInput.value = '';
+        userInput.style.height = 'auto';
+        sendBtn.disabled = true;
+
+        showLoadingIndicator();
+        const loadingIndicator = document.getElementById('loading-indicator');
+
+        try {
+          const response = await fetch(`${API_BASE_URL}/ask`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ question: question, mode: mode, language: language }),
+          });
+
+          if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(errorData.detail || 'An unknown server error occurred.');
+          }
+
+          const data = await response.json();
+          addMessage(data.answer, 'assistant');
+
+        } catch (error) {
+          console.error('Error:', error);
+          const errorMessage = `**Connection Error**\n\nI'm having trouble connecting to my knowledge base. Please try again in a moment.\n\n*(Error: ${error.message})*`;
+          addMessage(errorMessage, 'assistant', true);
+        } finally {
+          if (loadingIndicator) {
+            loadingIndicator.remove();
+          }
+          sendBtn.disabled = false;
+          userInput.focus();
+        }
+      };
+
+      const displayWelcomeMessage = () => {
+        const welcomeText = `👋 Hello! I'm your NPS Assistant. I can help with questions about:\n\n- **Registration & Account Opening**\n- **Contributions & Tax Benefits**\n- **Investment Choices & Asset Classes**\n- **Exit, Withdrawal & Annuity**\n\n## 📋 Chat Guidelines\n\n✅ **Do's:**\n- Ask specifically about NPS rules and regulations\n- Inquire about processes for different sectors (Govt, Corporate, All Citizens)\n\n❌ **Don'ts:**\n- Share personal financial details (PRAN, Passwords)\n\nHow can I assist you with your National Pension System queries today?`;
+        addMessage(welcomeText, 'assistant');
+      };
+
+      questionForm.addEventListener('submit', handleQuestionSubmit);
+      displayWelcomeMessage();
+      userInput.focus();
+    });
+  </script>
+</body>
+
+</html>

mistral.py

@@ -0,0 +1,517 @@
+import os, logging
+import glob
+import logging
+import re
+import hashlib
+import numpy as np
+import asyncio
+from typing import List, Optional, Any
+import shutil
+import secrets
+
+# --- Pydantic & FastAPI ---
+from pydantic import BaseModel, Field
+import uvicorn
+from fastapi import FastAPI, HTTPException, APIRouter, UploadFile, File, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.security import HTTPBasic, HTTPBasicCredentials
+
+# --- LangChain & RAG Core ---
+from PyPDF2 import PdfReader
+
+try:
+    from docx import Document as DocxDocument
+except ImportError:
+    DocxDocument = None
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.retrievers import EnsembleRetriever
+from langchain.chains.combine_documents import (
+    create_stuff_documents_chain,
+)  # <-- DEPRECATION FIX
+from langchain.chains import create_retrieval_chain
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.llms.base import LLM
+from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+from langchain.docstore.document import Document
+from langchain_core.retrievers import BaseRetriever
+from langchain.prompts import PromptTemplate
+
+# --- Scikit-Learn for TF-IDF ---
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# --- TruLens for Evaluation ---
+# from trulens_eval import Feedback, Tru, TruChain
+# from trulens_eval.feedback.provider import LiteLLM
+
+# tru = Tru()
+
+# --- Mistral AI ---
+from mistralai import Mistral as MistralClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# --- Global Variables & Configuration ---
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Define the original, read-only data folder from the repo
+REPO_DATA_FOLDER = "data"
+
+# Use persistent storage if available (on Hugging Face Spaces)
+if os.path.exists("/data"):
+    logger.info("Persistent storage '/data' found. Using it for PDFs and cache.")
+    DATA_FOLDER = "/data/pdf_storage"
+    CACHE_DIR = "/data/cache"
+else:
+    logger.info(
+        "No persistent storage '/data' found. Using local 'data' folder and '/tmp/cache'."
+    )
+    DATA_FOLDER = REPO_DATA_FOLDER
+    CACHE_DIR = "/tmp/cache"
+
+os.makedirs(DATA_FOLDER, exist_ok=True)
+os.makedirs(CACHE_DIR, exist_ok=True)
+retrieval_chain = None
+
+HF_CACHE = "/tmp/hf"
+os.environ["HF_HOME"] = HF_CACHE
+os.environ["HF_HOME"] = HF_CACHE
+os.environ["HF_DATASETS_CACHE"] = HF_CACHE
+os.environ["HF_MODULES_CACHE"] = HF_CACHE
+
+retrieval_chain = None
+
+db_path = "/data/default.sqlite" if os.path.exists("/data") else "default.sqlite"
+
+# ✅ Only run the dashboard locally (not in Hugging Face Spaces)
+if os.environ.get("SPACE_ID") is None:
+    # tru.run_dashboard()
+    pass
+
+
+# --- Pydantic Models ---
+class QuestionRequest(BaseModel):
+    question: str = Field(..., min_length=1)
+
+
+class AnswerResponse(BaseModel):
+    answer: str
+    sources: List[str]
+
+
+# --- Greeting Handler ---
+GREETING_RESPONSES = {
+    "hi": "Hello! How can I assist you?",
+    "hello": "Hello! How can I help you today?",
+    "bye": "Bye-bye! See you soon.",
+    "ty": "Your Welcome!",
+}
+
+# --- Enhanced Prompt ---
+UNIVERSITY_ASSISTANT_PROMPT = PromptTemplate.from_template(
+    """
+You are a meticulous Guru Nanak Dev University Academic Assistant.
+Your task is to provide accurate, specific, and concise answers based ONLY on the provided Context.
+**Instructions:**
+1.  **Analyze the Context:** Carefully read the user's question and the provided context to synthesize an answer.
+2.  **Extract Specifics:** If asked for a fee, number, or date, provide the EXACT information.
+3.  **Cite Sources:** After your answer, cite the source document and page number: `(Source: Prospectus.pdf, Page: 15)`.
+4.  **Handle Missing Information:** If the info is not in the context, state: "Based on the provided documents, I could not find specific information about this topic."
+---
+**Context:**
+{context}
+---
+**Question:**
+{input}
+**Answer (with citations):**
+"""
+)
+
+
+# --- Custom Scikit-Learn TF-IDF Retriever ---
+class ScikitLearnTfidfRetriever(BaseRetriever):
+    docs: List[Document]
+    tfidf_vectorizer: TfidfVectorizer
+    tfidf_matrix: Any
+    k: int = 15
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def _get_relevant_documents(self, query: str) -> List[Document]:
+        query_vector = self.tfidf_vectorizer.transform([query])
+        similarity_scores = cosine_similarity(query_vector, self.tfidf_matrix).flatten()
+        top_k_indices = np.argsort(similarity_scores)[-self.k :][::-1]
+        return [self.docs[i] for i in top_k_indices]
+
+
+# --- MistralLLM Class ---
+class MistralLLM(LLM):
+    client: Any = None
+    model: str = "mistral-small-latest"
+    temperature: float = 0.0
+    api_key: str = ""
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str = "mistral-small-latest",
+        temperature: float = 0.0,
+    ):
+        super().__init__()
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.client = MistralClient(api_key=self.api_key)
+
+    @property
+    def _llm_type(self) -> str:
+        return "mistral"
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        messages = [{"role": "user", "content": prompt}]
+        response = self.client.chat.complete(
+            model=self.model, messages=messages, temperature=self.temperature
+        )
+        return response.choices[0].message.content.strip()
+
+
+# --- Caching and Data Processing Functions ---
+def get_data_hash(folder_path=DATA_FOLDER) -> str:
+    """Generates a hash based on the filenames and modification times of supported files."""
+    hasher = hashlib.md5()
+    if not os.path.exists(folder_path):
+        return "no_data"
+
+    supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+    files_to_hash = []
+    for ext in supported_extensions:
+        files_to_hash.extend(glob.glob(os.path.join(folder_path, f"*{ext}")))
+
+    for file_path in sorted(files_to_hash):
+        try:
+            stat = os.stat(file_path)
+            file_info = f"{os.path.basename(file_path)}-{stat.st_mtime}-{stat.st_size}"
+            hasher.update(file_info.encode("utf-8"))
+        except FileNotFoundError:
+            continue  # File might have been deleted during the process
+
+    return hasher.hexdigest()
+
+
+def get_documents_from_files(folder_path=DATA_FOLDER) -> List[Document]:
+    docs = []
+    supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+
+    for file_path in glob.glob(os.path.join(folder_path, "*")):
+        file_name = os.path.basename(file_path)
+        file_ext = os.path.splitext(file_name)[1].lower()
+
+        if file_ext not in supported_extensions:
+            continue
+
+        if file_ext == ".pdf":
+            pdf_reader = PdfReader(file_path)
+            for i, page in enumerate(pdf_reader.pages):
+                text = page.extract_text() or ""
+                docs.append(
+                    Document(
+                        page_content=text, metadata={"source": file_name, "page": i + 1}
+                    )
+                )
+        elif file_ext in [".txt", ".md"]:
+            with open(file_path, "r", encoding="utf-8") as f:
+                text = f.read()
+                docs.append(
+                    Document(
+                        page_content=text, metadata={"source": file_name, "page": 1}
+                    )
+                )
+        elif file_ext == ".docx":
+            if DocxDocument is None:
+                logger.warning(
+                    "Skipping .docx file because 'python-docx' is not installed. Please install it with 'pip install python-docx'."
+                )
+                continue
+            try:
+                doc = DocxDocument(file_path)
+                text = "\n".join([para.text for para in doc.paragraphs])
+                docs.append(
+                    Document(
+                        page_content=text, metadata={"source": file_name, "page": 1}
+                    )
+                )
+            except Exception as e:
+                logger.error(f"Error processing .docx file {file_name}: {e}")
+
+    return docs
+
+
+async def initialize_rag_system():
+    global retrieval_chain
+    logger.info("🚀 Initializing RAG system...")
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    data_hash = get_data_hash()
+    cache_path = os.path.join(CACHE_DIR, f"vectorstore_{data_hash}.faiss")
+
+    embeddings = HuggingFaceEmbeddings(
+        model_name="BAAI/bge-base-en-v1.5",
+        model_kwargs={"device": "cpu"},
+        encode_kwargs={"normalize_embeddings": True},
+    )
+
+    if os.path.exists(cache_path):
+        logger.info(f"✅ Loading vector store from cache: {cache_path}")
+        vectorstore = FAISS.load_local(
+            cache_path, embeddings, allow_dangerous_deserialization=True
+        )
+        documents = get_documents_from_files()
+        text_chunks = RecursiveCharacterTextSplitter(
+            chunk_size=1000, chunk_overlap=150
+        ).split_documents(documents)
+    else:
+        logger.warning(
+            "No cache found or data has changed. Building new vector store..."
+        )
+        documents = get_documents_from_files()
+        if not documents:
+            logger.warning(
+                "No documents found in /data folder. RAG system will be inactive."
+            )
+            retrieval_chain = None  # Ensure chain is None
+            return
+
+        text_chunks = RecursiveCharacterTextSplitter(
+            chunk_size=1000, chunk_overlap=150
+        ).split_documents(documents)
+
+        logger.info(
+            f"Embedding {len(text_chunks)} chunks... (This will be slow on the first run)"
+        )
+        vectorstore = FAISS.from_documents(documents=text_chunks, embedding=embeddings)
+
+        logger.info(f"💾 Saving new vector store to cache: {cache_path}")
+        vectorstore.save_local(cache_path)
+
+    # --- Chain Setup ---
+    mistral_api_key = os.getenv("MISTRAL_API_KEY")
+    if not mistral_api_key:
+        raise ValueError("MISTRAL_API_KEY not found")
+
+    llm = MistralLLM(api_key=mistral_api_key)
+
+    # --- DEPRECATION FIX: Use create_stuff_documents_chain ---
+    question_answer_chain = create_stuff_documents_chain(
+        llm, UNIVERSITY_ASSISTANT_PROMPT
+    )
+
+    faiss_retriever = vectorstore.as_retriever(
+        search_type="similarity", search_kwargs={"k": 15}
+    )
+
+    tfidf_vectorizer = TfidfVectorizer(stop_words="english")
+
+    # Ensure text_chunks is not empty before fitting
+    if not text_chunks:
+        logger.warning("No text chunks to process for TF-IDF.")
+        # Handle case with no documents gracefully
+        tfidf_retriever = ScikitLearnTfidfRetriever(
+            docs=[],
+            tfidf_vectorizer=tfidf_vectorizer,  # an empty vectorizer
+            tfidf_matrix=tfidf_vectorizer.fit_transform([]),  # an empty matrix
+            k=15,
+        )
+    else:
+        tfidf_matrix = tfidf_vectorizer.fit_transform(
+            [doc.page_content for doc in text_chunks]
+        )
+        tfidf_retriever = ScikitLearnTfidfRetriever(
+            docs=text_chunks,
+            tfidf_vectorizer=tfidf_vectorizer,
+            tfidf_matrix=tfidf_matrix,
+            k=15,
+        )
+
+    ensemble_retriever = EnsembleRetriever(
+        retrievers=[tfidf_retriever, faiss_retriever], weights=[0.5, 0.5]
+    )
+
+    # Create the final retrieval chain that combines the retriever and the QA chain
+    retrieval_chain = create_retrieval_chain(ensemble_retriever, question_answer_chain)
+
+    logger.info("✅ RAG system initialized successfully.")
+
+
+def extract_sources_from_docs(docs: List[Document]) -> List[str]:
+    """Extracts unique source and page numbers from a list of documents."""
+    return sorted(
+        list(
+            set(
+                f"({doc.metadata.get('source', 'N/A')}, Page: {doc.metadata.get('page', 'N/A')})"
+                for doc in docs
+            )
+        )
+    )
+
+
+# --- FastAPI Application ---
+app = FastAPI(title="GNDU Assistant (Cached)", version="4.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+security = HTTPBasic()
+
+
+def get_current_username(credentials: HTTPBasicCredentials = Depends(security)):
+    correct_username = secrets.compare_digest(
+        credentials.username, os.environ.get("ADMIN_USERNAME", "admin")
+    )
+    correct_password = secrets.compare_digest(
+        credentials.password, os.environ.get("ADMIN_PASSWORD", "password")
+    )
+    if not (correct_username and correct_password):
+        raise HTTPException(
+            status_code=401,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Basic"},
+        )
+    return credentials.username
+
+
+@app.on_event("startup")
+async def startup_event():
+    # On Hugging Face, copy initial files from the read-only repo folder to persistent storage
+    if DATA_FOLDER != REPO_DATA_FOLDER and os.path.exists(REPO_DATA_FOLDER):
+        supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+        # Check if the destination is empty of supported files before copying
+        if not any(
+            any(f.endswith(ext) for ext in supported_extensions)
+            for f in os.listdir(DATA_FOLDER)
+        ):
+            logger.info(
+                f"Copying initial files from '{REPO_DATA_FOLDER}' to '{DATA_FOLDER}'..."
+            )
+            for filename in os.listdir(REPO_DATA_FOLDER):
+                if any(filename.endswith(ext) for ext in supported_extensions):
+                    src_path = os.path.join(REPO_DATA_FOLDER, filename)
+                    dest_path = os.path.join(DATA_FOLDER, filename)
+                    if not os.path.exists(dest_path):
+                        shutil.copy(src_path, dest_path)
+
+    await initialize_rag_system()
+
+
+admin_router = APIRouter()
+
+
+@admin_router.get("/files")
+async def get_files(_: str = Depends(get_current_username)):
+    """Lists all supported files in the data directory."""
+    if not os.path.exists(DATA_FOLDER):
+        return []
+    supported_extensions = [".pdf", ".txt", ".md", ".docx"]
+    files = sorted(
+        [
+            f
+            for f in os.listdir(DATA_FOLDER)
+            if any(f.endswith(ext) for ext in supported_extensions)
+        ]
+    )
+    return files
+
+
+@admin_router.post("/files")
+async def upload_file(
+    file: UploadFile = File(...), _: str = Depends(get_current_username)
+):
+    """Uploads a new PDF file."""
+    file_path = os.path.join(DATA_FOLDER, file.filename)
+    if os.path.exists(file_path):
+        raise HTTPException(
+            status_code=409, detail="File with this name already exists."
+        )
+
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    finally:
+        file.file.close()
+
+    await initialize_rag_system()
+
+    return {"filename": file.filename}
+
+
+@admin_router.delete("/files/{filename}")
+async def delete_file(filename: str, _: str = Depends(get_current_username)):
+    """Deletes a PDF file."""
+    # Basic security check
+    if ".." in filename:
+        raise HTTPException(status_code=400, detail="Invalid filename.")
+
+    file_path = os.path.join(DATA_FOLDER, filename)
+
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found.")
+
+    os.remove(file_path)
+
+    await initialize_rag_system()
+
+    return {"message": f"File '{filename}' deleted successfully."}
+
+
+app.include_router(admin_router, prefix="/admin")
+
+
+@app.post("/ask", response_model=AnswerResponse)
+async def ask_question(request: QuestionRequest):
+    normalized_question = request.question.strip().lower()
+    if normalized_question in GREETING_RESPONSES:
+        return AnswerResponse(
+            answer=GREETING_RESPONSES[normalized_question],
+            sources=["Conversational Greeting"],
+        )
+
+    if not retrieval_chain:
+        raise HTTPException(
+            status_code=503,
+            detail="RAG system is not initialized. Please add PDF files to the /data folder and restart.",
+        )
+
+    try:
+        # The new chain structure returns a dictionary with 'answer' and 'context'
+        result = await retrieval_chain.ainvoke({"input": request.question})
+
+        answer = result.get("answer", "No answer could be generated.")
+        sources = extract_sources_from_docs(result.get("context", []))
+
+        return AnswerResponse(answer=answer, sources=sources)
+
+    except Exception as e:
+        logger.error(f"Error during RAG chain invocation: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+app.mount("/", StaticFiles(directory="frontend", html=True), name="static")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

nps_agent.py

@@ -0,0 +1,473 @@
+import asyncio
+import os
+import json
+import logging
+import sys
+from typing import Any, Optional
+from dotenv import load_dotenv
+from pathlib import Path
+
+# Ensure we can import nanobot if installed in venv
+from playwright.async_api import async_playwright, BrowserContext, Page, Browser
+
+try:
+    from nanobot.agent.loop import AgentLoop
+    from nanobot.agent.tools.base import Tool
+    from nanobot.bus.queue import MessageBus
+    from nanobot.providers.litellm_provider import LiteLLMProvider
+    from nanobot.config.schema import ExecToolConfig
+except ImportError:
+    print("Error: 'nanobot' not found. Please install 'nanobot-ai'.")
+    # We don't exit here so it can be imported safely, but it will likely fail on run
+    pass
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger("nps_nanobot")
+
+class PlaywrightTool(Tool):
+    """
+    A tool to control a web browser using Playwright.
+    Supports navigation, clicking, typing, and extracting text.
+    """
+    name = "browser"
+    description = (
+        "Control a web browser to navigate, interact, and extract information. "
+        "Use this tool to visit websites, click elements, fill forms, and read content."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["navigate", "click", "type", "press", "scroll", "get_text", "get_links", "get_dom", "screenshot"],
+                "description": "The action to perform."
+            },
+            "url": {"type": "string", "description": "URL to navigate to (required for 'navigate')"},
+            "selector": {"type": "string", "description": "CSS selector or text to interact with (required for 'click', 'type', 'get_text')"},
+            "text": {"type": "string", "description": "Text to type (required for 'type')"},
+            "key": {"type": "string", "description": "Key to press (required for 'press', e.g., 'Enter')"},
+            "direction": {"type": "string", "enum": ["up", "down"], "description": "Scroll direction (required for 'scroll')"},
+            "amount": {"type": "integer", "description": "Scroll amount in pixels (optional for 'scroll')"},
+        },
+        "required": ["action"]
+    }
+
+    def __init__(self):
+        self._playwright = None
+        self._browser = None
+        self._context: Optional[BrowserContext] = None
+        self._page: Optional[Page] = None
+        self._initialized = False
+
+    async def _ensure_initialized(self):
+        if not self._initialized:
+            self._playwright = await async_playwright().start()
+            # Launch with anti-detection args
+            self._browser = await self._playwright.chromium.launch(
+                headless=False,
+                args=[
+                    "--no-sandbox",
+                    "--disable-blink-features=AutomationControlled",
+                    "--disable-infobars"
+                ],
+                ignore_default_args=["--enable-automation"]
+            )
+            self._context = await self._browser.new_context(
+                viewport={"width": 1280, "height": 720},
+                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            )
+            self._page = await self._context.new_page()
+            self._page.set_default_timeout(15000) # 15s timeout
+            
+            # Auto-handle native dialogs
+            self._page.on("dialog", lambda dialog: dialog.accept())
+            
+            self._initialized = True
+            logger.info("Playwright browser initialized")
+
+    async def _handle_popups(self):
+        """Try to dismiss common cookie banners and popups."""
+        try:
+            # Common patterns for dismissal
+            patterns = [
+                "text=Accept", "text=Agree", "text=Allow", 
+                "text=Reject", "text=Close", "text=No thanks", 
+                "text=Not now", "text=OK", "text=I understand",
+                "button[aria-label='Close']", ".close-button",
+                "#dismiss-button", "div[aria-label='Close ad']",
+                ".ri-close-line", ".close-icon"
+            ]
+            for selector in patterns:
+                try:
+                    # Check if visible and click. fast timeout.
+                    elem = await self._page.query_selector(selector)
+                    if elem and await elem.is_visible():
+                        await elem.click(timeout=500)
+                        logger.info(f"Dismissed popup using {selector}")
+                        await asyncio.sleep(0.5) # Wait for animation
+                except Exception:
+                    pass
+        except Exception as e:
+            logger.warning(f"Popup dismissal error: {e}")
+
+    async def execute(self, action: str, **kwargs: Any) -> str:
+        try:
+            await self._ensure_initialized()
+            page = self._page
+            
+            if action == "navigate":
+                url = kwargs.get("url")
+                if not url: return "Error: 'url' is required for navigate"
+                if not url.startswith("http"): url = "https://" + url
+                try:
+                    await page.goto(url, timeout=20000)
+                    await page.wait_for_load_state("domcontentloaded", timeout=10000)
+                    # Attempt to clean up view
+                    await self._handle_popups()
+                except Exception as e:
+                    # Ignore timeout and assume page loaded partially
+                    logger.warning(f"Navigation to {url} timed out: {e}")
+                    await self._handle_popups() # Try finding popups even if timed out
+                    return f"Navigated to {url}, but timed out waiting for full load. Content might be available."
+                
+                title = await page.title()
+                return f"Navigated to {url}. Page title: {title}"
+
+            elif action == "click":
+                selector = kwargs.get("selector")
+                if not selector: return "Error: 'selector' is required for click"
+                # specialized selector handling: try text if loose selector
+                try:
+                    # If it looks like "link: <text>", extract
+                    if selector.startswith("link: "):
+                        selector = f"text={selector[6:]}"
+                    await page.click(selector, timeout=5000)
+                except Exception:
+                    # Fallback to text match
+                    await page.click(f"text={selector}")
+                return f"Clicked element: {selector}"
+
+            elif action == "type":
+                selector = kwargs.get("selector")
+                text = kwargs.get("text")
+                if not selector or text is None: return "Error: 'selector' and 'text' are required for type"
+                await page.fill(selector, text)
+                return f"Typed '{text}' into {selector}"
+
+            elif action == "press":
+                key = kwargs.get("key")
+                if not key: return "Error: 'key' is required for press"
+                await page.keyboard.press(key)
+                return f"Pressed key: {key}"
+
+            elif action == "scroll":
+                direction = kwargs.get("direction", "down")
+                amount = kwargs.get("amount", 500)
+                if direction == "down":
+                    await page.evaluate(f"window.scrollBy(0, {amount})")
+                else:
+                    await page.evaluate(f"window.scrollBy(0, -{amount})")
+                return f"Scrolled {direction} by {amount} pixels"
+
+            elif action == "get_text":
+                selector = kwargs.get("selector", "body")
+                if selector == "body":
+                    # Smart extraction: get text but also hints of links
+                    # We'll stick to text for this action to keep it simple, 
+                    # but maybe use Readability if we had it. For now, innerText is fine.
+                    content = await page.evaluate("document.body.innerText")
+                    return content[:4000] + "... (truncated)"
+                else:
+                    element = await page.query_selector(selector)
+                    if element:
+                        text = await element.inner_text()
+                        return text
+                    return f"Element not found: {selector}"
+            
+            elif action == "get_links":
+                # new action to find clickable links
+                links = await page.evaluate("""() => {
+                    const params = [];
+                    document.querySelectorAll('a').forEach(a => {
+                        if (a.innerText.trim().length > 3 && a.offsetParent !== null) {
+                            params.push({text: a.innerText.trim().slice(0, 50), href: a.href});
+                        }
+                    });
+                    return params.slice(0, 20); // Top 20 relevant links
+                }""")
+                return json.dumps(links, indent=2)
+
+            elif action == "get_dom":
+                # Simplified interactive DOM tree for buttons and inputs
+                dom = await page.evaluate("""() => {
+                    const params = [];
+                    const elements = document.querySelectorAll('button, input, select, textarea, [role="button"]');
+                    elements.forEach(el => {
+                        if (el.offsetParent !== null) { // visible
+                            let label = el.innerText || el.placeholder || el.getAttribute('aria-label') || el.name || el.id || el.value;
+                            label = label ? label.trim().slice(0, 50) : '[No Label]';
+                            const tag = el.tagName.toLowerCase();
+                            params.push(`${tag}: ${label}`);
+                        }
+                    });
+                    return params.slice(0, 50).join('\\n'); // Top 50 interactive elements
+                }""")
+                return dom if dom else "No interactive elements found."
+
+            elif action == "screenshot":
+                path = "screenshot.png"
+                await page.screenshot(path=path)
+                return f"Screenshot saved to {path}"
+
+            else:
+                return f"Unknown action: {action}"
+
+        except Exception as e:
+            logger.error(f"Playwright error: {e}")
+            return f"Error executing {action}: {str(e)}"
+
+    async def close(self):
+        if self._browser:
+            await self._browser.close()
+        if self._playwright:
+            await self._playwright.stop()
+
+
+async def run_nps_task(task: str) -> str:
+    """
+    Executes a task using the NPS Nanobot Agent.
+    
+    Args:
+        task: The natural language task description.
+        
+    Returns:
+        The result of the task execution.
+    """
+    print("\n" + "="*60)
+    print("🐈  NPS OPERATIONAL AGENT (Nanobot + Playwright + Ollama)")
+    print("="*60)
+
+    # Initialize bus
+    bus = MessageBus()
+    
+    # Configure LiteLLM for Hugging Face Inference API
+    # Using 'huggingface/model_name' tells LiteLLM to use the HF provider
+    
+    model_name = "huggingface/Qwen/Qwen2.5-72B-Instruct"
+    
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        logger.warning("HF_TOKEN not found in environment variables. Agent may fail if not authenticated.")
+
+    # Initialize standard LiteLLM provider for Hugging Face
+    class HFProvider(LiteLLMProvider):
+        async def chat(self, messages, tools=None, model=None, max_tokens=4096, temperature=0.7):
+            model = model or self.default_model
+            
+            kwargs = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                # "api_base": "https://api-inference.huggingface.co/models/", # LiteLLM handles this default
+            }
+            if tools:
+                kwargs["tools"] = tools
+                kwargs["tool_choice"] = "auto"
+                
+            # Retry loop for empty responses
+            max_retries = 5
+            for attempt in range(max_retries):
+                try:
+                    # Import litellm here to ensure it's available
+                    from litellm import acompletion
+                    from nanobot.providers.base import LLMResponse, ToolCallRequest
+                    import json
+                    
+                    # Ensure HF_TOKEN is used
+                    os.environ["HUGGINGFACE_API_KEY"] = os.getenv("HF_TOKEN", "")
+
+                    response = await acompletion(**kwargs)
+                    
+                    # Standard parsing
+                    llm_response = self._parse_response(response)
+                    
+                    # Fallback: if no tool calls but content looks like JSON tool call, parse it
+                    if not llm_response.tool_calls and llm_response.content:
+                        import re
+                        content = llm_response.content.strip()
+                        # Regex to find JSON array or object
+                        json_match = re.search(r'(\[.*\]|\{.*\})', content, re.DOTALL)
+                        
+                        if json_match:
+                            try:
+                                json_str = json_match.group(1)
+                                try:
+                                    data = json.loads(json_str)
+                                except json.JSONDecodeError:
+                                    # Try parsing as NDJSON (multiple objects, one per line)
+                                    data = []
+                                    for line in json_str.splitlines():
+                                        line = line.strip()
+                                        if line:
+                                            try:
+                                                obj = json.loads(line)
+                                                data.append(obj)
+                                            except json.JSONDecodeError:
+                                                pass
+                                    if not data: raise
+                                
+                                tool_calls = []
+                                # Handle list of calls
+                                if isinstance(data, list):
+                                    for item in data:
+                                        if isinstance(item, dict) and "name" in item and "arguments" in item:  # Check simplified structure
+                                            args = item["arguments"]
+                                            if isinstance(args, str):
+                                                try:
+                                                    args = json.loads(args)
+                                                except:
+                                                    pass
+                                                
+                                            import uuid
+                                            tool_calls.append(ToolCallRequest(
+                                                id=f"call_{uuid.uuid4().hex[:8]}",
+                                                name=item["name"],
+                                                arguments=args
+                                            ))
+                                        elif isinstance(item, dict) and "type" in item and item["type"] == "function": # Standard format
+                                            func = item["function"]
+                                            args = func["arguments"]
+                                            if isinstance(args, str):
+                                                try:
+                                                    args = json.loads(args)
+                                                except:
+                                                    pass
+                                            
+                                            import uuid
+                                            tool_calls.append(ToolCallRequest(
+                                                id=item.get("id", f"call_{uuid.uuid4().hex[:8]}"),
+                                                name=func["name"],
+                                                arguments=args
+                                            ))
+
+                                # Handle single object call
+                                elif isinstance(data, dict):
+                                    if "name" in data and "arguments" in data:
+                                        args = data["arguments"]
+                                        if isinstance(args, str):
+                                            try:
+                                                args = json.loads(args)
+                                            except:
+                                                pass
+                                        import uuid
+                                        tool_calls.append(ToolCallRequest(
+                                            id=f"call_{uuid.uuid4().hex[:8]}",
+                                            name=data["name"],
+                                            arguments=args
+                                        ))
+
+                                if tool_calls:
+                                    llm_response.tool_calls = tool_calls
+                                    llm_response.content = None # specific for tool use
+                                    llm_response.finish_reason = "tool_calls"
+                                    
+                            except Exception as e:
+                                logger.warning(f"Failed to parse JSON tool call fallback: {e}")
+                    
+                    return llm_response
+
+                except Exception as e:
+                    if attempt == max_retries - 1:
+                        from nanobot.providers.base import LLMResponse
+                        return LLMResponse(content=f"Error calling LLM after {max_retries} attempts: {str(e)}", finish_reason="error")
+                    logger.warning(f"LLM call failed (attempt {attempt+1}/{max_retries}): {e}")
+            
+            return LLMResponse(content="Error: Max retries exceeded", finish_reason="error")
+
+    provider = HFProvider(
+        default_model=model_name,
+        api_key=hf_token
+    )
+
+    # Initialize Agent Loop
+    # We use current directory as workspace
+    workspace_path = Path(os.getcwd())
+
+    # Clear memory to ensure fresh start
+    memory_path = workspace_path / "memory"
+    if memory_path.exists():
+        import shutil
+        try:
+            shutil.rmtree(memory_path)
+            print("INFO: Cleared previous agent memory.")
+        except Exception as e:
+            print(f"WARN: Could not clear memory: {e}")
+
+    agent = AgentLoop(
+        bus=bus,
+        provider=provider,
+        workspace=workspace_path,
+        model=model_name,
+        max_iterations=15,
+    )
+
+    # Register our custom Playwright tool
+    playwright_tool = PlaywrightTool()
+    agent.tools.register(playwright_tool)
+
+    print(f"\nINFO: Agent initialized with model: {model_name}")
+    print("INFO: Browser tool (Playwright) registered")
+
+    try:
+        if not task:
+            return "❌ No task provided."
+
+        print(f"\n🚀 Starting task: {task}")
+        
+        # Append strong instruction to the task
+        system_instruction = (
+             "\n\nIMPORTANT INSTRUCTIONS:"
+             "\n1. You are an autonomous browser agent. You MUST USE TOOLS to perform actions."
+             "\n2. DO NOT narrate what you are going to do (e.g., 'I will click...'). JUST CALL THE TOOL."
+             "\n3. If the task is not complete, your response MUST contain a tool call."
+             "\n4. Only output text when you have fully completed the user's request and have the answer."
+             "\n5. Start by navigating: browser(action='navigate', ...)."
+             "\n6. Use 'get_links' to find clickable items."
+             "\n7. Use 'get_dom' to find buttons and inputs on interactive pages."
+             "\n8. If you see popups, 'OK' dialogs, or cookie banners that block you, click them to dismiss."
+        )
+        full_task = task + system_instruction
+        
+        # Use a unique session ID for each task execution to prevent history leakage
+        import uuid
+        session_id = f"task_{uuid.uuid4().hex[:8]}"
+        
+        # Run the agent with a unique session key
+        response = await agent.process_direct(
+            full_task,
+            session_key=f"cli:{session_id}",
+            channel="cli",
+            chat_id=session_id
+        )
+        
+        print("\n" + "="*60)
+        print("✅ TASK COMPLETED")
+        print("="*60)
+        return response
+
+    except KeyboardInterrupt:
+        return "Task interrupted by user."
+    finally:
+        # Cleanup
+        await playwright_tool.close()
+        agent.stop()
+
+if __name__ == "__main__":
+    # Test block
+    task = input("Enter test task: ")
+    asyncio.run(run_nps_task(task))

requirements.txt

@@ -0,0 +1,20 @@
+fastapi>=0.100.0
+uvicorn>=0.23.0
+python-multipart>=0.0.6
+jinja2>=3.1.2
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+mistralai>=0.0.12
+scikit-learn>=1.3.0
+pypdf2>=3.0.0
+langchain>=0.1.0
+langchain-community>=0.0.10
+langchain-huggingface>=0.0.1
+sentence-transformers>=2.2.2
+faiss-cpu>=1.7.4
+python-docx>=0.8.11
+langchain-text-splitters
+nanobot-ai
+playwright
+huggingface_hub
+litellm