upload source code

all files and folders are uploaded

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MD SHAFIQUL ISLAM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent.py

@@ -0,0 +1,64 @@
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import warnings
+from config import Config
+from dotenv import load_dotenv
+from llm.gemini_llm import GeminiLLM
+from tool_registry import ToolRegistry
+from langchain_core.messages import SystemMessage
+from langchain.agents import initialize_agent, AgentType
+from langchain_core.exceptions import OutputParserException
+from langchain_core.messages import HumanMessage, BaseMessage
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+load_dotenv()
+
+
+class Agent:
+    def __init__(self):
+        prompt_content = self.load_prompt(Config.AGENT_PROMPT)
+        system_prompt = SystemMessage(content=prompt_content)
+
+        # Wrap Gemini LLM with system prompt using .with_config
+        self.llm = GeminiLLM().get_client().with_config({
+            "system_message": system_prompt
+        })
+
+        # Dynamically load all tools
+        registry = ToolRegistry()
+        tools = registry.get_all_tools()
+
+        self.react_agent = initialize_agent(
+            tools=tools,
+            llm=self.llm,
+            agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION,
+            verbose=True,
+            handle_parsing_errors=True
+        )
+
+    def load_prompt(self, path: str) -> str:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+
+    def run(self, query: str, history: list[BaseMessage] = None) -> str:
+        # Copy full history
+        messages = history.copy() if history else []
+
+        # Append current user query
+        messages.append(HumanMessage(content=query))
+
+        try:
+            return self.react_agent.invoke(messages)
+        except OutputParserException as e:
+            print("⚠️ OutputParserException:", e)
+
+        # Fallback: use the LLM directly to answer
+        return self.llm.invoke(messages)
+
+
+if __name__ == "__main__":
+    agent = Agent()
+    user_query = "What is the full form of K12HSN?"
+    answer = agent.run(user_query)
+    print("\n### Agent Response:\n", answer)

config.py

@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+
+
+class Config:
+
+    # === Base paths ===
+    PROJECT_ROOT = Path(__file__).resolve().parent
+    ICON_DIR = os.path.join(PROJECT_ROOT, "icons")
+    DATA_DIR = os.path.join(PROJECT_ROOT, "data")
+    STORED_CHUNK_DIR = os.path.join(PROJECT_ROOT, "doc_chunks")
+    UPLOAD_DIR = os.path.join(PROJECT_ROOT, "upload")
+    PROMPT_DIR = os.path.join(PROJECT_ROOT, "prompts")
+    NLTK_DIR = os.path.join(PROJECT_ROOT, "nltk_words")
+
+    SAVED_ID_PATH = os.path.join(DATA_DIR, "saved_ids.csv")
+    SAVED_DATA_PATH = os.path.join(DATA_DIR, "saved_data.txt")
+
+    RAG_PROMPT = os.path.join(PROMPT_DIR, "rag_prompt.txt")
+    AGENT_PROMPT = os.path.join(PROMPT_DIR, "agent_prompt.txt")
+
+    UPLOAD_ICON = os.path.join(ICON_DIR, "upload.png")
+
+    COLLECTION_NAME = "qdrant_collection"
+    QDRANT_PERSIST_PATH = "qdrant_database"
+
+    # Qdrant DB
+    EMBEDDING_MODEL_NAME = "BAAI/bge-large-en-v1.5"  # "BAAI/bge-base-en-v1.5"
+    BATCH_SIZE = 20  # Qdrant batch size
+    TOP_K = 4
+    ALPHA = 0.5
+    CHUNK_SIZE = 500
+    CHUNK_OVERLAP = 100
+
+    FILE_EXTENSIONS = [".pdf", ".docx", ".xlsx", ".pptx", ".csv", ".txt", ".json"]
+
+    LLM_MODEL = "gemini-2.5-flash"
+    TEMPERATURE = 0.7
+
+    SESSION_ID = "chatbot_user"
+

llm/gemini_llm.py

@@ -0,0 +1,35 @@
+import os
+from config import Config
+from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+load_dotenv()
+
+
+class GeminiLLM:
+    def __init__(self):
+        self.api_key = os.getenv("GOOGLE_API_KEY")
+        if not self.api_key:
+            raise ValueError("GOOGLE_API_KEY not found in environment variables")
+
+        self.model_name = Config.LLM_MODEL
+        self.temperature = Config.TEMPERATURE
+        self.gemini_client = self._initialize_client()
+
+    def _initialize_client(self):
+        return ChatGoogleGenerativeAI(
+            google_api_key=self.api_key,
+            model=self.model_name,
+            temperature=self.temperature
+        )
+
+    def get_client(self):
+        return self.gemini_client
+
+
+if __name__ == "__main__":
+    gemini_llm = GeminiLLM()
+    llm = gemini_llm.get_client()
+    response = llm.invoke([HumanMessage(content="Explain LangChain in 5 sentences")])
+    print("### Gemini Response:\n", response.content)

memory/chat_memory.py

@@ -0,0 +1,51 @@
+from typing import Dict, List
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+
+
+class MemoryManager:
+    def __init__(self):
+        self.sessions: Dict[str, List[BaseMessage]] = {}
+
+    def get(self, session_id: str = "default") -> List[BaseMessage]:
+        """Returns message history for a given session."""
+        if session_id not in self.sessions:
+            self.sessions[session_id] = []
+        return self.sessions[session_id]
+
+    def add(self, session_id: str, message: BaseMessage):
+        """Appends a message to the session memory."""
+        if session_id not in self.sessions:
+            self.sessions[session_id] = []
+        self.sessions[session_id].append(message)
+
+    def clear(self, session_id: str = "default"):
+        """Clears memory for a given session."""
+        if session_id in self.sessions:
+            self.sessions[session_id] = []
+
+    def list_sessions(self) -> List[str]:
+        """Lists all active session IDs."""
+        return list(self.sessions.keys())
+
+
+if __name__ == "__main__":
+    memory = MemoryManager()
+
+    # Add messages to session "test1"
+    memory.add("test1", HumanMessage(content="What's the weather today?"))
+    memory.add("test1", AIMessage(content="It's sunny in Tokyo."))
+
+    # Retrieve and print messages
+    print("\n--- Chat history for 'test1' ---")
+    for msg in memory.get("test1"):
+        role = "User" if isinstance(msg, HumanMessage) else "Assistant"
+        print(f"{role}: {msg.content}")
+
+    # List sessions
+    print("\n--- Active Sessions ---")
+    print(memory.list_sessions())
+
+    # Clear session
+    memory.clear("test1")
+    print("\n--- Chat history after clearing ---")
+    print(memory.get("test1"))

nltk_words/corpora/stopwords/english

