A tiny Retrieval-Augmented-Generation (RAG) App

Project Reference : https://www.youtube.com/watch?v=swCPic00c30&t=1366s

🚀 What You’re About to Build

• A tiny Retrieval-Augmented-Generation (RAG) app: ask a question → system looks inside your own files → returns the most relevant passage.
• Uses no heavy servers – just a Python script plus a friendly Gradio web page.
• Ideal for tutorials, personal note searchers, quick prototypes.

1 ▸ Big-Picture Flow (in plain words)

• Collect content you trust (PDFs, text files, blog posts).
• Break it up into bite-sized chunks so search stays sharp.
• Turn each chunk into a math vector (OpenAI “embeddings”).
• Save those vectors in a mini database (FAISS) built for similarity search.
• When someone asks a question:
• Gradio adds a one-box web UI so anyone can try it.

2 ▸ Libraries & Why They Matter

• langchain – glue layer; offers loaders, splitters, vector-store wrappers.
• langchain-openai – simplified call to OpenAI APIs.
• faiss-cpu – Facebook AI Similarity Search; fast in-memory index.
• gradio – two-line way to spin up a browser demo.
• python-dotenv – hides your API key in a .env file.

(Everything installs with one pip command.)

3 ▸ One-Time Setup Steps

• Create a virtual env (python -m venv rag_env && activate).
• pip install the five libraries above.
• Grab an OpenAI key from platform.openai.com and place it in .env like:
• Fire up VS Code or Jupyter using that virtual env.

4 ▸ Code Blocks Explained in Sequence

1. Load documents
2. Split them
3. Embed them
4. Index them
5. Query function
6. Gradio interface

Each numbered block is modular – swap a loader or vector store without touching the rest.

5 ▸ Graph Thinking (for when you move to LangGraph)

• Node = an action (load, split, embed, retrieve, answer).
• Edge = data flow between nodes (documents ➜ chunks ➜ vectors).
• State = what rides along those edges (text, vectors, metadata).
• Result node = final answer returned to the user interface.
• You’ve already written the linear version; LangGraph simply draws it visually and lets you branch, loop, or add guards later.

6 ▸ Typical Questions a Non-Coder Asks

• “Will this leak my data?” → No; embeddings are numeric and the script runs locally.
• “Do I pay each time I ask?” → Embeddings are paid once; queries are free.
• “How big can my files be?” → Splitter keeps memory stable; thousands of pages run fine on a laptop.
• “Can I add more docs tomorrow?” → Yes; load new docs, call faiss.merge_from() or rebuild.

7 ▸ Real-Life Use Cases

• Personal note search: feed your journal, instantly retrieve a passage.
• Student study aid: load textbook PDFs, ask “Define enthalpy”.
• Workplace FAQ: ingest policy docs, share the Gradio link with colleagues.
• Travel helper: scrape blog posts, ask “Best vegetarian spots near Eiffel Tower”.

8 ▸ Example Session Walk-Through

1. Open the Gradio page → you see a textbox.
2. Type: “Who wrote the ‘Attention Is All You Need’ paper?”
3. Behind the scenes:
4. The answer text appears instantly.

9 ▸ Next Milestones After the Demo

• Add an LLM (e.g., chat-completions) to paraphrase retrieved text into a friendly answer.
• Persist FAISS to disk (faiss.write_index) so you don’t recompute on every run.
• Switch to Chroma once your environment issues are solved and you need filtering or advanced metadata search.
• Deploy the Gradio app on Hugging Face Spaces for a shareable public demo.

🏁 Takeaway

With roughly 50 lines of Python and five cheap libraries you can build a pocket-sized RAG system that lets anyone query their own knowledge base. No deep ML expertise required—just follow the load → split → embed → store → query pattern, hide your API key, and wrap it all in Gradio for instant usability.

10. RESULTS

11. Full code template for simple RAG (Retrieval-Augmented Generation)

✅ Full RAG App Template (Gradio + FAISS)

# 📦 Step 1: Install these in terminal or notebook if not already installed:
# !pip install langchain langchain-openai faiss-cpu gradio python-dotenv openai tiktoken

# 📂 Directory structure:
# .
# ├── app.py
# ├── speech.txt
# └── .env  # contains your OpenAI API key

# =============================
# 📜 app.py
# =============================

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from dotenv import load_dotenv
import gradio as gr
import os

# 🔐 Load API key securely
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")

# 📄 Load a local text file (can change this to PDF/Web later)
loader = TextLoader("yourfile.txt")
documents = loader.load()

# ✂️ Split text into smaller chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=100
)
docs = text_splitter.split_documents(documents)

# 🔍 Generate vector embeddings
embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)

# 🧠 Create FAISS vector store
vectorstore = FAISS.from_documents(docs, embeddings)

# ❓ Define a question-answering function
def ask_question(query):
    results = vectorstore.similarity_search(query, k=1)
    if results:
        return results[0].page_content
    else:
        return "No relevant information found in the document."

# 🌐 Launch Gradio UI
gr.Interface(
    fn=ask_question,
    inputs=gr.Textbox(lines=2, placeholder="Ask something about the document..."),
    outputs="text",
    title="Simple RAG App - Ask Your Document",
    description="This app uses LangChain + FAISS to find relevant chunks of your uploaded document."
).launch() 

✅ Sample .env file (in the same folder)

OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 

🧪 To Run This App:

1. Place your .env and files in the same folder as app.py.
2. Open terminal and run
3. A Gradio interface will launch in your browser.

📘 Want to Try with PDF?

Just change:

from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("yourfile.pdf")