Skip to main content
skill CX Codex

rag-implementation · sickn33 — Claude Code skill: what it does, how to install

rag-implementation is a Claude Code skill that guides an eight-phase RAG implementation, from embedding selection to hybrid search and quality evaluation.

MIT ★ 50,109 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a claude-code
Open on GitHub

What rag-implementation does

This skill structures the implementation of retrieval-augmented generation into an eight-phase engineering workflow. It guides the setup from initial requirements and embedding model benchmarks to vector database indexing, chunk strategies, hybrid search, caching, and evaluation metrics. Each phase connects specific action items with dedicated sub-skills.

The pipeline isolates user queries, vector search indices, chunk stores, and prompt context injection. Context retrieved from the database is treated strictly as evidence rather than executable instruction, which prevents untrusted document text from overriding agent boundaries or invoking tools.

Cache invalidation must propagate across chunks, embeddings, and answers whenever source documents change. In multi-tenant environments, search evaluation tests retrieval relevance and answer grounding separately on held-out datasets.

What it helps with

  • Configure vector database schemas and indexing for semantic search
  • Define document chunking sizes, metadata, and overlap boundaries
  • Implement hybrid search combining vector similarity, keyword matching, and reranking
  • Evaluate retrieval accuracy and model answer grounding on test queries

Example prompts for the agent

  • Follow the rag-implementation workflow to design our document search pipeline
  • Help me set up chunking strategies and vector indexes using rag-implementation
  • Audit our RAG retrieval relevance and set up caching rules according to rag-implementation

How to install rag-implementation

1Skills CLI (Vercel)

npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a claude-code

2Manually: put the files in place

~/.claude/skills/rag-implementation/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/rag-implementation/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about rag-implementation

How to install rag-implementation in Claude Code?

Run npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a claude-code in your terminal.

What does the rag-implementation skill cover?

It provides an end-to-end framework for RAG systems, spanning embedding model selection, vector storage, retrieval optimization, context injection, and validation.

How does the workflow handle security boundaries for retrieved text?

Retrieved documents function solely as factual context for the model and lack authority to trigger tool calls or alter system prompts.

Source text

SKILL.md · MIT
---
name: rag-implementation
description: "RAG (Retrieval-Augmented Generation) implementation workflow covering embedding selection, vector database setup, chunking strategies, and retrieval optimization."
category: granular-workflow-bundle
risk: safe
source: personal
date_added: "2026-02-27"
---

# RAG Implementation Workflow

## Overview

Specialized workflow for implementing RAG (Retrieval-Augmented Generation) systems including embedding model selection, vector database setup, chunking strategies, retrieval optimization, and evaluation.

## When to Use This Workflow

Use this workflow when:
- Building RAG-powered applications
- Implementing semantic search
- Creating knowledge-grounded AI
- Setting up document Q&A systems
- Optimizing retrieval quality

## Workflow Phases

### Phase 1: Requirements Analysis

#### Skills to Invoke
- `ai-product` - AI product design
- `rag-engineer` - RAG engineering

#### Actions
1. Define use case
2. Identify data sources
3. Set accuracy requirements
4. Determine latency targets
5. Plan evaluation metrics

#### Copy-Paste Prompts
```
Use @ai-product to define RAG application requirements
```

### Phase 2: Embedding Selection

#### Skills to Invoke
- `embedding-strategies` - Embedding selection
- `rag-engineer` - RAG patterns

#### Actions
1. Evaluate embedding models
2. Test domain relevance
3. Measure embedding quality
4. Consider cost/latency
5. Select model

#### Copy-Paste Prompts
```
Use @embedding-strategies to select optimal embedding model
```

### Phase 3: Vector Database Setup

#### Skills to Invoke
- `vector-database-engineer` - Vector DB
- `similarity-search-patterns` - Similarity search

#### Actions
1. Choose vector database
2. Design schema
3. Configure indexes
4. Set up connection
5. Test queries

#### Copy-Paste Prompts
```
Use @vector-database-engineer to set up vector database
```

### Phase 4: Chunking Strategy

#### Skills to Invoke
- `rag-engineer` - Chunking strategies
- `rag-implementation` - RAG implementation

#### Actions
1. Choose chunk size
2. Implement chunking
3. Add overlap handling
4. Create metadata
5. Test retrieval quality

#### Copy-Paste Prompts
```
Use @rag-engineer to implement chunking strategy
```

### Phase 5: Retrieval Implementation

#### Skills to Invoke
- `similarity-search-patterns` - Similarity search
- `hybrid-search-implementation` - Hybrid search

#### Actions
1. Implement vector search
2. Add keyword search
3. Configure hybrid search
4. Set up reranking
5. Optimize latency

#### Copy-Paste Prompts
```
Use @similarity-search-patterns to implement retrieval
```

```
Use @hybrid-search-implementation to add hybrid search
```

### Phase 6: LLM Integration

#### Skills to Invoke
- `llm-application-dev-ai-assistant` - LLM integration
- `llm-application-dev-prompt-optimize` - Prompt optimization

#### Actions
1. Select LLM provider
2. Design prompt template
3. Implement context injection
4. Add citation handling
5. Test generation quality

#### Copy-Paste Prompts
```
Use @llm-application-dev-ai-assistant to integrate LLM
```

