Contextual ChatBot

app.py

@@ -1,70 +0,0 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
-
-if __name__ == "__main__":
-    demo.launch()

imagequerying.py

@@ -0,0 +1,50 @@
+# import cv2
+# import torch
+# import ollama
+# import base64
+# import os
+# import time
+# from sentence_transformers import SentenceTransformer, util
+# import chromadb
+# import os
+# from langchain.schema import Document  # Import the Document class from LangChain
+# import re
+# import fitz
+# from langchain_chroma import Chroma
+# from chromadb.config import Settings, DEFAULT_DATABASE, DEFAULT_TENANT
+# from chromadb.utils import embedding_functions
+# from langchain.text_splitter import RecursiveCharacterTextSplitter
+# from langchain.chains.qa_with_sources.retrieval import RetrievalQAWithSourcesChain
+# from langchain_huggingface import HuggingFaceEmbeddings
+# from langchain_core.prompts import PromptTemplate
+# from langchain_core.output_parsers import StrOutputParser
+# from langchain_ollama import ChatOllama
+
+
+# def vision_model(file_path, query):
+#     """Processes an image and queries the LLaMA vision model."""
+#     print("<<<<< VISION MODEL STARTED >>>>>")
+
+#     image = cv2.imread(file_path)
+#     if image is None:
+#         return "Error: Failed to load image."
+
+#     _, buffer = cv2.imencode(".jpg", image)
+#     image_base64 = base64.b64encode(buffer).decode("utf-8")
+
+#     prompt = f"""
+#     Please describe the following image based on the given query.
+#     If the query is not relevant, respond with: 
+#     "Sorry, I don't have enough information from this specific image."
+    
+#     Query: {query}
+#     """
+
+#     try:
+#         response = ollama.chat(
+#             model="llama3.2-vision",
+#             messages=[{"role": "user", "content": prompt, "images": [image_base64]}],
+#         )
+#         return response.get("message", {}).get("content", "").strip()
+#     except Exception as e:
+#         return f"Error: {str(e)}"

requirement.txt

@@ -0,0 +1,30 @@
+# Core LLM / RAG dependencies
+ollama
+chromadb
+langchain
+langchain-community
+sentence-transformers
+
+# For PDF, text & image handling
+pypdf
+pdfplumber
+Pillow
+pytesseract
+
+# Web API / Backend
+flask
+flask-cors
+requests
+
+# Data handling
+pandas
+numpy
+
+# Optional: Streamlit UI
+streamlit
+
+# For environment/config management
+python-dotenv
+
+# If you use MongoDB for storing docs/chat
+pymongo

retrievingQueryResponse.py

