hi

.gitignore

@@ -0,0 +1,3 @@
+venv
+chroma_*
+__pycache__

README.md

@@ -1,13 +0,0 @@
----
-title: Test
-emoji: 🦀
-colorFrom: red
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.44.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Readme.md

@@ -0,0 +1,26 @@
+## PDF Q&A Chatbot
+This project is a PDF-based chatbot that allows users to upload a PDF, process its content, and ask questions related to the document using the Langchain library and OllamaLLM (gemma2:2b). The chatbot utilizes Streamlit for the user interface and Chroma for vector storage, enabling efficient document processing and retrieval-based question-answering.
+
+## Features
+* PDF Upload: Users can upload a PDF file which will be processed and split into smaller chunks for efficient retrieval.
+* Persisted Vector Store: The PDF is processed once and stored in a vector database, allowing for fast responses to user queries without reprocessing the document.
+* Q&A: Users can ask questions related to the uploaded PDF, and the chatbot will provide concise answers based on the document content.
+* Fast PDF Processing: The use of vector storage ensures that once the PDF is processed, users can query it efficiently.
+Tech Stack
+* Langchain: For building the Q&A chatbot pipeline and vector-based document retrieval.
+* OllamaLLM: The LLM used for generating answers to user queries.
+* Chroma: Vector store for document embeddings, enabling fast document retrieval.
+
+### Create and activate a virtual environment:
+```bash
+python3 -m venv ven
+```
+### Install the required libraries:
+```bash
+pip install -r requirements.txt
+```
+
+### Run the application:
+```bash
+streamlit run app.py
+```

app.py

@@ -1,198 +1,46 @@
 import streamlit as st
-from langchain_community.callbacks import StreamlitCallbackHandler
-from langchain_core.runnables import RunnableConfig
+import tempfile
+import os
+from llm import load_and_process_pdf, create_vectorstore, create_rag_chain, get_response
 
-from src import CFG
-from src.query_expansion import build_multiple_queries_expansion_chain
-from src.retrieval_qa import (
-    build_retrieval_qa,
-    build_base_retriever,
-    build_rerank_retriever,
-    build_compression_retriever,
-)
-from src.vectordb import build_vectordb, load_faiss, load_chroma
-from streamlit_app.pdf_display import get_doc_highlighted, display_pdf
-from streamlit_app.utils import load_base_embeddings, load_llm, load_reranker
+st.set_page_config(page_title="PDF Q&A Chatbot", page_icon="📚")
 
-st.set_page_config(page_title="Retrieval QA", layout="wide")
+st.title("PDF Q&A Chatbot")
 
-LLM = load_llm()
-BASE_EMBEDDINGS = load_base_embeddings()
-RERANKER = load_reranker()
+# Initialize session state for vector store and chain
+if 'vectorstore' not in st.session_state:
+    st.session_state.vectorstore = None
+if 'rag_chain' not in st.session_state:
+    st.session_state.rag_chain = None
 
+# File uploader
+uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
 
-@st.cache_resource
-def load_vectordb():
-    if CFG.VECTORDB_TYPE == "faiss":
-        return load_faiss(BASE_EMBEDDINGS)
-    if CFG.VECTORDB_TYPE == "chroma":
-        return load_chroma(BASE_EMBEDDINGS)
-    raise NotImplementedError
+if uploaded_file is not None and st.session_state.vectorstore is None:
+    # Save the uploaded file temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
+        tmp_file.write(uploaded_file.getvalue())
+        tmp_file_path = tmp_file.name
 
+    # Process the PDF only once
+    with st.spinner("Processing PDF..."):
+        splits = load_and_process_pdf(tmp_file_path)
+        st.session_state.vectorstore = create_vectorstore(splits)
+        st.session_state.rag_chain = create_rag_chain()
 
-@st.cache_resource
-def load_retriever(_vectordb, retrieval_mode):
-    if retrieval_mode == "Base":
-        return build_base_retriever(_vectordb)
-    if retrieval_mode == "Rerank":
-        return build_rerank_retriever(_vectordb, RERANKER)
-    if retrieval_mode == "Contextual compression":
-        return build_compression_retriever(_vectordb, BASE_EMBEDDINGS)
-    raise NotImplementedError
+    st.success("PDF processed successfully! Now you can ask questions.")
 