@@ -0,0 +1,198 @@
+a
+about
+above
+after
+again
+against
+ain
+all
+am
+an
+and
+any
+are
+aren
+aren't
+as
+at
+be
+because
+been
+before
+being
+below
+between
+both
+but
+by
+can
+couldn
+couldn't
+d
+did
+didn
+didn't
+do
+does
+doesn
+doesn't
+doing
+don
+don't
+down
+during
+each
+few
+for
+from
+further
+had
+hadn
+hadn't
+has
+hasn
+hasn't
+have
+haven
+haven't
+having
+he
+he'd
+he'll
+her
+here
+hers
+herself
+he's
+him
+himself
+his
+how
+i
+i'd
+if
+i'll
+i'm
+in
+into
+is
+isn
+isn't
+it
+it'd
+it'll
+it's
+its
+itself
+i've
+just
+ll
+m
+ma
+me
+mightn
+mightn't
+more
+most
+mustn
+mustn't
+my
+myself
+needn
+needn't
+no
+nor
+not
+now
+o
+of
+off
+on
+once
+only
+or
+other
+our
+ours
+ourselves
+out
+over
+own
+re
+s
+same
+shan
+shan't
+she
+she'd
+she'll
+she's
+should
+shouldn
+shouldn't
+should've
+so
+some
+such
+t
+than
+that
+that'll
+the
+their
+theirs
+them
+themselves
+then
+there
+these
+they
+they'd
+they'll
+they're
+they've
+this
+those
+through
+to
+too
+under
+until
+up
+ve
+very
+was
+wasn
+wasn't
+we
+we'd
+we'll
+we're
+were
+weren
+weren't
+we've
+what
+when
+where
+which
+while
+who
+whom
+why
+will
+with
+won
+won't
+wouldn
+wouldn't
+y
+you
+you'd
+you'll
+your
+you're
+yours
+yourself
+yourselves
+you've

prompts/agent_prompt.txt

@@ -0,0 +1,41 @@
+You are a smart AI assistant that uses tools to answer user questions.
+
+You must follow this exact reasoning format step by step:
+
+Thought: Explain what you are thinking.
+Action: {"action": "tool_name", "action_input": "input string"}
+Observation: Describe the result from the tool.
+
+Always follow this format: Thought → Action → Observation → (repeat if needed) → Final Answer.
+After each Observation, you must always provide either a new Thought, a new Action (in JSON), or a Final Answer.
+Never generate an answer or conclusion directly after Observation — always include the proper prefix.
+
+When you are confident of the final answer, say:
+Final Answer: <your answer here>
+
+# Important Instructions:
+
+- Always format Action as a "single-line JSON object" — no backticks.
+- Always try using the "rag_search" tool first for factual, abbreviation, or document-based queries.
+- Only use tools like "web_search", "wikipedia", "weather" etc. if "rag_search" fails or returns irrelevant information.
+- Use the "calculator" tool for math questions or numeric queries. First convert natural language math into Python syntax (e.g. "What is 2 to the power 5" → 2**5).
+- Use the "llm_instruction" tool for general tasks like summarization, rewriting, explanation, storytelling, or creative writing.
+- NEVER make up answers — rely only on tool results (observations).
+- If no tool gives a good result, say: `Final Answer: I couldn’t find enough information.`
+- If a tool fails or returns an error, continue reasoning with another Thought or try a different tool.
+- You must always respond with either a new Thought, an Action (JSON format), or a Final Answer. Never respond with standalone text or conclusions without a proper prefix.
+
+# Additional Rules for Date Validation:
+
+- Use today's date (from the system or datetime tool) to interpret and validate time-sensitive information.
+- When interpreting web_search or wikipedia results that contain a date (e.g., "as of January 20, 2025"), compare it with today's date.
+- If the date is in the past or today, and multiple sources confirm, you may trust the result.
+- If the date is in the future, be cautious — either retry the query or state the result may be uncertain or speculative.
+
+# Available tools:
+- rag_search: search vector DB with uploaded docs
+- web_search: search the web
+- wikipedia: get definitions or summaries from Wikipedia
+- weather: get current weather info
+- calculator: evaluate math expressions like '2+2', '37593**(1/5)', or 'pi * 2**2'
+- llm_instruction: handle general language tasks like summarization, rewriting, storytelling, and explanations

prompts/rag_prompt.txt

@@ -0,0 +1,19 @@
+You are a knowledgeable and friendly assistant. Answer the user's question using only the information provided in the context and prior conversation. Your responses should be clear, complete, and naturally phrased — like a human assistant.
+
+Chat History:
+{chat_history}
+
+User Question:
+{input}
+
+Relevant Context:
+{context}
+
+# Instructions:
+- If possible, extract the answer directly from the context without guessing.
+- Phrase your response in a grammatically correct, conversational tone.
+- Provide step-by-step reasoning or explanation if the question involves multiple facts or a process.
+- Include all relevant details; do not omit key points.
+- Do not use any knowledge beyond what is in the provided context and chat history.
+- If the answer cannot be found, respond with:
+  "I don't know based on the document and our previous conversation."

rag.py

@@ -0,0 +1,86 @@
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import warnings
+from config import Config
+from llm.gemini_llm import GeminiLLM
+from memory.chat_memory import MemoryManager
+from langchain_core.prompts import ChatPromptTemplate
+from retriever.qdrant_retriever import QdrantRetriever
+from langchain.chains.retrieval import create_retrieval_chain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain_core.messages import HumanMessage, AIMessage, BaseMessage, SystemMessage
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+class RAGPipeline:
+    def __init__(self):
+        self.retriever = QdrantRetriever()
+        self.memory = MemoryManager()
+        self.llm = GeminiLLM().get_client()
+
+        self.prompt = self._load_prompt(Config.RAG_PROMPT)
+        self.qa_chain = create_stuff_documents_chain(self.llm, self.prompt)
+        self.chain = create_retrieval_chain(self.retriever, self.qa_chain)
+
+    def _load_prompt(self, path: str) -> ChatPromptTemplate:
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Prompt file not found: {path}")
+        with open(path, "r", encoding="utf-8") as f:
+            system_prompt = f.read()
+
+        return ChatPromptTemplate.from_messages([
+            ("system", "{chat_history}\n\n" + system_prompt),
+            ("human", "{input}")
+        ])
+
+    def messages_to_string(self, messages: list[BaseMessage]) -> str:
+        history = []
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                role = "user"
+            elif isinstance(msg, AIMessage):
+                role = "assistant"
+            elif isinstance(msg, SystemMessage):
+                role = "system"
+            else:
+                role = "unknown"
+            history.append(f"{role}: {msg.content}")
+        return "\n".join(history)
+
+    def ask(self, query: str) -> str:
+        session_id = Config.SESSION_ID
+
+        # Get conversation history and format it
+        history_messages = self.memory.get(session_id)
+        chat_history_str = self.messages_to_string(history_messages)
+
+        # Prepare inputs for the chain
+        inputs = {
+            "input": query,
+            "chat_history": chat_history_str.strip()
+        }
+
+        # Invoke RAG chain
+        response = self.chain.invoke(inputs)
+
+        # Extract final answer
+        answer = response["answer"]
+
+        # Save interaction to memory
+        self.memory.add(session_id, HumanMessage(content=query))
+        self.memory.add(session_id, AIMessage(content=answer))
+
+        return answer
+
+
+if __name__ == "__main__":
+    rag = RAGPipeline()
+    query1 = "What is the full form of K12HSN?"
+    query2 = "What does the abbreviation stand for?"
+
+    response1 = rag.ask(query1)
+    print(f"Q1: {query1}\nA1: {response1}")
+
+    response2 = rag.ask(query2)
+    print(f"Q2: {query2}\nA2: {response2}")