@@ -0,0 +1,152 @@
+import chromadb
+import os
+from langchain_chroma import Chroma
+from chromadb.config import  DEFAULT_DATABASE, DEFAULT_TENANT
+import time
+import transformers
+from langchain_community.llms import CTransformers
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.prompts import PromptTemplate
+from transformers import pipeline
+from langchain_core.output_parsers import StrOutputParser
+from langchain_ollama import ChatOllama
+
+
+
+
+
+
+
+
+
+client = chromadb.HttpClient("http://localhost:8000")
+
+
+def using_ollama_model(retriever, query, results,conversation_history):
+
+    history_text = ""
+    for item in conversation_history:
+        if "question" in item and item["question"]:
+            history_text += f"User: {item['question']}\n"
+        if "answer" in item and item["answer"]:
+            history_text += f"Assistant: {item['answer']}\n"
+
+    print("<<<<<< LLM MODEL STARTED >>>>>>")
+    print(" ========>", history_text)
+    # Ensure the prompt template is well-structured
+    prompt_template = """
+    You are a helpful assistant. Answer the following question using the provided context and previous conversation history.
+    If the context does not contain the answer, only then reply with: "Sorry, I don't have enough information."
+    Conversation History :{history} 
+    Context:{results}
+    Question:{query}
+    """
+
+    # Initialize the PromptTemplate
+
+    template = PromptTemplate(
+        input_variables=["history","results", "query"], template=prompt_template,
+    )
+
+    doc_texts = "\\n".join([doc.page_content for doc in results])
+
+    formatted_output = template.format(history=history_text,results=doc_texts, query=query)
+
+    print("<<<<<<<<<<< Formatted Output >>>>>>>>>>>")
+    print(formatted_output)
+    print("type of formatted output is ", type(formatted_output))
+
+
+    llm = ChatOllama(model="llama3.2", temperature=0.4, num_predict=512)
+
+    rag_chain = template | llm | StrOutputParser()
+
+    # results = retriever.invoke(query)
+    # doc_texts = "\\n".join([doc.page_content for doc in results])
+
+    answer = rag_chain.invoke({"history" : history_text,"results": doc_texts, "query": query})
+
+    return answer
+
+    # # Set up the RAG pipeline
+    # rag_pipeline = RetrievalQAWithSourcesChain.from_chain_type(
+    #     llm=llm, chain_type="stuff", retriever=retriever
+    # )
+    #
+    # try:
+    # #     # answer = rag_pipeline.run(formatted_output)
+    #     answer = rag_pipeline.invoke(formatted_output)
+    #     return answer
+    # except Exception as e:
+        # print(f"Error occurred during invocation: {e}")
+        # return None
+
+
+
+
+
+
+def retrievingReponse(docId, query, conversation_history) :
+    
+    model_kwargs = {"device": "mps"}
+    encode_kwargs = {"normalize_embeddings": True}
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/paraphrase-distilroberta-base-v1",
+        model_kwargs=model_kwargs,
+        encode_kwargs=encode_kwargs,
+    )
+
+    vectorDB = Chroma(
+        collection_name="embeddings",
+        embedding_function=embeddings,  # Using the encode method to get embeddings
+        persist_directory="MM_CHROMA_DB",
+    )
+
+    # retriever = vectorDB.as_retriever(
+    # search_type="mmr",
+    # search_kwargs={
+    #     "k": 6, # was 5 originally
+    #     "lambda_mult": 1, # was 0.30 originally
+    #     "filter": {"docId": docId}
+    # }
+    # )
+    retriever = vectorDB.as_retriever(
+    search_type="similarity",
+    search_kwargs={
+        "k": 4, # was 5 originally
+        # "lambda_mult": 1, # was 0.30 originally
+        "filter": {"docId": docId}
+    }
+    )
+
+      # retriever = vectorDB.as_retriever()
+    print("<<<<<<<<<<<<<<<< Retriever >>>>>>>>>>>>>>>>")
+    # print("d",retriever)
+    print("\n")
+
+    results = retriever.invoke(
+        query
+    ) 
+
+    unique_results = []
+    seen_texts = set()
+
+    for result in results:
+        print(result)
+        # If the result's content has not been seen before, process it
+        if result.page_content not in seen_texts:
+            ans = result.page_content
+            ans = ans.replace("\n", "")  # Clean the content by removing newlines
+            unique_results.append(ans)  # Add the cleaned answer to the results list
+            seen_texts.add(result.page_content)  # Mark this text as seen
+
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+    start = time.time()
+
+    # llm_result = using_llm_model(retriever, query, results)
+    llm_result = using_ollama_model(retriever, query, results, conversation_history)
+    end = time.time()
+    print("Inference Time:>>>>>>> ", end - start)
+    return llm_result
+

run.py

