Production AI Skills

RAG Engineering Playbook

Name: RAG Engineering Playbook
Brand: lib-pro
SKU: rag-engineering
Price: 35.00 GBP
Availability: InStock

Stop building naive RAG. Start building RAG that doesn't hallucinate.

Ship a RAG pipeline that doesn't hallucinate.

See use cases ↓

One-time paymentLifetime updatesCommercial license

Skills

Stages covered

15+

Patterns documented

What you'll be able to do

Concrete outcomes, not vague promises.

Your first RAG pipeline

You want to ground an LLM in your company's docs. You picked a vector DB, embedded naively, and the answers are 'okay-ish' but full of hallucinations.

Walk the 5-stage pipeline, pick the right patterns for your data, ship a RAG that doesn't hallucinate.

Your RAG is good, not great

Your RAG works for some queries. Others miss. You don't know which patterns to change. Tuning is hit-or-miss.

Add a golden set. Measure retrieval quality. Find the weak stage. Apply the right pattern. Iteratively improve.

Naive RAG isn't enough

Single-step retrieval misses multi-hop questions. Your users need answers that combine 3+ documents. Time for advanced patterns.

Move to agentic RAG (multi-step retrieval) or graph RAG (knowledge graph). The advanced-rag skill teaches when each is worth the complexity.

Built for

If any of these are you, this is for you.

AI engineers building their first RAG pipelineAI builders with naive RAG that hallucinatesSenior engineers evaluating vector DBs and chunking strategiesAI product teams who need to defend retrieval quality with data

Built withpi-agentClaude CodeCursorClineMarkdownVector DBs (Pinecone, Weaviate, Qdrant, pgvector — vendor-agnostic)

Why this playbook works

Three things that make this different from a wall of prompts.

5-stage pipeline, 2-3 patterns per stage

Parse → chunk → embed → retrieve → generate. Each stage has patterns with explicit tradeoffs. The architecture is your choice. The pack teaches the choices.

Retrieval that actually retrieves

Vector alone misses. BM25 alone misses. Hybrid (vector + BM25) with a reranker catches 40% more relevant chunks. The pack teaches the patterns.

Measure retrieval quality

NDCG, MRR, recall@k. Without metrics, you're guessing. The rag-evaluation skill teaches you to measure, then improve.

Quick start

Drop the package into your project and start using the commands.

terminal

$tar -xzf rag-engineering-0.1.0.tgz && cd rag-engineering-0.1.0

$# Pick your agent host

$ls adapters/

$# pi-agent: cp -r skills/* ~/.pi/agent/skills/

What's in the box

5 skills
decision tree + 4 stage skills
5 tool adapters
pi-agent, Claude Code, Cursor, Cline, generic
2 worked examples
chunking comparison + reranker eval
Pattern selection
tradeoffs for each stage
Vendor-agnostic
works with any stack

Everything in the pack

What you get the moment your payment clears.

rag-engineering skill — master orchestrator + RAG decision tree

chunking-strategies skill — fixed-size, semantic, hierarchical, late-chunking, table-aware

retrieval-patterns skill — vector, BM25, hybrid, rerankers, multi-query, HyDE, query rewriting

rag-evaluation skill — retrieval metrics (NDCG, MRR, recall@k) + end-to-end metrics + golden sets

advanced-rag skill — agentic RAG, graph RAG, multimodal RAG, when to escalate

5 tool adapters — pi-agent, Claude Code, Cursor, Cline, generic

2 worked examples — chunking comparison + reranker evaluation

Adapters included

These skills were authored for pi-agent, but we include drop-in adapters for the major AI coding tools.

