HF push again

multi_doc_chat/config/config.yaml

@@ -1,23 +0,0 @@
-embedding_model:
-  provider: "google"
-  model_name: "models/text-embedding-004"
-
-retriever:
-  top_k: 10
-  search_type: "mmr"  # Options: "similarity", "mmr", "similarity_score_threshold"
-  # MMR (Maximal Marginal Relevance) parameters for diverse results
-  fetch_k: 20  # Number of documents to fetch before MMR re-ranking (should be > top_k)
-  lambda_mult: 0.5  # Diversity vs relevance (0=max diversity, 1=max relevance)
-
-llm:
-  groq:
-    provider: "groq"
-    model_name: "openai/gpt-oss-20b"
-    temperature: 0
-    max_output_tokens: 2048
-
-  google:
-    provider: "google"
-    model_name: "gemini-2.0-flash"
-    temperature: 0
-    max_output_tokens: 2048

multi_doc_chat/exception/custom_exception.py

@@ -1,53 +0,0 @@
-import sys
-import traceback
-from typing import Optional, cast
-
-
-class DocumentPortalException(Exception):
-    def __init__(self, error_message, error_details: Optional[object] = None):
-        # Normalize message
-        if isinstance(error_message, BaseException):
-            norm_msg = str(error_message)
-        else:
-            norm_msg = str(error_message)
-
-        # Resolve exc_info (supports: sys module, Exception object, or current context)
-        exc_type = exc_value = exc_tb = None
-        if error_details is None:
-            exc_type, exc_value, exc_tb = sys.exc_info()
-        else:
-            if hasattr(error_details, "exc_info"):  # e.g., sys
-                #exc_type, exc_value, exc_tb = error_details.exc_info()
-                exc_info_obj = cast(sys, error_details)
-                exc_type, exc_value, exc_tb = exc_info_obj.exc_info()
-            elif isinstance(error_details, BaseException):
-                exc_type, exc_value, exc_tb = type(error_details), error_details, error_details.__traceback__
-            else:
-                exc_type, exc_value, exc_tb = sys.exc_info()
-
-        # Walk to the last frame to report the most relevant location
-        last_tb = exc_tb
-        while last_tb and last_tb.tb_next:
-            last_tb = last_tb.tb_next
-
-        self.file_name = last_tb.tb_frame.f_code.co_filename if last_tb else "<unknown>"
-        self.lineno = last_tb.tb_lineno if last_tb else -1
-        self.error_message = norm_msg
-
-        # Full pretty traceback (if available)
-        if exc_type and exc_tb:
-            self.traceback_str = ''.join(traceback.format_exception(exc_type, exc_value, exc_tb))
-        else:
-            self.traceback_str = ""
-
-        super().__init__(self.__str__())
-
-    def __str__(self):
-        # Compact, logger-friendly message (no leading spaces)
-        base = f"Error in [{self.file_name}] at line [{self.lineno}] | Message: {self.error_message}"
-        if self.traceback_str:
-            return f"{base}\nTraceback:\n{self.traceback_str}"
-        return base
-
-    def __repr__(self):
-        return f"DocumentPortalException(file={self.file_name!r}, line={self.lineno}, message={self.error_message!r})"

multi_doc_chat/model/models.py

@@ -1,29 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Annotated
-from enum import Enum
-
-
-
-class ChatAnswer(BaseModel):
-    """Validate chat answer type and length."""
-    answer: Annotated[str, Field(min_length=1, max_length=4096)]
-
-
-class PromptType(str, Enum):
-    CONTEXTUALIZE_QUESTION = "contextualize_question"
-    CONTEXT_QA = "context_qa"
-
-
-class UploadResponse(BaseModel):
-    session_id: str
-    indexed: bool
-    message: str | None = None
-
-
-class ChatRequest(BaseModel):
-    session_id: str
-    message: str
-
-
-class ChatResponse(BaseModel):
-    answer: str

multi_doc_chat/src/document_chat/retrieval.py

