Building RAG from Scratch: 02

Setting Up Your RAG Development Environment

Series: Building RAG from Scratch
Article: 2 of 12
Level: Beginner
Prerequisites: Article 1, Basic Python knowledge

Infographic for setting up a RAG development environment with LangChain, vector storage, and LLMs. — Master the essentials and set up your development environment for building RAG applications from scratch.

Introduction

In Article 1, you learned what RAG is and why it matters. Now it's time to get your hands dirty! In this article, we'll transform theory into practice by:

Setting up a complete Python development environment for RAG
Installing and configuring all necessary libraries
Understanding the RAG tool ecosystem
Building your first working RAG system (it's simpler than you think!)
Running actual queries and seeing RAG in action

By the end of this article, you'll have a functioning RAG application running on your machine. You'll be able to load documents, ask questions, and get intelligent answers backed by your knowledge base.

Let's dive in!

Prerequisites Check

Before we start, make sure you have:

Python 3.8 or higher installed (Python 3.10+ recommended)
Basic Python knowledge (variables, functions, imports)
A text editor or IDE (VS Code, PyCharm, or even Jupyter)
Internet connection (for downloading packages and API access)
Terminal/Command Prompt access

Don't worry if you're not a Python expert! We'll explain everything as we go.

Part 1: Understanding the RAG Tool Ecosystem

Before installing anything, let's understand the landscape of RAG tools. This will help you make informed choices for your projects.

The Three Approaches to Building RAG

1. From Scratch (DIY)

Build everything yourself
Maximum control and understanding
Most time-consuming
Best for learning

2. Using Frameworks (LangChain, LlamaIndex)

Pre-built components and abstractions
Faster development
Less boilerplate code
Industry standard

3. All-in-One Solutions (Managed Services)

Hosted RAG platforms
Minimal code required
Limited customization
Usually paid services

In this series, we'll use approach #2 (frameworks) while explaining the underlying concepts (#1). This gives you both speed and understanding.

Key Libraries We'll Use

Here's what each library does and why we need it:

Core Framework:

LangChain - Orchestration framework that ties everything together

Vector Storage:

ChromaDB - Vector database for storing and searching embeddings (local, free)

Embeddings:

OpenAI - High-quality embeddings (requires API key, paid)
Sentence Transformers - Open-source embeddings (free, runs locally)

LLM Access:

OpenAI - GPT models (requires API key, paid)
Anthropic - Claude models (alternative, requires API key, paid)

Utilities:

python-dotenv - Manage API keys securely
pypdf - Read PDF files
tiktoken - Token counting for OpenAI models

Don't worry about the costs! We'll show you how to use free alternatives, and the paid options have generous free tiers.

Part 2: Setting Up Your Python Environment

Step 1: Verify Python Installation

Open your terminal and run:

python --version
# or
python3 --version

You should see something like Python 3.10.x or higher.

Don't have Python? Download it from python.org

Step 2: Create a Project Directory

Let's create a clean workspace for our RAG project:

# Create project directory
mkdir rag-from-scratch
cd rag-from-scratch

# Create subdirectories
mkdir documents
mkdir scripts
mkdir data

Directory structure:

rag-from-scratch/
├── documents/       # Your knowledge base documents
├── scripts/         # Python scripts we'll write
├── data/           # Vector database storage
└── .env            # API keys (we'll create this)

Step 3: Create a Virtual Environment

Virtual environments keep your project dependencies isolated. This is a best practice!

# Create virtual environment
python -m venv rag_env

# Activate it (Mac/Linux)
source rag_env/bin/activate

# Activate it (Windows)
rag_env\Scripts\activate

You should see (rag_env) in your terminal prompt. This means it's active.

To deactivate later:

deactivate

Step 4: Upgrade pip

pip install --upgrade pip

Part 3: Installing Required Packages

Option A: Quick Install (Recommended for Beginners)

Install everything at once:

pip install langchain langchain-community langchain-openai \
            chromadb sentence-transformers \
            openai python-dotenv pypdf tiktoken

This will take 2-5 minutes. Grab a coffee! ☕

Option B: Understanding Each Package

Let's install packages one by one to understand what each does:

1. Core LangChain:

pip install langchain

2. LangChain Community Components:

pip install langchain-community

Includes document loaders, vector stores, and more

3. LangChain OpenAI Integration:

pip install langchain-openai

For using OpenAI's models and embeddings

4. ChromaDB (Vector Database):

pip install chromadb

Local vector database, no server needed

5. Sentence Transformers (Free Embeddings):

pip install sentence-transformers

Open-source embedding models

6. OpenAI SDK:

pip install openai

For calling OpenAI's API

7. Utilities:

pip install python-dotenv pypdf tiktoken

Environment variables, PDF reading, token counting

Verify Installation

Create a test script:

# test_imports.py
try:
    import langchain
    import chromadb
    import sentence_transformers
    import openai
    print("✅ All packages installed successfully!")
    print(f"LangChain version: {langchain.__version__}")
except ImportError as e:
    print(f"❌ Missing package: {e}")

Run it:

python test_imports.py

Part 4: API Keys and Configuration

Understanding API Keys

Some services require API keys for authentication. Think of them as passwords for accessing AI models.

Free Options (No API Key Needed):

Sentence Transformers (embeddings)
Local LLMs via Ollama
ChromaDB (vector database)

Paid Options (API Key Required):

OpenAI (GPT-4, GPT-3.5, embeddings)
Anthropic (Claude)
Cohere (embeddings and reranking)

For this article, we'll show both approaches!

Getting an OpenAI API Key (Optional)

If you want to use OpenAI:

Go to platform.openai.com
Sign up (free tier includes $5 credit)
Navigate to API Keys
Click "Create new secret key"
Copy the key (you'll only see it once!)

Cost estimate: Our examples will cost less than $0.10

Setting Up Environment Variables

Never hardcode API keys in your code! Use environment variables instead.

Create a .env file in your project root:

# .env
OPENAI_API_KEY=your-key-here

# Optional: If using Anthropic
ANTHROPIC_API_KEY=your-key-here

IMPORTANT: Add .env to .gitignore if using Git:

echo ".env" >> .gitignore

Loading Environment Variables

Create a config file:

# scripts/config.py
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Access API keys
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

# Validate
if not OPENAI_API_KEY:
    print("⚠️ Warning: OPENAI_API_KEY not found")
    print("Some features will be limited")

Part 5: Your First RAG System - "Hello RAG"

Now for the exciting part - let's build a working RAG system! We'll start super simple and explain every line.

The Simplest RAG Possible

Create this file: scripts/hello_rag.py

"""
Hello RAG - The simplest possible RAG implementation
This uses completely free, local tools - no API keys needed!
"""

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# Step 1: Create some sample documents
documents = [
    "RAG stands for Retrieval-Augmented Generation. It's a technique that enhances LLMs by giving them access to external knowledge.",
    "The main components of RAG are: document loading, chunking, embedding, vector storage, retrieval, and generation.",
    "Vector databases store embeddings and enable fast similarity search. Popular options include ChromaDB, Pinecone, and Weaviate.",
    "Embeddings convert text into numerical vectors. Similar meanings produce similar vectors, enabling semantic search.",
    "LangChain is a framework for building applications with LLMs. It provides pre-built components for RAG systems."
]

print("📚 Step 1: Documents loaded")
print(f"   We have {len(documents)} documents\n")

# Step 2: Initialize embedding model (runs locally, free!)
print("🔤 Step 2: Loading embedding model...")
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)
print("   Embedding model ready\n")

# Step 3: Create vector store
print("💾 Step 3: Creating vector database...")
vectorstore = Chroma.from_texts(
    texts=documents,
    embedding=embeddings,
    persist_directory="./data/hello_rag_db"
)
print("   Vector database created\n")

# Step 4: Test retrieval
print("🔍 Step 4: Testing retrieval...")
query = "What is RAG?"
relevant_docs = vectorstore.similarity_search(query, k=2)
print(f"   Query: '{query}'")
print(f"   Found {len(relevant_docs)} relevant documents:")
for i, doc in enumerate(relevant_docs, 1):
    print(f"   {i}. {doc.page_content[:100]}...")
print()

# Step 5: (Optional) Set up LLM and generation
print("🤖 Step 5: Setting up LLM...")
print("   Note: This requires Ollama to be installed")
print("   If you don't have it, that's okay - we've already demonstrated RAG retrieval!")
print()

# Uncomment this section if you have Ollama installed
"""
llm = Ollama(model="llama2")

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(),
    return_source_documents=True
)

result = qa_chain({"query": "What are the main components of RAG?"})
print("Answer:", result["result"])
"""

print("✅ Success! Your first RAG system is working!")
print("   - Documents are embedded and stored")
print("   - Similarity search is functioning")
print("   - You're ready to build more complex systems!")

Run Your First RAG System

python scripts/hello_rag.py

Expected output:

📚 Step 1: Documents loaded
   We have 5 documents

🔤 Step 2: Loading embedding model...
   Embedding model ready

💾 Step 3: Creating vector database...
   Vector database created

🔍 Step 4: Testing retrieval...
   Query: 'What is RAG?'
   Found 2 relevant documents:
   1. RAG stands for Retrieval-Augmented Generation. It's a technique that enhances LLMs by giving ...
   2. The main components of RAG are: document loading, chunking, embedding, vector storage, retri...

✅ Success! Your first RAG system is working!

Congratulations! 🎉 You just built a working RAG system!

What Just Happened? Code Breakdown

Let's understand each part:

1. Documents:

documents = [
    "RAG stands for...",
    "The main components..."
]

In a real system, these would come from files, databases, or APIs
For now, we're using simple strings to keep it clear

2. Embedding Model:

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

Downloads a free, open-source embedding model
Runs locally on your machine
Converts text to 384-dimensional vectors

3. Vector Store:

vectorstore = Chroma.from_texts(
    texts=documents,
    embedding=embeddings,
    persist_directory="./data/hello_rag_db"
)

Creates ChromaDB database
Embeds each document
Stores vectors locally in ./data/hello_rag_db

4. Similarity Search:

relevant_docs = vectorstore.similarity_search(query, k=2)

Embeds the query
Finds 2 most similar documents
Returns them for generation

This is the essence of RAG! Everything else is optimization and refinement.

Part 6: Building a Practical RAG System

Now let's build something more realistic - a RAG system that reads actual documents and uses a real LLM.

Version 1: With OpenAI (Requires API Key)

Create scripts/practical_rag.py:

"""
Practical RAG - A complete RAG system with real documents and LLM
Version: OpenAI (requires API key)
"""

import os
from dotenv import load_dotenv
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# Load environment variables
load_dotenv()

def create_sample_document():
    """Create a sample document about RAG"""
    content = """
    Retrieval-Augmented Generation (RAG) Implementation Guide
    
    What is RAG?
    RAG is an AI framework that combines information retrieval with text generation.
    It addresses key limitations of large language models by grounding their responses
    in external, retrievable knowledge.
    
    Key Benefits:
    1. Access to current information beyond training data
    2. Reduced hallucinations through grounding
    3. Source attribution and transparency
    4. Cost-effective knowledge updates
    5. Domain-specific expertise without fine-tuning
    
    Core Components:
    - Document Loader: Ingests various file formats
    - Text Splitter: Breaks documents into chunks
    - Embedding Model: Converts text to vectors
    - Vector Database: Stores and searches embeddings
    - Retriever: Finds relevant information
    - LLM: Generates natural language responses
    
    Best Practices:
    - Use chunk sizes between 500-1000 tokens
    - Add overlap between chunks (10-20%)
    - Test different embedding models
    - Implement proper error handling
    - Monitor retrieval quality
    - Cache common queries
    
    Common Challenges:
    Retrieval quality is paramount - if the wrong chunks are retrieved,
    the answer will be wrong regardless of LLM quality. Always evaluate
    your retrieval separately from generation.
    
    Production Considerations:
    For production systems, consider latency, cost, and scalability.
    Use caching, batch processing, and optimize chunk sizes for your use case.
    """
    
    # Save to file
    os.makedirs("documents", exist_ok=True)
    with open("documents/rag_guide.txt", "w") as f:
        f.write(content)
    
    print("✅ Sample document created: documents/rag_guide.txt\n")

def build_rag_system():
    """Build a complete RAG system"""
    
    # Step 1: Create sample document
    print("Step 1: Creating sample document...")
    create_sample_document()
    
    # Step 2: Load document
    print("Step 2: Loading document...")
    loader = TextLoader("documents/rag_guide.txt")
    documents = loader.load()
    print(f"   Loaded {len(documents)} document(s)\n")
    
    # Step 3: Split into chunks
    print("Step 3: Splitting into chunks...")
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        length_function=len,
    )
    chunks = text_splitter.split_documents(documents)
    print(f"   Created {len(chunks)} chunks\n")
    
    # Step 4: Create embeddings and vector store
    print("Step 4: Creating vector store...")
    embeddings = OpenAIEmbeddings()
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory="./data/practical_rag_db"
    )
    print("   Vector store created\n")
    
    # Step 5: Create retriever
    print("Step 5: Setting up retriever...")
    retriever = vectorstore.as_retriever(
        search_type="similarity",
        search_kwargs={"k": 3}  # Retrieve top 3 chunks
    )
    print("   Retriever ready\n")
    
    # Step 6: Create LLM
    print("Step 6: Initializing LLM...")
    llm = ChatOpenAI(
        model_name="gpt-3.5-turbo",
        temperature=0  # Deterministic responses
    )
    print("   LLM ready\n")
    
    # Step 7: Create custom prompt
    print("Step 7: Setting up prompt template...")
    template = """Use the following pieces of context to answer the question at the end.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
Always provide specific details from the context when possible.

Context: {context}

Question: {question}

Detailed Answer:"""
    
    PROMPT = PromptTemplate(
        template=template,
        input_variables=["context", "question"]
    )
    print("   Prompt template ready\n")
    
    # Step 8: Create RAG chain
    print("Step 8: Building RAG chain...")
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=retriever,
        return_source_documents=True,
        chain_type_kwargs={"prompt": PROMPT}
    )
    print("   RAG chain ready\n")
    
    return qa_chain