requirements.txt

@@ -0,0 +1,18 @@
+streamlit==1.46.1
+langchain==0.3.26
+langchain-community==0.3.26
+langchain-google-genai==2.1.5
+qdrant-client==1.14.3
+pdfplumber==0.11.7
+unstructured==0.18.3
+python-docx==1.2.0
+python-pptx==1.0.2
+openpyxl==3.1.5
+jq==1.9.1
+python-dotenv==1.1.1
+sentence-transformers==4.1.0
+transformers==4.53.0
+tavily-python==0.7.9
+wikipedia-api==0.8.1
+nltk==3.9.1
+numexpr==2.11.0

retriever/qdrant_retriever.py

@@ -0,0 +1,27 @@
+from config import Config
+from typing import List, Optional
+from langchain_core.documents import Document
+from vector_db.qdrant_db import QdrantDBClient
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.runnables.config import RunnableConfig
+
+
+class QdrantRetriever(BaseRetriever):
+    def __init__(self):
+        super().__init__()
+        self._qdrant_client = QdrantDBClient()
+        self._k = Config.TOP_K
+
+    def _get_relevant_documents(self, input: str, *, config: Optional[RunnableConfig] = None) -> List[Document]:
+        docs = self._qdrant_client.search(query=input, top_k=self._k)
+        return docs
+
+
+if __name__ == "__main__":
+    retriever = QdrantRetriever()
+    query = "Who is the president of the United States?"
+
+    docs = retriever.invoke(query)
+    print(f"\n### Top {len(docs)} documents:")
+    for i, doc in enumerate(docs, 1):
+        print(f"\n{i}. {doc.page_content[:200]}...")

tool_registry.py

@@ -0,0 +1,82 @@
+import pkgutil
+import importlib
+from typing import Dict, List
+from langchain.tools import Tool
+from tools.base_tool import BaseTool
+
+
+class ToolRegistry:
+    """Registry for dynamically loading and managing tools."""
+
+    def __init__(self, tools_package: str = "tools"):
+        self.tools_package = tools_package
+        self.tools: Dict[str, BaseTool] = {}
+        self.register_tools()
+
+    def register_tools(self):
+        """Dynamically registers all available tools in the tools package."""
+        tool_modules = [name for _, name, _ in pkgutil.iter_modules([self.tools_package])]
+
+        for module_name in tool_modules:
+            try:
+                module = importlib.import_module(f"{self.tools_package}.{module_name}")
+                for attr_name in dir(module):
+                    attr = getattr(module, attr_name)
+                    if (
+                        isinstance(attr, type)
+                        and issubclass(attr, BaseTool)
+                        and attr is not BaseTool
+                    ):
+                        tool_instance = attr()
+                        self.tools[tool_instance.name.lower()] = tool_instance
+            except Exception as e:
+                print(f"[ERROR] Failed to register tool '{module_name}': {e}")
+
+    def get_tool(self, name: str) -> BaseTool:
+        """Retrieve a tool by name."""
+        return self.tools.get(name.lower())
+
+    def list_tools(self) -> str:
+        """Returns a formatted string listing available tools."""
+        return "\n".join(
+            [f"{tool.name}: {tool.description}" for tool in self.tools.values()]
+        )
+
+    def all(self) -> Dict[str, BaseTool]:
+        """Returns all registered tools as a dictionary."""
+        return self.tools
+
+    def get_all_tools(self) -> List[Tool]:
+        """Returns tools as LangChain Tool objects."""
+        return [
+            Tool(
+                name=tool.name,
+                description=tool.description,
+                func=tool.run
+            )
+            for tool in self.all().values()
+        ]
+
+
+if __name__=="__main__":
+    registry = ToolRegistry()
+
+    print("🔧 Registered Tools:\n")
+    print(registry.list_tools())
+
+    # Example usage
+    tools = registry.get_all_tools()
+    print("\n### LangChain Tool Definitions:")
+    for t in tools:
+        print(t["name"], "-", t["description"])
+
+    # query = "what is the capital of Japan?"
+    # tool = registry.get_tool("web_search")
+    #
+    # if tool:
+    #     result = tool.run(query)
+    #     print("\n### Web Search Result:")
+    #     for item in result:
+    #         print(item)
+    # else:
+    #     print("Tool not found.")

tools/__init__.py

@@ -0,0 +1,3 @@
+from tools.web_search_tool import WebSearchTool
+
+__all__ = ["WebSearchTool"]

tools/base_tool.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+
+
+class BaseTool(ABC):
+    """Abstract base class for all tools."""
+
+    def __init__(self, name: str, description: str):
+        """
+        Initializes a tool with a name and description.
+
+        :param name: Name of the tool (converted to lowercase for consistency).
+        :param description: A brief description of the tool.
+        """
+        if not isinstance(name, str):
+            raise ValueError("Tool name must be a string.")
+
+        self._name = name.lower()  # Ensuring consistent lowercase tool names
+        self._description = description
+
+    @property
+    def name(self) -> str:
+        """Returns the tool's name."""
+        return self._name
+
+    @property
+    def description(self) -> str:
+        """Returns the tool's description."""
+        return self._description
+
+    @abstractmethod
+    def run(self, query: str) -> str:
+        """
+        Abstract method that must be implemented by all tools.
+
+        :param query: The input query for the tool.
+        :return: The tool's response as a string.
+        """
+        pass

tools/calculator_tool.py

@@ -0,0 +1,49 @@
+import math
+import numexpr
+from tools.base_tool import BaseTool
+
+
+class CalculatorTool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            name="calculator",
+            description=(
+                "Evaluates structured math expressions. Use this tool to solve arithmetic problems. "
+                "Before calling, convert natural language to proper Python-style math expressions. "
+                "Examples: '2+2', '37593 * 67', '2**5', 'pi * 2**2', '37593**(1/5)'. "
+                "Supports constants like pi and e."
+            )
+        )
+        self.local_dict = {"pi": math.pi, "e": math.e}
+
+    def run(self, query: str) -> str:
+        """Evaluates a mathematical expression securely using numexpr."""
+        if not query or not query.strip():
+            return "❌ Expression cannot be empty."
+
+        try:
+            result = numexpr.evaluate(
+                query.strip(),
+                global_dict={},            # Secure: no global access
+                local_dict=self.local_dict # Allow pi, e
+            )
+            return str(result.item()) if hasattr(result, "item") else str(result)
+
+        except Exception as e:
+            return f"⚠️ Failed to evaluate expression: {str(e)}"
+
+
+# === For standalone testing ===
+if __name__ == "__main__":
+    calc_tool = CalculatorTool()
+    expressions = [
+        "2 + 2",
+        "37593 * 67",
+        "37593**(1/5)",
+        "pi * 2**2",
+        "e**2"
+    ]
+
+    for expr in expressions:
+        answer = calc_tool.run(expr)
+        print(f"{expr} = {answer}")

