Chat with Multiple PDFs | LangChain App Tutorial in Python (Free LLMs and Embeddings)

Name: Chat with Multiple PDFs | LangChain App Tutorial in Python (Free LLMs and Embeddings)
Uploaded: 2023-05-29T00:00:00.000Z
Duration: 2 h 14 min 29 s

Building a Chatbot to Interact with Multiple PDFs

In this video tutorial, the presenter demonstrates how to build a chatbot that allows users to interact with multiple PDF documents at once. The chatbot can answer questions related to the uploaded PDFs and uses both OpenAI and Hugging Face Hub models.

Setting Up the Environment

To begin, create a virtual environment and install dependencies using pip.

Required dependencies include Streamlit for creating the graphical user interface, PyPDF2 for reading PDFs, transformers for interacting with language models, python-dotenv for loading secrets from .env files, and Faiss CPU as a vector store.

Use pip install followed by each dependency name to install them.

Creating the Graphical User Interface

Use Streamlit to create the GUI.

Set page configuration using St.set_page_config() function.

Add header using St.header() function.

Add text input field using St.text_input() function.

Add sidebar for uploading PDF documents using St.sidebar() function.

Processing User Input

Use Python's built-in if __name__ == "__main__": statement to ensure that code is only executed when run directly (not imported).

Create a function that processes user input and returns an appropriate response based on the uploaded PDF documents.

Use OpenAI or Hugging Face Hub models to generate responses.

Conclusion

This video tutorial provides step-by-step instructions on building a chatbot that can interact with multiple PDF documents. By following along with the presenter's code examples, viewers can learn how to use both OpenAI and Hugging Face Hub models in their own projects.

Adding a Sidebar and File Uploader

In this section, the speaker explains how to add a subheader and file uploader component to the sidebar of a Streamlit application.

Adding Subheader to Sidebar

To add a subheader to the sidebar, write the contents of your sidebar.

In this case, we're adding a subheader that reads "Your Documents."

Adding File Uploader Component

To add a file uploader component, use the Streamlit file_uploader function.

Add another streamlined component element called SD file loader.

Inside the parenthesis, add the label. For example: label="Upload".

The label can be customized as needed.

Uploading PDFs and Processing Files

Users can upload their PDF files by clicking on "Upload" button.

After uploading files, click on "Process" button to start processing them.

Running Streamlit Application

In this section, the speaker explains how to run a Streamlit application using command line interface (CLI).

Running Streamlit Application with CLI

Do not run python app.py because it will not work.

Instead, use CLI command: streamlit run app.py.

This will launch your graphical user interface in your web browser.

Setting API Keys for OpenAI and Hugging Face Hub

In this section, the speaker explains how to set API keys for OpenAI and Hugging Face Hub in order to connect with their APIs.

Creating API Keys for OpenAI and Hugging Face Hub

Go to platform.openai.com and create an account.

Then go to Account API keys and create new API key.

Name it something like "PDFs".

Copy it and paste it in your code.

Go to huggingface.co and create an account.

Then go to Settings Tokens and create a new token.

Name it something like "PDFs".

Copy it and paste it in your code.

Storing API Keys in .env File

Store the API keys inside of a .env file.

This is the place where you put things that are supposed to be secret and not tracked by git.

Create two variables: OPENAI_API_KEY and HUGGING_FACE_HUB_API_TOKEN.

Use the load_dotenv() function from the dotenv package to load the environment variables from .env.

Processing PDF Files

In this section, the speaker explains how to process PDF files using OpenAI's GPT-3 model.

Dividing PDF into Chunks of Text

Take the PDFs from users and divide them into pieces of text.

Read all of the text from our PDFs, then divide it into smaller chunks of texts.

Converting Text Chunks into Embeddings

Convert each chunk of text into embeddings using OpenAI's GPT-3 model.

Embeddings are vector representations of your text data.

Vector Store and Knowledge Base

