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
npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/rag-implementation/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/rag-implementation/
1Skills CLI (Vercel)
npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a codex2Manually: put the files in place
.agents/skills/rag-implementation/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a cursor2Manually: put the files in place
.cursor/skills/rag-implementation/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install sickn33/agentic-awesome-skills skills/rag-implementation2Manually: put the files in place
.github/skills/rag-implementation/SKILL.md1Skills CLI (Vercel)
npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a gemini-cli2Platform CLI
gemini skills install https://github.com/sickn33/agentic-awesome-skills --path skills/rag-implementationManually: put the files in place
.devin/skills/rag-implementation/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add sickn33/agentic-awesome-skills --skill rag-implementation -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.