@GitHub_Daily: Want to understand how RAG really works? Online tutorials either skip steps or directly call cloud APIs, leaving the intermediate process invisible. RAG from Scratch breaks the entire pipeline into a dozen or so small experiments, each step running with local models—no black box. From text chunking, vectorization, retrieval to final generation, the code is all right there...

X AI KOLs Timeline Tools
rag retrieval-augmented-generation embeddings vector-database tutorial open-source local-llm

Summary

Introduces the open-source project RAG from Scratch, which fully breaks down the RAG pipeline through step-by-step local code experiments, covering text chunking, vectorization, retrieval, reranking, query rewriting and other advanced strategies, helping developers understand RAG implementation from the ground up.

Want to understand how RAG really works? Online tutorials either skip steps or directly call cloud APIs, leaving the intermediate process invisible. RAG from Scratch breaks the entire pipeline into about a dozen small experiments, each step running with local models—no black box. From text chunking, vectorization, retrieval to final generation, the code is right there in front of you, with function-level explanations. GitHub: http://github.com/pguso/rag-from-scratch... It also covers advanced strategies like hybrid retrieval, multi-query retrieval, and query rewriting—if you want to go deeper, just keep reading. If you want to understand how RAG works at a low level, following this project will be rewarding.
Original Article
View Cached Full Text

Cached at: 08/14/26, 01:33 PM

Want to really understand how RAG works? Online tutorials either skip steps or just call cloud APIs, leaving the intermediate process invisible.

RAG from Scratch breaks the entire pipeline into a dozen small experiments, each step running with local models — no black boxes.

From text chunking, embedding, retrieval, and final generation, the code is all in front of you, explained at the function level.

GitHub: http://github.com/pguso/rag-from-scratch…

It also covers advanced strategies like hybrid search, multi-query retrieval, and query rewriting — if you want to go deeper, just keep reading.

If you want to understand how RAG works from the ground up, following this project from start to finish will be rewarding.

pguso/rag-from-scratch

Source: https://github.com/pguso/rag-from-scratch

image

RAG from Scratch

Demystify Retrieval-Augmented Generation (RAG) by building it yourself - step by step.
No black boxes. No cloud APIs. Just clear explanations, simple examples, and local code you fully understand.

