Bulletproof RAG: Production Curriculum

Module 01: Introduction

Module 02: Naive RAG

Module 03: Data Engineering

Module 04: Query Intelligence

Module 05: Advanced Retrieval

Module 06: Agentic Architectures

Module 07: Evaluation

RAG Logging and Observability

The Naive RAG Implementation

Senior-grade implementation of a Naive RAG pipeline using Vercel AI SDK v6, LangChain Recursive splitters, and unpdf extraction.

Naive RAG (Basic RAG) is the architectural baseline for grounding Large Language Models in private data. It operates as a linear "Retrieve-then-Generate" bridge. The system identifies relevant document snippets from a local depository and injects them into the model context window before inference. This creates a factual anchor, mitigating the risk of hallucinations and providing clear data provenance.

Engineering Trade-offs

Feature	Technical Impact
Pros	Low architectural complexity; stateless execution; minimal latency overhead for small datasets.
Cons	Linear memory scaling limits; sensitive to chunk boundaries; lacks support for multi-document relational reasoning.

Architecture Overview

The transformation from binary document data to a grounded response follows this data flow:

        [Document]
             │
             ▼
   ┌───────────────────┐
   │  unpdf Extraction  │
   └─────────┬─────────┘
             │
     ┌───────┴───────┐
     ▼               ▼
 ┌───────────┐   ┌───────────┐
 │ Chunk A   │   │ Chunk B   │ (Recursive Character Splitting)
 │ (Size: X) │   │ (Size: X) │
 └─────┬─────┘   └─────┬─────┘
       └───────┬───────┘
               ▼
     ┌───────────────────┐
     │  Vercel AI SDK    │
     │  (Vectorization)  │
     └─────────┬─────────┘
               ▼
     ┌───────────────────┐
     │ Context Injection │ (Balancing Precision vs Context)
     └───────────────────┘

Implementation Walkthrough

The following steps trace the data lifecycle from local PDF storage to a high-fidelity AI response.

Document Ingestion and Buffer Loading

Read the local binary data. We use fs/promises for non-blocking I/O to ensure the main thread remains available during large file reads.

import fs from 'fs/promises';
import path from 'path';
 
const pdfPath = path.resolve('./data/AI_Information.pdf');
const buffer = await fs.readFile(pdfPath);
 
console.log(`[SYS] File loaded: ${pdfPath}`);
console.log(`[SYS] Buffer size: ${(buffer.length / 1024).toFixed(2)} KB`);

Text Extraction via Proxy

Use unpdf to parse the document. We enable mergePages to prevent page headers and footers from fragmenting semantic continuity.

import { getDocumentProxy, extractText } from 'unpdf';
 
const pdfProxy = await getDocumentProxy(new Uint8Array(buffer));
const { text: fullText } = await extractText(pdfProxy, { mergePages: true });
 
console.log(`[DATA] Extraction complete. Total characters: ${fullText.length}`);

Recursive Text Segmentation

We implement RecursiveCharacterTextSplitter. This algorithm prioritizes splits on paragraphs and sentences over raw character counts, preserving the logical structure of the data.

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
 
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
 
const segments = await splitter.splitText(fullText);
console.log(`[DATA] Segmentation complete. Total chunks generated: ${segments.length}`);

High-Dimensional Vectorization

Transform text segments into 1536-dimensional embeddings. Batch vectorization via embedMany reduces total HTTP overhead compared to sequential processing.

import { embedMany } from 'ai';
import { openai } from '@ai-sdk/openai';
 
const { embeddings } = await embedMany({
  model: openai.embedding('text-embedding-3-small'),
  values: segments,
});
 
const vectorStore = segments.map((content, i) => ({
  content,
  vector: embeddings[i]
}));
 
console.log(`[INDEX] Successfully indexed ${vectorStore.length} vectors to memory store.`);

Semantic Retrieval Logic

Execute the search using cosineSimilarity. This calculates the angular distance between the query and every document in the local store.

import { embed, cosineSimilarity } from 'ai';
 