@@ -0,0 +1,166 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from pymongo import MongoClient
+import uuid
+import os
+from storingEmbedding import process_pdf
+# from imagequerying import vision_model
+from retrievingQueryResponse import retrievingReponse
+from storeConversation import storingConversation
+
+
+app = Flask(__name__)
+CORS(app) 
+
+# MongoDB Connection
+client = MongoClient("mongodb://localhost:27017/") 
+db = client["document_system"]
+docs_collection = db["documents"]
+query_collection = db["queryStorage"]
+
+UPLOAD_FOLDER = "uploads"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+IMAGE_EXTENSIONS = {".png", ".svg", ".jpeg", ".jpg"}
+
+@app.route("/getDoc", methods=["GET"])
+def retireveAllDoc ():
+    documents = list(docs_collection.find({}, {"_id": 0}))  # Exclude `_id`
+    return jsonify(documents)
+
+@app.route("/upload", methods=["POST"])
+def upload_document():
+    """Upload a document (PDF or Image), generate a unique ID, and store metadata."""
+    if 'file' not in request.files:
+        return jsonify({"error": "No file part in the request."}), 400
+
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({"error": "No file selected."}), 400
+    
+    file_ext = os.path.splitext(file.filename)[1].lower()
+    
+    if file_ext not in IMAGE_EXTENSIONS and file_ext != ".pdf":
+        return jsonify({"error": "Unsupported file type."}), 400
+    
+    doc_id = str(uuid.uuid4())
+    file_path = os.path.join(UPLOAD_FOLDER, file.filename)
+    file.save(file_path)
+
+    doc_type = "pdf" if file_ext == ".pdf" else "image"
+
+    # Store metadata in MongoDB
+    docs_collection.insert_one({
+        "doc_id": doc_id,
+        "doc_name": file.filename,
+        "doc_type": file_ext,
+        "file_path": file_path,
+        "doc_Category" :doc_type
+    })
+
+    if file_ext == ".pdf":
+        process_pdf(doc_id, file_path)
+
+    return jsonify({
+        "message": "Document uploaded successfully.",
+        "doc_id": doc_id,
+        "doc_name": file.filename,
+        "doc_type": file_ext
+    }), 201
+
+@app.route("/askBot", methods=["POST"])
+def retrieve_answer():
+    print("dfghjkl")
+    """Retrieve an answer for the given query (text-based or image-based)."""
+    data = request.json
+
+    userId = data.get('userId')
+    userName = data.get('userName')
+    query = data.get('query')
+    docId = data.get('doc_id')
+
+    # Get document details from MongoDB
+    doc_info = docs_collection.find_one({"doc_id": docId})
+    chat_info = query_collection.find_one({"doc_id":docId})
+
+    if not doc_info:
+        return jsonify({"error": "Document ID not found"}), 404
+    
+    file_type = doc_info["doc_type"]
+    file_path = doc_info["file_path"]
+    doc_name = doc_info['doc_name']
+    conversation_history = chat_info['conversation']
+
+    if file_type == ".pdf":
+        response = retrievingReponse(docId, query, conversation_history)
+    elif file_type in IMAGE_EXTENSIONS:
+        response = vision_model(file_path, query)
+    else:
+        return jsonify({"error": "Unsupported file type"}), 400
+
+    
+    storingConversation(docId,query,response,doc_name)
+
+    return jsonify({
+        "question":query,
+        "answer": response,
+        "doc_id": docId
+    }), 201
+
+
+@app.route("/getChat", methods=["GET"])
+def get_chats():
+    
+    doc_id = request.args.get("doc_id") 
+
+    if doc_id:
+        # Fetch complete chat history for the given doc_id
+        chat_session = query_collection.find_one({"doc_id": doc_id}, {"_id": 0})
+        if not chat_session:
+            return jsonify({"error": "No chat found for this document"}), 404
+        return jsonify(chat_session)
+
+    else:
+        # Fetch only doc_id and chatHeading for all documents
+        all_chats = list(query_collection.find({}, {"_id": 0, "doc_id": 1, "chatHeading": 1,"doc_name":1}))
+        return jsonify({"chats": all_chats})
+
+@app.route("/deleteDoc", methods=["DELETE"])
+def delete_document():
+    """Delete a document and its associated data."""
+    doc_id = request.args.get("doc_id")
+
+    if not doc_id:
+        return jsonify({"error": "Missing doc_id"}), 400
+
+    doc_info = docs_collection.find_one({"doc_id": doc_id})
+    if not doc_info:
+        return jsonify({"error": "Document not found"}), 404
+
+    # Delete physical file
+    file_path = doc_info.get("file_path")
+    if file_path and os.path.exists(file_path):
+        os.remove(file_path)
+
+    # Delete from MongoDB
+    docs_collection.delete_one({"doc_id": doc_id})
+    query_collection.delete_many({"doc_id": doc_id})  # for all chats of that doc
+
+    return jsonify({"message": "Document and related data deleted successfully."}), 200
+
+@app.route("/viewDoc", methods=["GET"])
+def view_doc():
+    doc_name = request.args.get("docName")
+    if not doc_name:
+        return jsonify({"error": "Missing doc_name"}), 400
+
+    # Optional: check if file actually exists
+    file_path = os.path.join(UPLOAD_FOLDER, doc_name)
+    if not os.path.isfile(file_path):
+        return jsonify({"error": "File not found"}), 404
+
+    return jsonify({
+        "url": f"/uploads/{doc_name}"
+    })
+
+if __name__ == "__main__":
+    app.run(debug=True, host='0.0.0.0', port=5001)

storeConversation.py

@@ -0,0 +1,26 @@
+from pymongo import MongoClient
+
+
+client = MongoClient("mongodb://localhost:27017/")  # Update the URI if needed
+db = client["document_system"]
+query_collection = db["queryStorage"]
+
+def storingConversation (doc_id,user_query,model_reply,doc_name ):
+    existing_chat = query_collection.find_one({"doc_id": doc_id})
+
+    if not existing_chat:
+        # Create new chat session with the first message as chatHeading
+        chat_session = {
+            "doc_id": doc_id,
+            "doc_name":doc_name,
+            "chatHeading": user_query,  # First question becomes the heading
+            "conversation": []
+        }
+        query_collection.insert_one(chat_session)
+
+
+    # Update the conversation array in MongoDB
+    query_collection.update_one(
+        {"doc_id": doc_id},
+        {"$push": {"conversation": {"question": user_query, "answer": model_reply}}}
+    )