This project follows the same philosophy as AI Agents from Scratch (https://github.com/pguso/ai-agents-from-scratch):
make advanced AI concepts approachable for developers through minimal, well-explained, real code.

What You’ll Learn

  • What RAG really is, and why it’s so powerful for knowledge retrieval.
  • How embeddings work, turn text into numbers your model can understand.
  • How to build a local vector database, store and query documents efficiently.
  • How to connect everything, retrieve context and feed it into an LLM for grounded answers.
  • How to re-rank and normalize, improving retrieval precision and reducing noise.
  • Query rewriting, normalize and rewrite user queries (heuristic and LLM) before retrieval.
  • Step-by-step code walkthroughs, every function explained, nothing hidden.

Concept Overview

Retrieval-Augmented Generation (RAG) enhances language models by giving them access to external knowledge.
Instead of asking the model to “remember” everything, you let it retrieve relevant context before generating a response.

Pipeline:

  1. Knowledge Requirements, define questions and data needs.
  2. Data Loading, import and structure your documents.
  3. Text Splitting & Chunking, divide data into manageable pieces.
  4. Embedding, turn chunks into numerical vectors.
  5. Vector Store, save and index embeddings for fast retrieval.
  6. Retrieval, fetch the most relevant context for a given query.
  7. Post-Retrieval Re-Ranking, re-order results to prioritize the best context.
  8. Query Preprocessing & Embedding Normalization, clean and standardize input vectors for consistency.
  9. Augmentation, merge retrieved context into the model’s prompt.
  10. Generation, produce grounded answers using a local LLM.

Learning Path

Follow these examples in order to build understanding progressively:

0. How RAG Works

examples/00_how_rag_works/
Code | Code Explanation | Concepts

What you’ll learn:

  • The core idea behind Retrieval-Augmented Generation
  • How retrieval and generation work together
  • A minimal, simplified end-to-end RAG flow in under 70 lines of code

Key concepts: retrieval, generation, context injection, similarity search

1. Data Loading

examples/02_data_loading/
Code | Code Explanation | Concepts

What you’ll learn:

  • Loading raw text data
  • Normalizing and preparing documents

Key concepts: file I/O, preprocessing, document structure

2. Text Splitting & Chunking

examples/03_text_splitting_and_chunking/
Code | Code Explanation | Concepts

What you’ll learn:

  • How to split long text into manageable chunks
  • Overlaps, boundaries, and chunk strategies

Key concepts: chunking logic, context windows, granularity trade-offs

3. Embedding

examples/04_intro_to_embeddings/02_generate_embeddings/
Code | Code Explanation | Concepts

What you’ll learn:

  • How embeddings represent meaning as vectors
  • How to generate embeddings locally

Key concepts: vector representation, similarity, embedding models

4. Vector Store

examples/05_building_vector_store/01_in_memory_store/
Code | Code Explanation | Concepts

What you’ll learn:

  • How to store embeddings
  • How nearest-neighbor search works

Key concepts: indexing, vector search, metadata storage

5. Basic Retrieval

examples/06_retrieval_strategies/01_basic_retrieval/
Code | Code Explanation | Concepts

What you’ll learn:

  • Retrieving relevant chunks from the vector store
  • Understanding similarity scoring

Key concepts: augment, scoring, top-k retrieval

At the end you can look into Showcase to see everything you learned so far in action.

7. Query Preprocessing

examples/06_retrieval_strategies/02_query_preprocessing/
Code | Code Explanation | Concepts

What you’ll learn:

  • Cleaning and normalizing user queries before embedding
  • Reducing noise and improving embedding consistency

Key concepts: normalization, stopword removal, query cleaning, vector stability

8. Hybrid Search

examples/06_retrieval_strategies/03_hybrid_search/
Code | Code Explanation | Concepts

What you’ll learn:

  • Combining multiple retrieval strategies (e.g., vector + keyword)
  • Balancing semantic similarity with traditional search signals

Key concepts: hybrid scoring, weighted search, BM25 + embeddings, multi-strategy retrieval

9. Multi-Query Retrieval

examples/06_retrieval_strategies/04_multi_query_retrieval/
Code | Code Explanation | Concepts

What you’ll learn:

  • Decomposing complex queries into sub-queries (e.g. with an LLM)
  • Running multiple queries in parallel and fusing results (RRF, weighted)
  • Query expansion, perspective-based retrieval, and adaptive strategy selection
  • Deduplication and ranking when combining result lists

Key concepts: query decomposition, parallel retrieval, reciprocal rank fusion (RRF), weighted fusion, deduplication

10. Query Rewriting

examples/06_retrieval_strategies/05_query_rewriting/
Code | Code Explanation | Concepts

What you’ll learn:

  • Normalizing and cleaning user queries before retrieval
  • Stripping filler, expanding acronyms, and stripping injection-like content
  • Intent classification and optional LLM rewrite (Qwen 3-1 via node-llama-cpp) with heuristic fallback

Key concepts: query normalization, intent classification, heuristic rewrite, LLM rewrite, alternate queries

Project Structure

├── src/ # Reusable library code │ ├── embeddings/ │ │ ├── index.js # Main exports │ │ ├── EmbeddingModel.js # Model wrapper class │ │ └── EmbeddingCache.js # Caching layer │ │ │ ├── vector-stores/ │ │ ├── index.js # Main exports │ │ ├── BaseVectorStore.js # Abstract base class │ │ ├── InMemoryVectorStore.js # In-memory implementation │ │ ├── LanceDBVectorStore.js # LanceDB implementation │ │ └── QdrantVectorStore.js # Qdrant implementation │ │ │ ├── loaders/ │ │ ├── index.js │ │ ├── BaseLoader.js # Abstract loader │ │ ├── PDFLoader.js # PDF loading │ │ ├── TextLoader.js # Text file loading │ │ └── DirectoryLoader.js # Batch loading │ │ │ ├── text-splitters/ │ │ ├── index.js │ │ ├── BaseTextSplitter.js # Base class │ │ ├── CharacterTextSplitter.js │ │ ├── RecursiveCharacterTextSplitter.js │ │ └── TokenTextSplitter.js │ │ │ ├── retrievers/ │ │ ├── index.js │ │ ├── BaseRetriever.js # Base retriever │ │ ├── VectorStoreRetriever.js # Vector search │ │ ├── RerankerRetriever.js # With reranking │ │ └── HybridRetriever.js # Multiple strategies │ │ │ ├── chains/ │ │ ├── index.js │ │ ├── RetrievalChain.js # Query → Retrieve → Format │ │ ├── RAGChain.js # Full RAG pipeline │ │ └── ConversationalChain.js # With memory │ │ │ ├── prompts/ │ │ ├── index.js │ │ ├── PromptTemplate.js # Template class │ │ └── templates/ │ │ ├── qa.js # Q&A templates │ │ ├── summarization.js │ │ └── conversation.js │ │ │ ├── utils/ │ │ ├── index.js │ │ ├── Document.js # Document class │ │ ├── similarity.js # Similarity functions │ │ ├── tokenizer.js # Token counting │ │ └── validators.js # Input validation │ │ │ └── index.js # Main library export │ ├── examples/ │ ├── 00_how_rag_works/ │ │ └── example.js # Minimal RAG simulation with naive keyword search │ │ │ ├── 01_intro_to_llms/ │ │ └── example.js # Introduction to LLMs, the brain of your RAG system │ │ │ ├── 02_data_loading/ │ │ └── example.js # Load and preprocess raw text data │ │ │ ├── 03_text_splitting_and_chunking/ │ │ └── example.js # Split long text into chunks for embedding │ │ │ ├── 04_intro_to_embeddings/ │ │ ├── 01_text_similarity_basics/ │ │ └── 02_generate_embeddings/ │ │ │ ├── 05_building_vector_store/ │ │ ├── 01_in_memory_store/ │ │ ├── 02_nearest_neighbor_search/ │ │ └── 03_metadata_filtering/ │ │ │ ├── 06_retrieval_strategies/ │ │ ├── 01_basic_retrieval/ # Top-k retrieval, similarity scoring; includes showcase.js │ │ ├── 02_query_preprocessing/ # Normalize and clean queries before embedding │ │ ├── 03_hybrid_search/ # Vector + keyword (e.g. BM25) combined │ │ ├── 04_multi_query_retrieval/ # Decomposition (LLM), parallel retrieval, RRF, dedup (config, helpers) │ │ ├── 05_query_rewriting/ # Heuristic + LLM rewrite (Qwen), intent, alternates (config, query-rewriter) │ │ ├── 06_rank_results/ # (planned) Score normalization, ranking methods │ │ └── 07_post_retrieval_reranking/ # (planned) Rerank retrieved results for precision │ │ │ ├── 07_prompt_engineering_for_rag/ # (planned) Context stuffing, citations, compression │ │ ├── 01_context_stuffing/ │ │ ├── 02_citation_prompts/ │ │ └── 03_context_compression/ │ │ │ ├── 08_rag_in_action/ # (planned) Full pipeline, error handling, streaming │ │ ├── 01_basic_rag/ │ │ ├── 02_error_handling/ │ │ └── 03_streaming_responses/ │ │ │ ├── 09_evaluating_rag_quality/ # (planned) Retrieval and generation metrics │ │ ├── 01_retrieval_metrics/ │ │ ├── 02_generation_metrics/ │ │ └── 03_end_to_end_evaluation/ │ │ │ ├── 10_observability_and_caching/ # (planned) Cache repeated queries, log performance │ │ └── example.js │ │ │ ├── 11_metadata_and_structured_data/ # (planned) Metadata and structured data handling │ │ └── example.js │ │ │ ├── 12_graph_db_integration/ # (planned) Graph database (e.g. kuzu) for retrieval │ │ └── example.js │ │ │ ├── 13_knowledge_requiremens/ # (planned) Define knowledge needs and sources │ │ └── example.js │ │ │ ├── tutorials/ # (planned) Higher-level guides │ │ ├── basic-rag-pipeline.js │ │ ├── conversational-rag.js │ │ ├── multi-modal-rag.js │ │ └── advanced-retrieval.js │ │ │ ├── templates/ # (planned) Starter templates │ │ ├── simple-rag/ │ │ ├── api-server/ │ │ └── chatbot/ │ │ │ ├── tests/ # Unit tests │ │ ├── embeddings/ │ │ ├── vector-stores/ │ │ └── ... │ │ │ └── README.md

Retrieval strategies 01–05 are implemented; 06_rank_results and 07_post_retrieval_reranking are planned (see What’s Coming Next). Implemented examples often include config.js, CODE.md, and CONCEPT.md alongside example.js.

How it works

GoalWhat You AddWhy It Helps
Concept clarity00_how_rag_worksSee retrieval + generation in <70 lines before touching vectors.
Mathematical intuition04_intro_to_embeddings/01_text_similarity_basics.jsLearn cosine similarity without black-box APIs.
Hands-on understanding05_building_vector_store/01_in_memory_store.jsUnderstand how embeddings are stored and compared.
Better results06_retrieval_strategies/07_post_retrieval_reranking.jsReduce noise and redundancy in retrieved context.
Query quality06_retrieval_strategies/02_query_preprocessing.jsEnsure embeddings represent consistent meaning.
Knowledge connectivity12_graph_db_integration/example.jsExplore how a graph database can improve retrieval and reasoning.

Each folder contains:

  • A minimal example (example.js)
  • A detailed explanation of every step
  • Comments in the code to teach the concept clearly

Current Implementation Status

This project is being built step by step, following an educational approach where each concept is introduced incrementally.

What’s Implemented

The following core components and examples are currently available:

Examples and tutorials:

  • 00_how_rag_works - Minimal RAG simulation to understand the concept
  • 01_intro_to_llms - Getting started with local LLMs (node-llama-cpp basics, building LLM wrapper)
  • 02_data_loading - Loading and preprocessing raw text data
  • 03_text_splitting_and_chunking - Splitting long text into manageable chunks
  • 04_intro_to_embeddings - Text similarity basics and generating embeddings
  • 05_building_vector_store - In-memory store, nearest neighbor search, metadata filtering
  • `06_retrieval_strateg

Similar Articles

@mate_mattt: I built a real, runnable RAG project and a Notebook RAG practical course, breaking down RAG pixel by pixel: Markdown chunking → FTS5 / BM25 → Embedding vector search → Hybrid recall RRF → Cross-Encod…

X AI KOLs Timeline

This is a hands-on project for learning local RAG retrieval core from scratch, including Notebook and real runnable code. It covers the complete workflow: Markdown chunking, BM25, Embedding vector search, hybrid recall RRF, Cross-Encoder re-ranking, and comes with evaluation metrics.

@Ryrenz: Guys, I found another gem of a course: Build a Production-Grade RAG System from Scratch in 7 Weeks — 7.7k stars on GitHub, hands-on coding throughout, not a slides-only course. Most RAG tutorials out there jump straight to vector search; the demo works but crashes in production. This course follows the real path used in companies...

X AI KOLs Timeline

A 7-week course with 7.7k stars on GitHub, building a production-grade RAG system from scratch, covering Docker, FastAPI, hybrid search, LangGraph agentic RAG, and a Telegram bot, with hands-on coding throughout.

Learn everything about RAG with actual code

Reddit r/AI_Agents

The author announces education-first documentation for the open-source RAG framework RAG Me Up, explaining RAG concepts with code and runnable examples.

@seclink: Fun fact, the evolution path of RAG technology ① 2020 — Basic RAG (solving "knowledge not in the model") The starting point is the RAG by Lewis et al.: DPR dense retrieval + vector similarity + generation. It was the first to let LLMs "connect to external knowledge bases," alleviating hallucination and timeliness issues. But this generation is...

X AI KOLs Timeline

It explains the evolution path of RAG technology from basic RAG in 2020 to autonomous agents + reinforcement learning in 2025-2026, covering retrieval precision improvement, reflection and correction, graph enhancement, routing optimization, and Agentic RAG, and summarizes representative works and pain points of each stage.