HF spaces

.gitattributes

@@ -0,0 +1,41 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png
+.png
+frontend/images/architecture.png filter=lfs diff=lfs merge=lfs -text
+StudybotAPI/assets/*.png filter=lfs diff=lfs merge=lfs -text
+StudybotAPI/backend/data/History_1.pdf filter=lfs diff=lfs merge=lfs -text
+

.github/workflows/checkfilesize.yaml

@@ -0,0 +1,16 @@
+name: Check file size
+on:               # or directly `on: [push]` to run the action on every push on any branch
+  pull_request:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check large files
+        uses: ActionsDesk/lfs-warning@v2.0
+        with:
+          filesizelimit: 10485760 # this is 10MB so we can sync to HF Spaces

.github/workflows/githubtohfsync.yaml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://HemanthSai7:$HF_TOKEN@huggingface.co/spaces/HemanthSai7/StudybotAPI main

.gitignore

@@ -0,0 +1,137 @@
+marvin.toml
+.marvin-history
+marvin.egg-info
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+# dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# vector store
+studybot/vectorstore/
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+cpcli-env/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+COPY --chown=user ./StudybotAPI $HOME/StudybotAPI
+
+WORKDIR $HOME/StudybotAPI
+
+RUN mkdir $HOME/.cache
+
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,56 @@
+---
+title: StudybotAPI
+emoji: 😻
+colorFrom: gray
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+# StudyBot x Streamlit
+
+✨ Streamlit is an open-source app framework for Machine Learning and Data Science teams. Create beautiful data apps in hours, not weeks. All in pure Python. ✨
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Start development server
+
+> If you're using the default template, **remember to set the OpenAI API key** in `main.py`.
+
+Run the following command:
+
+```bash
+cd StudybotAPI
+uvicorn app:app --reload
+```
+
+Now go to [http://localhost:4000](http://localhost:4000) and start chatting with your bot! The bot will automatically reload when you change the code.
+
+## Motive
+When studying a theoretical subject, which has a lot of concepts, dates, important events etc. No matter how hard we try to momrize them, its hard to remember them all. So, I thought of making a bot which can help us in quick revision of the subject. For example, if we are studying history, and we forget the event of 1857 revolt, we can ask the bot like **"What happened in 1857?"** and it will tell us brief answer. This will help us in quick revision of the subject.
+
+## How to use
+Input the prompt in the text box and press enter. The bot will give you the answer. If you want to ask another question, just enter the question and the bot will try to answer.
+
+## Screenshots
+![image](StudybotAPI/assets/ss1.png)
+![image](StudybotAPI/assets/ss2.png)
+![image](StudybotAPI/assets/ss3.png)
+
+## How it works
+![image](StudybotAPI/assets/flowchart.png)
+
+## Tech Stack
+![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54)
+![FastAPI](https://img.shields.io/badge/FastAPI-005571?style=for-the-badge&logo=fastapi)
+![JavaScript](https://img.shields.io/badge/javascript-%23323330.svg?style=for-the-badge&logo=javascript&logoColor=%23F7DF1E)
+![HTML5](https://img.shields.io/badge/html5-%23E34F26.svg?style=for-the-badge&logo=html5&logoColor=white)
+![GitHub Actions](https://img.shields.io/badge/github%20actions-%232671E5.svg?style=for-the-badge&logo=githubactions&logoColor=white)
+![Langchain](https://img.shields.io/badge/langchain-%23E34F26.svg?style=for-the-badge&logo=langchains&logoColor=white)
+![Huggingface](https://img.shields.io/badge/huggingface-%23E34F26.svg?style=for-the-badge&logo=huggingface&logoColor=white)
+![Streamlit](https://img.shields.io/badge/streamlit-%23E34F26.svg?style=for-the-badge&logo=streamlit&logoColor=white)
+![Docker](https://img.shields.io/badge/docker-%23E34F26.svg?style=for-the-badge&logo=docker&logoColor=white)

StudybotAPI/app.py

@@ -0,0 +1 @@
+from backend import app

StudybotAPI/backend/__init__.py

@@ -0,0 +1,40 @@
+import os
+import box
+import yaml
+
+from fastapi import FastAPI
+
+from backend.ingestion import *
+
+# from langchain.llms.huggingface_pipeline import HuggingFacePipeline
+
+
+app = FastAPI(title="StudyBot API", version="0.1.0", description="API for StudyBot Project")
+
+from backend import routes
+# from backend.retriever import EmbeddingModel
+
+
+try:
+    os.environ["TRANSFORMERS_CACHE"] = "/.cache"
+
+    with open("config.yml", "r", encoding="utf8") as ymlfile:
+        cfg = box.Box(yaml.safe_load(ymlfile))
+    app.state.emb = Embeddings(cfg) 
+
+    # llm = HuggingFacePipeline(pipeline=EmbeddingModel._initialize_pipeline())
+    # llm = LlamaCpp(
+    #     streaming=True,
+    #     model_path="models/mistral-7b-instruct-v0.1.Q4_K_M.gguf",
+    #     max_tokens=1500,
+    #     temperature=0.4,
+    #     top_p=1,
+    #     gpu_layers=0,
+    #     stream=True,
+    #     verbose=False,
+    #     n_threads=int(os.cpu_count() / 2),
+    #     n_ctx=4096
+    # )
+
+except Exception as e:
+    print(e)

StudybotAPI/backend/core/ExceptionHandlers.py

@@ -0,0 +1,27 @@
+from backend import app
+from .Exceptions import *
+
+from fastapi.responses import JSONResponse
+from fastapi.requests import Request
+from fastapi import status
+
+@app.exception_handler(ModelDeploymentException)
+async def model_deploying_exception_handler(request: Request, exc: ModelDeploymentException):
+    return JSONResponse(
+        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+        content=repr(exc)
+    )
+
+@app.exception_handler(InfoNotProvidedException)
+async def info_not_provided_exception_handler(request: Request, exc: InfoNotProvidedException):
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content=repr(exc)
+    )
+
+@app.exception_handler(DataNotUploadedException)
+async def data_not_uploaded_exception_handler(request: Request, exc: DataNotUploadedException):
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content=repr(exc)
+    )

StudybotAPI/backend/core/Exceptions.py

@@ -0,0 +1,48 @@
+from backend.schemas import FrontendResponseModel
+
+
+class ModelDeploymentException(Exception):
+    def __init__(self, response_result: FrontendResponseModel):
+        self.response_result = response_result
+        self.set_status()
+        super(ModelDeploymentException, self).__init__()
+
+    def set_status(self):
+        self.response_result["status"] = "Error"
+        self.response_result["message"][0]="Model is deploying. Please try again later."
+
+    def __repr__(self):
+        return f"exception.ModelDeployingException()"
+    
+
+
+class InfoNotProvidedException(Exception):
+    def __init__(self, response_result: FrontendResponseModel, message: str):
+        self.response_result = response_result
+        self.message = message
+        self.set_status()
+        super(InfoNotProvidedException, self).__init__(message)
+
+    def set_status(self):
+        self.response_result["status"] = "Error"
+        self.response_result["message"][0] = "Information not provided."
+        self.response_result["message"].append(self.message)
+
+    def __repr__(self):
+        return f"exception.InfoNotProvidedException()"
+
+
+class DataNotUploadedException(Exception):
+    def __init__(self, response_result: FrontendResponseModel):
+        self.response_result = response_result
+        self.set_status()
+        super(ModelDeploymentException, self).__init__()
+
+    def set_status(self):
+        self.response_result["status"] = "Error"
+        self.response_result["message"].append(
+            "Data not uploaded. Please upload a file."
+        )
+
+    def __repr__(self):
+        return f"exception.DataNotUploadedException()"

StudybotAPI/backend/core/configEnv.py

@@ -0,0 +1,24 @@
+"""Config class for handling env variables.
+"""
+from functools import lru_cache
+from pydantic import BaseSettings
+
+
+class Settings(BaseSettings):
+    QDRANT_API_KEY: str
+    APP_ID: str
+    USER_ID: str
+    MODEL_ID: str
+    CLARIFAI_PAT: str
+    MODEL_VERSION_ID: str
+
+    class Config:
+        env_file = ".env"
+
+
+@lru_cache()
+def get_settings():
+    return Settings()
+
+
+config = get_settings()

StudybotAPI/backend/ingestion/__init__.py

@@ -0,0 +1,3 @@
+from .embeddings import Embeddings
+from .prepare_data import *
+from .preprocess_data import *

StudybotAPI/backend/ingestion/embeddings.py

@@ -0,0 +1,55 @@
+from langchain.vectorstores import Qdrant
+from langchain.embeddings import HuggingFaceBgeEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+import shutil
+import warnings
+from backend.ingestion import *
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+
+class Embeddings:
+    def __init__(self, cfg):
+        self.cfg = cfg
+
+    def split_docs(self, documents, chunk_size=1000, chunk_overlap=150):
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size, chunk_overlap=chunk_overlap
+        )
+        docs = text_splitter.split_documents(documents)
+        return docs
+
+    def store_embeddings(self, docs):
+        embeddings = HuggingFaceBgeEmbeddings(
+            model_name=self.cfg.EMBEDDINGS,
+            model_kwargs={"device": self.cfg.DEVICE},
+            encode_kwargs={"normalize_embeddings": self.cfg.NORMALIZE_EMBEDDINGS}
+            # cache_folder = self.cfg.CACHE_FOLDER
+        )
+
+        shutil.rmtree(self.cfg.VECTOR_DB, ignore_errors=True)
+
+        texts = self.split_docs(docs)
+
+        vector_store = Qdrant.from_documents(
+            texts,
+            embeddings,
+            # path=self.cfg.VECTOR_DB,
+            location=":memory:",
+            # host="localhost",
+            # prefer_grpc=True,
+            collection_name=self.cfg.VECTOR_DB,
+        )
+
+        print(f"Vector store created at {self.cfg.VECTOR_DB}")
+
+        return vector_store
+
+
+# with open("config.yml", "r", encoding="utf8") as ymlfile:
+#     cfg = box.Box(yaml.safe_load(ymlfile))
+# emb = Embeddings(cfg)
+
+# docs=PDFDataLoader(cfg.DATA_PATH).load()
+# emb.store_embeddings(docs)

StudybotAPI/backend/ingestion/prepare_data.py

@@ -0,0 +1,79 @@
+import os
+from typing import Iterator
+
+from langchain.schema import Document
+from langchain.document_loaders.base import BaseLoader
+from langchain.document_loaders import PyPDFLoader, TextLoader, DirectoryLoader
+
+from .preprocess_data import make_texts_tokenisation_safe
+
+
+class DataLoader(BaseLoader):
+    def __init__(self, data_dir: str):
+        self.data_dir = data_dir
+        self.metadata = {}
+
+    def lazy_load(self) -> Iterator[Document]:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} does not implement lazy_load()"
+        )
+
+    def load(self):
+        documents = list(self.lazy_load())
+        self.metadata.update({"num_documents": len(documents)})
+        return documents
+
+
+class PDFDataLoader(DataLoader):
+    def __init__(self, data_dir: str):
+        super().__init__(data_dir)
+        self.metadata = {
+            "data_dir": data_dir,
+            "loader": "PDFDataLoader",
+            "num_documents": None,
+        }
+
+    @make_texts_tokenisation_safe
+    def lazy_load(self) -> Iterator[Document]:
+        try:
+            # document = DirectoryLoader(
+            #     self.data_dir, glob="*.pdf", loader_cls=PyPDFLoader
+            # ).load()
+            document = PyPDFLoader(self.data_dir).load()
+            for doc in document:
+                doc.metadata["file_type"] = os.path.splitext(doc.metadata["source"])[-1]
+            return document
+
+        except Exception as e:
+            print(f"Error loading : {e}")
+            return None
+
+
+class TextDataLoader(DataLoader):
+    def __init__(self, data_dir: str):
+        super().__init__(data_dir)
+        self.metadata = {
+            "data_dir": data_dir,
+            "loader": "TextDataLoader",
+            "num_documents": None,
+        }
+
+    @make_texts_tokenisation_safe
+    def lazy_load(self) -> Iterator[Document]:
+        try:
+            document = DirectoryLoader(
+                self.data_dir, glob="*.txt", loader_cls=TextLoader
+            ).load()
+            for doc in document:
+                doc.metadata["file_type"] = os.path.splitext(doc.metadata["source"])[-1]
+            return document
+
+        except Exception as e:
+            print(f"Error loading : {e}")
+            return None
+
+
+# pdf_loader = PDFDataLoader(data_dir="E:/Projects/Hackathons/StudyBot/data")
+
+# documents = pdf_loader.load()
+# print(documents)

StudybotAPI/backend/ingestion/preprocess_data.py

@@ -0,0 +1,35 @@
+import tiktoken
+
+def make_texts_tokenisation_safe(func):
+    encoding = tiktoken.get_encoding("cl100k_base")
+    special_tokens_set = encoding.special_tokens_set
+
+    def remove_special_tokens(text):
+        for token in special_tokens_set:
+            text = text.replace(token, "")
+        return text
+
+    def wrapper(*args, **kwargs):
+        documents = func(*args, **kwargs)
+        for document in documents:
+            document.page_content = remove_special_tokens(document.page_content)
+        return documents
+
+    return wrapper
+
+
+# def remove_whitespace(func):
+#     def wrapper(*args, **kwargs):
+#         result = func(*args, **kwargs)
+#         if isinstance(result, str):
+#             return result.replace(" ", "").replace("\t", "").replace("\n", "")
+#         elif isinstance(result, bytes):
+#             return (
+#                 result.decode("utf-8")
+#                 .replace(" ", "")
+#                 .replace("\t", "")
+#                 .replace("\n", "")
+#             )
+#         return result
+
+#     return wrapper

StudybotAPI/backend/retriever/__init__.py

@@ -0,0 +1,2 @@
+from .ops import *
+from .pipeline import *

StudybotAPI/backend/retriever/ops.py

@@ -0,0 +1,25 @@
+from backend.schemas import *
+
+from backend.core.Exceptions import *
+from backend.core.ExceptionHandlers import *
+from backend import app
+
+from clarifai_grpc.grpc.api.status import status_code_pb2
+
+def ops_inference(response_result: FrontendResponseModel, question: str):
+
+    if question == "":
+        raise InfoNotProvidedException(response_result, "Come on, I'm not telepathic. I can't read your mind. Please provide me with a question.")
+
+    try:
+        llm_response = app.state.qa_chain(question)
+        output = Inference(
+            answer=llm_response["result"].strip(),
+            source_documents=llm_response["source_documents"],
+        )
+
+        response_result["result"] = output.dict()
+    except Exception as e:
+        response_result["status"] = "error"
+        response_result["message"].append(str(e))
+        raise ModelDeploymentException(response_result)

StudybotAPI/backend/retriever/pipeline.py

@@ -0,0 +1,72 @@
+import torch
+
+from transformers import (
+    BitsAndBytesConfig,
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    GenerationConfig,
+    pipeline,
+)
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+class EmbeddingModel:
+    def __init__(self, model_name, generation_config):
+        self.model_name = model_name
+        self.generation_config = generation_config
+        self.tokenizer = self._initialize_tokenizer()
+        self.model = self._initialize_model()
+
+    def _initialize_tokenizer(self):
+        tokenizer = AutoTokenizer.from_pretrained(self.model_name, use_fast=True)
+        tokenizer.pad_token = tokenizer.eos_token
+        return tokenizer
+
+    def _initialize_model(self):
+        quantization_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_use_double_quant=True,
+        )
+        
+        model = AutoModelForCausalLM.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16,
+            trust_remote_code=True,
+            device_map="auto",
+            quantization_config=quantization_config,
+        )
+        return model
+
+    def _initialize_generation_config(self):
+        generation_config = GenerationConfig.from_pretrained(self.model_name)
+        generation_config.max_new_tokens = 1024
+        generation_config.temperature = 0.0001
+        generation_config.top_p = 0.95
+        generation_config.do_sample = True
+        generation_config.repetition_penalty = 1.15
+        return generation_config
+
+    def _initialize_pipeline(self):
+        pipeline_obj = pipeline(
+            "text-generation",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            return_full_text=True,
+            generation_config=self.generation_config,
+        )
+        return pipeline_obj
+
+
+# if __name__ == "__main__":
+#     MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.1"
+
+#     text_generator = MyTextGenerator(
+#         MODEL_NAME, MyTextGenerator._initialize_generation_config()
+#     )
+#     generated_text = text_generator.generate_text()
+#     print(generated_text)

StudybotAPI/backend/routes.py

@@ -0,0 +1,65 @@
+import os
+import shutil
+from pathlib import Path
+from typing import Callable
+from tempfile import NamedTemporaryFile
+
+from fastapi import Request, BackgroundTasks
+from fastapi import UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+
+from backend import app
+from backend.schemas import *
+from backend.retriever import *
+from backend.utils import *
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/", tags=["Home"])
+def api_home():
+    return {"detail": "Welcome to Studybot API"}
+
+
+@app.post("/api/upload", response_model=DataResponseModel,summary="Upload", tags=["Resource Server"])
+async def upload_data(file: UploadFile = File(...)):
+
+    response_result = {
+        "status": "success",
+        "message": ["Data uploaded successfully."]
+    }
+
+    try:
+        suffix = Path(file.filename).suffix
+        with NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+            shutil.copyfileobj(file.file, tmp)
+            tmp_path = os.path.join(os.getcwd(), tmp.name)
+    except Exception as e:
+        response_result["status"] = "error"
+        response_result["message"][0]=str(e)
+        raise DataNotUploadedException(response_result)
+    
+    finally:
+        file.file.close()
+
+    await llm_chain_loader(DATA_PATH=tmp_path)
+    return response_result
+
+
+@app.post("/api/inference",summary="Inference",response_model=FrontendResponseModel,tags=["Resource Server"])
+def inference(data: Chat):
+    response_result = {
+        "status": "success",
+        "message": [""], 
+        "result": {}
+    }
+
+    ops_inference(response_result, data.promptMessage)
+    return response_result

StudybotAPI/backend/schemas/FrontendResponseSchema.py

@@ -0,0 +1,12 @@
+from typing import List
+from pydantic import BaseModel
+
+
+class FrontendResponseModel(BaseModel):
+    status: str
+    message: List[str]
+    result: dict
+
+class DataResponseModel(BaseModel):
+    status: str
+    message: List[str]

StudybotAPI/backend/schemas/__init__.py

@@ -0,0 +1,2 @@
+from .chatschema import *
+from .FrontendResponseSchema import *

StudybotAPI/backend/schemas/chatschema.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+from fastapi import File, UploadFile
+
+
+class Inference(BaseModel):
+    answer: str
+    source_documents: list
+
+class Chat(BaseModel):
+    promptMessage: str
+
+class Upload(BaseModel):
+    file : UploadFile

StudybotAPI/backend/utils/__init__.py

@@ -0,0 +1 @@
+from .chain_loader import *

StudybotAPI/backend/utils/chain_loader.py

@@ -0,0 +1,40 @@
+from backend.ingestion import *
+from backend import app
+from backend.core.configEnv import config
+
+from langchain.chains import (
+    LLMChain,
+    SimpleSequentialChain,
+    RetrievalQA,
+    ConversationalRetrievalChain,
+)
+from langchain.llms import Clarifai
+from langchain.prompts import PromptTemplate
+
+
+async def llm_chain_loader(DATA_PATH: str):
+    docs = PDFDataLoader(DATA_PATH).load()
+    db = app.state.emb.store_embeddings(docs)
+
+    with open("backend/utils/prompt.txt", "r", encoding="utf8") as f:
+        prompt = f.read()
+
+    prompt = PromptTemplate(template=prompt, input_variables=["context", "question"])
+
+    llm = Clarifai(
+        pat=config.CLARIFAI_PAT,
+        user_id=config.USER_ID,
+        app_id=config.APP_ID,
+        model_id=config.MODEL_ID,
+        model_version_id=config.MODEL_VERSION_ID,
+    )
+
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=db.as_retriever(search_type="similarity",search_kwargs={"k": 2}),
+        return_source_documents=True,
+        chain_type_kwargs={"prompt": prompt},
+    )
+
+    app.state.qa_chain = qa_chain

StudybotAPI/backend/utils/prompt.txt

@@ -0,0 +1,12 @@
+[INST] <>
+You are a revolutionary educational AI bot to assist students in quick revisions of theoretical subjects, which often involve numerous concepts, dates, and important events. You need to answer such that it aids in recalling key information for efficient study sessions. If you do not know the answer reply with 'I am sorry, I dont have enough information.
+ALWAYS return a "SOURCES" part in your answer.
+The "SOURCES" part should be a reference to the source of the document from which you got your answer.
+<>
+
+{context}
+
+Consider a student engaged in the study of any theoretical subject, where the abundance of concepts and events poses a challenge to memorization. The aim is to overcome this hurdle and be capable of providing brief answers to specific queries. For example, if a student forgets a key concept, date, or event, they can ask the bot a question like "What is [specific query]?" for a concise answer.
+Note that students can also ask multiple questions in a single query. For example, "What is [specific query 1]?, What is [specific query 2]?, What is [specific query 3]?".
+
+{question} [/INST]

StudybotAPI/backend/utils/prompts.py

@@ -0,0 +1,62 @@
+social_sciences_teacher = """
+[INST] <>
+You are a revolutionary educational AI bot to assist students in quick revisions of theoretical subjects, which often involve numerous concepts, dates, and important events. You need to answer such that it aids in recalling key information for efficient study sessions. If you do not know the answer reply with 'I am sorry, I dont have enough information.
+ALWAYS return a "SOURCES" part in your answer.
+The "SOURCES" part should be a reference to the source of the document from which you got your answer.
+<>
+
+{context}
+
+Consider a student engaged in the study of any theoretical subject, where the abundance of concepts and events poses a challenge to memorization. The aim is to overcome this hurdle and be capable of providing brief answers to specific queries. For example, if a student forgets a key concept, date, or event, they can ask the bot a question like "What is [specific query]?" for a concise answer.
+Note that students can also ask multiple questions in a single query. For example, "What is [specific query 1]?, What is [specific query 2]?, What is [specific query 3]?".
+
+{question} [/INST]
+"""
+
+
+english_teacher = """
+[INST] <>
+You are an innovative language learning AI designed to assist students in improving their English language skills. Your goal is to provide helpful and engaging responses that aid in language comprehension, grammar, and vocabulary building. If you are unable to answer a question, respond with 'I am sorry, I don't have enough information.'
+ALWAYS include a "RESOURCES" section in your answer, providing guidance on where students can find additional information or practice materials.
+<>
+
+{context}
+
+Imagine a student immersed in the study of the English language, aiming to enhance their understanding of grammar, vocabulary, and overall language proficiency. Your role is to assist them by providing concise and informative answers to specific language-related queries. For instance, if a student is uncertain about a grammatical rule or the meaning of a word, they can ask you questions like "What is [specific query]?" for clear and detailed responses.
+Keep in mind that students may pose multiple questions within a single query. For example, "What is the meaning of [specific query 1]?, How do I use [specific query 2] in a sentence?, Can you explain the grammar rule for [specific query 3]?".
+
+{question} [/INST]
+"""
+
+
+science_teacher = """
+[INST] <>
+You are a cutting-edge science education AI, dedicated to helping students grasp complex scientific concepts and theories. Your mission is to provide insightful and understandable explanations to foster a deeper understanding of various scientific topics. If you don't have enough information to answer a question, respond with 'I am sorry, I don't have enough information.'
+Always include a "REFERENCES" section in your answer, directing students to relevant sources for further exploration.
+<>
+
+{context}
+
+Envision a student engrossed in the study of science, navigating through intricate theories and phenomena. Your purpose is to assist them by offering clear and concise answers to their scientific inquiries. For instance, if a student is struggling to comprehend a particular scientific concept or needs clarification on an experiment, they can pose questions like "What is [specific query]?" for detailed responses.
+It's important to note that students might present multiple questions within a single query. For instance, "Explain [specific query 1]?, How does [specific query 2] work?, Can you provide examples of [specific query 3]?".
+
+{question} [/INST]
+"""
+
+prompt_infos = [
+    {
+        "name": "Math Teacher",
+        "description": "Good for answering questions about Social Sciences subject like History, Geography, Civics, etc.",
+        "prompt_template": social_sciences_teacher,
+    },
+    {
+        "name": "Spanish Teacher",
+        "description": "Good for answering questions about English Language",
+        "prompt_template": english_teacher,
+    },
+    {
+        "name": "Calculus Teacher",
+        "description": "Good for answering questions about Science subjects like Physics, Chemistry, Biology, etc.",
+        "prompt_template": science_teacher,
+    },
+]

StudybotAPI/config.yml

@@ -0,0 +1,10 @@
+CHUNK_SIZE: 1000
+CHUNK_OVERLAP: 100
+NUM_RESULTS: 3
+EMBEDDINGS: "BAAI/llm-embedder"
+VECTOR_DB: "./vectorstore/studybotstore"
+NORMALIZE_EMBEDDINGS: True
+COLLECTION_NAME: "studybotstore"
+DEVICE: "cpu"
+VECTOR_SPACE: "cosine"
+CACHE_FOLDER: "./cache"

StudybotAPI/requirements.txt

@@ -0,0 +1,15 @@
+fastapi==0.99.1
+uvicorn
+requests
+langchain==0.0.346
+pydantic==1.10.2
+pypdf
+python-box
+qdrant-client
+torch
+transformers
+sentence_transformers
+clarifai
+Pillow
+tiktoken
+python-multipart

frontend/components/__init__.py

@@ -0,0 +1,2 @@
+from .authors import *
+from .user_greetings import *

frontend/components/authors.py

@@ -0,0 +1,13 @@
+import json
+import streamlit as st
+
+
+def authors():
+    st.sidebar.divider()
+    st.sidebar.info(
+        """
+    Follow me on:
+
+    Github → [@HemanthSai7](https://github.com/HemanthSai7)
+    """
+    )

frontend/components/user_greetings.py

@@ -0,0 +1,6 @@
+import streamlit as st
+
+def user_greetings():
+    with st.sidebar.expander("👋 Greetings!", expanded=True):
+        st.write("Welcome to Studybot! This is a tool to help you revise your subjects. You can use the sidebar to navigate to the different pages. Have fun!")
+        st.write("If you have any feedback, please contact me on [LinkedIn](https://www.linkedin.com/in/hemanthsai7/) or [GitHub](https://github.com/HemanthSai7).")

frontend/layouts/mainlayout.py

@@ -0,0 +1,19 @@
+import json
+import streamlit as st
+from typing import Callable
+from components import authors, user_greetings
+
+
+def mainlayout(func: Callable):
+    def wrapper():
+        with open("layouts/st_page_layouts.json", "r", encoding="utf-8") as f:
+            st_page_layouts = json.load(f)
+
+        st.set_page_config(**st_page_layouts[f"{func.__name__}" if func.__name__ in st_page_layouts.keys() else "home"])
+        st.markdown('# :rainbow[Welcome to Studybot]🚀')
+        user_greetings()
+        authors()
+
+        func()
+
+    return wrapper

frontend/layouts/st_page_layouts.json

@@ -0,0 +1,14 @@
+{
+  "home": {
+    "page_title": "Studybot",
+    "layout": "wide",
+    "page_icon": "🏡",
+    "initial_sidebar_state": "expanded"
+  },
+  "bot": {
+    "page_title": "Chatbot",
+    "layout": "wide",
+    "page_icon": "💻",
+    "initial_sidebar_state": "expanded"
+  }
+}

frontend/pages/2_🤖_bot.py

@@ -0,0 +1,9 @@
+import streamlit as st
+
+from layouts.mainlayout import mainlayout
+
+@mainlayout
+def bot():
+    st.subheader("Revise your subjects with Studybot!")
+
+bot()

frontend/requirements.txt

@@ -0,0 +1 @@
+streamlit

frontend/test.py

@@ -0,0 +1,26 @@
+import streamlit as st
+
+import requests
+
+# from studybot import qa_chain
+# st.write(qa_chain)
+
+upload_pdf = st.file_uploader("Upload PDF", type="pdf")
+if upload_pdf is not None:
+    files = {"file": upload_pdf}
+    response = requests.post(
+        "https://hemanthsai7-studybotapi.hf.space/api/upload", files=files
+    )
+    st.write(response)
+
+query = st.text_input("Question", key="question")
+st.write(st.session_state)
+
+if st.button("Ask"):
+    # answer = qa_chain(query)
+    answer = requests.post(
+        "https://hemanthsai7-studybotapi.hf.space/api/inference",
+        json={"promptMessage": query},
+    ).json()
+    st.write(answer)
+    # st.session_state["question"] = ""

frontend/🏡_Home.py

@@ -0,0 +1,65 @@
+import streamlit as st
+
+from layouts.mainlayout import mainlayout
+
+
+@mainlayout
+def home():
+    st.subheader("Revise your subjects with Studybot!")
+
+    st.markdown(
+        """
+            <p style='text-align: justify;'>
+                <b>Studybot</b> is a <b>free</b> and <b>open-source</b> tool for <b>automated</b> and <b>personalized</b> learning. 
+                It is a <b>chatbot</b> that helps you to <b>learn</b> and <b>memorize</b> new information in a <b>fun</b> and <b>easy</b> way.  
+                Studybot is <b>free</b> and <b>open-source</b>, so you can use it <b>without any limitations</b> and <b>without any costs</b>. 
+                You can also <b>customize</b> it to your needs and <b>contribute</b> to its development. 
+                <b>Enjoy</b> your learning with Studybot!
+            </p>
+            """,
+        unsafe_allow_html=True,
+    )
+
+    with st.expander("How does it work?", expanded=True):
+        st.markdown(
+            """
+            - When you upload a document, it will be divided into smaller chunks and stored in a special type of database called a vector index that allows for semantic search and retrieval. I'm using Qdrant vector database for this purpose.
+
+            - When you ask a question, Studybot will search through the document chunks and find the most relevant ones using the vector index. Then, it will use Mistral-7B-instruct to generate a final answer.
+
+            """
+        )
+
+    with st.expander("FAQs 🤔"):
+        st.markdown(
+            """
+            - **What is the best way to upload a document?**<br>
+            The best way to upload a document is to upload a PDF file. Studybot will automatically divide it into smaller chunks. You can also upload a text file. In this case, Studybot will divide it into smaller chunks.
+
+            - **What is the best way to ask questions?**<br>
+            The best way to ask questions is to ask questions that are related to the document you uploaded. If you ask questions that are not related to the document you uploaded, Studybot will not be able to answer them.
+
+            - **Is my data safe?**<br>
+            Yes, your data is safe. Studybot does not store your documents or questions. All uploaded data is deleted after you close the browser tab since it is stored in the RAM memory. However, if you want to be sure that your data is safe, you can use the `Clear data 🧹` button to delete all uploaded data.
+
+            - **Why does it take so long to index my document?**<br>
+            When you upload a document, it is divided into smaller chunks and stored in a special type of database called a vector index that allows for semantic search and retrieval. It takes some time to index your document because it has to be divided into smaller chunks and stored in the vector index. However, once your document is indexed, it will be much faster to search through it.
+
+            - **Are the answers 100% accurate?**<br>
+              - No, the answers are not 100% accurate. Studybot uses Mistral-7B to generate answers. Mistral-7B is a powerful language model, but it sometimes makes mistakes and is prone to hallucinations. Also, Studybot uses semantic search to find the most relevant chunks and does not see the entire document, which means that it may not be able to find all the relevant information and may not be able to answer all questions (especially summary-type questions or questions that require a lot of context from the document).
+
+              - But for most of the time, Studybot is very accurate and can answer most questions. Always check with the sources to make sure that the answers are correct.
+
+            - **What is the best way to contribute to Studybot?**<br>
+            The best way to contribute to Studybot is to create an issue on GitHub. I will be happy to answer your questions and help you with your contributions.
+            """,
+            unsafe_allow_html=True,
+        )
+    
+    st.divider()
+    # architecture heading in the middle
+    st.markdown("<h2 style='text-align: center; color: black;'>Studybot Architecture</h1>", unsafe_allow_html=True)
+    st.image("images/architecture.png")
+
+
+home()

test.py

@@ -0,0 +1,26 @@
+class A:
+    def __init__(self):
+        self._bill = 1
+
+    @property
+    def bill(self):
+        return self._bill
+    
+    @bill.setter
+    def bill(self,value):
+        self._bill = value
+        # raise PermissionError("You can't change the bill")
+
+class B(A):
+    def __init__(self):
+        super().__init__()
+        self._bill = 2
+
+# b = B()
+# print(b.bill)
+a=A()
+a.bill=3
+print(a.bill)
+
+
+