tools/llm_tool.py

@@ -0,0 +1,40 @@
+import os
+from config import Config
+from tools.base_tool import BaseTool
+from langchain.schema import HumanMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+
+class LLMInstructionTool(BaseTool):
+    def __init__(self):
+        super().__init__(
+            name="llm_instruction",
+            description=(
+                "Handles creative and instructional tasks using an LLM. "
+                "Use this tool for tasks like summarizing, rewriting, poem generation, storytelling, or following general instructions "
+                "when no specific tool is applicable."
+            )
+        )
+        self.llm = ChatGoogleGenerativeAI(
+            google_api_key=os.environ["GOOGLE_API_KEY"],
+            model=Config.LLM_MODEL,
+            temperature=Config.TEMPERATURE
+        )
+
+    def run(self, input_data: str) -> str:
+        if not input_data.strip():
+            return "Error: Empty input for LLM tool."
+
+        try:
+            response = self.llm.invoke([HumanMessage(content=input_data)])
+            return response.content.strip()
+        except Exception as e:
+            return f"Failed to run LLM tool: {str(e)}"
+
+
+# === For standalone testing ===
+if __name__ == "__main__":
+    tool = LLMInstructionTool()
+    test_input = "Rewrite this in a more formal tone.. Hey there! Just wanted to say thanks for your help yesterday. It really meant a lot."
+    result = tool.run(test_input)
+    print(result)

tools/rag_tool.py

@@ -0,0 +1,34 @@
+from rag import RAGPipeline
+from tools.base_tool import BaseTool
+
+
+class RAGTool(BaseTool):
+    """A tool for answering queries using a vector store-backed RAG pipeline."""
+
+    def __init__(self):
+        super().__init__(
+            name="rag_search",
+            description=(
+                "Use this tool to answer factual, abbreviation-based, educational, or document-related questions. "
+                "It searches internal documents using a vector database. "
+                "Always try this first before considering external tools like web_search, wikipedia, weather etc."
+            )
+        )
+        self.rag = RAGPipeline()
+
+    def run(self, query: str) -> str:
+        """Run the RAG pipeline for the given query and return the answer."""
+        if not query or not query.strip():
+            return "❌ Query cannot be empty."
+        try:
+            return self.rag.ask(query)
+        except Exception as e:
+            return f"⚠️ RAG processing failed: {str(e)}"
+
+
+# === For standalone testing ===
+if __name__ == "__main__":
+    rag_tool = RAGTool()
+    question = "What is K12HSN?"
+    answer = rag_tool.run(question)
+    print(f"Q: {question}\nA: {answer}")

tools/weather_tool.py

@@ -0,0 +1,67 @@
+import os
+import requests
+from dotenv import load_dotenv
+from tools.base_tool import BaseTool
+
+load_dotenv()
+
+
+class WeatherTool(BaseTool):
+    """A tool for retrieving current weather information using the OpenWeather API."""
+
+    def __init__(self):
+        super().__init__(
+            name="weather",
+            description=(
+                "Provides real-time weather information (temperature, humidity, wind, etc.) for a specific city. "
+                "Only use this tool if the question explicitly asks about the weather in a particular location. "
+                "Input should be just the city name, e.g., 'Tokyo'."
+            )
+        )
+
+        self.base_url = "http://api.openweathermap.org/data/2.5/weather"
+        self.api_key = os.getenv("OPENWEATHER_API_KEY")
+
+        if not self.api_key:
+            raise ValueError("Missing API Key: Please set 'OPENWEATHER_API_KEY' in the .env file.")
+
+    def run(self, query: str) -> str:
+        """Fetches weather data for a given city"""
+        if not query or not query.strip():
+            return "Error: City name cannot be empty."
+
+        url = f"{self.base_url}?q={query}&appid={self.api_key}&units=metric"
+        # print('###### weather url : ', url)
+
+        try:
+            response = requests.get(url, timeout=5)
+
+            # Checking HTTP status manually
+            if response.status_code != 200:
+                return f"Error: Unable to fetch weather data. Server responded with {response.status_code}: {response.json().get('message', 'Unknown error')}"
+
+            data = response.json()
+
+            # Ensuring response contains required data
+            if "main" not in data or "weather" not in data:
+                return f"Could not find weather data for '{query}'. Please check the city name."
+
+            temperature = data["main"]["temp"]
+            description = data["weather"][0]["description"]
+            humidity = data["main"]["humidity"]
+            wind_speed = data["wind"]["speed"]
+
+            return f"The temperature in {query} is {temperature}°C. " f"The weather is {description}. " f"The humidity is {humidity}%. " f"The wind speed is {wind_speed} m/s."
+
+        except requests.exceptions.RequestException as req_err:
+            return f"Request failed: {str(req_err)}"
+
+
+# === For standalone testing ===
+if __name__ == "__main__":
+
+    weather_tool = WeatherTool()
+    city = "Dhaka"
+
+    result = weather_tool.run(city)
+    print(result)

tools/web_search_tool.py