storingEmbedding.py

@@ -0,0 +1,128 @@
+from sentence_transformers import SentenceTransformer, util
+import chromadb
+import os
+from langchain.schema import Document
+import re
+import fitz
+from langchain_chroma import Chroma
+# from langchain.utils import embedding_functions
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+import shutil
+
+
+def initialize_chroma_db(collection_name, embeddings, persist_directory):
+    try:
+        print("Trying to load existing Chroma DB...")
+        vectorDB = Chroma(
+            collection_name=collection_name,
+            embedding_function=embeddings,
+            persist_directory=persist_directory,
+        )
+        print("Chroma DB loaded successfully.")
+        return vectorDB
+    except Exception as e:
+        print(f"Error loading Chroma DB: {e}")
+        print("Deleting corrupted persist directory and rebuilding...")
+        if os.path.exists(persist_directory):
+            shutil.rmtree(persist_directory)
+        # Recreate
+        vectorDB = Chroma(
+            collection_name=collection_name,
+            embedding_function=embeddings,
+            persist_directory=persist_directory,
+        )
+        print("New Chroma DB created.")
+        return vectorDB
+
+# Function to extract text from PDF
+def extract_text_from_pdf(pdf_file):
+    try:
+        if os.path.exists(pdf_file):
+            doc = fitz.open(pdf_file)
+            text = ""
+            for page in doc:
+                text += page.get_text("text")
+            return text
+        else:
+            print("No pdf file exists by this name.")
+    except Exception as e:
+        print(e)
+
+# Function to clean symbols using regex
+def applying_symbol_regex(text):
+    remove_symbols_text = re.sub(r"""[,._/?''"";{}\-*&^%$#@!,\\|()+=`~<>]""", "", text)
+    return remove_symbols_text
+
+# Function to clean whitespaces
+def clean_text(input_text):
+    cleaned_text = re.sub(r"\s+ ", " ", input_text)
+    cleaned_text = cleaned_text.strip()
+    clean_text = cleaned_text.replace("\n", "")
+    return clean_text
+
+# Main processing function
+def process_pdf(docId,pdf_file_path, collection_name="embeddings", persist_directory="./MM_CHROMA_DB"):
+    print(docId)
+    # Extract text from the PDF
+    pdf_result = extract_text_from_pdf(pdf_file_path)
+
+    # Apply regex to remove symbols
+    regex_result = applying_symbol_regex(pdf_result)
+
+    # Clean text result
+    clean_text_result = clean_text(regex_result)
+    print("Total tokens without symbols  in a PDF => ", len(clean_text_result))
+    
+    document = Document(page_content=clean_text_result)
+    print("came here")
+    # Splitting the document into chunks
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=30)
+    chunks = text_splitter.split_documents([document])
+
+    # Set up the embedding function
+    model_kwargs = {"device": "mps"}
+    encode_kwargs = {"normalize_embeddings": True}
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/paraphrase-distilroberta-base-v1",
+        model_kwargs=model_kwargs,
+        encode_kwargs=encode_kwargs,
+    )
+    print("beore vectorDB")
+    print("persist_directory exists:", os.path.exists(persist_directory))
+
+    # Set up the Chroma database
+    vectorDB = initialize_chroma_db(collection_name, embeddings, persist_directory)
+    print("after vectorDB")
+
+    metadata_chunks = []
+    # Concatenate all chunks into a single string
+    for i, chunk in enumerate(chunks):
+        # Add metadata to each chunk
+        metadata = {"source": f"example_source_{i}", "docId":str(docId)}
+        id = str(i)
+        doc_with_metadata = Document(
+            page_content=chunk.page_content, metadata=metadata, id=id,docId=docId
+        )
+        metadata_chunks.append(doc_with_metadata)
+ 
+    print("Done")
+
+    # Add the documents to the vector database
+    try:
+        vectorDB.add_documents(metadata_chunks)
+    except:
+        raise Exception()
+    
+    # for i, chunk in enumerate(chunks):
+    #     metadata = {"source": f"example_source_{i}"}
+        
+    #     # Use the same document ID for all chunks
+    #     doc_with_metadata = Document(
+    #         page_content=chunk.page_content, metadata=metadata, id=docId
+    #     )
+    #     print(f"Chunk {i} => {chunk.page_content}")
+    #     print("\n")
+
+
+    print("Documents have been added to the vector database.")