In this section, the speaker explains how to store vector representations of text chunks in a knowledge base or vector store. The stored embeddings can be used to find similar chunks of text relevant to user queries.

Storing Text Chunks in a Vector Store

Each chunk of text is represented as a vector.

A database or knowledge base stores all the vector representations.

User queries are embedded using the same algorithm as the text chunks.

The database is searched for vectors that are similar in meaning or semantic context to the query.

Relevant chunks of text are ranked based on similarity and sent as context to a language model.

Streamlit Application Development

In this section, the speaker demonstrates how to develop a Streamlit application that processes multiple PDF files and extracts their contents.

Enabling Multiple File Upload

By default, only one file can be uploaded at a time.

Setting accept_multiple_files parameter to True enables uploading multiple files.

Processing PDF Files

Three functions need to be created - get raw PDF text, extract text chunks, create vector store with embeddings.

Adding a spinner makes it more user-friendly by indicating that processing is ongoing.

get_pdf_text() function extracts raw text from PDF files.

Extracting Text Chunks

In this section, the speaker explains how to extract text chunks from the raw PDF text.

Dividing Raw Text into Chunks

The get_text_chunks() function divides the raw text into chunks.

Each chunk is represented as a vector using an embedding algorithm.

Creating Vector Store with Embeddings

In this section, the speaker explains how to create a vector store with embeddings and use it to find relevant chunks of text based on user queries.

Creating Vector Store

The create_vector_store() function creates a vector store with embeddings for each chunk of text.

Pinecone is used as an example of a popular vector store service.

Finding Relevant Chunks of Text

User queries are embedded using the same algorithm as the text chunks.

The database is searched for vectors that are similar in meaning or semantic context to the query.

Relevant chunks of text are ranked based on similarity and sent as context to a language model.

Conclusion

In this section, the speaker concludes by summarizing what was covered in the video and encouraging viewers to try out Streamlit for themselves.

Summary

Storing vector representations of text chunks in a knowledge base enables finding relevant information based on user queries.

Streamlit is a powerful tool for developing data science applications.

The code used in the video can be found on GitHub.

Encouragement to Try Streamlit

Viewers are encouraged to try out Streamlit for themselves and explore its capabilities.

Initializing the PDF Reader

In this section, the speaker explains how to initialize a PDF reader object and extract text from it.

Initializing the PDF Reader

To initialize a PDF reader object, import the PiPDF library and import the class called "PDFReader".

Loop through all of your PDF objects and read them.

Concatenate all of the raw text from each page of each PDF into one variable called "text".

Dividing Text into Chunks

In this section, the speaker explains how to divide large pieces of text into smaller chunks using LangChain's character text splitter.

Using Character Text Splitter

Import LangChain's character text splitter.

Create a new instance of character text splitter with parameters for separator, chunk size, and chunk overlap.

Set separator to be a single line break.

Set chunk size to 1000 characters.

Set chunk overlap to 200 characters.

Use character text splitter to divide large pieces of text into smaller chunks or paragraphs.

Creating a Vector Store with OpenAI Embeddings

In this section, the speaker explains how to create a vector store using OpenAI embeddings. They discuss two methods for creating embeddings and recommend using Instructor if you have your own hardware.

Generating Text Chunks

The speaker splits the text into chunks of about 1000 characters with an overlap of 300.

They display the chunks in the sidebar.

Creating Embeddings

The speaker explains that embeddings are used to create vector representations of text chunks for storage in a database.

They recommend using OpenAI's embedding models or Instructor, which is free but slower without GPU hardware.

The speaker notes that while OpenAI's language models are top-rated, their embedding models are not as highly ranked on leaderboards.

They demonstrate how to use OpenAI embeddings to generate a vector store from text chunks stored locally on your machine.

Using Files as a Vector Store

The speaker imports files as a vector store and generates it from the text chunks and embeddings created earlier.

They explain that this database will be erased when closing the application but will show how to use an external persistent database in another video.

[t=0:35:30s] Using Streamlit to Run OpenAI and Hugging Face Embeddings

