gradio

retrievingQueryResponse.py → app.py

@@ -1,39 +1,49 @@
-import chromadb
+import gradio as gr
 import os
-from langchain_chroma import Chroma
-from chromadb.config import  DEFAULT_DATABASE, DEFAULT_TENANT
 import time
+import chromadb
+from langchain_chroma import Chroma
 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):
-
+from langchain_core.documents import Document
+
+# Initialize in-memory ChromaDB client
+# This client runs entirely within the app.py script.
+client = chromadb.Client()
+
+# Load your embeddings model
+model_kwargs = {"device": "cpu"} # Hugging Face Spaces typically use CPU for free tiers
+encode_kwargs = {"normalize_embeddings": True}
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/paraphrase-distilroberta-base-v1",
+    model_kwargs=model_kwargs,
+    encode_kwargs=encode_kwargs,
+)
+
+# Initialize the vector DB using the in-memory client
+# You'll need to embed your documents here. In a real-world app, you'd load them from a file.
+# For a demo, let's create a dummy document.
+vectorDB = Chroma(
+    client=client,
+    collection_name="embeddings",
+    embedding_function=embeddings,
+)
+# Example of adding a document. You would replace this with your actual documents.
+sample_doc = "This is a sample document about the history of artificial intelligence. It was created to demonstrate the RAG pipeline."
+vectorDB.add_documents([Document(page_content=sample_doc, metadata={"docId": "my_doc_id"})])
+
+# Your existing functions without the HttpClient call
+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."
@@ -41,112 +51,59 @@ def using_ollama_model(retriever, query, results,conversation_history):
     Context:{results}
     Question:{query}
     """
-
-    # Initialize the PromptTemplate
-
+    
     template = PromptTemplate(
-        input_variables=["history","results", "query"], template=prompt_template,
+        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",
-    )
+    answer = rag_chain.invoke({"history": history_text, "results": doc_texts, "query": query})
+    
+    return answer
 
-    # retriever = vectorDB.as_retriever(
-    # search_type="mmr",
-    # search_kwargs={
-    #     "k": 6, # was 5 originally
-    #     "lambda_mult": 1, # was 0.30 originally
-    #     "filter": {"docId": docId}
-    # }
-    # )
+def retrievingReponse(docId, query, conversation_history):
     retriever = vectorDB.as_retriever(
-    search_type="similarity",
-    search_kwargs={
-        "k": 4, # was 5 originally
-        # "lambda_mult": 1, # was 0.30 originally
-        "filter": {"docId": docId}
-    }
+        search_type="similarity",
+        search_kwargs={
+            "k": 4,
+            "filter": {"docId": docId}
+        }
     )
-
-      # retriever = vectorDB.as_retriever()
-    print("<<<<<<<<<<<<<<<< Retriever >>>>>>>>>>>>>>>>")
-    # print("d",retriever)
-    print("\n")
-
-    results = retriever.invoke(
-        query
-    ) 
-
+    
+    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"
+            ans = result.page_content.replace("\n", "")
+            unique_results.append(ans)
+            seen_texts.add(result.page_content)
 
-    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
 
+# Gradio interface
+def gradio_rag_wrapper(query, history):
+    rag_history = []
+    for user_msg, bot_msg in history:
+        rag_history.append({"question": user_msg, "answer": bot_msg})
+
+    docId = "my_doc_id"
+    response = retrievingReponse(docId, query, rag_history)
+    
+    return response
+
+demo = gr.ChatInterface(
+    fn=gradio_rag_wrapper,
+    title="Your RAG Chatbot on Hugging Face Spaces",
+    description="Ask questions about the document to get answers.",
+)
+
+if __name__ == "__main__":
+    demo.launch()

imagequerying.py

@@ -1,50 +0,0 @@
-# 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

@@ -1,3 +1,6 @@
+# UI
+gradio
+
 # Core LLM / RAG dependencies
 ollama
 chromadb

run.py

@@ -1,166 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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.")