def query_rag(qa_chain, question):
    """Query the RAG system"""
    print(f"❓ Question: {question}\n")
    
    result = qa_chain({"query": question})
    
    print(f"💡 Answer: {result['result']}\n")
    
    print("📚 Sources:")
    for i, doc in enumerate(result['source_documents'], 1):
        print(f"   {i}. {doc.page_content[:150]}...")
    print()

def main():
    """Main execution"""
    print("="*60)
    print("Building Practical RAG System with OpenAI")
    print("="*60)
    print()
    
    # Build the system
    qa_chain = build_rag_system()
    
    print("="*60)
    print("RAG System Ready! Let's ask some questions")
    print("="*60)
    print()
    
    # Ask questions
    questions = [
        "What are the main benefits of RAG?",
        "What are some best practices for chunk sizes?",
        "What challenges should I be aware of?"
    ]
    
    for question in questions:
        query_rag(qa_chain, question)
        print("-"*60)
        print()

if __name__ == "__main__":
    # Check for API key
    if not os.getenv("OPENAI_API_KEY"):
        print("❌ Error: OPENAI_API_KEY not found in environment")
        print("Please set it in your .env file")
        exit(1)
    
    main()

Version 2: With Local Models (No API Key)

Create scripts/practical_rag_local.py:

"""
Practical RAG - A complete RAG system with real documents and LLM
Version: Local (no API key needed)
Requires: Ollama installed locally
"""