const query = "What are the primary safety concerns?";
const { embedding: queryVector } = await embed({
  model: openai.embedding('text-embedding-3-small'),
  value: query,
});
 
const matches = vectorStore
  .map(item => ({
    ...item,
    similarity: cosineSimilarity(queryVector, item.vector)
  }))
  .sort((a, b) => b.similarity - a.similarity)
  .slice(0, 3);
 
console.log(`[SEARCH] Query vectorized. Top match similarity: ${matches[0].similarity.toFixed(4)}`);

Grounded Response Generation

The final phase involves prompt augmentation. We inject the top matches as context fragments, forcing the LLM to restrict its response to the provided dataset.

import { generateText } from 'ai';
 
const context = matches.map(m => m.content).join('\n\n---\n\n');
const { text: answer } = await generateText({
  model: openai('gpt-4o-mini'),
  system: "Answer using only the provided context snippets. Respond with 'Data not found' if context is insufficient.",
  prompt: `Context:\n${context}\n\nQuestion: ${query}`,
});
 
console.log(`[GEN] Response generated via gpt-4o-mini.`);

Complete Production Script

This script consolidates the logic into a single execution unit with verbose logging.

import fs from 'fs/promises';
import { getDocumentProxy, extractText } from 'unpdf';
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { embedMany, embed, cosineSimilarity, generateText } from 'ai';
import { openai } from '@ai-sdk/openai';
import 'dotenv/config';
 
/**
 * Senior Developer RAG Baseline
 * Optimized for local search and document-specific grounding.
 */
async function main() {
  const logger = {
    info: (msg) => console.log(`[INFO]  ${new Date().toISOString()} | ${msg}`),
    timer: (label) => console.time(`[TIME]  ${label}`),
    timerEnd: (label) => console.timeEnd(`[TIME]  ${label}`)
  };
 
  try {
    logger.info("Initializing RAG Pipeline execution...");
    
    // 1. Ingestion
    logger.timer("extraction");
    const buffer = await fs.readFile('./data/AI_Information.pdf');
    const pdfProxy = await getDocumentProxy(new Uint8Array(buffer));
    const { text: rawText } = await extractText(pdfProxy, { mergePages: true });
    logger.timerEnd("extraction");
    logger.info(`Source text extracted: ${rawText.length} characters.`);
 
    // 2. Recursive Chunking
    const splitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000, chunkOverlap: 200 });
    const segments = await splitter.splitText(rawText);
    logger.info(`Logical segments created: ${segments.length}`);
 
    // 3. Vectorization
    logger.timer("indexing");
    const { embeddings } = await embedMany({
      model: openai.embedding('text-embedding-3-small'),
      values: segments,
    });
    const vectorStore = segments.map((text, i) => ({ text, vector: embeddings[i] }));
    logger.timerEnd("indexing");
    logger.info(`Vector store populated in memory.`);
 
    // 4. Inference and Grounding
    const userQuery = "What specific risks does the document outline regarding AI alignment?";
    logger.info(`Query submitted: "${userQuery}"`);
 
    const { embedding: queryVector } = await embed({
      model: openai.embedding('text-embedding-3-small'),
      value: userQuery,
    });
 
    const context = vectorStore
      .map(item => ({ text: item.text, score: cosineSimilarity(queryVector, item.vector) }))
      .sort((a, b) => b.score - a.score)
      .slice(0, 3)
      .map(m => m.text)
      .join("\n\n---\n\n");
 
    logger.timer("llm-generation");
    const { text } = await generateText({
      model: openai('gpt-4o-mini'),
      system: "You are a research analyst. Use provided context to answer questions precisely.",
      prompt: `Context:\n${context}\n\nQuestion: ${userQuery}`,
    });
    logger.timerEnd("llm-generation");
 
    console.log(`\n--- AI GROUNDED RESPONSE ---\n${text}\n---------------------------\n`);
 
  } catch (error) {
    console.error(`[FATAL] Pipeline failed: ${error.message}`);
  }
}
 
main();

Summary of Impact

