init

Dockerfile

@@ -0,0 +1,24 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory in the container
+WORKDIR $HOME/src/app
+
+# Install any needed packages specified in requirements.txt
+COPY --chown=user requirements.txt ./
+RUN pip install -r requirements.txt
+
+# Copy the rest of your application's code
+COPY --chown=user ./src .
+
+# Make port 7860 available to the world outside this container
+EXPOSE 7860
+
+# Run app.py when the container launches
+CMD ["python", "./app.py"]

requirements.txt

@@ -0,0 +1,10 @@
+docarray==0.39.1
+langchain-pinecone==0.1.5
+sentence-transformers==2.3.1
+gradio==4.8.0
+langchain==0.1.5
+openai==1.3.8
+pypdf==3.17.2
+docx2txt==0.8
+tiktoken==0.5.2
+transformers==4.36.0

src/app.py

@@ -0,0 +1,64 @@
+import gradio as gr
+from utils import *
+
+with gr.Blocks(gr.themes.Soft(primary_hue=gr.themes.colors.slate, secondary_hue=gr.themes.colors.purple)) as demo:
+    with gr.Row():
+
+        with gr.Column(scale=1, variant = 'panel'):
+            # gr.HTML(f"<img src='file/logo.png' width='100' height='100'>")
+            files = gr.File(type="filepath", file_count="multiple")
+            with gr.Row(equal_height=True):
+                vector_index_btn = gr.Button('Create vector store', variant='primary',scale=1)
+                vector_index_msg_out = gr.Textbox(show_label=False, lines=1,scale=1, placeholder="Creating vectore store ...")
+            
+            instruction = gr.Textbox(label="System instruction", lines=3, value="Use the following pieces of context to answer the question at the end by. Generate the answer based on the given context only.If you do not find any information related to the question in the given context, just say that you don't know, don't try to make up an answer. Keep your answer expressive.")
+
+            with gr.Accordion(label="Text generation tuning parameters"):
+                temperature = gr.Slider(label="temperature", minimum=0.1, maximum=1, value=0.1, step=0.05)
+                max_new_tokens = gr.Slider(label="max_new_tokens", minimum=1, maximum=4096, value=1024, step=1)
+                k_context=gr.Slider(label="k_context", minimum=1, maximum=15, value=5, step=1)
+
+            vector_index_btn.click(upload_and_create_vector_store, inputs=[files], outputs=vector_index_msg_out)
+
+        with gr.Column(scale=1, variant = 'panel'):
+            """
+            with gr.Row(equal_height=True):
+
+                with gr.Column(scale=1):
+                    llm = gr.Dropdown(choices= ["gpt-3.5-turbo", "gpt-3.5-turbo-instruct", "gpt-3.5-turbo-16k", "gpt-4", "gpt-4-32k"], 
+                                       label="Select the model")
+
+                with gr.Column(scale=1):
+                    model_load_btn = gr.Button('Load model', variant='primary',scale=2)
+                    load_success_msg = gr.Textbox(show_label=False,lines=1, placeholder="Model loading ...")
+            """
+            with gr.Row(equal_height=True):
+                model_load_btn = gr.Button('Load model', variant='primary',scale=2)
+                load_success_msg = gr.Textbox(show_label=False,lines=1, placeholder="Model loading ...")
+            
+            chatbot = gr.Chatbot([], elem_id="chatbot", label='Chatbox', height=600)
+
+            txt = gr.Textbox(label= "Question",lines=2,placeholder="Enter your question and press shift+enter ")
+
+            with gr.Row():
+
+                with gr.Column(scale=1):
+                    submit_btn = gr.Button('Submit',variant='primary', size = 'sm')
+
+                with gr.Column(scale=1):
+                    clear_btn = gr.Button('Clear',variant='stop',size = 'sm')
+
+            model_load_btn.click(load_models, [],load_success_msg, api_name="load_models")
+
+            txt.submit(add_text, [chatbot, txt], [chatbot, txt]).then(
+                bot, [chatbot,instruction,temperature,max_new_tokens,k_context], chatbot)
+            submit_btn.click(add_text, [chatbot, txt], [chatbot, txt]).then(
+                bot, [chatbot,instruction,temperature, max_new_tokens,k_context], chatbot).then(
+                    clear_cuda_cache, None, None
+                )
+
+            clear_btn.click(lambda: None, None, chatbot, queue=False)
+
+if __name__ == '__main__':
+    # demo.queue(concurrency_count=3)
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)

src/conversation.py