import os
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain_community.llms import Ollama

# Use the same create_sample_document function from above
# (copy it here or import it)

def build_local_rag_system():
    """Build RAG system with local models"""
    
    print("Step 1: Creating sample document...")
    # Create document (same as above)
    
    print("Step 2: Loading document...")
    loader = TextLoader("documents/rag_guide.txt")
    documents = loader.load()
    
    print("Step 3: Splitting into chunks...")
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50
    )
    chunks = text_splitter.split_documents(documents)
    
    print("Step 4: Creating vector store with local embeddings...")
    embeddings = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2"
    )
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory="./data/local_rag_db"
    )
    
    print("Step 5: Setting up retriever...")
    retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
    
    print("Step 6: Initializing local LLM (Ollama)...")
    try:
        llm = Ollama(model="llama2")
    except Exception as e:
        print(f"⚠️ Error: Could not connect to Ollama: {e}")
        print("Please install Ollama from https://ollama.ai")
        return None
    
    print("Step 7: Building RAG chain...")
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        retriever=retriever,
        return_source_documents=True
    )
    
    return qa_chain

# Main execution similar to OpenAI version

Installing Ollama (Optional - For Local LLM)

If you want to run LLMs locally without API keys:

Visit ollama.ai
Download and install for your OS
Open terminal and run:

