app.py

# -*- coding: utf-8 -*-
"""RAG Conversational Chat Application using lanchain, Mistral 7B , Pinecone vector DB

### Step-1: Upload Documents and Load with Langchain Document Loader
- Upload the documents to Google Colab.
- Use Langchain document loader to load the documents.

### Step-2: Perform Chunking
- Perform chunking on the loaded documents.

### Step-3: Initialize LLM and Use Huggingface Embedding Model
- Initialize a Large Language Model (LLM).
- Use the Huggingface Embedding Model to convert the chunks into embeddings.

### Step-4: Initialize Vector Database
- Initialize a Vector Database to store the resulting embeddings.

### Step-5: Upload Embeddings to Vector Database
- Upload the embeddings to the Vector Database.

### Step-6: Create Langchain Conversational Buffer Memory
- Create a Langchain conversational buffer memory.

### Step-7: Create Prompt Template
- Create a prompt template for generating responses.

### Step-8: Use Langchain RetreivalQA
- Use Langchain RetreivalQA for creating the conversational chat.

### Step-9: Create Front End with Streamlit
- Create a front end for the application using Gradio.

### Step-10: Upload Code to GitHub
- Upload the code to a GitHub repository.

### Step-11: Deploy App in Huggingface Spaces
- Deploy the application in Huggingface Spaces.

### Step-12: Create Documentation
- Create documentation for the entire process followed.
"""

# Installing the required libraries
# !pip install langchain
# !pip install pypdf
# !pip install sentence-transformers==2.2.2
# !pip install pinecone-client==2.2.4
# !pip install unstructured
# !pip install "unstructured[pdf]"

# initializing the Huggingface API to access Embeddig models
# from google.colab import userdata
# HUGGINGFACE_API_KEY = userdata.get('Hugging_Face_API_Key')
# HUGGINGFACE_API_KEY=HUGGINGFACE_API_KEY

# Creating a directory to store the data

# from langchain.document_loaders import PyPDFDirectoryLoader

# loader = PyPDFDirectoryLoader("data")

# importing all the required Libraries
from PyPDF2 import PdfReader
from langchain.chains.question_answering import load_qa_chain
from langchain.prompts import PromptTemplate
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain

# from langchain.document_loaders import PyPDFDirectoryLoader
# loader = PyPDFDirectoryLoader("data")
# data = loader.load()

# len(data)
import streamlit as st

# Get the Huggingface API token from streamlit secrets
import os
huggingfacehub_api_token = st.secrets["HF_API_TOKEN"]

def get_pdf_text(pdf_docs):
    text=""
    for pdf in pdf_docs:
        pdf_reader= PdfReader(pdf)
        for page in pdf_reader.pages:
            text+= page.extract_text()
    return  text

# creating chunking for the above data
def get_text_chunks(text):
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
    chunks = text_splitter.split_text(text)
    return chunks

# # creating chunking for the above data
# from langchain.text_splitter import RecursiveCharacterTextSplitter
# text_splitter=RecursiveCharacterTextSplitter(chunk_size=200,chunk_overlap=20)
# chunked_data=text_splitter.split_text(data)

# Create Embeddings using Huggingface Embeddings
import sentence_transformers
from langchain.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")


# Initializing Pinecone
PINECONE_API_KEY=os.environ.get('PINECONE_API_KEY', 'f7384d73-ea97-45ca-abaa-9b14327fd50f')
PINECONE_API_ENV=os.environ.get('PINECONE_API_ENV', 'gcp-starter')

import pinecone
# initialize pinecone
pinecone.init(
    api_key=PINECONE_API_KEY,  # find at app.pinecone.io
    environment=PINECONE_API_ENV  # next to api key in console
)
index_name = "pinecone-demo" # put in the name of your pinecone index here

from langchain.vectorstores import Pinecone

# Load the data into pinecone database
def get_vector_store(text_chunks):
   #docsearch = Pinecone.from_texts(chunked_data, embeddings, index_name=index_name)
   docsearch = Pinecone.from_texts([t for t in text_chunks], embeddings, index_name=index_name)
   return docsearch


# query = "How many topics are covered?"
# docs = docsearch.similarity_search(query, k=1)
# docs

