RAG System Design Best Practices 2026

Introduction

Following best practices for rag system design is the difference between fragile prototypes and production-grade AI systems. This guide covers the most important practices that experienced AI developers use.

The 4 Essential Practices

1. Optimize chunk sizes

#### Why it matters This practice prevents common failures and improves your system quality.

python
Implementation
TODO: implement this practice

2. Use MMR for retrieval diversity

#### Why it matters This practice prevents common failures and improves your system quality.

python
Implementation
TODO: implement this practice

3. Add reranking

#### Why it matters This practice prevents common failures and improves your system quality.

python
Implementation
TODO: implement this practice

4. Evaluate with RAGAS

Complete Implementation Example

python
"""
RAG System Design - Production Implementation
Following all 4 best practices
"""
from openai import OpenAI
from pydantic import BaseModel, validator
import logging
import time
import hashlib
from typing import Optional
from functools import wraps
logger = logging.getLogger(__name__)
client = OpenAI()
Practice 1: optimize chunk sizes
class AIConfig(BaseModel):
    model: str = "gpt-4o-mini"
    temperature: float = 0.7
    max_tokens: int = 2048
    system_prompt: str = ""
    
    @validator('temperature')
    def check_temperature(cls, v):
        if not 0 <= v <= 2:
            raise ValueError('temperature must be between 0 and 2')
        return v
Practice 2: use MMR for retrieval diversity
def with_retry(max_retries: int = 3, backoff: float = 1.0):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt < max_retries - 1:
                        wait = backoff * (2 ** attempt)
                        logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {wait}s")
                        time.sleep(wait)
                    else:
                        logger.error(f"All {max_retries} attempts failed: {e}")
                        raise
        return wrapper
    return decorator
Practice 3: Caching
_cache: dict = {}
def cache_response(func):
    @wraps(func)
    def wrapper(prompt: str, *args, **kwargs):
        cache_key = hashlib.md5(prompt.encode()).hexdigest()
        if cache_key in _cache:
            logger.info(f"Cache hit for prompt hash {cache_key[:8]}")
            return _cache[cache_key]
        
        result = func(prompt, *args, **kwargs)
        _cache[cache_key] = result
        return result
    return wrapper
Main AI function applying all practices
@with_retry(max_retries=3)
@cache_response
def ai_request(prompt: str, config: Optional[AIConfig] = None) -> str:
    """
    Make an AI request following rag system design best practices.
    
    Applies: optimize chunk sizes, use MMR for retrieval diversity, add reranking, evaluate with RAGAS
    """
    if config is None:
        config = AIConfig()
    
    messages = []
    if config.system_prompt:
        messages.append({"role": "system", "content": config.system_prompt})
    messages.append({"role": "user", "content": prompt})
    
    start_time = time.time()
    
    response = client.chat.completions.create(
        model=config.model,
        messages=messages,
        temperature=config.temperature,
        max_tokens=config.max_tokens
    )
    
    duration_ms = (time.time() - start_time) * 1000
    
    # Log for monitoring
    logger.info({
        "model": config.model,
        "input_tokens": response.usage.prompt_tokens,
        "output_tokens": response.usage.completion_tokens,
        "duration_ms": round(duration_ms, 2),
        "cost_estimate": (response.usage.total_tokens / 1_000_000) * 0.60
    })
    
    return response.choices[0].message.content
Example usage
if __name__ == "__main__":
    config = AIConfig(
        model="gpt-4o-mini",
        temperature=0.3,
        system_prompt="You are an expert assistant. Be concise and accurate."
    )
    
    result = ai_request("Explain rag system design in one paragraph", config)
    print(result)

Anti-Patterns to Avoid

python
❌ Bad: No error handling
def bad_ai_call(prompt):
    return client.chat.completions.create(model="gpt-4o", messages=[{"role": "user", "content": prompt}])
❌ Bad: Hardcoded credentials
client = OpenAI(api_key="sk-abc123...")  # Never do this!
❌ Bad: No input validation
def unsafe_prompt(user_input):
    return f"Do this: {user_input}"  # Prompt injection risk!
✅ Good: Sanitize inputs
def safe_prompt(user_input: str) -> str:
    # Remove potential injection attempts
    sanitized = user_input[:2000]  # Limit length
    sanitized = sanitized.replace("ignore previous instructions", "")
    return f"User request: {sanitized}"

Checklist

Before deploying AI features to production:

[ ] Optimize chunk sizes

[ ] Use MMR for retrieval diversity

[ ] Add reranking

[ ] Evaluate with RAGAS

[ ] Error handling with retry logic

[ ] Response caching implemented

[ ] Costs monitored and alerted

[ ] Outputs logged for debugging

[ ] Security review completed

Measuring Success

Track these metrics to validate your rag system design implementation:

Reliability: API success rate (target: >99.5%)

Performance: p95 latency (target: <3 seconds)

Cost: Cost per request (track over time)

Quality: User satisfaction scores

Safety: Output validation pass rate

Conclusion

Following these rag system design best practices ensures your AI application is reliable, cost-efficient, and production-ready. The patterns shown here are used by teams at leading AI companies.

Start by implementing the basics (error handling, logging) and gradually add the more advanced practices as your system matures.

---

*RAG System Design best practices guide | May 2026 | Production-tested*