Forem: EzioDeviox

🌟 Let’s Grow Together on GitHub! Fork, Star, and Watch Each Other’s Repos 🚀

EzioDeviox — Fri, 08 Nov 2024 22:10:40 +0000

Hello Dev Community! 👋 Are you looking to expand your GitHub presence, connect with other devs, and show off your projects? Let’s support each other by forking, starring, and watching each other’s repositories! Here’s the deal:

Fork, Star, and Watch my repo 👉 EzioDEVio/RAG-project.
Leave a comment with your repo link here or any note once you've done the above, and I’ll gladly do the same for your repo! 💖

Let’s dive into GitHub basics for anyone new to these features and make this campaign accessible for all! 🌱

👾 What is GitHub?

GitHub is a platform for developers to collaborate, host, and share their projects. It’s where you can store code, manage versioning, handle bug tracking, and even run CI/CD pipelines. But GitHub is also a social network for devs to connect, learn, and grow! Here’s a breakdown of key GitHub features to help you make the most of this platform.

🗃️ Key GitHub Concepts

1. Repositories (Repos)

A repository is like a digital workspace containing all the project files and version history. Repos keep track of every change, organize your project, and allow collaboration with others on open-source projects. Anything can live in a repo, from a simple script to a full-fledged application!

2. Forks 🍴

A fork is your personal copy of someone else’s repo. Forking lets you freely experiment without affecting the original project. This is essential in open source: you can contribute to someone else’s project, suggest improvements, and submit pull requests to share your updates.

How to Fork a Repo:
- Go to the repo you want to fork.
- Click on the Fork button at the top right corner.
- Now, you have a copy in your GitHub account! You can make changes, experiment, or contribute back to the original project.

3. Stars ⭐

A star shows appreciation for a project and makes it easier for you to revisit later. Think of it as a GitHub “like.” When you star a repo, you’re bookmarking it as a project of interest, which also gives the creator feedback and visibility.

How to Star a Repo:
- Visit the repo you’re interested in.
- Click the Star button at the top right.
- Voila! You’ve shown your support, and it’s easy to find in your starred repos later.

4. Watchers 👀

When you watch a repo, you receive notifications for updates—like new issues, pull requests, or releases. It’s perfect for staying informed about projects you’re invested in.

How to Watch a Repo:
- Go to the repo page.
- Click the Watch button at the top right.
- Select the notification level you want (all activity or just releases).

🌈 Contribution is Key

If you’ve forked a repo and made updates, you can share those changes with the original project through a pull request. Pull requests (PRs) are the heart of GitHub collaboration, allowing developers to contribute to projects they love.

Make changes to your forked repo.
Open a pull request:
- Go to the original repository.
- Navigate to the Pull Requests tab and start a new pull request.
Write a brief summary of your updates, submit it, and if accepted, your contribution will be part of the main project!

⭐ Why Forks, Stars, and Contributions Matter

Starring and forking a repo, along with making contributions, helps build a strong GitHub profile. It demonstrates involvement in the dev community and your interests and skills, which can lead to collaborations and new opportunities.

🔥 Join the Campaign and Let’s Grow Together!

To participate in this campaign:

Fork, Star, and Watch my repo: EzioDEVio/RAG-project
Leave a comment here with your repo link or a quick note once you’ve done the above steps, and I’ll gladly return the support by forking, starring, and watching your repo!

Let’s boost our GitHub profiles and build connections. Don’t forget to comment so we can keep this momentum going and help each other grow! 🚀

🔗 Connect with Me
Let’s stay connected! You can find me on these platforms:

X (Twitter): @KhalidIQ2021
DEV Community: dev.to/eziodeviox
Kaggle: kaggle.com/eziodevio
Hugging Face: huggingface.co/EzioDevio

Building a Document Retrieval & Q&A System with OpenAI and Streamlit

EzioDeviox — Wed, 06 Nov 2024 03:33:47 +0000

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!