Synced repo using 'sync_with_huggingface' Github Action

.dockerignore

@@ -0,0 +1,4 @@
+.vercel
+.venv
+.idea
+__pycache__

.env.example

@@ -0,0 +1,10 @@
+# Authentication to HuggingFaceHub  
+HUGGINGFACEHUB_API_TOKEN=
+
+# Authentication Token secret 
+JWT_SECRET=
+
+# database
+MONGO_DB_URL=
+MONGO_DB_NAME=
+MONGO_DB_NAME_CACHE=

CreateEnv.ps1

@@ -0,0 +1,15 @@
+# Set the project directory and virtual environment name
+$venvName = "venv"
+
+# Check if the virtual environment folder exists
+$venvExists = Test-Path ($venvName)
+
+if (-not $venvExists) {
+    # Create virtual environment if it doesn't exist
+    Write-Host "Creating virtual environment..."
+    python -m venv $venvName
+}
+Write-Host "Activate venv"
+& venv\Scripts\Activate.ps1
+Write-Host "Installing dependencies..."
+python -m pip install -r "requirements.txt"

DATABASE.py

@@ -0,0 +1,13 @@
+from appConfig import *
+from pymongo import MongoClient
+
+
+class DATABASE():
+    client = None
+
+    def __init__(self):
+        self._initialize_mongodb_client()
+
+    def _initialize_mongodb_client(self):
+        if DATABASE.client is None:
+            DATABASE.client = MongoClient(ENV_VAR.MONGO_DB_URL)

Middleware.py

@@ -0,0 +1,65 @@
+from MongoChainGenerator import *
+from MongoEmbeddingGenerator import *
+from DATABASE import *
+from appConfig import LOG
+
+
+class Main:
+    qa_chains = {}
+    embedding_generator = None
+
+    def __init__(self) -> None:
+        DATABASE()
+        self._initialize_embedding_generator()
+        self._load_existing_qa_chains()
+
+    def _initialize_embedding_generator(self):
+        if Main.embedding_generator is None:
+            Main.embedding_generator = MongoEmbeddingGenerator(repo_id=CONST_VAR.EMBEDDING_MODEL_REPO_ID)
+            LOG.debug("Embedding generator initialized")
+
+    def _load_existing_qa_chains(self):
+        chats = DATABASE.client["chatData"]["chats"].find()
+        for chat in chats:
+            if chat["collectionName"] not in Main.qa_chains:
+                self.create_exist_chains(chat)
+
+    def create_exist_chains(self, chat):
+        if chat["collectionName"] not in Main.qa_chains:
+            qa_generator = MongoChainGenerator(
+                embedding_model=Main.embedding_generator.embedding_model,
+                db_collection_name=chat["collectionName"],
+                template_context=chat["templateContext"]
+            )
+            Main.qa_chains[chat["collectionName"]] = qa_generator.generate_retrieval_qa_chain()
+            LOG.debug("Chain created for collection " + chat["collectionName"])
+        else:
+            LOG.debug("Chain already exists for collection " + chat["collectionName"])
+
+    def generate_embedding(self, content: str, file_name: str, collection_name: str):
+        return Main.embedding_generator.generate_embeddings(content, file_name, collection_name)
+
+    def generate_tmp_embedding_and_chain(self, contents: str, tmp_collection_name):
+        qa_generator = MongoChainGenerator(
+            embedding_model=Main.embedding_generator.embedding_model,
+            template_context=CONST_VAR.TEMPLATE_CONTEXT,
+            tmp_vector_embedding=Main.embedding_generator.generate_tmp_embeddings(pdf_bytes=contents)
+        )
+        Main.qa_chains[tmp_collection_name] = qa_generator.generate_retrieval_qa_chain()
+        LOG.debug(tmp_collection_name + ' chain created')
+
+    def ask_question(self, question: str, collection_name):
+        if collection_name in Main.qa_chains:
+            try:
+                LOG.debug(collection_name + " answering")
+                response = Main.qa_chains[collection_name]({"query": question, "early_stopping": True, "min_length": 2000, "max_tokens": 5000})
+                return response["result"]
+            except Exception as e:
+                LOG.error("An error occurred while answering question: {}".format(str(e)))
+                return "Retry to ask question! An error occurred: {}".format(str(e))
+        else:
+            LOG.warning("Chain for collection '{}' not found.".format(collection_name))
+            return "Chain for collection '{}' not found.".format(collection_name)
+
+    def check_collection_name(self, collection_name):
+        return collection_name in self.qa_chains