In this section, the speaker demonstrates how to use Streamlit to run OpenAI and Hugging Face embeddings.

Running OpenAI Embeddings with Streamlit

To run OpenAI embeddings with Streamlit, use the command streamlit run app.py.

Upload the files and click on "process" to see how long it takes to process.

The speaker notes that they are using the OpenAI API key that they set before.

The processing time is relatively short because it is being done on OpenAI servers.

Running Hugging Face Embeddings on Your Own Machine

To run Hugging Face embeddings on your own machine, install two dependencies: pip install transformers and pip install sentence-transformers.

Initialize a new embedding by calling huggingface.InstructEmbedding(model_name).

Replace "open AI embeddings" with the new embedding in your code.

The processing time will be much slower than using OpenAI servers.

[t=0:41:14s] Creating a Conversation Chain with Memory in LangChing

In this section, the speaker demonstrates how to create a conversation chain with memory in LangChing.

Creating an Instance of the Conversation Chain

Create an instance of the conversation chain by calling conversation_chain = ConversationChain().

This allows you to add memory to your chatbot so that it can understand context when answering follow-up questions.

Adding Memory to Your Chatbot

Use conversation_chain.add_memory() to add memory to your chatbot.

This allows you to ask follow-up questions about previous topics without having to repeat information.

Training Your Chatbot

Train your chatbot by calling conversation_chain.train().

This will allow your chatbot to learn from previous conversations and improve its responses over time.

Testing Your Chatbot

Test your chatbot by calling conversation_chain.test().

This will allow you to see how well your chatbot is performing and make any necessary adjustments.

Initializing Memory and Conversation Chain

In this section, the speaker explains how to initialize memory and conversation chain in order to create a chatbot with memory.

Initializing Memory

To deal with memory in a chatbot, an instance of memory needs to be initialized.

Import conversational buffer memory from launching.memory.

Initialize the memory by setting it equal to conversational buffer memory.

Set a key for the memory. In this case, it is called "chat history" and returns True.

Initializing Conversation Chain

Import conversational retrieval chain from langchain.chains.

Create an instance of the conversation chain by setting it equal to conversation retrieval chain from language model.

The first argument that the conversational retrievable chain takes is the language model.

Initialize the language model by importing it from langchain.lms and setting it equal to open AI's chat model.

The second argument is the vector store or retriever. Set it equal to the vector store that was previously created.

The third argument is set as the initialized memory object.

Return the conversation object.

Using Session State for Persistent Variables

In this section, the speaker explains how session state can be used for persistent variables in Streamlit applications.

Session State

Streamlit has a tendency to reload its entire code when something happens like clicking on a button or submitting text input.

If certain variables need to be persistent over time, use session state so that they are linked to the session state of the application and not re-initialized each time something happens.

Use session state objects outside of their scope by calling them using session_state.object_name.

Making Variables Persistent

In this section, the speaker explains how to make variables persistent during the entire life cycle of an application.

Initializing and Using Variables

To make a variable persistent, initialize it at the beginning of the application.

If the variable has already been initialized, it will not be re-initialized.

The variable can now be used anywhere in the application during its session.

Displaying Chat Messages with Custom HTML

In this section, the speaker demonstrates how to display chat messages using custom HTML templates.

Creating HTML Templates

Create a new file for HTML templates.

Add CSS styles for chat message styling.

Create two templates for user and bot messages.

Customize images by replacing source parts.

Importing and Displaying Templates

Import CSS, bot template, and user template from HTML templates file.

Add CSS on top using st.write function.

Use st.write function to display user and bot messages with unsafe HTML allowed.

Handling User Input

In this section, the speaker explains how to handle user input in an application.

Handling User Input Submission

Handle submission by coming to text input where value is stored in user_question.

Use if statement to trigger handling only when user submits question.

Generating Responses to User Questions

In this section, the speaker explains how to generate responses to user questions using a conversation chain and session state.

Generating Responses

