Upload 12 files

.env

@@ -0,0 +1,3 @@
+OPENAI_API_KEY="" 
+HUGGINGFACEHUB_API_TOKEN=""
+GROK_API_KEY="xai-tHIoTBXBRStLAx2AXugmiP8yEIQ1uJNw5ypsc77pQ8msbG9jz9F3W705y8YJM7AJM7dQlf0fydWtSHrA"

.env.example

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+HUGGINGFACEHUB_API_TOKEN=

.gitignore

@@ -0,0 +1,160 @@
+# 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/
+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/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .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
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea

.python-version

@@ -0,0 +1 @@
+3.9

app.py

@@ -0,0 +1,173 @@
+import os
+import streamlit as st
+from dotenv import load_dotenv
+from PyPDF2 import PdfReader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings  # Changed to HuggingFace
+from langchain.vectorstores import FAISS
+from langchain.chat_models import ChatOpenAI  # For LLM
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain
+from htmlTemplates import css, bot_template, user_template
+
+# Function to extract text from PDF documents
+def get_pdf_text(pdf_docs):
+    text = ""
+    for pdf in pdf_docs:
+        pdf_reader = PdfReader(pdf)
+        for page in pdf_reader.pages:
+            extracted_text = page.extract_text()
+            if extracted_text:
+                text += extracted_text
+    return text
+
+# Function to split text into manageable chunks
+def get_text_chunks(text):
+    text_splitter = CharacterTextSplitter(
+        separator="\n",
+        chunk_size=1000,
+        chunk_overlap=200,
+        length_function=len
+    )
+    chunks = text_splitter.split_text(text)
+    return chunks
+
+# Function to create a vector store using HuggingFace embeddings
+def get_vectorstore(text_chunks, huggingface_api_key):
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/all-MiniLM-L6-v2",  # Choose an appropriate model
+        model_kwargs={"use_auth_token": huggingface_api_key}
+    )
+    
+    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
+    return vectorstore
+
+# Function to initialize the conversational retrieval chain with GrokAI
+def get_conversation_chain(vectorstore, grok_api_key, grok_api_base):
+    llm = ChatOpenAI(
+        openai_api_key=grok_api_key,
+        openai_api_base=grok_api_base,
+        model_name="grok-beta",  # Specify GrokAI's model
+        temperature=0.5
+    )
+    
+    memory = ConversationBufferMemory(
+        memory_key='chat_history', return_messages=True
+    )
+    conversation_chain = ConversationalRetrievalChain.from_llm(
+        llm=llm,  # Use the configured GrokAI LLM
+        retriever=vectorstore.as_retriever(),
+        memory=memory
+    )
+    return conversation_chain
+
+# Function to handle user input and generate responses
+def handle_userinput(user_question):
+    if st.session_state.conversation is None:
+        st.warning("Documents are still being processed. Please wait.")
+        return
+
+    response = st.session_state.conversation({'question': user_question})
+    st.session_state.chat_history = response['chat_history']
+
+# Function triggered when the user presses Enter in the input box
+def on_enter():
+    user_question = st.session_state.user_question
+    if user_question:
+        handle_userinput(user_question)
+        st.session_state.user_question = ""  # Clear the input box
+
+# Function to load and process PDF documents
+def load_and_process_pdfs(folder_path, huggingface_api_key, grok_api_key, grok_api_base):
+    pdf_files = [file for file in os.listdir(folder_path) if file.lower().endswith('.pdf')]
+    if not pdf_files:
+        st.error(f"No PDF files found in the directory: {folder_path}")
+        return
+
+    pdf_docs = []
+    for file in pdf_files:
+        file_path = os.path.join(folder_path, file)
+        pdf_docs.append(file_path)
+
+    with st.spinner("Processing documents..."):
+        # Extract text from PDFs
+        with st.spinner("Extracting text from PDFs..."):
+            pdf_file_objects = [open(file, 'rb') for file in pdf_docs]
+            raw_text = get_pdf_text(pdf_file_objects)
+            # Close the files after reading
+            for f in pdf_file_objects:
+                f.close()
+
+        # Split text into chunks
+        with st.spinner("Splitting text into chunks..."):
+            text_chunks = get_text_chunks(raw_text)
+
+        # Create vector store using HuggingFace embeddings
+        with st.spinner("Creating vector store..."):
+            vectorstore = get_vectorstore(text_chunks, huggingface_api_key)
+
+        # Initialize conversation chain with GrokAI LLM
+        with st.spinner("Initializing conversation chain..."):
+            st.session_state.conversation = get_conversation_chain(vectorstore, grok_api_key, grok_api_base)
+
+    st.success("Documents processed successfully!")
+
+# Function to display chat history with auto-scrolling
+def display_chat_history():
+    if st.session_state.chat_history:
+        for i, message in enumerate(st.session_state.chat_history):
+            if i % 2 == 0:
+                st.markdown(user_template.replace("{{MSG}}", message.content), unsafe_allow_html=True)
+            else:
+                st.markdown(bot_template.replace("{{MSG}}", message.content), unsafe_allow_html=True)
+        
+        # Inject JavaScript to scroll the entire page to the bottom
+        scroll_script = """
+        <script>
+            // Function to scroll to the bottom of the page
+            function scrollToBottom() {
+                window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' });
+            }
+            // Delay to ensure the DOM is fully rendered
+            setTimeout(scrollToBottom, 100);
+        </script>
+        """
+        st.markdown(scroll_script, unsafe_allow_html=True)
+
+# Main function to run the Streamlit app
+def main():
+    load_dotenv()
+    
+    # Retrieve credentials from .env
+    grok_api_key = os.getenv("GROK_API_KEY")
+    grok_api_base = "https://api.x.ai/v1"  # GrokAI's API base URL
+    huggingface_api_key = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    
+    st.set_page_config(page_title="Chat with AI Tax Agent", page_icon=":books:")
+    st.write(css, unsafe_allow_html=True)
+
+    if "conversation" not in st.session_state:
+        st.session_state.conversation = None
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+
+    # Title Section
+    st.header("Chat with AI Tax Agent :books:")
+
+    # Automatically load and process PDFs on startup
+    if st.session_state.conversation is None:
+        documents_folder = "./documents/"  # Specify your documents folder path here
+        load_and_process_pdfs(documents_folder, huggingface_api_key, grok_api_key, grok_api_base)
+
+    # Chat History Section
+    display_chat_history()
+
+    # Input Box Section
+    st.text_input(
+        "Ask a question about your documents:",
+        key='user_question',
+        on_change=on_enter
+    )
+
+if __name__ == '__main__':
+    main()