MongoChainGenerator.py

@@ -0,0 +1,58 @@
+from appConfig import *
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+from langchain.llms.huggingface_endpoint import HuggingFaceEndpoint
+from langchain.vectorstores.mongodb_atlas import MongoDBAtlasVectorSearch
+from langchain.vectorstores.faiss import FAISS
+from huggingface_hub import login
+
+login(token=ENV_VAR.HUGGINGFACEHUB_API_TOKEN,write_permission=True,add_to_git_credential=True)
+
+class MongoChainGenerator:
+    LLM = None
+
+    def __init__(self, embedding_model, template_context, db_collection_name=None,tmp_vector_embedding=None):
+        if db_collection_name:
+            self._load_vectors(embedding_model, db_collection_name)
+        else:
+            self._create_tmp_retriever(tmp_vector_embedding)
+
+        self._initialize_prompt(template_context)
+        
+        if MongoChainGenerator.LLM is None:
+            self._initialize_llm()
+
+    def _create_tmp_retriever(self, tmp_vector_embedding: FAISS):
+        self.qa_retriever = tmp_vector_embedding.as_retriever(search_type="similarity", search_kwargs={"k": 7})
+        LOG.debug("Temporary retriever created")
+
+    def _load_vectors(self, embedding_model, db_collection_name):
+        self.qa_retriever = MongoDBAtlasVectorSearch.from_connection_string(
+            connection_string=ENV_VAR.MONGO_DB_URL,
+            namespace=ENV_VAR.MONGO_DB_NAME + "." + db_collection_name,
+            embedding=embedding_model,
+        ).as_retriever(search_type="similarity", search_kwargs={"k": 7})
+        LOG.debug("Retriever loaded from MongoDB Atlas")
+
+    def _initialize_prompt(self, template_context):
+        template = template_context + """
+        {context}
+        
+        Question: {question} all related details.
+        Answer:"""
+        self.prompt = PromptTemplate(template=template, input_variables=["context", "question"])
+        LOG.debug("Prompt template initialized")
+
+    def _initialize_llm(self):
+        MongoChainGenerator.LLM = HuggingFaceEndpoint(repo_id=CONST_VAR.TEXT_GENERATOR_MODEL_REPO_ID, temperature=0.8, max_new_tokens=4096)
+        # MongoChainGenerator.LLM = HuggingFaceHub(repo_id=CONST_VAR.TEXT_GENERATOR_MODEL_REPO_ID, model_kwargs={"temperature": 0.85, "return_full_text": False, "max_length": 4096, "max_new_tokens": 4096})
+        LOG.info("LLM initialized")
+
+    def generate_retrieval_qa_chain(self):
+        chain = RetrievalQA.from_chain_type(
+            llm=MongoChainGenerator.LLM,
+            retriever=self.qa_retriever,
+            chain_type_kwargs={"prompt": self.prompt},
+        )
+        LOG.debug("Retrieval QA chain generated")
+        return chain

MongoEmbeddingGenerator.py