from langchain import HuggingFaceHub

llm=HuggingFaceHub(huggingfacehub_api_token=huggingfacehub_api_token,repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1")

# from langchain.chains import RetrievalQA
# # retriever = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=docsearch.as_retriever())
# retriever = docsearch.as_retriever(search_kwargs={"k": 2})

# qa_chain = RetrievalQA.from_chain_type(llm=llm,
#                                   chain_type="stuff",
#                                   retriever=retriever,
#                                   return_source_documents=True)

#question = "What are the Technical  Skills to learn for a Promising AI Career?"

#print(qa_chain(question))

## Adding Memory component
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True, max_history_length=5
)





# Chat History
#chat = llm.start_chat(history=[])
# intialize session state for chat history if it doesn't exist
if 'chat_history' not in st.session_state:
    st.session_state['chat_history'] = []

def user_input(user_question):
    # Load embeddings only once (assuming same model for both)
    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")

    # Pinecone search using the loaded embeddings
    docsearch = Pinecone.from_existing_index(index_name, embeddings)
    docs = docsearch.similarity_search(user_question)

    # Define prompt template
    template = """Answer the question as detailed as possible from the provided context, make sure to provide all the details,
                if the answer is not available in the provided context just say, "answer is not available in the context", don't provide the wrong answer\n\n
                {context}
                Donot provide the Context , Provide the Answer only , to the question in the following format
                Question: {question}
                Helpful Answer:"""
    prompt = PromptTemplate(input_variables=["context", "question"], template=template)
    #prompt =  PromptTemplate(input_variables=["question"], template=template)
    
    # Create retriever and chain using the loaded embeddings
    retriever = docsearch.as_retriever()
    qa_chain = ConversationalRetrievalChain.from_llm(
        llm, 
        retriever=retriever,
        memory=memory
    )

    # Extract context from retrieved documents (replace with your logic)
    # Consider filtering or summarizing retrieved documents
    #context = " ".join([doc.get("text", "") for doc in docs[:3]])
    context = docs

    # Inject prompt into query (alternative approach)
    query = f"{template.format(context=context, question=user_question)}\nQuestion: {user_question}"
    #query = f"{template.format( question=user_question)}\nQuestion: {user_question}"
    
    response = qa_chain(
        {"question": query},
        return_only_outputs=True
    )

    # Display response
    #st.write("Reply: ", response["answer"])
    Ans = extract_helpful_answer(response)
    st.write(Ans)
    
    # Feature to load Chat history
    if st.button("Load Chat History"):
        # add user query and response to session chat history
        st.session_state['chat_history'].append(("you",user_question))
        # for chunk in Ans:
        #     #st.write(chunk.text)
        #     st.session_state['chat_history'].append(("AI Assistant",chunk))
        st.session_state['chat_history'].append(("AI Assistant",Ans))
        st.subheader("The chat history is ")
        for role,text in st.session_state['chat_history']:
            st.write(f"{role}: {text}")
            
    # Feature to load Related Context from the uploaded Documents
    if st.button("Load Related Context from Your Document"):
        related_context = docs
        st.subheader("Related Context from Your Document:")
        for doc in related_context:
            st.write(f"Document: {doc}")
            st.write("\n")
    else:
        st.warning("Please enter a question before loading related context.")

def extract_helpful_answer(response):
    # Split the response by the delimiter "Helpful Answer:"
    parts = response["answer"].split("Helpful Answer:")

    # If there are two parts (before and after "Helpful Answer:"), return the second part
    return parts[2].strip()



      
def main():
    #st.set_page_config("Chat PDF")
    st.header("Chat with PDF using Mistral")

    user_question = st.text_input("Ask a Question from the PDF Files")

    if user_question:
        user_input(user_question)

    with st.sidebar:
        st.title("Menu:")
        pdf_docs = st.file_uploader("Upload your PDF Files and Click on the Submit & Process Button", accept_multiple_files=True)
        if st.button("Submit & Process"):
            with st.spinner("Processing..."):
                raw_text = get_pdf_text(pdf_docs)
                text_chunks = get_text_chunks(raw_text)
                get_vector_store(text_chunks)
                st.success("Done")



if __name__ == "__main__":
    main()