ollama pull llama2

This downloads a 4GB model. It's free and runs entirely on your machine!

Part 7: Project Structure Best Practices

As your RAG project grows, organization matters. Here's a recommended structure:

rag-from-scratch/
├── .env                    # API keys (gitignored)
├── .gitignore             # Git ignore rules
├── requirements.txt        # Package dependencies
├── README.md              # Project documentation
│
├── documents/             # Source documents
│   ├── rag_guide.txt
│   └── more_docs.pdf
│
├── data/                  # Vector databases
│   ├── practical_rag_db/
│   └── local_rag_db/
│
├── scripts/               # Main scripts
│   ├── config.py          # Configuration
│   ├── hello_rag.py       # Simple example
│   ├── practical_rag.py   # Full example
│   └── utils.py           # Helper functions
│
└── notebooks/             # Jupyter notebooks (optional)
    └── rag_experiments.ipynb

Creating requirements.txt

Save your dependencies:

pip freeze > requirements.txt

Or manually create it:

# requirements.txt
langchain==0.1.0
langchain-community==0.0.13
langchain-openai==0.0.2
chromadb==0.4.22
sentence-transformers==2.2.2
openai==1.10.0
python-dotenv==1.0.0
pypdf==4.0.0
tiktoken==0.5.2

Recreating Environment