@@ -0,0 +1,34 @@
+from io import BytesIO
+import PyPDF2
+from appConfig import *
+from DATABASE import *
+from langchain.vectorstores.faiss import FAISS
+from langchain.vectorstores.mongodb_atlas import MongoDBAtlasVectorSearch
+from langchain.embeddings.huggingface_hub import HuggingFaceHubEmbeddings
+
+class MongoEmbeddingGenerator:
+
+    def __init__(self, repo_id):
+        self.embedding_model = HuggingFaceHubEmbeddings(repo_id=repo_id, huggingfacehub_api_token=ENV_VAR.HUGGINGFACEHUB_API_TOKEN)
+        LOG.info("Embedding model initialised")
+
+    def _extract_text_from_pdf(self, pdf_bytes):
+        pdf_file = BytesIO(pdf_bytes)
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        return [pdf_reader.pages[page_num].extract_text() for page_num in range(len(pdf_reader.pages))]
+
+    def generate_tmp_embeddings(self, pdf_bytes):
+        texts = self._extract_text_from_pdf(pdf_bytes)
+        return FAISS.from_texts(texts=texts, embedding=self.embedding_model)
+
+    def generate_embeddings(self, pdf_bytes, file_name: str, collection_name: str):
+        client = DATABASE.client
+        if client[ENV_VAR.MONGO_DB_NAME_CACHE][collection_name].find_one({"src_file_name": file_name}):
+            LOG.debug(f"Vectors already exist in MongoDB for file {file_name}")
+            return f"Vectors already exist in MongoDB for file {file_name}"
+        else:
+            texts = self._extract_text_from_pdf(pdf_bytes)
+            client[ENV_VAR.MONGO_DB_NAME_CACHE][collection_name].insert_one({"src_file_name": file_name})
+            MongoDBAtlasVectorSearch.from_texts(texts=texts, embedding=self.embedding_model, collection=client[ENV_VAR.MONGO_DB_NAME][collection_name])
+            LOG.debug(f"Vectors stored in MongoDB for file {file_name}")
+            return f"Vectors stored in MongoDB for file {file_name}"

OtherFun.py

@@ -0,0 +1,38 @@
+from fastapi import UploadFile
+import asyncio
+from Middleware import Main
+from appConfig import LOG
+
+
+def delete_chain_after_delay(model: Main, chain_name: str):
+    async def delete_chain():
+        try:
+            await asyncio.sleep(7200)  # Sleep for 2 hours
+            if chain_name in model.qa_chains:
+                del model.qa_chains[chain_name]
+                # Log deletion
+                LOG.info(f"Chain '{chain_name}' deleted after 2 hours")
+        except Exception as e:
+            LOG.error(f"An error occurred while deleting chain '{chain_name}': {e}")
+
+    return delete_chain
+
+
+async def process_file(model: Main, collection_name: str, file: UploadFile):
+    try:
+        contents = await file.read()
+
+        file_extension = file.filename.split(".")[-1]
+
+        if file_extension == "pdf":
+            response = model.generate_embedding(
+                contents, file.filename, collection_name)
+        elif file_extension == "txt":
+            response = contents.decode("utf-8")
+        else:
+            raise ValueError(f"Unsupported file format for {file.filename}")
+
+        return response
+    except Exception as e:
+        LOG.error(f"An error occurred while processing file '{file.filename}': {e}")
+        return f"Error processing file '{file.filename}': {e}"

ReadME.md