+    # Clean up the temporary file
+    os.unlink(tmp_file_path)
 
-def init_sess_state():
-    if "uploaded_filename" not in st.session_state:
-        st.session_state["uploaded_filename"] = ""
+# Question input
+if st.session_state.vectorstore is not None:
+    question = st.text_input("Ask a question about the PDF:")
 
-    if "last_form" not in st.session_state:
-        st.session_state["last_form"] = list()
+    if question:
+        with st.spinner("Generating answer..."):
+            answer = get_response(st.session_state.rag_chain, st.session_state.vectorstore, question)
+        st.write("Answer:", answer)
 
-    if "last_query" not in st.session_state:
-        st.session_state["last_query"] = ""
-
-    if "last_response" not in st.session_state:
-        st.session_state["last_response"] = dict()
-
-    if "last_related" not in st.session_state:
-        st.session_state["last_related"] = list()
-
-
-def doc_qa():
-    init_sess_state()
-
-    with st.sidebar:
-        st.header("RAG with quantized LLM")
-        st.info(f"LLM: `{CFG.LLM_PATH}`")
-        st.info(f"Embeddings: `{CFG.EMBEDDINGS_PATH}`")
-        st.info(f"Reranker: `{CFG.RERANKER_PATH}`")
-
-        uploaded_file = st.file_uploader(
-            "Upload a PDF and build VectorDB", type=["pdf"]
-        )
-        if st.button("Build VectorDB"):
-            if uploaded_file is None:
-                st.error("No PDF uploaded")
-            else:
-                uploaded_filename = f"./data/{uploaded_file.name}"
-                with open(uploaded_filename, "wb") as f:
-                    f.write(uploaded_file.getvalue())
-                with st.spinner("Building VectorDB..."):
-                    build_vectordb(uploaded_filename)
-                st.session_state.uploaded_filename = uploaded_filename
-
-        if st.session_state.uploaded_filename != "":
-            st.info(f"Current document: {st.session_state.uploaded_filename}")
-
-        try:
-            with st.status("Load VectorDB", expanded=False) as status:
-                st.write("Loading VectorDB ...")
-                vectordb = load_vectordb()
-                status.update(
-                    label="Loading complete!", state="complete", expanded=False
-                )
-
-            st.success("Reading from existing VectorDB")
-        except Exception as e:
-            st.error(f"No existing VectorDB found: {e}")
-
-    c0, c1 = st.columns(2)
-
-    with c0.form("qa_form"):
-        user_query = st.text_area("Your query")
-        with st.expander("Settings"):
-            mode = st.radio(
-                "Mode",
-                ["Retrieval only", "Retrieval QA"],
-                index=1,
-                help="""Retrieval only will output extracts related to your query immediately, \
-                while Retrieval QA will output an answer to your query and will take a while on CPU.""",
-            )
-            retrieval_mode = st.radio(
-                "Retrieval method",
-                ["Base", "Rerank", "Contextual compression"],
-                index=1,
-            )
-
-        submitted = st.form_submit_button("Query")
-        if submitted:
-            if user_query == "":
-                st.error("Please enter a query.")
-
-    if user_query != "" and (
-        st.session_state.last_query != user_query
-    ):
-        st.session_state.last_query = user_query
-
-        if mode == "Retrieval only":
-            retriever = load_retriever(vectordb, retrieval_mode)
-            with c0:
-                with st.spinner("Retrieving ..."):
-                    relevant_docs = retriever.get_relevant_documents(user_query)
-
-            st.session_state.last_response = {
-                "query": user_query,
-                "source_documents": relevant_docs,
-            }
-
-            chain = build_multiple_queries_expansion_chain(LLM)
-            res = chain.invoke(user_query)
-            st.session_state.last_related = [
-                x.strip() for x in res.split("\n") if x.strip()
-            ]
-        else:
-            retriever = load_retriever(db, retrieval_mode)
-            retrieval_qa = build_retrieval_qa(LLM, retriever)
-
-            st_callback = StreamlitCallbackHandler(
-                parent_container=c0.container(),
-                expand_new_thoughts=True,
-                collapse_completed_thoughts=True,
-            )
-            st.session_state.last_response = retrieval_qa.invoke(
-                user_query, config=RunnableConfig(callbacks=[st_callback])
-            )
-            st_callback._complete_current_thought()
-
-    if st.session_state.last_response:
-        with c0:
-            st.warning(f"##### {st.session_state.last_query}")
-            if st.session_state.last_response.get("result") is not None:
-                st.success(st.session_state.last_response["result"])
-
-            if st.session_state.last_related:
-                st.write("#### Related")
-                for r in st.session_state.last_related:
-                    st.write(f"```\n{r}\n```")
-
-        with c1:
-            st.write("#### Sources")
-            for row in st.session_state.last_response["source_documents"]:
-                st.write("**Page {}**".format(row.metadata["page"] + 1))
-                st.info(row.page_content.replace("$", r"\$"))
-
-            # Display PDF
-            st.write("---")
-            _display_pdf_from_docs(st.session_state.last_response["source_documents"])
-
-
-def _display_pdf_from_docs(source_documents):
-    n = len(source_documents)
-    i = st.radio(
-        "View in PDF", list(range(n)), format_func=lambda x: f"Extract {x + 1}"
-    )
-    row = source_documents[i]
-    try:
-        extracted_doc, page_nums = get_doc_highlighted(
-            row.metadata["source"], row.page_content
-        )
-        if extracted_doc is None:
-            st.error("No page found")
-        else:
-            display_pdf(extracted_doc, page_nums[0] + 1)
-    except Exception as e:
-        st.error(e)
-
-
-if __name__ == "__main__":
-    doc_qa()
+else:
+    st.info("Please upload a PDF file to get started.")