@@ -0,0 +1,76 @@
+import os
+from datetime import datetime
+from dotenv import load_dotenv
+from tavily import TavilyClient
+from tools.base_tool import BaseTool
+
+load_dotenv()
+
+
+class WebSearchTool(BaseTool):
+    """A tool for performing web searches using the Tavily API."""
+
+    def __init__(self):
+        super().__init__(
+            name="web_search",
+            description=(
+                "Use this tool to find up-to-date or real-time information from the web. "
+                "Best for current events, recent news, trending topics, or anything not covered in internal documents or Wikipedia. "
+                "Input should be a full natural-language query, e.g., 'Champion of the 2024 Champions League'."
+            )
+        )
+
+        self.api_key = os.getenv("TAVILY_API_KEY")
+        if not self.api_key:
+            raise ValueError("Missing API Key: Please set 'TAVILY_API_KEY' in the .env file.")
+
+        self.tavily_client = TavilyClient(api_key=self.api_key)
+
+    def run(self, query: str) -> str:
+        """Performs a web search for a given query and returns summarized results as a string."""
+        if not query or not query.strip():
+            return "Error: Query cannot be empty."
+
+        # Append today's date to guide LLM reasoning
+        today = datetime.now().strftime("%Y-%m-%d")
+        query_with_date = f"(Today is {today}) {query}"
+
+        try:
+            search_results = self.tavily_client.search(query=query_with_date, max_results=2)
+
+            if not search_results or "results" not in search_results:
+                return "Error: No search results available."
+
+            results = search_results["results"]
+            if not results:
+                return "Error: No results found."
+
+            # Format the top results as a readable string
+            formatted = []
+            for i, result in enumerate(results, start=1):
+                title = result.get("title", "No title")
+                content = result.get("content", "No content")
+                url = result.get("url", "No URL")
+                formatted.append(f"{i}. **{title}**\n{content}\n🔗 {url}")
+
+            return "\n\n".join(formatted)
+
+        except Exception as e:
+            return f"Error: Search request failed: {str(e)}"
+
+
+# === For standalone testing ===
+if __name__ == "__main__":
+
+    queries = ["F1 winner 2024"]
+    web_search_tool = WebSearchTool()
+
+    for query in queries:
+        results = web_search_tool.run(query)
+        if results:
+            print(f"Context for '{query}':")
+            for res in results:
+                print(res)
+            print("\n")
+        else:
+            print(f"No context found for '{query}'\n")

tools/wikipedia_tool.py

@@ -0,0 +1,50 @@
+import wikipediaapi
+from datetime import datetime
+from tools.base_tool import BaseTool
+
+
+class WikipediaTool(BaseTool):
+    """A tool for fetching Wikipedia summaries."""
+
+    def __init__(self):
+        super().__init__(
+            name="wikipedia",
+            description=(
+                "Use this tool to get general knowledge or definitions about well-known people, places, or concepts from Wikipedia. "
+                "Works best when the query is a specific topic or name like 'Albert Einstein' or 'blockchain'. "
+                "Use this if the question is not document-related and RAG is not helpful."
+            )
+
+        )
+        self.wiki_api = wikipediaapi.Wikipedia(user_agent="chatbot_user")
+
+    def run(self, query: str) -> str:
+        """Fetches summary information from Wikipedia for a given topic."""
+        if not query or not query.strip():
+            return "Error: Query cannot be empty."
+
+        try:
+            page = self.wiki_api.page(query)
+
+            if page.exists():
+                today = datetime.now().strftime("%Y-%m-%d")
+                return f"(Today is {today}) {page.summary.strip()}"
+
+            return f"Error: No Wikipedia page found for '{query}'."
+
+        except Exception as e:
+            return f"Error: An error occurred while searching Wikipedia: {str(e)}"
+
+
+# === For standalone testing ===
+if __name__ == "__main__":
+
+    wikipedia_tool = WikipediaTool()
+    queries = ["Julian Alvarez"]
+
+    for query in queries:
+        result = wikipedia_tool.run(query)
+        if result:
+            print(f"Result for '{query}':\n{result}\n")
+        else:
+            print(f"No result found for '{query}'\n")

utils/html_template.py

@@ -0,0 +1,50 @@
+
+class HtmlTemplates:
+    """Central place for raw HTML, CSS content."""
+
+    @staticmethod
+    def error_bar():
+        return """
+        <div style='border: 1px solid orange; width: 100%; padding: 8px; color: orange; text-align: center; border-radius: 5px;'>
+            ⚠️ No file selected. Please select a file to upload.
+        </div>
+        """
+
+    @staticmethod
+    def progress_bar(percent: int, current: int, total: int):
+        return f"""
+        <div style='border: 1px solid #ccc; width: 100%; height: 20px; position: relative; border-radius: 5px; overflow: hidden;'>
+            <div style='background-color: #4caf50; width: {percent}%; height: 100%; transition: width 0.5s;'></div>
+        </div>
+        <p style='text-align: center;'>Uploaded {current} / {total} files ({percent}%)</p>
+        """
+
+    @staticmethod
+    def css():
+        return """
+            #title {
+                margin-top: 8px;
+                text-align: center;
+                background-color: #2596be; /* blue */
+                color: white;
+                padding: 12px 20px;
+                border-radius: 6px;
+                font-weight: bold;
+                font-size: 24px;
+            }
+
+
+            #upload-btn {
+                background-color: #e28743;      /* orange */
+                color: white;                   /* Text color */
+                border-radius: 6px;             /* Rounded corners */
+                padding: 10px 16px;
+                font-weight: bold;
+                font-size: 18px;
+            }
+
+            #upload-btn:hover {
+                background-color: #cb7a3c;      /* Darker on hover */
+            }
+        """
+

utils/nltk.py

@@ -0,0 +1,26 @@
+import os
+import nltk
+from config import Config
+from nltk.corpus import stopwords
+from nltk.data import path as nltk_path
+
+
+class NLTK:
+    def __init__(self):
+        # Define your custom download path (e.g., current directory)
+        self.nltk_data_path = Config.NLTK_DIR
+
+        # Tell NLTK to look in your custom location
+        nltk_path.append(self.nltk_data_path)
+
+        self.download_stopwords()
+
+        self.stopwords = set(stopwords.words('english'))
+        self.punctuation = {".", ",", ";", ":", "'", '"', "~", "-", "–", "—", "(", ")", "[", "]", "{", "}", "!", "?", "`"}
+
+    def download_stopwords(self):
+        # Full path to the English stopwords file
+        stopwords_path = os.path.join(self.nltk_data_path, "corpora", "stopwords", "english")
+
+        if not os.path.exists(stopwords_path):
+            nltk.download("stopwords", download_dir=self.nltk_data_path)

utils/normalizer.py

@@ -0,0 +1,22 @@
+import unicodedata
+
+
+class Normalizer:
+    def __init__(self):
+        pass
+
+    def normalize_text(self, text: str) -> str:
+        # Unicode normalization (e.g., full-width → half-width, etc.)
+        text = unicodedata.normalize("NFKC", text)
+
+        # Lowercase
+        #text = text.lower()
+
+        # Remove punctuation
+        #text = "".join(char for char in text if char not in self.punctuation)
+
+        # Collapse multiple whitespace
+        #text = re.sub(r"\s+", " ", text).strip()
+
+        return text
+

vector_db/chunker.py