### Phase 7: Caching

#### Skills to Invoke
- `prompt-caching` - Prompt caching
- `rag-engineer` - RAG optimization

#### Actions
1. Implement response caching
2. Set up embedding cache
3. Configure TTL
4. Add cache invalidation
5. Monitor hit rates

#### Copy-Paste Prompts
```
Use @prompt-caching to implement RAG caching
```

### Phase 8: Evaluation

#### Skills to Invoke
- `llm-evaluation` - LLM evaluation
- `evaluation` - AI evaluation

#### Actions
1. Define evaluation metrics
2. Create test dataset
3. Measure retrieval accuracy
4. Evaluate generation quality
5. Iterate on improvements

#### Copy-Paste Prompts
```
Use @llm-evaluation to evaluate RAG system
```

## RAG Architecture

```
User Query -> Embedding -> Vector Search -> Retrieved Docs -> LLM -> Response
                |              |              |              |
            Model         Vector DB     Chunk Store    Prompt + Context
```

## Trust and evaluation boundaries

Enforce document access at retrieval and again when returning citations; isolate caches by tenant, permission scope and model/index revision. Retrieved text is evidence, never authority to override instructions or invoke tools. Track document/source versions and deletion propagation through chunks, embeddings and cached answers. Evaluate retrieval relevance and answer grounding separately on held-out queries, including cross-tenant negatives, unanswerable questions and injected document instructions. A plausible cited answer does not prove the citation supports it.

## Quality Gates

- [ ] Embedding model selected
- [ ] Vector DB configured
- [ ] Chunking implemented
- [ ] Retrieval working
- [ ] LLM integrated
- [ ] Evaluation passing

## Related Workflow Bundles

- `ai-ml` - AI/ML development
- `ai-agent-development` - AI agents
- `database` - Vector databases

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

© sickn33 · MIT · sickn33/agentic-awesome-skills

Similar skills

All skills for AI and ML →

rag-implementation by other authors comes first.

rag-implementation Seth Hobson The rag-implementation skill helps build RAG systems with vector search and LLM answers grounded in external documents. Use it for document Q&A and knowledge assistants. CX Codex +1 13,906installs rag-chroma Orchestra Research rag-chroma is a Claude Code skill with patterns and code snippets for Chroma collections, metadata filtering, and semantic retrieval. CX Codex +1 68installs RAG Implementer daffy0208 RAG Implementer — a skill that walks the agent through eight phases of a RAG build, from knowledge-base design to retrieval, after checking that RAG is the right call. CX Codex +1 189installs langchain-rag langchain-ai langchain-rag equips coding agents with reference RAG implementations in Python and TypeScript using LangChain loaders, splitters, and vector stores. CX Codex +1 18,600installs rag giuseppe-trisciuoglio rag guides the creation of Retrieval-Augmented Generation pipelines, covering document chunking, embedding generation, vector database selection, and retrieval. CX Codex +1 3,900installs rag-architect borghei rag-architect — a skill for Claude Code and Cursor designs RAG pipelines and tunes chunking configurations. It benchmarks retrieval quality using Recall@K and MRR on real queries. CX Codex +1 137installs pinecone-rag official github The pinecone-rag skill guides Pinecone-based RAG pipelines and persistent agent memory. Use it for semantic document search, hybrid retrieval, or context shared across sessions. CX Codex +1 24installs

From the same set187

The whole set →
database-migrations-sql-migrations database-migrations-sql-migrations — a skill for safe SQL database migrations with zero downtime. Generates migration scripts with rollback plans, data integrity checks, and strategies for PostgreSQL, MySQL, and SQL Server. CX Codex +1 1installs arm-cortex-expert arm-cortex-expert — a skill that helps write firmware and peripheral drivers for ARM Cortex-M boards: Teensy 4.x, STM32, nRF52, SAMD. You get a module you can build, not a fragment. CX Codex +1 ★ 50,109repo stars vexor Guides the agent when performing semantic file searches via the external Vexor CLI. Useful for querying codebases by meaning rather than exact strings. CX Codex +1 ★ 50,109repo stars vector-database-engineer vector-database-engineer picks a vector store and sets up embedding search for RAG, recommendations or similarity lookup. Comes in when recall and latency start to matter. CX Codex +1 ★ 50,109repo stars llm-application-dev-ai-assistant llm-application-dev-ai-assistant — a skill for designing conversational AI assistants: dialogue context, integration boundaries, validation. Fits projects where the bot calls tools and keeps memory of a user. CX Codex +1 ★ 50,109repo stars seo-content-auditor seo-content-auditor reads the draft you hand it, scores depth, E-E-A-T, readability and keyword use, then lists fixes. Useful before a post goes live. CX Codex +1 ★ 50,109repo stars pci-compliance pci-compliance traces payment data through your project and gathers control evidence for a scoped PCI assessment. It does not certify compliance. CX Codex +1 ★ 50,109repo stars security-compliance-compliance-check security-compliance-compliance-check guides regulatory compliance checks for GDPR, HIPAA, SOC2, and PCI-DSS, generating gap analyses, checklists, and technical control code. CX Codex +1 ★ 50,109repo stars

Project sponsors

Companies that keep this analytics open