Anyone can now recreate your environment:

pip install -r requirements.txt

Part 8: Testing Your Setup

Let's verify everything works with a comprehensive test:

Create scripts/test_setup.py:

"""
Test script to verify RAG environment setup
"""

def test_imports():
    """Test that all packages can be imported"""
    print("Testing imports...")
    try:
        import langchain
        import chromadb
        import sentence_transformers
        import openai
        from dotenv import load_dotenv
        print("✅ All packages imported successfully\n")
        return True
    except ImportError as e:
        print(f"❌ Import error: {e}\n")
        return False

def test_embedding_model():
    """Test embedding model"""
    print("Testing embedding model...")
    try:
        from langchain_community.embeddings import HuggingFaceEmbeddings
        
        embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-MiniLM-L6-v2"
        )
        
        # Test embedding
        test_text = "This is a test"
        vector = embeddings.embed_query(test_text)
        
        print(f"✅ Embedding model working")
        print(f"   Vector dimension: {len(vector)}\n")
        return True
    except Exception as e:
        print(f"❌ Embedding test failed: {e}\n")
        return False

def test_vector_store():
    """Test vector database"""
    print("Testing vector store...")
    try:
        from langchain_community.vectorstores import Chroma
        from langchain_community.embeddings import HuggingFaceEmbeddings
        
        embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-MiniLM-L6-v2"
        )
        
        # Create test database
        texts = ["RAG is great", "LLMs are powerful", "Vector databases are fast"]
        vectorstore = Chroma.from_texts(
            texts=texts,
            embedding=embeddings,
            persist_directory="./data/test_db"
        )
        
        # Test search
        results = vectorstore.similarity_search("information retrieval", k=1)
        
        print(f"✅ Vector store working")
        print(f"   Retrieved: {results[0].page_content}\n")
        return True
    except Exception as e:
        print(f"❌ Vector store test failed: {e}\n")
        return False

def test_openai_key():
    """Test OpenAI API key (if provided)"""
    print("Testing OpenAI API key...")
    try:
        import os
        from dotenv import load_dotenv
        
        load_dotenv()
        api_key = os.getenv("OPENAI_API_KEY")
        
        if not api_key:
            print("⚠️ No OpenAI API key found (this is okay for local models)\n")
            return None
        
        from openai import OpenAI
        client = OpenAI(api_key=api_key)
        
        # Test with minimal request
        response = client.embeddings.create(
            model="text-embedding-3-small",
            input="test"
        )
        
        print("✅ OpenAI API key is valid\n")
        return True
    except Exception as e:
        print(f"❌ OpenAI test failed: {e}\n")
        return False

def main():
    """Run all tests"""
    print("="*60)
    print("RAG Development Environment Test Suite")
    print("="*60)
    print()
    
    results = {
        "Imports": test_imports(),
        "Embeddings": test_embedding_model(),
        "Vector Store": test_vector_store(),
        "OpenAI API": test_openai_key()
    }
    
    print("="*60)
    print("Test Summary")
    print("="*60)
    
    for test, result in results.items():
        if result is True:
            status = "✅ PASS"
        elif result is False:
            status = "❌ FAIL"
        else:
            status = "⚠️ SKIP"
        print(f"{test:20} {status}")
    
    print()
    
    if all(r in [True, None] for r in results.values()):
        print("🎉 Your environment is ready for RAG development!")
    else:
        print("⚠️ Some tests failed. Please review errors above.")

if __name__ == "__main__":
    main()

Run the test:

python scripts/test_setup.py

Part 9: Common Setup Issues and Solutions

Issue 1: "Module not found"

Problem: ModuleNotFoundError: No module named 'langchain'

Solution:

# Make sure virtual environment is activated
# Then reinstall
pip install langchain

Issue 2: SSL Certificate Errors

Problem: SSL errors when downloading models

Solution:

# Mac/Linux
pip install --trusted-host pypi.org --trusted-host files.pythonhosted.org langchain

# Or update certificates
pip install --upgrade certifi

Issue 3: Out of Memory

Problem: Computer runs out of RAM when loading models

Solution:

Use smaller embedding models
Close other applications
Consider cloud deployment

Issue 4: Slow Embedding Model Download

Problem: Sentence transformers taking forever to download

Solution:

# Manually download and specify path
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
model.save('/path/to/local/models')

# Then use local path
embeddings = HuggingFaceEmbeddings(
    model_name='/path/to/local/models'
)

Issue 5: API Key Not Working

Problem: OpenAI API key not recognized

Solution:

# Verify .env file location (should be in project root)
# Check file format (no quotes needed)
OPENAI_API_KEY=sk-abc123...

# Not this:
OPENAI_API_KEY="sk-abc123..."

# Test directly:
import os
from dotenv import load_dotenv
load_dotenv()
print(os.getenv("OPENAI_API_KEY"))

Part 10: Next Steps and Practice Exercises

Practice Exercises

Now that your environment is set up, try these exercises:

Exercise 1: Custom Documents

Create your own text file with information about your favorite topic
Modify practical_rag.py to use your document
Ask questions about it

Exercise 2: Multiple Documents

Create 3-5 text files on related topics
Load all of them into one RAG system
Ask questions that require information from multiple files

Exercise 3: Parameter Tuning

Experiment with different chunk sizes (250, 500, 1000)
Try different overlap amounts (0, 50, 100)
Compare retrieval quality

Exercise 4: Different Embedding Models

Try "sentence-transformers/all-mpnet-base-v2" (better quality)
Compare with "all-MiniLM-L6-v2" (faster)
Measure speed and quality differences

What's Next?

In Article 3, we'll dive deep into:

Loading documents from various sources (PDFs, web pages, databases)
Advanced chunking strategies
Text preprocessing and cleaning
Metadata extraction and enrichment
Building a robust data pipeline

Key Takeaways

Let's review what we accomplished:

✅ Environment Setup:

Created isolated Python virtual environment
Installed all necessary packages
Configured API keys securely

✅ Understanding Tools:

Learned the RAG tool ecosystem
Understood framework vs. from-scratch approaches
Explored free vs. paid options

✅ Built First RAG System:

Created "Hello RAG" with local tools
Built practical RAG with real documents
Tested retrieval and generation

✅ Best Practices:

Project structure organization
Requirements management
Error handling and testing

✅ Problem Solving:

Common setup issues
Debugging strategies
Alternative approaches

Quick Reference

Essential Commands

# Create virtual environment
python -m venv rag_env

# Activate (Mac/Linux)
source rag_env/bin/activate

# Activate (Windows)
rag_env\Scripts\activate

# Install packages
pip install langchain chromadb sentence-transformers

# Save requirements
pip freeze > requirements.txt

# Test setup
python scripts/test_setup.py

Essential Code Snippets

Load Environment Variables:

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

Create Vector Store:

from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings()
vectorstore = Chroma.from_texts(
    texts=documents,
    embedding=embeddings
)

Query Vector Store:

results = vectorstore.similarity_search(query, k=3)

Resources

Documentation:

Tools:

Community:

LangChain Discord
Reddit: r/LangChain
Stack Overflow: langchain tag

Review Questions

Test your understanding:

What's the purpose of a virtual environment?
Name three vector database options.
What's the difference between OpenAI embeddings and Sentence Transformers?
Why should API keys be in .env files, not in code?
What does similarity_search(query, k=3) return?
What's the advantage of using LangChain over building from scratch?
What directory should contain your source documents?

If you can answer these, you're ready for Article 3!

Next Article: Data Preparation and Chunking Strategies
Coming Soon: Where we'll learn to handle any document type and optimize chunking for best results!

This is Article 2 of the "Building RAG from Scratch" series. You now have a working development environment and your first RAG system running. In the next article, we'll make it production-ready!

framework

Related Topics

Building RAG from Scratch: 02