@@ -0,0 +1,53 @@
+# Automated Legal Document Analysis and Question Answering System
+
+## Requirements
+### Python Version
+- Python 3.9.10
+
+### Huggingface API
+- Generate your API key and place it in the .env file:
+    ```
+    HUGGINGFACEHUB_API_TOKEN=""
+    ```
+
+## Setup Environment
+
+### Option 1: Automated Setup (PowerShell)
+- Run `CreateEnv.ps1` file in PowerShell. It will:
+    - Create a virtual environment
+    - Activate it
+    - Create temporary folders
+    - Install necessary Python modules
+
+### Option 2: Manual Setup
+- Create a virtual environment:
+    ```bash
+    python -m venv venv
+    ```
+- Activate virtual environment:
+    ```bash
+    venv\Scripts\Activate.ps1
+    ```
+- Install Python modules:
+    ```bash
+    python -m pip install -r "requirements.txt"
+    ```
+- Create folders:
+    1. Outputs
+    2. Models (if you want to download manually) (Not necessary)
+
+## References
+- [YouTube Video Reference](https://www.youtube.com/watch?v=dXxQ0LR-3Hg&t=123s)
+- [GitHub](https://github.com/curiousily/Get-Things-Done-with-Prompt-Engineering-and-LangChain)
+
+### Models
+- [gpt2](https://huggingface.co/gpt2)
+- [gte-small](https://huggingface.co/thenlper/gte-small)
+- [Mixtral](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1)
+
+### PDF Documents
+- [The Indian Penal Code](https://www.iitk.ac.in/wc/data/IPC_186045.pdf)
+
+
+### HuggingFaceHub Repository link: 
+- https://huggingface.co/spaces/dhruv4023/APIchatbot

appConfig.py

@@ -0,0 +1,62 @@
+import os
+import logging
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class ENV_VAR():
+    MONGO_DB_URL = os.environ.get("MONGO_DB_URL")
+    MONGO_DB_NAME = os.environ.get("MONGO_DB_NAME")
+    HUGGINGFACEHUB_API_TOKEN = os.environ.get("HUGGINGFACEHUB_API_TOKEN")
+    MONGO_DB_NAME_CACHE = os.environ.get("MONGO_DB_NAME_CACHE")
+    JWT_SECRET = os.environ.get("JWT_SECRET")
+
+
+class CONST_VAR():
+    TEXT_GENERATOR_MODEL_REPO_ID = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+    EMBEDDING_MODEL_REPO_ID = "sentence-transformers/all-MiniLM-L6-v2"
+    TEMPLATE_CONTEXT = """
+        Use the following pieces of context to answer the question at the end.
+        You should prefer information which are more related to asked question.
+        Make sure to rely on information from text only and not on questions to provide accurate responses.
+        When you find particular answer in given text, display its context useful, make sure to cite it in the your answer.
+        If you don't know the answer, just say that you don't know, don't try to make up an answer.
+        You can only use the given to you to answer the question.
+        Generate concise answers and relevant data related to the asked question.
+        You must represent the answer in proper format such as make points highlight some major information.
+        don't attach your created quetions. if you don't get answer from the given text just say i don't know and terminate answering.
+        if you get answer from the text than write all about the asked quetion and relevant data related to it.    
+        don't use your own knowledge just use the provided text to answer the question.  
+    """
+
+
+class LOG:
+    def __init__(self) -> None:
+        pass
+    
+    @staticmethod
+    def configure_logging(level=logging.INFO):
+        logging.basicConfig(level=level)  # Set the logging level
+        
+    @staticmethod
+    def debug(msg):
+        logging.debug(msg)
+        
+    @staticmethod
+    def info(msg):
+        logging.info(msg)
+        
+    @staticmethod
+    def warning(msg):
+        logging.warning(msg)
+        
+    @staticmethod
+    def error(msg):
+        logging.error(msg)
+        
+    @staticmethod
+    def critical(msg):
+        logging.critical(msg)
+
+LOG.configure_logging()  # Set logging level to INFO

docker-compose.yml

@@ -0,0 +1,5 @@
+services:
+  web:
+    build: .
+    ports:
+      - "8000:8000"

main.py

@@ -1,7 +1,86 @@
-from fastapi import FastAPI
+from pydantic import BaseModel
+from typing import List, Optional
+from fastapi.responses import JSONResponse
+from starlette.middleware import Middleware
+from starlette.middleware.gzip import GZipMiddleware
+from starlette.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, File, UploadFile, Depends, Form, BackgroundTasks
 
-app = FastAPI()
+from OtherFun import * 
+from Middleware import Main
+from verifyToken import verify_token_and_role
+# import os
+origins = ["https://chatbotservernode.onrender.com","https://cbns.vercel.app", "https://hfhchatbot.vercel.app", "http://localhost:5000", "http://localhost:3000", "https://localhost:5000"]
 
+# origins = os.getenv("ALLOWED_ORIGINS", "").split(",")
+
+app = FastAPI(debug=True)
+
+app.add_middleware(GZipMiddleware)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,  # You can replace '*' with specific origins
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],  # or specific methods
+    allow_headers=["Authorization", "Content-Type", "Accept"]  # or specific headers
+)
+
+model = Main()
+
+class BodyModel(BaseModel):
+    query: str
+    chain_name: Optional[str] = None  # Made chain_name optional
+    
 @app.get("/")
-async def read_root():
-    return {"message": "Hello, Dhruv!"}
+async def home():
+    return "chatbot api server is running..."
+
+
+@app.post("/ask")
+async def askQ(body: BodyModel, token: str = Depends(verify_token_and_role)):
+    try:
+        response = model.ask_question(body.query, token["username"] if body.chain_name is None else body.chain_name)
+        return JSONResponse(content={"success": True, "data": response})
+    except Exception as e:  # Catch specific exceptions
+        return JSONResponse(content={"success": False, "error": str(e)})
+
+
+@app.post("/create/embedding")
+async def createEmbedding(collection_name: str = Form(...), files: List[UploadFile] = File(None), token: str = Depends(verify_token_and_role)):
+    try:
+        if not files:
+            return JSONResponse(content={"success": False, "error":"No files provided"})
+        
+        responses = []
+        for file in files:
+            response = await process_file(model, collection_name, file)
+            responses.append(response)
+
+        return JSONResponse(content={"success": True,"responses": responses})
+    except Exception as e:
+        return JSONResponse(content={"success": False, "error": str(e)})
+
+
+@app.post("/create/tmp/chain")
+async def createTmpChain(background_tasks: BackgroundTasks, files: List[UploadFile] = File(...), token: str = Depends(verify_token_and_role)):
+    try:
+        if not files:
+            return JSONResponse(content={"success": False, "error":"No files provided"})
+                                
+        all_contents = b""
+        for file in files:
+            contents = await file.read()
+            all_contents += contents
+
+        file_extension = files[0].filename.split(".")[-1]
+        if file_extension == "pdf":
+            chain_name = token["username"]
+            model.generate_tmp_embedding_and_chain(all_contents, chain_name)
+            background_tasks.add_task(delete_chain_after_delay(model, chain_name))
+            return JSONResponse(content={"success": True, "message": "Chain created. Will be deleted after 2 hours."})
+        elif file_extension == "txt":
+            all_contents.decode("utf-8")
+            return JSONResponse(content={"success": False, "error": "Unsupported file format"})
+    except Exception as e:
+        return JSONResponse(content={"success": False, "error": str(e)})
+

requirements.txt

@@ -1,2 +1,27 @@
-fastapi
-uvicorn
+langchain==0.1.8
+python-dotenv==1.0.0
+
+# pdf
+PyPDF2==3.0.1
+pypdf==3.17.3
+
+# embedding
+InstructorEmbedding==1.0.1
+torch==2.2.1
+tqdm==4.66.2
+sentence-transformers==2.2.2
+faiss-cpu
+
+# mongodb
+pymongo==4.6.1
+
+# API-END point
+fastapi==0.109.2
+fastapi-cors
+uvicorn[standard]==0.17.*
+python-multipart==0.0.9
+PyJWT==2.8.0
+
+
+huggingface_hub
+typing

verifyToken.py

@@ -0,0 +1,26 @@
+from fastapi import HTTPException, Header, status
+from appConfig import ENV_VAR, LOG
+import jwt
+
+async def verify_token_and_role(authorization: str = Header(None)):
+    try:
+        if not authorization or not authorization.startswith("Bearer "):
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Token not provided or invalid")
+        
+        token = authorization.split("Bearer ")[1]
+
+        try:
+            verified = jwt.decode(token, ENV_VAR.JWT_SECRET, algorithms=["HS256"])
+            LOG.debug("Token verified successfully")
+        except jwt.ExpiredSignatureError:
+            LOG.debug("Token expired")
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Token expired")
+        
+        if "role" not in verified or verified["role"] not in ["user","admin"]:
+            LOG.error("Insufficient permissions")
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Insufficient permissions")
+        
+        return verified
+    except Exception as e:
+        LOG.error(f"An error occurred: {e}")
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))