Metric	Standard LLM	Basic RAG Pipeline
Data Scope	Static Training Data	Live Document Context
Hallucination Risk	Significant on Niche Topics	Traceable and Low
Provenance	None	Directly Citable
System Latency	Baseline	Baseline + ~3s (Search & Vectorization)

When to Use This

Small internal technical knowledge bases.
Validating retrieval logic before scaling to a production vector database.
Applications where data must remain local and transient (in-memory).

Next PageThe Limitations of Naive RAG

On This Page

Engineering Trade-offs Architecture Overview Implementation Walkthrough Complete Production Script Summary of Impact When to Use This

Connect with the Author

Have questions or suggestions? Feel free to reach out.

Feature

Technical Impact

Pros

Low architectural complexity; stateless execution; minimal latency overhead for small datasets.

Cons

Linear memory scaling limits; sensitive to chunk boundaries; lacks support for multi-document relational reasoning.

Architecture Overview

The transformation from binary document data to a grounded response follows this data flow:

        [Document]
             │
             ▼
   ┌───────────────────┐
   │  unpdf Extraction  │
   └─────────┬─────────┘
             │
     ┌───────┴───────┐
     ▼               ▼
 ┌───────────┐   ┌───────────┐
 │ Chunk A   │   │ Chunk B   │ (Recursive Character Splitting)
 │ (Size: X) │   │ (Size: X) │
 └─────┬─────┘   └─────┬─────┘
       └───────┬───────┘
               ▼
     ┌───────────────────┐
     │  Vercel AI SDK    │
     │  (Vectorization)  │
     └─────────┬─────────┘
               ▼
     ┌───────────────────┐
     │ Context Injection │ (Balancing Precision vs Context)
     └───────────────────┘

Implementation Walkthrough

The following steps trace the data lifecycle from local PDF storage to a high-fidelity AI response.

Document Ingestion and Buffer Loading

Read the local binary data. We use fs/promises for non-blocking I/O to ensure the main thread remains available during large file reads.

import fs from 'fs/promises';
import path from 'path';
 
const pdfPath = path.resolve('./data/AI_Information.pdf');
const buffer = await fs.readFile(pdfPath);
 
console.log(`[SYS] File loaded: ${pdfPath}`);
console.log(`[SYS] Buffer size: ${(buffer.length / 1024).toFixed(2)} KB`);

Text Extraction via Proxy

Use unpdf to parse the document. We enable mergePages to prevent page headers and footers from fragmenting semantic continuity.

import { getDocumentProxy, extractText } from 'unpdf';
 
const pdfProxy = await getDocumentProxy(new Uint8Array(buffer));
const { text: fullText } = await extractText(pdfProxy, { mergePages: true });
 
console.log(`[DATA] Extraction complete. Total characters: ${fullText.length}`);

Recursive Text Segmentation

We implement RecursiveCharacterTextSplitter. This algorithm prioritizes splits on paragraphs and sentences over raw character counts, preserving the logical structure of the data.

import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
 
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
});
 
const segments = await splitter.splitText(fullText);
console.log(`[DATA] Segmentation complete. Total chunks generated: ${segments.length}`);

High-Dimensional Vectorization

Transform text segments into 1536-dimensional embeddings. Batch vectorization via embedMany reduces total HTTP overhead compared to sequential processing.

import { embedMany } from 'ai';
import { openai } from '@ai-sdk/openai';
 
const { embeddings } = await embedMany({
  model: openai.embedding('text-embedding-3-small'),
  values: segments,
});
 
const vectorStore = segments.map((content, i) => ({
  content,
  vector: embeddings[i]
}));
 
console.log(`[INDEX] Successfully indexed ${vectorStore.length} vectors to memory store.`);

Semantic Retrieval Logic

Execute the search using cosineSimilarity. This calculates the angular distance between the query and every document in the local store.

import { embed, cosineSimilarity } from 'ai';
 
const query = "What are the primary safety concerns?";
const { embedding: queryVector } = await embed({
  model: openai.embedding('text-embedding-3-small'),
  value: query,
});
 