condaenv.khtzjjyc.requirements.txt

@@ -1,12 +0,0 @@
-chromadb==0.4.22
-ctransformers==0.2.27
-faiss-cpu==1.7.4
-fastapi==0.104.1
-langchain==0.1.3
-PyMuPDF==1.23.8
-python-box==7.1.1
-rank-bm25==0.2.2
-sentence-transformers==2.2.2
-simsimd==3.3.0
-streamlit==1.30.0
-umap-learn==0.5.5

llm.py

@@ -0,0 +1,54 @@
+from langchain_ollama.llms import OllamaLLM
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain.chains import create_retrieval_chain
+
+def load_and_process_pdf(pdf_path):
+    loader = PyPDFLoader(pdf_path)
+    pages = loader.load_and_split()
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    splits = text_splitter.split_documents(pages)
+    return splits
+
+def create_vectorstore(splits):
+    embeddings = HuggingFaceEmbeddings()  # Initialize the embedding function
+    vectorstore = Chroma(
+        collection_name="example_collection",
+        embedding_function=embeddings,
+        persist_directory="./chroma_langchain_db"  # Optional: Directory for local persistence
+    )
+    vectorstore.add_documents(splits)  # Add processed document splits to the vector store
+    return vectorstore
+
+def create_rag_chain():
+    llm = OllamaLLM(model="gemma2:2b")
+    
+    system_prompt = (
+        "You are an assistant for question-answering tasks. "
+        "Use the following pieces of retrieved context to answer "
+        "the question. If you don't know the answer, say that you "
+        "don't know. Provide a clear and concise answer, using "
+        "up to three sentences."
+        "\n\n"
+        "{context}"
+    )
+    
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            ("human", "{input}"),
+        ]
+    )
+    
+    question_answer_chain = create_stuff_documents_chain(llm, prompt)
+    return question_answer_chain
+
+def get_response(rag_chain, vectorstore, question):
+    retriever = vectorstore.as_retriever()
+    retrieval_chain = create_retrieval_chain(retriever, rag_chain)
+    response = retrieval_chain.invoke({"input": question})
+    return response["answer"]

requirements.txt

@@ -1,12 +1,7 @@
-chromadb==0.4.22
-ctransformers==0.2.27
-faiss-cpu==1.7.4
-fastapi==0.104.1
-langchain==0.1.3
-PyMuPDF==1.23.8
-python-box==7.1.1
-rank-bm25==0.2.2
-sentence-transformers==2.2.2
-simsimd==3.3.0
-streamlit==1.30.0
-umap-learn==0.5.5
+streamlit
+pypdf
+langchain
+langchain-community
+langchain-huggingface
+langchain-ollama
+langchain-chroma