@@ -0,0 +1,61 @@
+import hashlib
+from typing import List
+from config import Config
+from utils.normalizer import Normalizer
+from langchain_core.documents import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+
+class DocumentChunker:
+    def __init__(self):
+        self.splitter = RecursiveCharacterTextSplitter(
+            chunk_size=Config.CHUNK_SIZE,
+            chunk_overlap=Config.CHUNK_OVERLAP
+        )
+        self.existing_hashes = set()
+        self.normalizer = Normalizer()
+
+    def hash_text(self, text: str) -> str:
+        return hashlib.md5(text.encode('utf-8')).hexdigest()
+
+    def split_documents(self, docs: List[Document]) -> List[dict]:
+        """Split and deduplicate documents. Returns list of dicts with id, text, metadata."""
+        chunks = self.splitter.split_documents(docs)
+        results = []
+
+        for i, chunk in enumerate(chunks):
+            normalized_text = self.normalizer.normalize_text(chunk.page_content)
+            if not normalized_text:
+                continue
+            chunk_hash = self.hash_text(normalized_text)
+            if chunk_hash in self.existing_hashes:
+                continue
+            self.existing_hashes.add(chunk_hash)
+
+            results.append({
+                "id": int(chunk_hash, 16) % (10 ** 9),
+                "text": normalized_text,
+                "metadata": {
+                    **chunk.metadata,
+                    "chunk_order": i  # Preserve order
+                }
+            })
+
+        return results
+
+
+if __name__ == "__main__":
+
+    sample_docs = [
+        Document(
+            page_content="This is a long document that needs to be split into smaller pieces.",
+            metadata={"source": "example.txt"}
+        )
+    ]
+
+    chunker = DocumentChunker()
+    chunks = chunker.split_documents(sample_docs)
+
+    for i, cnk in enumerate(chunks):
+        print(f"#### Chunk {i}: {cnk['text']}")
+

vector_db/data_embedder.py

@@ -0,0 +1,28 @@
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+from typing import List
+from config import Config
+from langchain.embeddings.base import Embeddings
+from sentence_transformers import SentenceTransformer
+
+
+class BAAIEmbedder(Embeddings):
+    def __init__(self):
+        self.model = SentenceTransformer(Config.EMBEDDING_MODEL_NAME)
+        self.batch_size = Config.BATCH_SIZE
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        return self.model.encode(texts, batch_size=self.batch_size, show_progress_bar=True, convert_to_numpy=True).tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        return self.model.encode(text, convert_to_numpy=True).tolist()
+
+
+if __name__ == "__main__":
+    embedder = BAAIEmbedder()
+    sample_texts = ["LangChain is powerful", "Qdrant is great for vectors"]
+    embeddings = embedder.embed_documents(sample_texts)
+    print("### Sample embeddings (first 5 dims):")
+    for emb in embeddings:
+        print(emb[:5])

vector_db/qdrant_db.py