@@ -1,197 +0,0 @@
-import sys
-import os
-from operator import itemgetter
-from typing import List, Optional, Dict, Any
-
-from langchain_core.messages import BaseMessage
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_community.vectorstores import FAISS
-
-from multi_doc_chat.utils.model_loader import ModelLoader
-from multi_doc_chat.exception.custom_exception import DocumentPortalException
-from multi_doc_chat.logger import GLOBAL_LOGGER as log
-from multi_doc_chat.prompts.prompt_library import PROMPT_REGISTRY
-from multi_doc_chat.model.models import PromptType, ChatAnswer
-from pydantic import ValidationError
-
-
-class ConversationalRAG:
-    """
-    LCEL-based Conversational RAG with lazy retriever initialization.
-
-    Usage:
-        rag = ConversationalRAG(session_id="abc")
-        rag.load_retriever_from_faiss(index_path="faiss_index/abc", k=5, index_name="index")
-        answer = rag.invoke("What is ...?", chat_history=[])
-    """
-
-    def __init__(self, session_id: Optional[str], retriever=None):
-        try:
-            self.session_id = session_id
-
-            # Load LLM and prompts once
-            self.llm = self._load_llm()
-            self.contextualize_prompt: ChatPromptTemplate = PROMPT_REGISTRY[
-                PromptType.CONTEXTUALIZE_QUESTION.value
-            ]
-            self.qa_prompt: ChatPromptTemplate = PROMPT_REGISTRY[
-                PromptType.CONTEXT_QA.value
-            ]
-
-            # Lazy pieces
-            self.retriever = retriever
-            self.chain = None
-            if self.retriever is not None:
-                self._build_lcel_chain()
-
-            log.info("ConversationalRAG initialized", session_id=self.session_id)
-        except Exception as e:
-            log.error("Failed to initialize ConversationalRAG", error=str(e))
-            raise DocumentPortalException("Initialization error in ConversationalRAG", sys)
-
-    # ---------- Public API ----------
-
-    def load_retriever_from_faiss(
-        self,
-        index_path: str,
-        k: int = 5,
-        index_name: str = "index",
-        search_type: str = "mmr",
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        search_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Load FAISS vectorstore from disk and build retriever + LCEL chain.
-        
-        Args:
-            index_path: Path to FAISS index directory
-            k: Number of documents to return
-            index_name: Name of the index file
-            search_type: Type of search ("similarity", "mmr", "similarity_score_threshold")
-            fetch_k: Number of documents to fetch before MMR re-ranking (only for MMR)
-            lambda_mult: Diversity parameter for MMR (0=max diversity, 1=max relevance)
-            search_kwargs: Custom search kwargs (overrides other parameters if provided)
-        """
-        try:
-            if not os.path.isdir(index_path):
-                raise FileNotFoundError(f"FAISS index directory not found: {index_path}")
-
-            embeddings = ModelLoader().load_embeddings()
-            vectorstore = FAISS.load_local(
-                index_path,
-                embeddings,
-                index_name=index_name,
-                allow_dangerous_deserialization=True,  # ok if you trust the index
-            )
-
-            if search_kwargs is None:
-                search_kwargs = {"k": k}
-                if search_type == "mmr":
-                    search_kwargs["fetch_k"] = fetch_k
-                    search_kwargs["lambda_mult"] = lambda_mult
-
-            self.retriever = vectorstore.as_retriever(
-                search_type=search_type, search_kwargs=search_kwargs
-            )
-            self._build_lcel_chain()
-
-            log.info(
-                "FAISS retriever loaded successfully",
-                index_path=index_path,
-                index_name=index_name,
-                search_type=search_type,
-                k=k,
-                fetch_k=fetch_k if search_type == "mmr" else None,
-                lambda_mult=lambda_mult if search_type == "mmr" else None,
-                session_id=self.session_id,
-            )
-            return self.retriever
-
-        except Exception as e:
-            log.error("Failed to load retriever from FAISS", error=str(e))
-            raise DocumentPortalException("Loading error in ConversationalRAG", sys)
-
-    def invoke(self, user_input: str, chat_history: Optional[List[BaseMessage]] = None) -> str:
-        """Invoke the LCEL pipeline."""
-        try:
-            if self.chain is None:
-                raise DocumentPortalException(
-                    "RAG chain not initialized. Call load_retriever_from_faiss() before invoke().", sys
-                )
-            chat_history = chat_history or []
-            payload = {"input": user_input, "chat_history": chat_history}
-            answer = self.chain.invoke(payload)
-            if not answer:
-                log.warning(
-                    "No answer generated", user_input=user_input, session_id=self.session_id
-                )
-                return "no answer generated."
-            # Validate answer type and length using Pydantic model
-            try:
-                validated = ChatAnswer(answer=str(answer))
-                answer = validated.answer
-            except ValidationError as ve:
-                log.error("Invalid chat answer", error=str(ve))
-                raise DocumentPortalException("Invalid chat answer", sys)
-            log.info(
-                "Chain invoked successfully",
-                session_id=self.session_id,
-                user_input=user_input,
-                answer_preview=str(answer)[:150],
-            )
-            return answer
-        except Exception as e:
-            log.error("Failed to invoke ConversationalRAG", error=str(e))
-            raise DocumentPortalException("Invocation error in ConversationalRAG", sys)
-
-    # ---------- Internals ----------
-
-    def _load_llm(self):
-        try:
-            llm = ModelLoader().load_llm()
-            if not llm:
-                raise ValueError("LLM could not be loaded")
-            log.info("LLM loaded successfully", session_id=self.session_id)
-            return llm
-        except Exception as e:
-            log.error("Failed to load LLM", error=str(e))
-            raise DocumentPortalException("LLM loading error in ConversationalRAG", sys)
-
-    @staticmethod
-    def _format_docs(docs) -> str:
-        return "\n\n".join(getattr(d, "page_content", str(d)) for d in docs)
-
-    def _build_lcel_chain(self):
-        try:
-            if self.retriever is None:
-                raise DocumentPortalException("No retriever set before building chain", sys)
-
-            # 1) Rewrite user question with chat history context
-            question_rewriter = (
-                {"input": itemgetter("input"), "chat_history": itemgetter("chat_history")}
-                | self.contextualize_prompt
-                | self.llm
-                | StrOutputParser()
-            )
-
-            # 2) Retrieve docs for rewritten question
-            retrieve_docs = question_rewriter | self.retriever | self._format_docs
-
-            # 3) Answer using retrieved context + original input + chat history
-            self.chain = (
-                {
-                    "context": retrieve_docs,
-                    "input": itemgetter("input"),
-                    "chat_history": itemgetter("chat_history"),
-                }
-                | self.qa_prompt
-                | self.llm
-                | StrOutputParser()
-            )
-
-            log.info("LCEL graph built successfully", session_id=self.session_id)
-        except Exception as e:
-            log.error("Failed to build LCEL chain", error=str(e), session_id=self.session_id)
-            raise DocumentPortalException("Failed to build LCEL chain", sys)

multi_doc_chat/utils/config_loader.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-import os
-import yaml
-
-def _project_root() -> Path:
-    # .../utils/config_loader.py -> parents[1] == project root
-    return Path(__file__).resolve().parents[1]
-
-def load_config(config_path: str | None = None) -> dict:
-    """
-    Resolve config path reliably irrespective of CWD.
-    Priority: explicit arg > CONFIG_PATH env > <project_root>/config/config.yaml
-    """
-    env_path = os.getenv("CONFIG_PATH")
-    if config_path is None:
-        # _project_root() already points to the package root (multi_doc_chat)
-        config_path = env_path or str(_project_root() / "config" / "config.yaml")
-
-    path = Path(config_path)
-    if not path.is_absolute():
-        path = _project_root() / path
-
-    if not path.exists():
-        raise FileNotFoundError(f"Config file not found: {path}")
-
-    with open(path, "r", encoding="utf-8") as f:
-        return yaml.safe_load(f) or {}

multi_doc_chat/utils/file_io.py

@@ -1,58 +0,0 @@
-
-from __future__ import annotations
-import re
-import uuid
-from pathlib import Path
-from typing import Iterable, List
-from multi_doc_chat.logger.cutom_logger import CustomLogger
-from multi_doc_chat.exception.custom_exception import DocumentPortalException
-
-SUPPORTED_EXTENSIONS = {".pdf", ".docx", ".txt", ".pptx", ".md", ".csv", ".xlsx", ".xls", ".db", ".sqlite", ".sqlite3"}
-
-# Local logger instance
-log = CustomLogger().get_logger(__name__)
-
-
-def save_uploaded_files(uploaded_files: Iterable, target_dir: Path) -> List[Path]:
-    """Save uploaded files (Streamlit-like) and return local paths."""
-    try:
-        target_dir.mkdir(parents=True, exist_ok=True)
-        saved: List[Path] = []
-        for uf in uploaded_files:
-            # Handle Starlette UploadFile (has .filename and .file) and generic objects (have .name)
-            name = getattr(uf, "filename", getattr(uf, "name", "file"))
-            ext = Path(name).suffix.lower()
-            if ext not in SUPPORTED_EXTENSIONS:
-                log.warning("Unsupported file skipped", filename=name)
-                continue
-            # Clean file name (only alphanum, dash, underscore)
-            safe_name = re.sub(r'[^a-zA-Z0-9_\-]', '_', Path(name).stem).lower()
-            fname = f"{safe_name}_{uuid.uuid4().hex[:6]}{ext}"
-            fname = f"{uuid.uuid4().hex[:8]}{ext}"
-            out = target_dir / fname
-            with open(out, "wb") as f:
-                # Prefer underlying file buffer when available (e.g., Starlette UploadFile.file)
-                if hasattr(uf, "file") and hasattr(uf.file, "read"):
-                    f.write(uf.file.read())
-                elif hasattr(uf, "read"):
-                    data = uf.read()
-                    # If a memoryview is returned, convert to bytes; otherwise assume bytes
-                    if isinstance(data, memoryview):
-                        data = data.tobytes()
-                    f.write(data)
-                else:
-                    # Fallback for objects exposing a getbuffer()
-                    buf = getattr(uf, "getbuffer", None)
-                    if callable(buf):
-                        data = buf()
-                        if isinstance(data, memoryview):
-                            data = data.tobytes()
-                        f.write(data)
-                    else:
-                        raise ValueError("Unsupported uploaded file object; no readable interface")
-            saved.append(out)
-            log.info("File saved for ingestion", uploaded=name, saved_as=str(out))
-        return saved
-    except Exception as e:
-        log.error("Failed to save uploaded files", error=str(e), dir=str(target_dir))
-        raise DocumentPortalException("Failed to save uploaded files", e) from e

templates/index.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>MultiDocChat</title>
+  <title>RAG Solution</title>
   <link rel="stylesheet" href="/static/styles.css" />
   <style>
     /* Minimal inline tweaks; most styles live in styles.css */