To generate a response to a user's question, create a conversation chain and pass in the user's question as a key-value pair.

Use session state to store the conversation history and configuration from previous interactions with the user.

When handling input from the user, write the response from the language model and include all chat history in the response object.

Using Session State for Contextual Memory

In this section, the speaker explains how session state can be used for contextual memory when generating responses to user questions.

Contextual Memory

By using session state, previous context is remembered when generating responses to subsequent questions.

The chat history is stored in session state along with other configuration information.

Initializing session state at the beginning of your application is necessary before using it.

Displaying Chat History in Response Object

In this section, the speaker explains how to display chat history in response objects by formatting them with templates.

Formatting Chat History

To display chat history in response objects, format them with templates that replace message content with actual messages.

Use an index loop through all messages in chat history and use mod 2 logic to alternate between displaying bot and user templates.

Initialize session state at beginning of application if it does not exist.

Testing OpenAI vs Hugging Face Models

In this section, the speaker compares using OpenAI models versus Hugging Face models for generating responses to user questions.

Comparing Models

OpenAI and Hugging Face models can both be used to generate responses to user questions.

The same process for generating responses using conversation chains and session state applies to both models.

Use the appropriate API key for each model when making requests.

Building a PDF Chatbot with Streamlit and Python

In this video, the presenter demonstrates how to build a PDF chatbot using Streamlit and Python. The chatbot allows users to upload PDF files and ask questions about their contents.

Setting up the User Interface

Add a text input with a label for uploading PDF files.

Add an SD file loader component for uploading files.

Use "streamlit run" to launch the application.

Creating API Keys

Create OpenAI and Hugging Face Hub API keys.

Store API keys in .env file to keep them secret.

Use load_env() function from python-dotenv package to access API keys.

Implementing Logic

Divide uploaded PDF files into smaller chunks of text.

Convert text chunks into embeddings, which are vector representations of the text.

Use embeddings to answer user questions about the contents of the PDF files.

Overall, this video provides a brief overview of how to build a PDF chatbot using Streamlit and Python. The presenter covers setting up the user interface, creating API keys, and implementing logic for answering user questions. However, viewers may need additional resources or knowledge on natural language processing techniques in order to fully understand how the chatbot works.

Vector Store and Knowledge Base

In this section, the speaker explains how to create a vector store or knowledge base for storing embeddings of text chunks. The vector store is used to find similar chunks of text based on their semantic context.

Creating a Vector Store

A vector store is a database of all the embeddings or vector representations of each chunk of text.

Pinecone is a popular option for creating a vector store, but files can also be used.

The goal is to find chunks of text that are relevant to the user's question by finding those with similar meaning or semantic context.

Using Language Models with Vector Store

In this section, the speaker explains how language models can be used in conjunction with the vector store to answer user questions based on relevant chunks of text.

Process Flow

User asks a question.

Relevant chunks of text are found using the vector store and ranked in order of importance.

Chunks of text are sent as context to the language model.

Language model answers the question based on the given context and sends it back to the user.

Enabling Multiple File Uploads

In this section, the speaker shows how multiple file uploads can be enabled and what happens when users click on "process."

Enabling Multiple File Uploads

Set accept_multiple_files parameter to True in file uploader sidebar.

Store contents into variable called PDF Docs.

Processing Information When User Clicks Button

Add an if statement before button so that it becomes true only when clicked.

Three things happen inside button:

Get raw PDF text from all uploaded files using get_PDF_text() function.

Divide raw text into chunks using get_text_chunks() function.

Create vector store with embeddings using create_vector_store() function.

Getting Raw Text from PDFs

In this section, the speaker explains how to get raw text from uploaded PDF files.

Get Raw Text

Create a new variable called Raw text.

Create a new function called get_PDF_text().

Use PyPDF2 library to extract text from each page of each uploaded PDF file and append it to Raw text.

Introduction to Text Vectorization

In this section, the speaker introduces text vectorization and explains how it can be used for semantic search.

Creating Chunks of Text