@@ -0,0 +1,358 @@
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import json
+import hashlib
+import pandas as pd
+from config import Config
+from utils.nltk import NLTK
+from typing import List, Dict
+from dotenv import load_dotenv
+from qdrant_client import QdrantClient
+from utils.normalizer import Normalizer
+from qdrant_client.models import ScoredPoint
+from langchain_core.documents import Document
+from vector_db.chunker import DocumentChunker
+from vector_db.data_embedder import BAAIEmbedder
+from qdrant_client.models import Distance, VectorParams, PointStruct
+from qdrant_client.http.models import Filter, FieldCondition, MatchText
+from qdrant_client.models import TextIndexParams, TextIndexType, TokenizerType
+from langchain_community.document_loaders import (
+    PDFPlumberLoader,
+    UnstructuredWordDocumentLoader,
+    UnstructuredPowerPointLoader,
+    UnstructuredExcelLoader,
+    TextLoader,
+    CSVLoader,
+    JSONLoader
+)
+
+load_dotenv()
+
+
+class QdrantDBClient:
+    def __init__(self):
+        self.collection_name = Config.COLLECTION_NAME
+        self.client = QdrantClient(url=os.getenv('QDRANT_URL'), api_key=os.getenv('QDRANT_API_KEY'))  # Qdrant - Cloud
+        #self.client = QdrantClient(path=Config.QDRANT_PERSIST_PATH)  # Qdrant - Local
+        self.embedder = BAAIEmbedder()
+        self.chunker = DocumentChunker()
+        self.normalizer = Normalizer()
+        self.nltk = NLTK()
+
+        if not self.client.collection_exists(self.collection_name):
+            self.client.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=VectorParams(
+                    size=self.embedder.model.get_sentence_embedding_dimension(),
+                    distance=Distance.COSINE,
+                )
+            )
+
+        # Optional performance optimization
+        self.client.update_collection(
+            collection_name=self.collection_name,
+            optimizers_config={"default_segment_number": 2}
+        )
+
+        # Add BM25 support on 'tokenized_text' field
+        self.client.create_payload_index(
+            collection_name=self.collection_name,
+            field_name="tokenized_text",
+            field_schema=TextIndexParams(
+                type=TextIndexType.TEXT,
+                tokenizer=TokenizerType.WHITESPACE,
+                min_token_len=1,
+                max_token_len=20,
+                lowercase=False
+            )
+        )
+
+    def tokenize_for_bm25(self, text: str) -> str:
+        norm_text = self.normalizer.normalize_text(text)
+        tokens = norm_text.split()
+        filtered_tokens = [t for t in tokens if t.lower() not in self.nltk.stopwords]
+        return " ".join(filtered_tokens)
+
+    def get_jq_schema(self, file_path: str) -> str:
+        """
+        Dynamically determines the jq_schema based on whether the JSON root is a list or a dict.
+        Handles:
+          - Root list: [. {...}, {...}]
+          - Root dict with list key: { "key": [ {...}, {...} ] }
+
+        Raises:
+            ValueError: If no valid list is found.
+        """
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        if isinstance(data, list):
+            return ".[]"
+
+        elif isinstance(data, dict):
+            for key, value in data.items():
+                if isinstance(value, list):
+                    return f".{key}[]"
+
+            raise ValueError("No list found in the top-level JSON object.")
+
+        else:
+            raise ValueError("Unsupported JSON structure: must be list or dict")
+
+    def load_excel_with_headers(self, file_path):
+        df = pd.read_excel(file_path)
+        docs = []
+
+        for i, row in df.iterrows():
+            text = "\n".join([f"{col}: {row[col]}" for col in df.columns])
+            metadata = {"source": file_path, "row_index": i}
+            docs.append(Document(page_content=text, metadata=metadata))
+
+        return docs
+
+    def load_and_chunk_docs(self, file_path: str) -> List[dict]:
+        ext = os.path.splitext(file_path)[1]
+        if ext == ".pdf":
+            docs = PDFPlumberLoader(file_path).load()
+        elif ext == ".docx":
+            docs = UnstructuredWordDocumentLoader(file_path).load()
+        elif ext == ".xlsx":
+            #docs = UnstructuredExcelLoader(file_path).load()
+            docs = self.load_excel_with_headers(file_path)
+        elif ext == ".pptx":
+            docs = UnstructuredPowerPointLoader(file_path).load()
+        elif ext == ".txt":
+            docs = TextLoader(file_path, encoding="utf-8").load()
+        elif ext == ".csv":
+            docs = CSVLoader(file_path).load()
+        elif ext == ".json":
+            docs = JSONLoader(file_path, jq_schema=self.get_jq_schema(file_path), text_content=False).load()
+        else:
+            return []
+
+        # Add source metadata to each Document
+        for doc in docs:
+            doc.metadata["source"] = os.path.basename(file_path)
+
+        return self.chunker.split_documents(docs)
+
+    def hash_text(self, text: str) -> str:
+        return hashlib.md5(text.encode('utf-8')).hexdigest()
+
+    def insert_chunks(self, chunk_dicts: List[dict]):
+        seen_hashes = set()
+        all_points = []
+
+        texts = [self.normalizer.normalize_text(d["text"]) for d in chunk_dicts]
+        embeddings = self.embedder.embed_documents(texts)
+
+        for i, chunk in enumerate(chunk_dicts):
+            text = self.normalizer.normalize_text(chunk["text"])
+
+            chunk_hash = self.hash_text(text)
+            if chunk_hash in seen_hashes:
+                continue
+            seen_hashes.add(chunk_hash)
+
+            tokenized_text = self.tokenize_for_bm25(text)
+
+            all_points.append(
+                PointStruct(
+                    id=chunk["id"],
+                    vector=embeddings[i],
+                    payload={
+                        "text": text,
+                        "tokenized_text": tokenized_text,
+                        **chunk["metadata"]
+                    }
+                )
+            )
+
+        for i in range(0, len(all_points), Config.BATCH_SIZE):
+            self.client.upsert(collection_name=self.collection_name, points=all_points[i:i + Config.BATCH_SIZE])
+
+    def search(self, query: str, top_k: int = Config.TOP_K) -> List[Document]:
+        query = self.normalizer.normalize_text(query)
+        query_embedding = self.embedder.embed_query(query)
+        query_tokens = self.tokenize_for_bm25(query).split()
+
+        # print(f"\n🔍 Query: {query}")
+        # print(f"🔑 Query Tokens: {query_tokens}")
+
+        # BM25 Search
+        bm25_results = self.client.scroll(
+            collection_name=self.collection_name,
+            scroll_filter=Filter(
+                should=[
+                    FieldCondition(
+                        key="tokenized_text",
+                        match=MatchText(text=token)
+                    ) for token in query_tokens
+                ]
+            ),
+            limit=top_k
+        )[0]
+
+        bm25_dict = {
+            pt.payload.get("text", ""): {
+                "source": "BM25",
+                "bm25_score": getattr(pt, "score", 0.0),  # Handle missing scores
+                "vector_score": 0.0,
+                "metadata": pt.payload or {}
+            }
+            for pt in bm25_results
+        }
+
+        # print(f"\n### BM25 Results ({len(bm25_dict)}):")
+        # for i, (text, info) in enumerate(bm25_dict.items(), 1):
+        #     print(f"{i}. {text[:100]}... | BM25 Score: {info['bm25_score']:.4f}")
+
+        # Vector Search (using query_points instead of deprecated search)
+        vector_results: List[ScoredPoint] = self.client.query_points(
+            collection_name=self.collection_name,
+            query=query_embedding,
+            limit=top_k,
+            with_payload=True,
+            with_vectors=False
+        ).points
+
+        vector_dict = {
+            pt.payload.get("text", ""): {
+                "source": "Vector",
+                "bm25_score": 0.0,
+                "vector_score": getattr(pt, "score", 0.0),  # Handle missing scores
+                "metadata": pt.payload or {}
+            }
+            for pt in vector_results
+        }
+
+        # print(f"\n### Vector Results ({len(vector_dict)}):")
+        # for i, (text, info) in enumerate(vector_dict.items(), 1):
+        #     print(f"{i}. {text[:100]}... | Vector Score: {info['vector_score']:.4f}")
+
+        # Merge & Deduplicate Results
+        combined_results: Dict[str, Dict] = {}
+
+        for text, info in bm25_dict.items():
+            combined_results[text] = {
+                "source": info["source"],
+                "bm25_score": info["bm25_score"],
+                "vector_score": 0.0,
+                "metadata": info["metadata"]
+            }
+
+        for text, info in vector_dict.items():
+            if text in combined_results:
+                combined_results[text]["source"] = "Hybrid"
+                combined_results[text]["vector_score"] = info["vector_score"]
+            else:
+                combined_results[text] = {
+                    "source": info["source"],
+                    "bm25_score": 0.0,
+                    "vector_score": info["vector_score"],
+                    "metadata": info["metadata"]
+                }
+
+        # Compute Hybrid Score
+        for text in combined_results:
+            combined_results[text]["final_score"] = (
+                    Config.ALPHA * combined_results[text]["bm25_score"]
+                    + (1 - Config.ALPHA) * combined_results[text]["vector_score"]
+            )
+
+        # Sort and return as LangChain Documents
+        sorted_results = sorted(combined_results.items(), key=lambda x: x[1]["final_score"], reverse=True)
+
+        # print(f"\n### Combined Results (Sorted by Final Score):")
+        # for i, (text, info) in enumerate(sorted_results, 1):
+        #     print(f"{i}. {text[:100]}... | Final Score: {info['final_score']:.4f} | "
+        #           f"BM25: {info['bm25_score']:.4f} | Vector: {info['vector_score']:.4f} | Source: {info['source']}")
+
+        return [
+            Document(
+                page_content=text,
+                metadata={
+                    **info["metadata"],
+                    "source": info["source"],
+                    "bm25_score": info["bm25_score"],
+                    "vector_score": info["vector_score"],
+                    "final_score": info["final_score"]
+                }
+            )
+            for text, info in sorted_results  # Don't Remove zero-score docs
+            #for text, info in sorted_results if info["final_score"] > 0  # Remove zero-score docs
+        ]
+
+    def export_all_documents(self, output_dir: str = Config.STORED_CHUNK_DIR):
+        """Export all inserted documents from Qdrant grouped by source."""
+        os.makedirs(output_dir, exist_ok=True)
+
+        file_text_map = {}
+        next_offset = None
+
+        while True:
+            points, next_offset = self.client.scroll(
+                collection_name=self.collection_name,
+                with_payload=True,
+                with_vectors=False,
+                limit=1000,  # You can tune this batch size
+                offset=next_offset
+            )
+
+            for pt in points:
+                payload = pt.payload or {}
+                source = payload.get("source", "unknown_file.txt")
+                text = payload.get("text", "")
+                if not text.strip():
+                    continue
+                file_text_map.setdefault(source, []).append((text, payload.get("chunk_order", 0)))
+
+            if next_offset is None:
+                break
+
+        # Write all collected texts grouped by file name
+        for source, chunks in file_text_map.items():
+            file_name = os.path.splitext(os.path.basename(source))[0]
+            file_path = os.path.join(output_dir, f"{file_name}.txt")
+
+            # Sort by chunk_order
+            sorted_chunks = sorted(chunks, key=lambda x: x[1])
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                for chunk_text, chunk_order in sorted_chunks:
+                    f.write(f"### Chunk Order: {chunk_order}\n")
+                    f.write(chunk_text.strip() + "\n\n---\n\n")
+
+        print(f"### Exported {len(file_text_map)} source files to '{output_dir}'")
+
+    def clear_qdrant_db(self):
+        if self.client.collection_exists(self.collection_name):
+            self.client.delete_collection(collection_name=self.collection_name) # deletes full collection
+            print("### All data is removed")
+
+
+if __name__ == "__main__":
+    qdrant_db_client = QdrantDBClient()
+    data_dir = Config.DATA_DIR
+
+    for filename in os.listdir(data_dir):
+        file_path = os.path.join(data_dir, filename)
+        ext = os.path.splitext(filename)[1].lower()
+
+        if os.path.isfile(file_path) and ext in Config.FILE_EXTENSIONS:
+            print(f"📄 Processing: {filename}")
+            chunk_dicts = qdrant_db_client.load_and_chunk_docs(file_path)
+            qdrant_db_client.insert_chunks(chunk_dicts)
+
+    print(f"### Total documents in collection: {qdrant_db_client.client.count(qdrant_db_client.collection_name)}")
+
+    qdrant_db_client.export_all_documents()
+    #qdrant_db_client.clear_qdrant_db()
+
+    query = "What is the full form of K12HSN?"
+    docs = qdrant_db_client.search(query)
+    print(f"\n### Retrieved {len(docs)} results:")
+    for i, doc in enumerate(docs, 1):
+        print(f"\n{i}. {doc.page_content[:]}...")
+