Tool	Adapter location	What you get
pi-agent	`adapters/pi-agent/`	SKILL.md drop-in
Claude Code	`adapters/claude-code/`	.claude/commands/*.md + CLAUDE.md
Cursor	`adapters/cursor/`	.cursorrules rule sets
Cline / Continue	`adapters/cline/`	System-prompt rules
Aider / generic	`adapters/generic/`	INSTRUCTIONS.md snippets

Same playbook, different packaging. The adapters translate the methodology into the format each tool expects. Install once, swap agents without re-learning the method.

Full documentation

Everything in the package, every prop, every pattern.

RAG Engineering Playbook

Stop building naive RAG. Start building RAG that doesn't hallucinate.

Built and battle-tested. 5 skills covering the RAG architecture decision tree, chunking strategies, retrieval patterns, evaluation metrics, and advanced patterns (agentic, graph, multimodal). Adapters for pi-agent, Claude Code, Cursor, Cline.

What's Inside

Skill	Purpose
rag-engineering	Master orchestrator — the RAG decision tree, when to use RAG vs long-context vs fine-tuning
chunking-strategies	Fixed-size, semantic, hierarchical, late-chunking, table-aware
retrieval-patterns	Vector search, hybrid search, rerankers, multi-query, HyDE, query rewriting
rag-evaluation	Retrieval metrics (NDCG, MRR, recall@k), end-to-end metrics, golden sets
advanced-rag	Agentic RAG, graph RAG, multimodal RAG, when to escalate beyond naive

Quick Start

# 1. Extract
tar -xzf rag-engineering-0.1.0.tgz
cd rag-engineering-0.1.0

# 2. Pick your agent host
ls adapters/

# pi-agent (recommended)
mkdir -p ~/.pi/agent/skills
cp -r skills/* ~/.pi/agent/skills/
# /reload in pi to pick them up

# Claude Code
mkdir -p .claude/commands
cp -r adapters/claude-code/commands/* .claude/commands/
cat adapters/claude-code/CLAUDE.md >> CLAUDE.md

The Core Idea

The single sentence that ties this whole pack together:

Naive RAG fails in production. The fix is not "better embeddings" — it's a deliberate architecture.

The pack teaches the 5-stage RAG pipeline: parse → chunk → embed → retrieve → generate. Each stage has 2-3 patterns. The architecture is your choice of patterns, with the tradeoffs explicit.

The 5 Skills in Detail

`rag-engineering` — The orchestrator

The RAG decision tree (when to use RAG vs long-context vs fine-tuning)
The 5-stage pipeline
Pattern selection per stage

`chunking-strategies` — Stage 1

Fixed-size (cheap, lossy)
Semantic (better boundaries, slower)
Hierarchical (multi-resolution)
Late-chunking (embed full, chunk for retrieval)
Table-aware (preserve structure)

`retrieval-patterns` — Stage 2-3

Vector search (semantic)
BM25 / lexical (keyword)
Hybrid (vector + BM25)
Rerankers (cross-encoder)
Multi-query (decompose)
HyDE (hypothetical document)
Query rewriting

`rag-evaluation` — How to measure

Retrieval metrics (NDCG, MRR, recall@k)
End-to-end metrics (faithfulness, answer relevance)
Golden set construction
Failure-mode catalog

`advanced-rag` — Beyond naive

Agentic RAG (multi-step retrieval)
Graph RAG (knowledge graph)
Multimodal RAG (images, tables)
When each pattern is worth the complexity

Adapters Included

Works in every major AI coding tool:

Tool	Adapter location	What you get
pi-agent	`adapters/pi-agent/`	SKILL.md drop-in
Claude Code	`adapters/claude-code/`	`.claude/commands/*.md` + CLAUDE.md fragments
Cursor	`adapters/cursor/`	`.cursorrules` rule sets
Cline / Continue	`adapters/cline/`	System-prompt rules
Aider / generic	`adapters/generic/`	`INSTRUCTIONS.md` snippets

Updates

Free for life. Re-download for new chunking patterns, new retrieval techniques, new evaluation metrics.

What This Isn't

Not a RAG framework — works with LangChain, LlamaIndex, Haystack, custom
Not a vector DB — methodology, not infrastructure
Not pre-tuned embeddings — teaches you to pick and tune your own

What's in the download

rag-engineering-0.1.0/
├── README.md
├── OVERVIEW.md
├── METHODOLOGY.md
├── INSTALL.md
├── LICENSE.md
├── package.json
├── skills/                ← 5 SKILL.md files
│   ├── rag-engineering/
│   ├── chunking-strategies/
│   ├── retrieval-patterns/
│   ├── rag-evaluation/
│   └── advanced-rag/
├── adapters/              ← drop-in for AI coders
├── examples/              ← 2 worked examples
└── docs/                  ← diagrams + decision trees

Common questions

Things people ask before buying.

Does this work with my vector DB?

Yes. The pack is methodology, not infrastructure. It teaches you to pick the right chunking, embedding, and retrieval patterns. Your vector DB (Pinecone, Weaviate, Qdrant, pgvector, Chroma) doesn't change the patterns.

How is this different from LangChain / LlamaIndex docs?

Framework docs tell you *what* the framework does. This pack tells you *which pattern to pick and why*. The methodology is portable; the framework isn't.

I have naive RAG. Will this fix it?

Probably. The first step is rag-evaluation — build a golden set, measure retrieval quality. Then apply the right pattern (often hybrid search + reranker). Most naive RAGs improve 30-50% with one or two pattern swaps.

£35 — lifetime

One purchase. Yours forever.

Pay once via Stripe. Get the complete package instantly. Free updates for the same major version. Commercial license included.

Secure payment via Stripe · Instant download · 30-day money-back if it doesn't save you time

RAG Engineering Playbook

What you'll be able to do

Your first RAG pipeline

Your RAG is good, not great

Naive RAG isn't enough

Built for

Why this playbook works

5-stage pipeline, 2-3 patterns per stage

Retrieval that actually retrieves

Measure retrieval quality

Quick start

Everything in the pack

Adapters included

Full documentation

RAG Engineering Playbook

What's Inside

Quick Start

The Core Idea

The 5 Skills in Detail

rag-engineering — The orchestrator

chunking-strategies — Stage 1

retrieval-patterns — Stage 2-3

rag-evaluation — How to measure

advanced-rag — Beyond naive

Adapters Included

Updates

What This Isn't

What's in the download

Common questions

One purchase. Yours forever.

`rag-engineering` — The orchestrator

`chunking-strategies` — Stage 1

`retrieval-patterns` — Stage 2-3

`rag-evaluation` — How to measure

`advanced-rag` — Beyond naive