const matches = vectorStore
  .map(item => ({
    ...item,
    similarity: cosineSimilarity(queryVector, item.vector)
  }))
  .sort((a, b) => b.similarity - a.similarity)
  .slice(0, 3);
 
console.log(`[SEARCH] Query vectorized. Top match similarity: ${matches[0].similarity.toFixed(4)}`);

Grounded Response Generation

The final phase involves prompt augmentation. We inject the top matches as context fragments, forcing the LLM to restrict its response to the provided dataset.

import { generateText } from 'ai';
 
const context = matches.map(m => m.content).join('\n\n---\n\n');
const { text: answer } = await generateText({
  model: openai('gpt-4o-mini'),
  system: "Answer using only the provided context snippets. Respond with 'Data not found' if context is insufficient.",
  prompt: `Context:\n${context}\n\nQuestion: ${query}`,
});
 
console.log(`[GEN] Response generated via gpt-4o-mini.`);

Complete Production Script

This script consolidates the logic into a single execution unit with verbose logging.

import fs from 'fs/promises';
import { getDocumentProxy, extractText } from 'unpdf';
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import { embedMany, embed, cosineSimilarity, generateText } from 'ai';
import { openai } from '@ai-sdk/openai';
import 'dotenv/config';
 
/**
 * Senior Developer RAG Baseline
 * Optimized for local search and document-specific grounding.
 */
async function main() {
  const logger = {
    info: (msg) => console.log(`[INFO]  ${new Date().toISOString()} | ${msg}`),
    timer: (label) => console.time(`[TIME]  ${label}`),
    timerEnd: (label) => console.timeEnd(`[TIME]  ${label}`)
  };
 
  try {
    logger.info("Initializing RAG Pipeline execution...");
    
    // 1. Ingestion
    logger.timer("extraction");
    const buffer = await fs.readFile('./data/AI_Information.pdf');
    const pdfProxy = await getDocumentProxy(new Uint8Array(buffer));
    const { text: rawText } = await extractText(pdfProxy, { mergePages: true });
    logger.timerEnd("extraction");
    logger.info(`Source text extracted: ${rawText.length} characters.`);
 
    // 2. Recursive Chunking
    const splitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000, chunkOverlap: 200 });
    const segments = await splitter.splitText(rawText);
    logger.info(`Logical segments created: ${segments.length}`);
 
    // 3. Vectorization
    logger.timer("indexing");
    const { embeddings } = await embedMany({
      model: openai.embedding('text-embedding-3-small'),
      values: segments,
    });
    const vectorStore = segments.map((text, i) => ({ text, vector: embeddings[i] }));
    logger.timerEnd("indexing");
    logger.info(`Vector store populated in memory.`);
 
    // 4. Inference and Grounding
    const userQuery = "What specific risks does the document outline regarding AI alignment?";
    logger.info(`Query submitted: "${userQuery}"`);
 
    const { embedding: queryVector } = await embed({
      model: openai.embedding('text-embedding-3-small'),
      value: userQuery,
    });
 
    const context = vectorStore
      .map(item => ({ text: item.text, score: cosineSimilarity(queryVector, item.vector) }))
      .sort((a, b) => b.score - a.score)
      .slice(0, 3)
      .map(m => m.text)
      .join("\n\n---\n\n");
 
    logger.timer("llm-generation");
    const { text } = await generateText({
      model: openai('gpt-4o-mini'),
      system: "You are a research analyst. Use provided context to answer questions precisely.",
      prompt: `Context:\n${context}\n\nQuestion: ${userQuery}`,
    });
    logger.timerEnd("llm-generation");
 
    console.log(`\n--- AI GROUNDED RESPONSE ---\n${text}\n---------------------------\n`);
 
  } catch (error) {
    console.error(`[FATAL] Pipeline failed: ${error.message}`);
  }
}
 
main();

Metric

Standard LLM

Basic RAG Pipeline

Data Scope

Static Training Data

Live Document Context

Hallucination Risk

Significant on Niche Topics

Traceable and Low

Provenance

None

Directly Citable

System Latency

Baseline

Baseline + ~3s (Search & Vectorization)