@@ -0,0 +1,52 @@
+from langchain.chains import ConversationalRetrievalChain
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import PromptTemplate
+import pinecone
+from langchain_community.vectorstores import Pinecone
+from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+import os
+
+openai_api_key = os.environ.get("OPENAI_API_KEY")
+
+class Conversation_RAG:
+    def __init__(self, model_name="gpt-3.5-turbo"):
+        self.model_name = model_name
+
+    def get_vectordb(self):
+        index = pinecone.Index(os.environ.get("PINECONE_INDEX"))
+        embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-mpnet-base-v2",
+        )
+        vectordb = Pinecone(index, embeddings, "text")
+        
+        return vectordb
+    
+    def create_model(self, max_new_tokens=512, temperature=0.1):
+        llm = ChatOpenAI(
+            openai_api_key=openai_api_key,
+            model_name=self.model_name,
+            temperature=temperature,
+            max_tokens=max_new_tokens,
+            )
+    
+        return llm
+    
+    def create_conversation(self, model, vectordb, k_context=5, instruction="Use the following pieces of context to answer the question at the end by. Generate the answer based on the given context only. If you do not find any information related to the question in the given context, just say that you don't know, don't try to make up an answer. Keep your answer expressive."):
+
+        template = instruction + """
+        context:\n
+        {context}\n
+        data: {question}\n
+        """
+
+        QCA_PROMPT = PromptTemplate(input_variables=["instruction", "context", "question"], template=template)
+
+        qa = ConversationalRetrievalChain.from_llm(
+            llm=model,
+            chain_type='stuff',
+            retriever=vectordb.as_retriever(search_kwargs={"k": k_context}),
+            combine_docs_chain_kwargs={"prompt": QCA_PROMPT},
+            get_chat_history=lambda h: h,
+            verbose=True
+        )
+        return qa

src/setup.py

@@ -0,0 +1,16 @@
+from conversation import Conversation_RAG
+from vector_index import *
+
+class ModelSetup:
+    def __init__(self, model_name):
+
+        self.model_name = model_name
+
+    def setup(self):
+
+        conv_rag = Conversation_RAG(self.model_name)
+
+        self.vectordb = conv_rag.get_vectordb()
+        self.pipeline = conv_rag.create_model()
+
+        return "Model Setup Complete"

src/utils.py

@@ -0,0 +1,58 @@
+import gc
+from conversation import Conversation_RAG
+from vector_index import *
+from setup import ModelSetup
+import json
+
+def load_models(model_name="gpt-3.5-turbo"):
+    global conv_qa 
+    conv_qa = Conversation_RAG(model_name)
+    global model_setup
+    model_setup = ModelSetup(model_name)
+    success_prompt = model_setup.setup()
+    return success_prompt
+
+def get_chat_history(inputs):
+
+    res = []
+    for human, ai in inputs:
+        res.append(f"Human:{human}\nAssistant:{ai}")
+    return "\n".join(res)
+
+def add_text(history, text):
+
+    history = history + [[text, None]]
+    return history, ""
+
+
+def bot(history,
+        instruction="Use the following pieces of context to answer the question at the end. Generate the answer based on the given context only if you find the answer in the context. If you do not find any information related to the question in the given context, just say that you don't know, don't try to make up an answer. Keep your answer expressive.",
+        temperature=0.1,
+        max_new_tokens=512,
+        k_context=5,
+        ):
+
+    model = conv_qa.create_model(max_new_tokens=max_new_tokens, temperature=temperature)
+                             
+    qa = conv_qa.create_conversation(
+                             model=model,
+                             vectordb=model_setup.vectordb,
+                             k_context=k_context,
+                             instruction=instruction
+    )
+
+    chat_history_formatted = get_chat_history(history[:-1])
+    res = qa(
+        {
+            'question': history[-1][0],
+            'chat_history': chat_history_formatted
+        }
+    )
+
+    history[-1][1] = res['answer']
+    return history
+
+def clear_cuda_cache():
+
+    gc.collect()
+    return None

src/vector_index.py

@@ -0,0 +1,58 @@
+from pinecone import Pinecone
+from langchain_community.document_loaders import Docx2txtLoader
+from langchain.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings.huggingface import HuggingFaceEmbeddings
+import os, uuid
+
+def create_vector_store_index(file_path):
+
+    file_path_split = file_path.split(".")
+    file_type = file_path_split[-1].rstrip('/')
+
+    if file_type == 'csv':
+        loader = Docx2txtLoader(file_path)
+
+    elif file_type == 'pdf':
+        loader = PyPDFLoader(file_path)
+    
+    pages = loader.load()
+
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size = 512,
+        chunk_overlap = 128)
+
+    docs = text_splitter.split_documents(pages)
+
+    pc = Pinecone(
+        api_key=os.environ.get("PINECONE_API_KEY"),
+    )
+
+    index = pc.Index(os.environ.get("PINECONE_INDEX"))
+
+    embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-mpnet-base-v2",
+        )
+
+    batch_size = 32
+
+    for i in range(0, len(docs), batch_size):
+        i_end = min(len(docs), i+batch_size)
+        batch = docs[i:i_end]
+        ids = [str(uuid.uuid4()) for _ in batch]
+        texts = [x.page_content for x in batch]
+        embeds = embeddings.embed_documents(texts)
+        metadata = [
+            {'text': x.page_content, **x.metadata} for x in batch
+        ]
+        index.upsert(vectors=zip(ids, embeds, metadata))
+
+    return "Vector store index is created."
+
+
+def upload_and_create_vector_store(files):
+
+    for file in files:
+        index_success_msg = create_vector_store_index(file)
+
+    return index_success_msg