init

.gitignore

@@ -0,0 +1,4 @@
+venv
+__pycache__
+files
+.env

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10-slim
+
+COPY ./pyproject.toml /code/pyproject.toml
+RUN pip install --no-cache-dir --upgrade .
+
+# Set home to the user's home directory
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 8000
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port 8000 & python3 app.py"]

app.py

@@ -0,0 +1,46 @@
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_core.messages import AIMessage, HumanMessage
+from pydantic import BaseModel
+import time
+import gradio as gr
+import requests
+from typing import Generator
+    
+chat_history = []
+
+def generate_response(chat_input: str, bot_message: str) -> Generator[str, str, str] | str:
+    url = "http://127.0.0.1:8000/generatechat/"
+    payload = {
+        'question': chat_input,
+    }
+    headers = {
+        'Content-Type': 'application/json'
+    }
+    
+    response = requests.post(url, json=payload, headers=headers)
+    if response.status_code == 200:
+        data = response.json()
+        answer = data['response']['answer']
+        print("Success:", response.json())
+        
+        # Get a typewriting animation response
+        partial_response = ""
+        for char in answer:
+            partial_response += char
+            yield partial_response
+            time.sleep(0.005)
+    else:
+        print("Error:", response.status_code, response.text)
+        return f"Error: {response.status_code}, {response.text}"
+        
+with gr.Blocks() as demo:
+    with gr.Column():
+
+        chatbot = gr.ChatInterface(
+            fn=generate_response, 
+            title="AskmeAboutRAG Chat",
+            description="RAG model for asking about RAG",
+        )
+
+if __name__ == "__main__":
+    demo.launch()

main.py

@@ -0,0 +1,47 @@
+from langchain_core.messages import AIMessage, HumanMessage
+from fastapi import FastAPI
+from langchain_pinecone.vectorstores import Pinecone
+from pydantic import BaseModel
+from rag import Rag
+from retriever import AskMeAboutRagRetriever
+from langchain_huggingface import HuggingFaceEmbeddings
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+api_key=os.getenv('PINECONE_KEY')
+index_name="askmeaboutrag" 
+
+vectorstore = Pinecone(pinecone_api_key=api_key, index_name=index_name, embedding=HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2"))
+retriever = AskMeAboutRagRetriever(vectorstore)
+rag_llm = Rag(vectorstore, retriever);
+
+rag_llm.createRagChain()
+
+chat_history = []
+
+class ChatInput(BaseModel):
+    question: str
+
+app = FastAPI() 
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+
+@app.post("/generatechat/")
+async def generateResponse(chat_input: ChatInput):
+    ai_msg = rag_llm.generateResponse(chat_input.question, chat_history)
+    chat_history.extend(
+        [
+            HumanMessage(content=chat_input.question),
+            AIMessage(content=ai_msg["answer"]),
+        ]
+    )
+    return {"response": ai_msg}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+    print("Server is running")

pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "askmeaboutrag"
+version = "0.1.0"
+description = "RAG model for asking about RAG"
+authors = ["microhum, Beamlnwza, SupeemAFK, GGital"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+langchain="0.2.14"
+langchain_community="0.2.12"
+langchain_groq= "*"
+langchain_huggingface = "*"
+langchain_openai= "*"
+langchain-pinecone= "*"
+pypdf= "*"
+fastapi= "*"
+gradio = "^4.44.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

rag.py

@@ -0,0 +1,86 @@
+from langchain.chains import create_retrieval_chain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.prompts import MessagesPlaceholder
+from langchain.chains import create_history_aware_retriever
+from langchain_pinecone.vectorstores import Pinecone
+from uuid import uuid4
+from langchain_groq import ChatGroq
+from langchain.schema.retriever import BaseRetriever
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+class Rag:
+    def __init__(self, vectorstore: Pinecone, retriever: BaseRetriever):
+        self.model = ChatGroq(
+            model="llama-3.1-70b-versatile",
+            temperature=0,
+            max_tokens=None,
+            timeout=None,
+            max_retries=2,
+            api_key=os.getenv('GROQ_API_KEY')
+        )
+        self.system_prompt = (
+           """
+            You are "Ask me about RAG", a knowledgeable librarian specializing in RAG research papers. A user has requested assistance with research paper recommendations.
+
+            We have retrieved {num_docs} research paper(s) related to the user's query. These papers are listed below:
+
+            {context}
+
+            Please provide detailed information for EACH research paper retrieved, including:
+            1. The title of the research paper.
+            2. A concise summary of its content, highlighting key findings or topics covered.
+            3. Relevant details for locating or referencing the paper (e.g., a link, DOI, university, journal name, or organization).
+
+            Format your response as a numbered list, preserving the order in which the papers were retrieved.
+            """
+        )
+        self.contextualize_q_system_prompt = (
+            "Given a chat history and the latest user question "
+            "which might reference context in the chat history, "
+            "formulate a standalone question which can be understood "
+            "without the chat history. Do NOT answer the question, "
+            "just reformulate it if needed and otherwise return it as is."
+        )
+
+        self.contextualize_q_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", self.contextualize_q_system_prompt),
+                MessagesPlaceholder("chat_history"),
+                ("human", "{input}"),
+            ]
+        )
+        self.qa_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", self.system_prompt),
+                MessagesPlaceholder("chat_history"),
+                ("human", "{input}"),
+            ]
+        )
+
+        self.vectorstore = vectorstore
+        self.retriever = retriever
+
+    def storeDocumentsInVectorstore(self, documents):
+        uuids = [str(uuid4()) for _ in range(len(documents))]
+        self.vectorstore.add_documents(documents=documents, ids=uuids)
+    
+    def createRagChain(self):
+        self.question_answer_chain = create_stuff_documents_chain(self.model, self.qa_prompt)
+        self.history_aware_retriever = create_history_aware_retriever(self.model, self.retriever, self.contextualize_q_prompt)
+        self.rag_chain = create_retrieval_chain(self.history_aware_retriever, self.question_answer_chain)
+
+    def generateResponse(self, question, chat_history):
+        retrieved_docs = self.vectorstore.as_retriever().get_relevant_documents(question)
+        num_docs = len(retrieved_docs)
+
+        ai_msg = self.rag_chain.invoke({
+            "num_docs": num_docs,
+            "input": question,
+            "chat_history": chat_history
+        })
+        return ai_msg
+            