web_app.py

@@ -0,0 +1,155 @@
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import gradio as gr
+from agent import Agent
+from config import Config
+from memory.chat_memory import MemoryManager
+from utils.html_template import HtmlTemplates
+from vector_db.qdrant_db import QdrantDBClient
+from langchain_core.messages import HumanMessage, AIMessage
+
+
+class WebApp:
+    def __init__(self):
+        self.title = "RAGent Chatbot"
+        self.uploaded_files = None
+        self.upload_btn = None
+        self.progress_output = None
+        self.status_output = None
+        self.css = HtmlTemplates.css()
+
+        self.agent = Agent()
+        self.memory = MemoryManager()
+        self.qdrant_client = QdrantDBClient()
+
+    def build_ui(self):
+        with gr.Blocks(theme=gr.themes.Default(), css=self.css) as demo:
+            self.build_header()
+            with gr.Row():
+                self.build_upload_section()
+                self.build_chat_section()
+        return demo
+
+    def build_header(self):
+        with gr.Row():
+            with gr.Column():
+                gr.HTML(f"<h1 id='title'>💬 {self.title}</h1>")
+
+    def clear_outputs(self):
+        return "", ""
+
+    def build_upload_section(self):
+        with gr.Column(scale=3):
+            gr.Markdown("### 📂 Drag & Drop Files Below")
+            self.uploaded_files = gr.File(
+                file_types=Config.FILE_EXTENSIONS,
+                file_count="multiple",
+                label="pdf, docx, xlsx, pptx, csv, txt, json"
+            )
+            self.upload_btn = gr.Button(value="Upload Files", elem_id="upload-btn", icon=Config.UPLOAD_ICON)
+            self.progress_output = gr.HTML()
+            self.status_output = gr.Markdown()
+
+            self.upload_btn.click(
+                fn=self.clear_outputs,
+                inputs=[],
+                outputs=[self.progress_output, self.status_output]
+            ).then(
+                fn=self.upload_and_process,
+                inputs=self.uploaded_files,
+                outputs=[self.progress_output, self.status_output],
+                show_progress="hidden"
+            )
+
+    def build_chat_section(self):
+        with gr.Column(scale=7):
+            gr.Markdown("### 🤖 Ask Your Question")
+            gr.ChatInterface(
+                fn=self.run_agent,
+                type="messages",
+                show_progress="full",
+                save_history=False,
+            )
+
+    def run_agent(self, query, history):
+        session_id = Config.SESSION_ID
+
+        # Get history
+        past_messages = self.memory.get(session_id)
+
+        # Run agent (it appends the user query internally)
+        response = self.agent.run(query, past_messages)
+        #print("##### response : ", response)
+
+        # convert response to string. If response is a dict like {'input': ..., 'output': ...}
+        if isinstance(response, dict) and "output" in response:
+            answer = response["output"]
+        else:
+            answer = str(response)
+
+        # Save user + assistant message to memory
+        self.memory.add(session_id, HumanMessage(content=query))
+        self.memory.add(session_id, AIMessage(content=answer))
+
+        return f"‍🤖 {answer}"
+
+    def upload_and_process(self, files):
+        if not files or len(files) == 0:
+            yield HtmlTemplates.error_bar(), ""
+            return
+
+        total = len(files)
+        failed_files = []
+
+        for i, file in enumerate(files):
+            file_path = file.name  # path to temp file
+
+            try:
+                # Load, chunk, and insert to vector DB
+                file_chunks = self.qdrant_client.load_and_chunk_docs(file_path)
+                self.qdrant_client.insert_chunks(file_chunks)
+
+            except Exception as e:
+                failed_files.append(file_path)
+                yield HtmlTemplates.progress_bar(int((i + 1) / total * 100), i + 1, total), (
+                    f"⚠️ Skipped file {i + 1}/{total}: {os.path.basename(file_path)} - {str(e)}"
+                )
+                continue
+
+            percent = int((i + 1) / total * 100)
+            yield HtmlTemplates.progress_bar(percent, i + 1, total), f"📄 Processed {i + 1}/{total} file(s)..."
+
+        success_count = total - len(failed_files)
+        final_msg = f"✅ {success_count}/{total} file(s) processed and stored in DB!"
+
+        if failed_files:
+            failed_list = "\n".join(f"❌ {os.path.basename(f)}" for f in failed_files)
+            final_msg += f"\n\n⚠️ Failed to process:\n{failed_list}"
+
+        yield HtmlTemplates.progress_bar(100, total, total), final_msg
+
+    def upload_and_process1(self, files):
+        if not files or len(files) == 0:
+            yield HtmlTemplates.error_bar(), ""
+            return
+
+        total = len(files)
+
+        for i, file in enumerate(files):
+            file_path = file.name  # get file path of temporary folder
+
+            # Load, chunk, and insert to vector DB
+            file_chunks = self.qdrant_client.load_and_chunk_docs(file_path)
+            self.qdrant_client.insert_chunks(file_chunks)
+
+            percent = int((i + 1) / total * 100)
+            yield HtmlTemplates.progress_bar(percent, i + 1, total), f"📄 Processed {i + 1}/{total} file(s)..."
+
+        yield HtmlTemplates.progress_bar(100, total, total), f"✅ {total} file(s) processed and stored in DB!"
+
+
+if __name__ == "__main__":
+    app = WebApp()
+    demo = app.build_ui()
+    demo.launch()