Hello, Dev Community! π
Today, Iβm excited to walk you through my project: EzioDevIo RAG (Retrieval-Augmented Generation). This system allows users to upload PDF documents, ask questions based on their content, and receive real-time answers generated by OpenAI's GPT-3.5 Turbo model. This is particularly useful for navigating large documents or quickly extracting relevant information. ππ
You can find the complete code on my GitHub: EzioDevIo RAG Project. Letβs dive into the project and break down each step!
π Dive into the full codebase and setup instructions in the EzioDevIo RAG Project GitHub Repository!
Project Overview
What Youβll Learn
- How to integrate OpenAIβs language models with PDF document retrieval.
- How to create a user-friendly interface using Streamlit.
- How to containerize the application with Docker for easy deployment. Project Features
- Upload PDFs and get information from them.
- Ask questions based on the content of the uploaded PDFs.
- Real-time responses generated by OpenAIβs gpt-3.5-turbo model.
- Easy deployment with Docker for scalability.
*Hereβs the final structure of our project directory: *
RAG-project/
βββ .env # Environment variables (API key)
βββ app.py # Streamlit app for the RAG system
βββ document_loader.py # Code for loading and processing PDF documents
βββ retriever.py # Code for indexing and retrieving documents
βββ main.py # Main script for RAG pipeline
βββ requirements.txt # List of required libraries
βββ Dockerfile # Dockerfile for containerizing the app
βββ .gitignore # Ignore sensitive and unnecessary files
βββ data/
β βββ uploaded_pdfs/ # Folder to store uploaded PDFs
βββ images/
βββ openai_api_setup.png # Example image for OpenAI API setup instructions
Step 1: Setting Up the Project
Prerequisites
Make sure you have the following:
- Python 3.8+: To run the application locally.
- OpenAI API Key: Youβll need this to access OpenAIβs models. Sign up at OpenAI API to get your key.
- Docker: Optional, but recommended for containerizing the application for deployment.
Step 2: Clone the Repository and Set Up the Virtual Environment
2.1. Clone the Repository
Start by cloning the project repository from GitHub and navigating into the project directory.
git clone https://github.com/EzioDEVio/RAG-project.git
cd RAG-project
2.2. Set Up a Virtual Environment
To isolate project dependencies, create and activate a virtual environment. This helps prevent conflicts with other projectsβ packages.
python -m venv venv
source venv/bin/activate # On Windows, use `venv\Scripts\activate`
2.3. Install Dependencies
Install the required Python libraries listed in requirements.txt. This includes OpenAI for the language model, Streamlit for the UI, PyMuPDF for PDF handling, and FAISS for efficient similarity search.
pip install -r requirements.txt
2.4. Configure Your OpenAI API Key
Create a .env file in the project root directory. This file will store your OpenAI API key securely. Add the following line to the file, replacing your_openai_api_key_here with your actual API key:
OPENAI_API_KEY=your_openai_api_key_here
π‘ Tip: Make sure .env is added to your .gitignore file to avoid exposing your API key if you push your project to a public repository.
Step 3: Understanding the Project Structure
Hereβs a quick overview of the directory structure to help you navigate the code:
Hereβs a quick overview of the directory structure to help you navigate the code:
RAG-project/
βββ .env # Environment variables (API key)
βββ app.py # Streamlit app for the RAG system
βββ document_loader.py # Code for loading and processing PDF documents
βββ retriever.py # Code for indexing and retrieving documents
βββ main.py # Main script for RAG pipeline
βββ requirements.txt # List of required libraries
βββ Dockerfile # Dockerfile for containerizing the app
βββ .gitignore # Ignore sensitive and unnecessary files
βββ data/
β βββ uploaded_pdfs/ # Folder to store uploaded PDFs
βββ images/
βββ openai_api_setup.png # Example image for OpenAI API setup instructions
Each file has a specific role:
- app.py: Manages the Streamlit interface, allowing users to upload files and ask questions.
- document_loader.py: Handles loading and processing of PDFs using PyMuPDF.
- retriever.py: Uses FAISS to index document text and retrieve relevant sections based on user queries.
- main.py: Ties everything together, including calling OpenAIβs API to generate responses.
Step 4: Building the Core Code
Now, letβs dive into the main components of the project.
4.1. Loading Documents (document_loader.py)
The document_loader.py file is responsible for extracting text from PDFs. Here, we use the PyMuPDF library to process each page in the PDF and store the text.
import fitz # PyMuPDF
import os
def load_documents_from_folder(folder_path):
documents = []
for filename in os.listdir(folder_path):
if filename.endswith(".pdf"):
with fitz.open(os.path.join(folder_path, filename)) as pdf:
text = "".join(page.get_text() for page in pdf)
documents.append({"text": text, "filename": filename})
return documents
Explanation: This function reads all PDF files in a specified folder, extracts the text from each page, and adds the text to a list of dictionaries. Each dictionary represents a document with its text and filename.
4.2. Document Indexing and Retrieval (retriever.py)
FAISS (Facebook AI Similarity Search) helps us to perform similarity searches. We use it to create an index of the document embeddings, which allows us to retrieve relevant sections when users ask questions.
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
def create_index(documents):
embeddings = OpenAIEmbeddings()
texts = [doc["text"] for doc in documents]
metadata = [{"filename": doc["filename"]} for doc in documents]
return FAISS.from_texts(texts, embeddings, metadata=metadata)
def retrieve_documents(index, query):
return index.similarity_search(query)
Explanation:
create_index: Converts document text into embeddings using OpenAIEmbeddings and creates an index with FAISS.
retrieve_documents: Searches for relevant document sections based on the user query.
4.3. Generating Responses (main.py)
This module processes user queries, retrieves relevant documents, and generates answers using OpenAIβs language model.
import openai
import os
from dotenv import load_dotenv
from document_loader import load_documents_from_folder
from retriever import create_index, retrieve_documents
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def generate_response(query, retrieved_docs):
context = "\n\n".join([doc["text"][:1000] for doc in retrieved_docs])
messages = [
{"role": "system", "content": "You are a helpful assistant..."},
{"role": "user", "content": f"Context: {context}\n\nQuestion: {query}"}
]
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages,
max_tokens=150,
temperature=0.3,
)
return response.choices[0].message['content'].strip()
Explanation:
generate_response: Creates a prompt with context from retrieved documents and the userβs query, then sends it to OpenAIβs API. The response is then returned as the answer.
Step 5: Creating the Streamlit Interface (app.py)
Streamlit provides an interactive front end, making it easy for users to upload files and ask questions.
import streamlit as st
from document_loader import load_documents_from_folder
from retriever import create_index, retrieve_documents
from main import generate_response
st.title("EzioDevIo RAG")
st.write("Upload a PDF, then ask questions based on its content. Get responses in real-time!")
uploaded_files = st.file_uploader("Upload PDF(s)", type="pdf", accept_multiple_files=True)
if uploaded_files:
documents = [{"text": file.read().decode("utf-8"), "filename": file.name} for file in uploaded_files]
index = create_index(documents)
st.success("Files uploaded successfully!")
query = st.text_input("Enter your question here:")
if st.button("Get Answer"):
if query:
retrieved_docs = retrieve_documents(index, query)
answer = generate_response(query, retrieved_docs)
st.write("**Answer:**")
st.write(answer)
else:
st.warning("Please enter a question.")
Explanation:
- This code creates a simple UI with Streamlit, allowing users to upload PDFs and type questions.
- When users click "Get Answer," the app retrieves relevant documents and generates an answer.
Step 6: Dockerizing the Application
Docker allows you to package the app into a container, making it easy to deploy.
Dockerfile
# Dependency Installation Stage
FROM python:3.8-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Final Stage
FROM python:3.8-slim
RUN useradd -m nonrootuser
USER nonrootuser
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.8/site-packages /usr/local/lib/python3.8/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin
COPY . .
EXPOSE 8501
CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.enableCORS=false"]
Explanation:
We use a multi-stage build to keep the final image lean.
The application runs as a non-root user for security.
Running the Docker Container
- Build the Docker Image:
docker build -t ezio_rag_app .
- Run the Container:
docker run -p 8501:8501 --env-file .env ezio_rag_app
Step 7: Setting Up CI/CD with GitHub Actions
For production readiness, add a CI/CD pipeline to build, test, and scan Docker images. You can find the .github/workflows file in the repository for this setup.
Final Thoughts
This project combines OpenAIβs language model capabilities with document retrieval to create a functional and interactive tool. If you enjoyed this project, please star the GitHub repository and follow me here on Dev Community. Letβs build more amazing projects together! π
π View the GitHub Repository π EzioDevIo RAG Project GitHub Repository!
Top comments (0)