htmlTemplates.py

@@ -0,0 +1,48 @@
+css = '''
+<style>
+.chat-message {
+    padding: 1.5rem; 
+    border-radius: 0.5rem; 
+    margin-bottom: 1rem; 
+    display: flex;
+}
+.chat-message.user {
+    background-color: #2b313e;
+}
+.chat-message.bot {
+    background-color: #475063;
+}
+.chat-message .avatar {
+  width: 20%;
+}
+.chat-message .avatar img {
+  max-width: 78px;
+  max-height: 78px;
+  border-radius: 50%;
+  object-fit: cover;
+}
+.chat-message .message {
+  width: 80%;
+  padding: 0 1.5rem;
+  color: #fff;
+}
+</style>
+'''
+
+bot_template = '''
+<div class="chat-message bot">
+    <div class="avatar">
+        <img src="https://i.ibb.co/cN0nmSj/Screenshot-2023-05-28-at-02-37-21.png" style="max-height: 78px; max-width: 78px; border-radius: 50%; object-fit: cover;">
+    </div>
+    <div class="message">{{MSG}}</div>
+</div>
+'''
+
+user_template = '''
+<div class="chat-message user">
+    <div class="avatar">
+        <img src="https://i.ibb.co/rdZC7LZ/Photo-logo-1.png">
+    </div>    
+    <div class="message">{{MSG}}</div>
+</div>
+'''

new.py

@@ -0,0 +1,22 @@
+# just a simple code example of grok-ai api usage
+
+import os
+
+# pip install openai
+from openai import OpenAI
+
+# Set your API key here
+grokapi = "xai-XXXXXXXXXXXXXXXXXX" 
+
+# Make a call to function using openai library
+client = OpenAI(api_key=grokapi, base_url="https://api.x.ai/v1")
+
+completion = client.chat.completions.create(
+    model="grok-beta",
+    messages=[
+        {"role": "system", "content": "You are grok, an openai"},
+        {"role": "user", "content": "How does X algorithm work?"}
+    ]
+)
+
+print(completion.choices[0].message)

readme.md

@@ -0,0 +1,69 @@
+# MultiPDF Chat App
+
+## Introduction
+
+---
+
+The MultiPDF Chat App is a Python application that allows you to chat with multiple PDF documents. You can ask questions about the PDFs using natural language, and the application will provide relevant responses based on the content of the documents. This app utilizes a language model to generate accurate answers to your queries. Please note that the app will only respond to questions related to the loaded PDFs.
+
+## How to Run the Program
+
+To set up and run the program, follow these steps:
+
+1. Create a virtual environment:
+
+   ```bash
+   python -m venv venv
+   ```
+
+2. Activate the virtual environment:
+
+   - On Windows:
+     ```bash
+     venv\Scripts\activate
+     ```
+   - On macOS/Linux:
+     ```bash
+     source venv/bin/activate
+     ```
+
+3. Install the required dependencies
+   ```bash
+   pip install -r requirements.txt
+   ```
+4. Obtain an API key from GrokAI and add it to the `.env` file in the project directory.
+
+```commandline
+GROK_API_KEY=your_secrit_api_key
+```
+
+5. Run the application:
+   ```bash
+   streamlit run app.py
+   ```
+
+Once completed, the app will open in your default web browser. If it doesn't, check the terminal for the link (usually `http://localhost:8501`).
+
+## How It Works
+
+---
+
+![MultiPDF Chat App Diagram](./docs/PDF-LangChain.jpg)
+
+The application follows these steps to provide responses to your questions:
+
+1. PDF Loading: The app reads multiple PDF documents and extracts their text content.
+
+2. Text Chunking: The extracted text is divided into smaller chunks that can be processed effectively.
+
+3. Language Model: The application utilizes a language model to generate vector representations (embeddings) of the text chunks.
+
+4. Similarity Matching: When you ask a question, the app compares it with the text chunks and identifies the most semantically similar ones.
+
+5. Response Generation: The selected chunks are passed to the language model, which generates a response based on the relevant content of the PDFs.
+
+## License
+
+---
+
+The MultiPDF Chat App is released under the [MIT License](https://opensource.org/licenses/MIT).

requirements.txt

@@ -0,0 +1,13 @@
+langchain
+PyPDF2
+python-dotenv
+streamlit
+openai
+faiss-cpu
+altair
+tiktoken
+transformers  
+huggingface-hub
+InstructorEmbedding
+sentence-transformers
+langchain-community