requirements.txt

@@ -0,0 +1,11 @@
+langchain==0.2.14
+langchain_community==0.2.12
+langchain_ollama==0.1.1
+langchain_groq
+langchain_huggingface
+langchain_openai
+langchain_pinecone
+pypdf
+chromadb
+ollama
+fastapi

retriever.py

@@ -0,0 +1,23 @@
+from langchain.schema.retriever import BaseRetriever
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_pinecone.vectorstores import Pinecone
+from langchain.schema import Document
+from pydantic import PrivateAttr
+
+class AskMeAboutRagRetriever(BaseRetriever):
+    vectorstore: Pinecone = PrivateAttr()
+
+    def __init__(self, vectorstore: Pinecone, **data):
+        super().__init__(**data)
+        self.vectorstore = vectorstore
+        
+    def _get_relevant_documents(self, query: str, *, run_manager: CallbackManagerForRetrieverRun):
+        retrieved_docs = self.vectorstore.as_retriever().get_relevant_documents(query)
+        docs = [
+            Document(
+                page_content= str(i+1) + ".)" + "Title = " + "(" + doc.metadata.get('title') + ")" + " " + "Content = " + "(" + doc.page_content + ")",
+                metadata={"title": doc.metadata.get('title')}
+            )
+            for i, doc in enumerate(retrieved_docs)
+        ]
+        return docs

storePDF.py

@@ -0,0 +1,58 @@
+import fitz
+import os
+from sentence_transformers import SentenceTransformer
+from pinecone import Pinecone
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+pc = Pinecone(api_key=os.getenv('PINECONE_KEY'))
+index_name = "askmeaboutrag" 
+index = pc.Index(index_name)
+
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+def extract_pages_from_pdf(pdf_path):
+    doc = fitz.open(pdf_path) 
+    pages = []
+    for page_num in range(len(doc)):
+        page = doc.load_page(page_num) 
+        text = page.get_text("text") 
+        pages.append(text)
+    return pages
+
+def store_document_in_pinecone(document_id, pages, title, model):
+    for page_number, page_text in enumerate(pages):
+        embedding = model.encode(page_text) 
+        index.upsert(
+            vectors=[
+                {
+                    "id": f'{document_id}_page_{page_number}',
+                    "values": embedding,
+                    "metadata": {
+                        "document_id": document_id,
+                        "page_number": page_number,
+                        "text": page_text,
+                        "title": title,
+                    }
+                }
+            ],
+        )
+    print(f"Stored {len(pages)} pages for document: {document_id}")
+
+def process_pdfs_in_folder(folder_path):
+    for i, filename in enumerate(os.listdir(folder_path)):
+        if filename.endswith('.pdf'):
+            pdf_path = os.path.join(folder_path, filename)
+            document_id = str(i+1)
+            print(f"Processing {filename} with document_id: {document_id}")
+            
+            pages = extract_pages_from_pdf(pdf_path)
+            file_name_without_extension = os.path.splitext(filename)[0]
+
+            store_document_in_pinecone(document_id, pages, file_name_without_extension, model)
+            print("Stored Completed")
+
+folder_path = 'files' 
+process_pdfs_in_folder(folder_path)