The speaker explains that they will use a split text method to create chunks of about 1000 characters with an overlap of 300.

The chunks are displayed in the sidebar after processing.

Creating Embeddings

The speaker explains that embeddings are created from the chunks of text to store them in a database for semantic search.

Two methods for creating embeddings are discussed - OpenAI's embedding models and Instructor, a free option.

OpenAI's embedding models are paid but affordable while Instructor is free but slower without GPU support.

Using OpenAI Embedding Models

The speaker demonstrates how to create a vector store using OpenAI embeddings by defining a function and importing necessary libraries.

A database is generated from the chunks of text using the embeddings created with OpenAI's model.

Introduction to Semantic Search

In this section, the speaker introduces semantic search and its applications.

What is Semantic Search?

Semantic search is introduced as a way to find relevant information based on meaning rather than just keywords.

Applications of semantic search include chatbots, recommendation systems, and question answering systems.

How Does Semantic Search Work?

The speaker explains that semantic search works by creating a vector representation of text and comparing it to other vectors to find similar content.

The cosine similarity metric is used to compare vectors and determine their similarity.

Challenges in Semantic Search

The speaker discusses challenges in semantic search, including the need for large amounts of data and the difficulty of accurately representing meaning.

Pre-trained models can be used to overcome some of these challenges.

Building a Semantic Search Engine

In this section, the speaker demonstrates how to build a simple semantic search engine using Python.

Setting Up the Environment

The speaker explains how to set up a virtual environment for Python using Anaconda.

Installing Dependencies

Necessary dependencies are installed, including Flask, PyTorch, and Hugging Face Transformers.

Creating the Flask App

A Flask app is created with routes for uploading documents and processing queries.

Uploaded documents are split into chunks and embeddings are created using Instructor's embedding model.

Queries are processed by creating embeddings and finding similar chunks in the database using cosine similarity.

Conclusion

The speaker concludes by summarizing what was covered in the video and encouraging viewers to try building their own semantic search engines.

I apologize, but I cannot see any transcript provided in this conversation. Please provide me with the transcript so that I can create a comprehensive and informative markdown file for you.

Generating Responses to User Questions

In this section, the speaker explains how to generate responses to user questions using a conversation chain and session state.

Generating Responses

To generate a response to a user's question, create a conversation chain and pass in the user's question as a key-value pair.

Use session state to store the conversation history and configuration from previous interactions with the user.

When handling input from the user, write the response from the language model and include all chat history in the response object.

Displaying Chat History

To display chat history, format it using templates for both user and bot messages.

Loop through chat history with an index and content of each message.

Use mod 2 to alternate between displaying user and bot templates for odd/even numbered messages.

Using Hugging Face Models Instead of OpenAI Models

In this section, the speaker explains how to use Hugging Face models instead of OpenAI models for generating responses.

Using Hugging Face Models

Copy code used for OpenAI models.

Replace OpenAI-specific code with Hugging Face-specific code.

Thank you for the detailed instructions. I will follow them to create a clear and concise markdown file that makes use of timestamps when available.

Using Any Language

In this section, the speaker discusses how any language can be used in programming.

Programming languages are just tools to solve problems.

Different languages have different strengths and weaknesses.

It's important to choose the right tool for the job.

Learning New Languages

In this section, the speaker talks about learning new programming languages.

Learning new languages is important for growth as a programmer.

It's easier to learn new languages once you know one or two well.

Learning new languages helps you understand different approaches to solving problems.

Choosing a Language

In this section, the speaker discusses how to choose a programming language.

Consider what problem you're trying to solve and what tools are best suited for it.

Look at what other people are using for similar projects and consider why they chose those tools.

Don't be afraid to try something new if it seems like it might be a good fit for your project.

Conclusion

The speaker concludes by summarizing key points from the video.

Programming languages are just tools, and different tools are better suited for different jobs.

Learning new programming languages is important for growth as a programmer.

When choosing a programming language, consider the problem you're trying to solve and what tools are best suited for it.