diff --git a/website/docs/tutorials/intelligent-route/domain-routing.md b/website/docs/tutorials/intelligent-route/domain-routing.md
new file mode 100644
index 000000000..2ed3b6536
--- /dev/null
+++ b/website/docs/tutorials/intelligent-route/domain-routing.md
@@ -0,0 +1,228 @@
+# Domain Based Routing
+
+This guide shows you how to use fine-tuned classification models for intelligent routing based on academic and professional domains. Domain routing uses specialized models (ModernBERT, Qwen3-Embedding, EmbeddingGemma) with LoRA adapters to classify queries into categories like math, physics, law, business, and more.
+
+## Key Advantages
+
+- **Efficient**: Fine-tuned models with LoRA adapters provide fast inference (5-20ms) with high accuracy
+- **Specialized**: Multiple model options (ModernBERT for English, Qwen3 for multilingual/long-context, Gemma for small footprint)
+- **Multi-task**: LoRA enables running multiple classification tasks (domain + PII + jailbreak) with shared base model
+- **Cost-effective**: Lower latency than LLM-based classification, no API costs
+
+## What Problem Does It Solve?
+
+Generic classification approaches struggle with domain-specific terminology and nuanced differences between academic/professional fields. Domain routing provides:
+
+- **Accurate domain detection**: Fine-tuned models distinguish between math, physics, chemistry, law, business, etc.
+- **Multi-task efficiency**: LoRA adapters enable simultaneous domain classification, PII detection, and jailbreak detection with one base model pass
+- **Long-context support**: Qwen3-Embedding handles up to 32K tokens (vs ModernBERT's 8K limit)
+- **Multilingual routing**: Qwen3 trained on 100+ languages, ModernBERT optimized for English
+- **Resource optimization**: Expensive reasoning only enabled for domains that benefit (math, physics, chemistry)
+
+## When to Use
+
+- **Educational platforms** with diverse subject areas (STEM, humanities, social sciences)
+- **Professional services** requiring domain expertise (legal, medical, financial)
+- **Enterprise knowledge bases** spanning multiple departments
+- **Research assistance** tools needing academic domain awareness
+- **Multi-domain products** where classification accuracy is critical
+
+## Configuration
+
+Configure the domain classifier in your `config.yaml`:
+
+```yaml
+classifier:
+  category_model:
+    model_id: "models/category_classifier_modernbert-base_model"
+    use_modernbert: true
+    threshold: 0.6
+    use_cpu: true
+    category_mapping_path: "models/category_classifier_modernbert-base_model/category_mapping.json"
+  
+  pii_model:
+    model_id: "models/pii_classifier_modernbert-base_presidio_token_model"
+    use_modernbert: true
+    threshold: 0.7
+    use_cpu: true
+    pii_mapping_path: "models/pii_classifier_modernbert-base_presidio_token_model/pii_type_mapping.json"
+
+categories:
+  - name: math
+    system_prompt: "You are a mathematics expert. Provide step-by-step solutions."
+    model_scores:
+      - model: qwen3
+        score: 1.0
+        use_reasoning: true
+  
+  - name: physics
+    system_prompt: "You are a physics expert with deep understanding of physical laws."
+    model_scores:
+      - model: qwen3
+        score: 0.7
+        use_reasoning: true
+  
+  - name: computer science
+    system_prompt: "You are a computer science expert with knowledge of algorithms and data structures."
+    model_scores:
+      - model: qwen3
+        score: 0.6
+        use_reasoning: false
+  
+  - name: business
+    system_prompt: "You are a senior business consultant and strategic advisor."
+    model_scores:
+      - model: qwen3
+        score: 0.7
+        use_reasoning: false
+  
+  - name: health
+    system_prompt: "You are a health and medical information expert."
+    semantic_cache_enabled: true
+    semantic_cache_similarity_threshold: 0.95
+    model_scores:
+      - model: qwen3
+        score: 0.5
+        use_reasoning: false
+  
+  - name: law
+    system_prompt: "You are a knowledgeable legal expert."
+    model_scores:
+      - model: qwen3
+        score: 0.4
+        use_reasoning: false
+
+default_model: qwen3
+```
+
+## Supported Domains
+
+Academic: math, physics, chemistry, biology, computer science, engineering
+
+Professional: business, law, economics, health, psychology
+
+General: philosophy, history, other
+
+## Features
+
+- **PII Detection**: Automatically detects and handles sensitive information
+- **Semantic Caching**: Cache similar queries for faster responses
+- **Reasoning Control**: Enable/disable reasoning per domain
+- **Custom Thresholds**: Adjust cache sensitivity per category
+
+## Example Requests
+
+```bash
+# Math query (reasoning enabled)
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "Solve: x^2 + 5x + 6 = 0"}]
+  }'
+
+# Business query (reasoning disabled)
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "What is a SWOT analysis?"}]
+  }'
+
+# Health query (high cache threshold)
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "What are symptoms of diabetes?"}]
+  }'
+```
+
+## Real-World Use Cases
+
+### 1. Multi-Task Classification with LoRA (Efficient)
+**Problem**: Need domain classification + PII detection + jailbreak detection on every request
+**Solution**: LoRA adapters run all 3 tasks with one base model pass instead of 3 separate models
+**Impact**: 3x faster than running 3 full models, <1% parameter overhead per task
+
+### 2. Long Document Analysis (Specialized - Qwen3)
+**Problem**: Research papers and legal documents exceed 8K token limit of ModernBERT
+**Solution**: Qwen3-Embedding supports up to 32K tokens without truncation
+**Impact**: Accurate classification on full documents, no information loss from truncation
+
+### 3. Multilingual Education Platform (Specialized - Qwen3)
+**Problem**: Students ask questions in 100+ languages, ModernBERT limited to English
+**Solution**: Qwen3-Embedding trained on 100+ languages handles multilingual routing
+**Impact**: Single model serves global users, consistent quality across languages
+
+### 4. Edge Deployment (Specialized - Gemma)
+**Problem**: Mobile/IoT devices can't run large classification models
+**Solution**: EmbeddingGemma-300M with Matryoshka embeddings (128-768 dims)
+**Impact**: 5x smaller model, runs on edge devices with <100MB memory
+
+### 5. STEM Tutoring Platform (Efficient Reasoning Control)
+**Problem**: Math/physics need reasoning, but history/literature don't
+**Solution**: Domain classifier routes STEM → reasoning models, humanities → fast models
+**Impact**: 2x better STEM accuracy, 60% cost savings on non-STEM queries
+
+## Domain-Specific Optimizations
+
+### STEM Domains (Reasoning Enabled)
+
+```yaml
+- name: math
+  use_reasoning: true  # Step-by-step solutions
+  score: 1.0           # Highest priority
+- name: physics
+  use_reasoning: true  # Derivations and proofs
+  score: 0.7
+- name: chemistry
+  use_reasoning: true  # Reaction mechanisms
+  score: 0.6
+```
+
+### Professional Domains (PII + Caching)
+
+```yaml
+- name: health
+  semantic_cache_enabled: true
+  semantic_cache_similarity_threshold: 0.95  # Very strict
+  pii_detection_enabled: true
+- name: law
+  score: 0.4  # Conservative routing
+  pii_detection_enabled: true
+```
+
+### General Domains (Fast + Cached)
+
+```yaml
+- name: business
+  use_reasoning: false  # Fast responses
+  score: 0.7
+- name: other
+  semantic_cache_similarity_threshold: 0.75  # Relaxed
+  score: 0.7
+```
+
+## Performance Characteristics
+
+| Domain | Reasoning | Cache Threshold | Avg Latency | Use Case |
+|--------|-----------|-----------------|-------------|----------|
+| Math | ✅ | 0.85 | 2-5s | Step-by-step solutions |
+| Physics | ✅ | 0.85 | 2-5s | Derivations |
+| Chemistry | ✅ | 0.85 | 2-5s | Mechanisms |
+| Health | ❌ | 0.95 | 500ms | Safety-critical |
+| Law | ❌ | 0.85 | 500ms | Compliance |
+| Business | ❌ | 0.80 | 300ms | Fast insights |
+| Other | ❌ | 0.75 | 200ms | General queries |
+
+## Cost Optimization Strategy
+
+1. **Reasoning Budget**: Enable only for STEM (30% of queries) → 60% cost reduction
+2. **Caching Strategy**: High threshold for sensitive domains → 70% hit rate
+3. **Model Selection**: Lower scores for low-value domains → cheaper models
+4. **PII Detection**: Only for health/law → reduced processing overhead
+
+## Reference
+
+See [bert_classification.yaml](https://github.com/vllm-project/semantic-router/blob/main/config/intelligent-routing/in-tree/bert_classification.yaml) for complete configuration.
diff --git a/website/docs/tutorials/intelligent-route/embedding-routing.md b/website/docs/tutorials/intelligent-route/embedding-routing.md
new file mode 100644
index 000000000..7c3305002
--- /dev/null
+++ b/website/docs/tutorials/intelligent-route/embedding-routing.md
@@ -0,0 +1,205 @@
+# Embedding Based Routing
+
+This guide shows you how to route requests using semantic similarity with embedding models. Embedding routing matches user queries to predefined categories based on meaning rather than exact keywords, making it ideal for handling diverse phrasings and rapidly evolving categories.
+
+## Key Advantages
+
+- **Scalable**: Handles unlimited categories without retraining models
+- **Fast**: 10-50ms inference with efficient embedding models (Qwen3, Gemma)
+- **Flexible**: Add/remove categories by updating keyword lists, no model retraining
+- **Semantic**: Captures meaning beyond exact keyword matching
+
+## What Problem Does It Solve?
+
+Keyword matching fails when users phrase questions differently. Embedding routing solves:
+
+- **Paraphrase handling**: "How to install?" matches "installation guide" without exact words
+- **Intent detection**: Routes based on semantic meaning, not surface patterns
+- **Fuzzy matching**: Handles typos, abbreviations, informal language
+- **Dynamic categories**: Add new categories without retraining classification models
+- **Multilingual support**: Embeddings capture cross-lingual semantics
+
+## When to Use
+
+- **Customer support** with diverse query phrasings
+- **Product inquiries** where users ask the same thing many different ways
+- **Technical support** needing semantic understanding of error descriptions
+- **Rapidly evolving categories** where you need to add/update categories frequently
+- **Moderate latency tolerance** (10-50ms acceptable for better semantic accuracy)
+
+## Configuration
+
+Add embedding rules to your `config.yaml`:
+
+```yaml
+classifier:
+  category_model:
+    model_id: "models/category_classifier_modernbert-base_model"
+    use_modernbert: true
+    threshold: 0.6
+    use_cpu: true
+    category_mapping_path: "models/category_classifier_modernbert-base_model/category_mapping.json"
+
+embedding_models:
+  qwen3_model_path: "models/Qwen3-Embedding-0.6B"
+  gemma_model_path: "models/embeddinggemma-300m"
+  use_cpu: true
+
+embedding_rules:
+  - category: "technical_support"
+    threshold: 0.75
+    keywords:
+      - "how to configure the system"
+      - "installation guide"
+      - "troubleshooting steps"
+      - "error message explanation"
+    aggregation_method: "max"
+    model: "auto"
+    dimension: 768
+    quality_priority: 0.7
+    latency_priority: 0.3
+  
+  - category: "product_inquiry"
+    threshold: 0.70
+    keywords:
+      - "product features and specifications"
+      - "pricing information"
+      - "availability and stock"
+    aggregation_method: "avg"
+    model: "gemma"
+    dimension: 768
+  
+  - category: "account_management"
+    threshold: 0.72
+    keywords:
+      - "password reset"
+      - "account settings"
+      - "subscription management"
+    aggregation_method: "max"
+    model: "qwen3"
+    dimension: 1024
+
+categories:
+  - name: technical_support
+    system_prompt: "You are a technical support specialist."
+    model_scores:
+      - model: qwen3
+        score: 0.9
+        use_reasoning: true
+    jailbreak_enabled: true
+    pii_detection_enabled: true
+  
+  - name: product_inquiry
+    system_prompt: "You are a product specialist."
+    model_scores:
+      - model: qwen3
+        score: 0.85
+        use_reasoning: false
+```
+
+## Embedding Models
+
+- **qwen3**: High quality, 1024-dim, 32K context
+- **gemma**: Balanced, 768-dim, 8K context, Matryoshka support (128/256/512/768)
+- **auto**: Automatically selects based on quality/latency priorities
+
+## Aggregation Methods
+
+- **max**: Uses highest similarity score
+- **avg**: Uses average similarity across keywords
+- **any**: Matches if any keyword exceeds threshold
+
+## Example Requests
+
+```bash
+# Technical support query
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "How do I troubleshoot connection errors?"}]
+  }'
+
+# Product inquiry
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "What are the pricing options?"}]
+  }'
+```
+
+## Real-World Use Cases
+
+### 1. Customer Support (Scalable Categories)
+**Problem**: Need to add new support categories weekly without retraining models
+**Solution**: Add new categories by updating keyword lists, embeddings handle semantic matching
+**Impact**: Deploy new categories in minutes vs weeks for model retraining
+
+### 2. E-commerce Support (Fast Semantic Matching)
+**Problem**: "Where's my order?" vs "track package" vs "shipping status" all mean the same
+**Solution**: Gemma embeddings (10-20ms) route all variations to order tracking category
+**Impact**: 95% accuracy with 10-20ms latency, handles 5K+ queries/sec
+
+### 3. SaaS Product Inquiries (Flexible Routing)
+**Problem**: Users ask about pricing in 100+ different ways
+**Solution**: Semantic similarity matches all variations to "pricing information" keywords
+**Impact**: Single category handles all pricing queries without explicit rules
+
+### 4. Startup Iteration (Rapid Category Updates)
+**Problem**: Product evolves rapidly, need to adjust categories daily
+**Solution**: Update embedding keywords in config, no model retraining required
+**Impact**: Category updates in seconds vs days for fine-tuning
+
+### 5. Multilingual Platform (Semantic Understanding)
+**Problem**: Same question in English, Spanish, Chinese needs same routing
+**Solution**: Embeddings capture cross-lingual semantics automatically
+**Impact**: Single category definition works across languages
+
+## Model Selection Strategy
+
+### Auto Mode (Recommended)
+
+```yaml
+model: "auto"
+quality_priority: 0.7  # Favor accuracy
+latency_priority: 0.3  # Accept some latency
+```
+
+- Automatically selects Qwen3 (high quality) or Gemma (fast) based on priorities
+- Balances accuracy vs speed per request
+
+### Qwen3 (High Quality)
+
+```yaml
+model: "qwen3"
+dimension: 1024
+```
+
+- Best for: Complex queries, subtle distinctions, high-value interactions
+- Latency: ~30-50ms per query
+- Use case: Account management, financial queries
+
+### Gemma (Fast)
+
+```yaml
+model: "gemma"
+dimension: 768  # or 512, 256, 128 for Matryoshka
+```
+
+- Best for: High-throughput, simple categorization, cost-sensitive
+- Latency: ~10-20ms per query
+- Use case: Product inquiries, general support
+
+## Performance Characteristics
+
+| Model | Dimension | Latency | Accuracy | Memory |
+|-------|-----------|---------|----------|--------|
+| Qwen3 | 1024 | 30-50ms | Highest | 600MB |
+| Gemma | 768 | 10-20ms | High | 300MB |
+| Gemma | 512 | 8-15ms | Medium | 300MB |
+| Gemma | 256 | 5-10ms | Lower | 300MB |
+
+## Reference
+
+See [embedding.yaml](https://github.com/vllm-project/semantic-router/blob/main/config/intelligent-routing/in-tree/embedding.yaml) for complete configuration.
diff --git a/website/docs/tutorials/intelligent-route/keyword-routing.md b/website/docs/tutorials/intelligent-route/keyword-routing.md
new file mode 100644
index 000000000..6ccc3aeb4
--- /dev/null
+++ b/website/docs/tutorials/intelligent-route/keyword-routing.md
@@ -0,0 +1,144 @@
+# Keyword Based Routing
+
+This guide shows you how to route requests using explicit keyword rules and regex patterns. Keyword routing provides transparent, auditable routing decisions that are essential for compliance, security, and scenarios requiring explainable AI.
+
+## Key Advantages
+
+- **Transparent**: Routing decisions are fully explainable and auditable
+- **Compliant**: Deterministic behavior meets regulatory requirements (GDPR, HIPAA, SOC2)
+- **Fast**: Sub-millisecond latency, no ML inference overhead
+- **Interpretable**: Clear rules make debugging and validation straightforward
+
+## What Problem Does It Solve?
+
+ML-based classification is a black box that's hard to audit and explain. Keyword routing provides:
+
+- **Explainable decisions**: Know exactly why a query was routed to a specific category
+- **Regulatory compliance**: Auditors can verify routing logic meets requirements
+- **Deterministic behavior**: Same input always produces same output
+- **Zero latency**: No model inference, instant classification
+- **Precise control**: Explicit rules for security, compliance, and business logic
+
+## When to Use
+
+- **Regulated industries** (finance, healthcare, legal) requiring audit trails
+- **Security/compliance** scenarios needing deterministic PII detection
+- **High-throughput systems** where sub-millisecond latency is critical
+- **Urgent/priority routing** with clear keyword indicators
+- **Structured data** (emails, IDs, file paths) matching regex patterns
+
+## Configuration
+
+Add keyword rules to your `config.yaml`:
+
+```yaml
+classifier:
+  category_model:
+    model_id: "models/category_classifier_modernbert-base_model"
+    use_modernbert: true
+    threshold: 0.6
+    use_cpu: true
+    category_mapping_path: "models/category_classifier_modernbert-base_model/category_mapping.json"
+
+keyword_rules:
+  - category: "urgent_request"
+    operator: "OR"
+    keywords: ["urgent", "immediate", "asap"]
+    case_sensitive: false
+  
+  - category: "sensitive_data"
+    operator: "AND"
+    keywords: ["SSN", "social security number", "credit card"]
+    case_sensitive: false
+  
+  - category: "exclude_spam"
+    operator: "NOR"
+    keywords: ["buy now", "free money"]
+    case_sensitive: false
+  
+  - category: "regex_pattern_match"
+    operator: "OR"
+    keywords: ["user\\.name@domain\\.com", "C:\\Program Files\\\\"]
+    case_sensitive: false
+
+categories:
+  - name: urgent_request
+    system_prompt: "You are a highly responsive assistant specialized in handling urgent requests."
+    model_scores:
+      - model: qwen3
+        score: 0.8
+        use_reasoning: false
+  
+  - name: sensitive_data
+    system_prompt: "You are a security-conscious assistant specialized in handling sensitive data."
+    jailbreak_enabled: true
+    jailbreak_threshold: 0.6
+    model_scores:
+      - model: qwen3
+        score: 0.9
+        use_reasoning: false
+```
+
+## Operators
+
+- **OR**: Matches if any keyword is found
+- **AND**: Matches only if all keywords are found
+- **NOR**: Matches only if none of the keywords are found (exclusion)
+
+## Example Requests
+
+```bash
+# Urgent request (matches "urgent")
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "I need urgent help with my account"}]
+  }'
+
+# Sensitive data (matches all keywords)
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "My SSN and credit card were stolen"}]
+  }'
+```
+
+## Real-World Use Cases
+
+### 1. Financial Services (Transparent Compliance)
+**Problem**: Regulators require explainable routing decisions for audit trails
+**Solution**: Keyword rules provide clear "why" for each routing decision (e.g., "SSN" keyword → secure handler)
+**Impact**: Passed SOC2 audit, complete decision transparency
+
+### 2. Healthcare Platform (Compliant PII Detection)
+**Problem**: HIPAA requires deterministic, auditable PII detection
+**Solution**: AND operator detects multiple PII indicators with documented rules
+**Impact**: 100% deterministic, full audit trail for compliance
+
+### 3. High-Frequency Trading (Sub-millisecond Routing)
+**Problem**: Need <1ms classification for real-time market data routing
+**Solution**: Keyword matching provides instant classification without ML overhead
+**Impact**: 0.1ms latency, handles 100K+ requests/sec
+
+### 4. Government Services (Interpretable Rules)
+**Problem**: Citizens need to understand why requests were routed/rejected
+**Solution**: Clear keyword rules can be explained in plain language
+**Impact**: Reduced complaints, transparent decision-making
+
+### 5. Enterprise Security (Transparent Threat Detection)
+**Problem**: Security team needs to understand why queries were flagged
+**Solution**: Explicit keyword/regex rules for threat patterns with clear documentation
+**Impact**: Security team can validate and update rules confidently
+
+## Performance Benefits
+
+- **Sub-millisecond latency**: No ML inference overhead
+- **High throughput**: 100K+ requests/sec on single core
+- **Predictable costs**: No GPU/embedding model required
+- **Zero cold start**: Instant classification on first request
+
+## Reference
+
+See [keyword.yaml](https://github.com/vllm-project/semantic-router/blob/main/config/intelligent-routing/in-tree/keyword.yaml) for complete configuration.
diff --git a/website/docs/tutorials/intelligent-route/lora-routing.md b/website/docs/tutorials/intelligent-route/lora-routing.md
index b5eff404d..285968f95 100644
--- a/website/docs/tutorials/intelligent-route/lora-routing.md
+++ b/website/docs/tutorials/intelligent-route/lora-routing.md
@@ -1,19 +1,40 @@
-# LoRA Routing
+# Intelligent LoRA Routing
 
-This guide shows how to enable intent-aware LoRA (Low-Rank Adaptation) routing in the Semantic Router:
+This guide shows you how to combine intelligent routing (domain/embedding/keyword/MCP) with LoRA adapters to route requests to domain-specific models. LoRA routing uses the classification methods from previous guides to detect intent, then automatically selects the appropriate LoRA adapter on the vLLM backend.
 
-- Minimal configuration for LoRA routing
-- vLLM server setup with LoRA adapters
-- Example request/response showing automatic LoRA selection
-- Verification steps
+## Key Advantages
 
-## Prerequisites
+- **Intent-aware adapter selection**: Combines any classification method (domain/embedding/keyword/MCP) with LoRA adapters
+- **Memory efficient**: Share base model weights across multiple domain adapters (<1% parameters per adapter)
+- **Transparent to users**: Users send requests to one endpoint, router handles adapter selection
+- **Flexible classification**: Choose the best routing method for your use case (domain for accuracy, keyword for compliance, etc.)
+
+## What Problem Does It Solve?
+
+vLLM supports multiple LoRA adapters, but users must manually specify which adapter to use. LoRA routing automates this:
+
+- **Manual adapter selection**: Users don't know which adapter to use → Router classifies intent and selects adapter automatically
+- **Memory efficiency**: Multiple full models don't fit in GPU → LoRA adapters share base weights (~1% overhead per adapter)
+- **Deployment simplicity**: Managing multiple model endpoints is complex → Single vLLM instance serves all adapters
+- **Intent detection**: Generic base model lacks domain expertise → Router routes to specialized adapters based on query content
+
+## When to Use
+
+- **Multi-domain vLLM deployments** with LoRA adapters for different domains (technical, medical, legal, etc.)
+- **Automatic adapter selection** where you want users to send requests without knowing adapter names
+- **Combining classification + LoRA**: Use domain routing for accuracy, keyword routing for compliance, or MCP for custom logic
+- **Memory-constrained scenarios** where multiple full models don't fit but LoRA adapters do
+- **A/B testing** different adapter versions by adjusting category scores
+
+## Configuration
+
+### Prerequisites
 
 - A running vLLM server with LoRA support enabled
 - LoRA adapter files (fine-tuned for specific domains)
 - Envoy + the router (see [Installation](../../installation/installation.md) guide)
 
-## 1. Start vLLM with LoRA Adapters
+### 1. Start vLLM with LoRA Adapters
 
 First, start your vLLM server with LoRA support enabled:
 
@@ -34,7 +55,7 @@ vllm serve meta-llama/Llama-2-7b-hf \
 - `--lora-modules`: Registers LoRA adapters with their names and paths
 - Format: `adapter-name=/path/to/adapter`
 
-## 2. Minimal Configuration
+### 2. Router Configuration
 
 Put this in `config/config.yaml` (or merge into your existing config):
 
@@ -113,36 +134,43 @@ categories:
         use_reasoning: false
 ```
 
-## 3. How It Works
+## How It Works
+
+LoRA routing combines intelligent classification with vLLM's LoRA adapter support:
 
 ```mermaid
 graph TB
-    A[User Query] --> B[Semantic Router]
-    B --> C[Category Classifier]
-    
-    C --> D{Classified Category}
-    D -->|Technical| E[technical-lora]
-    D -->|Medical| F[medical-lora]
-    D -->|Legal| G[legal-lora]
-    D -->|General| H[llama2-7b base]
-    
-    E --> I[vLLM Server]
-    F --> I
-    G --> I
-    H --> I
-    
-    I --> J[Response]
+    A[User Query: 'Explain async/await'] --> B[Semantic Router]
+    B --> C[Classification Method]
+    C --> |Domain Routing| D1[Detects: technical]
+    C --> |Embedding Routing| D2[Matches: programming]
+    C --> |Keyword Routing| D3[Matches: code keywords]
+    C --> |MCP Routing| D4[Custom logic: technical]
+
+    D1 --> E[Category: technical]
+    D2 --> E
+    D3 --> E
+    D4 --> E
+
+    E --> F[Lookup model_scores]
+    F --> G[lora_name: technical-lora]
+
+    G --> H[vLLM Server]
+    H --> I[Load technical-lora adapter]
+    I --> J[Generate response with domain expertise]
 ```
 
 **Flow**:
 
-1. User sends a query to the router
-2. Category classifier detects the intent (e.g., "technical")
-3. Router looks up the best `ModelScore` for that category
-4. If `lora_name` is specified, it becomes the final model name
-5. Request is sent to vLLM with `model="technical-lora"`
-6. vLLM routes to the appropriate LoRA adapter
-7. Response is returned to the user
+1. **User sends query** to router (doesn't specify adapter)
+2. **Classification** using any method (domain/embedding/keyword/MCP) detects intent
+3. **Category matched** (e.g., "technical" category)
+4. **Router looks up** `model_scores` for that category
+5. **LoRA adapter selected** via `lora_name` field (e.g., "technical-lora")
+6. **Request forwarded** to vLLM with `model="technical-lora"`
+7. **vLLM loads adapter** and generates response with domain-specific knowledge
+
+**Key insight**: The classification method (domain/embedding/keyword/MCP) determines the category, then the category's `lora_name` determines which adapter to use.
 
 ### Test Domain Aware LoRA Routing
 
@@ -162,16 +190,35 @@ curl -X POST http://localhost:8080/v1/chat/completions \
 
 Check the router logs to confirm the correct LoRA adapter is selected for each query.
 
-## Benefits
+## Real-World Use Cases
+
+### 1. Healthcare Platform (Domain Routing + LoRA)
+**Problem**: Medical queries need specialized adapters, but users don't know which to use
+**Solution**: Domain routing classifies into diagnosis/pharmacy/mental-health, routes to corresponding LoRA adapters
+**Impact**: Automatic adapter selection, 70GB memory vs 210GB for 3 full models
+
+### 2. Legal Tech (Keyword Routing + LoRA for Compliance)
+**Problem**: Compliance requires auditable routing to jurisdiction-specific legal adapters
+**Solution**: Keyword routing detects "US law"/"EU law"/"contract" keywords, routes to compliant LoRA adapters
+**Impact**: 100% auditable routing decisions, 95% citation accuracy with specialized adapters
+
+### 3. Customer Support (Embedding Routing + LoRA)
+**Problem**: Support queries span IT/HR/finance, users phrase questions in many ways
+**Solution**: Embedding routing matches semantic intent, routes to department-specific LoRA adapters
+**Impact**: Handles paraphrases, single endpoint serves all departments with <10ms adapter switching
+
+### 4. EdTech Platform (Domain Routing + LoRA)
+**Problem**: Students ask math/science/literature questions, need subject-specific tutors
+**Solution**: Domain routing classifies academic subject, routes to subject-specific LoRA adapters
+**Impact**: 4 specialized tutors for cost of 1.2 base models, 70% cost savings
 
-- **Domain Expertise**: Each LoRA adapter is fine-tuned for specific domains
-- **Cost Efficiency**: Share base model weights across adapters (lower memory usage)
-- **Easy A/B Testing**: Compare adapter versions by adjusting scores
-- **Flexible Deployment**: Add/remove adapters without restarting the router
-- **Automatic Selection**: Users don't need to know which adapter to use
+### 5. Multi-Tenant SaaS (MCP Routing + LoRA)
+**Problem**: Each tenant has custom LoRA adapters, need dynamic routing based on tenant ID
+**Solution**: MCP routing queries tenant database, returns tenant-specific LoRA adapter name
+**Impact**: 1000+ tenants with custom adapters, private routing logic, A/B testing support
 
 ## Next Steps
 
 - See [complete LoRA routing example](https://github.com/vllm-project/semantic-router/blob/main/config/intelligent-routing/in-tree/lora_routing.yaml)
 - Learn about [category configuration](../../overview/categories/configuration.md#lora_name-optional)
-- Explore [reasoning routing](./reasoning.md) to combine with LoRA adapters
+- Read [modular LoRA blog post](https://blog.vllm.ai/2025/10/27/semantic-router-modular.html) for architecture details
diff --git a/website/docs/tutorials/intelligent-route/mcp-routing.md b/website/docs/tutorials/intelligent-route/mcp-routing.md
new file mode 100644
index 000000000..b52a2aaeb
--- /dev/null
+++ b/website/docs/tutorials/intelligent-route/mcp-routing.md
@@ -0,0 +1,290 @@
+# MCP Based Routing
+
+This guide shows you how to implement custom classification logic using the Model Context Protocol (MCP). MCP routing lets you integrate external services, LLMs, or custom business logic for classification decisions while keeping your data private and your routing logic extensible.
+
+## Key Advantages
+
+- **Baseline/High Accuracy**: Use powerful LLMs (GPT-4, Claude) for classification with in-context learning
+- **Extensible**: Easily integrate custom classification logic without modifying router code
+- **Private**: Keep classification logic and data in your own infrastructure
+- **Flexible**: Combine LLM reasoning with business rules, user context, and external data
+
+## What Problem Does It Solve?
+
+Built-in classifiers are limited to predefined models and logic. MCP routing enables:
+
+- **LLM-powered classification**: Use GPT-4/Claude for complex, nuanced categorization
+- **In-context learning**: Provide examples and context to improve classification accuracy
+- **Custom business logic**: Implement routing rules based on user tier, time, location, history
+- **External data integration**: Query databases, APIs, feature flags during classification
+- **Rapid experimentation**: Update classification logic without redeploying router
+
+## When to Use
+
+- **High-accuracy requirements** where LLM-based classification outperforms BERT/embeddings
+- **Complex domains** needing nuanced understanding beyond keyword/embedding matching
+- **Custom business rules** (user tiers, A/B tests, time-based routing)
+- **Private/sensitive data** where classification must stay in your infrastructure
+- **Rapid iteration** on classification logic without code changes
+
+## Configuration
+
+Configure MCP classifier in your `config.yaml`:
+
+```yaml
+classifier:
+  # Disable in-tree classifier
+  category_model:
+    model_id: ""
+  
+  # Enable MCP classifier
+  mcp_category_model:
+    enabled: true
+    transport_type: "http"
+    url: "http://localhost:8090/mcp"
+    threshold: 0.6
+    timeout_seconds: 30
+    # tool_name: "classify_text"  # Optional: auto-discovers if not specified
+
+categories: []  # Categories loaded from MCP server
+
+default_model: openai/gpt-oss-20b
+
+vllm_endpoints:
+  - name: endpoint1
+    address: 127.0.0.1
+    port: 8000
+    weight: 1
+
+model_config:
+  openai/gpt-oss-20b:
+    reasoning_family: gpt-oss
+    preferred_endpoints: [endpoint1]
+```
+
+## How It Works
+
+1. **Startup**: Router connects to MCP server and calls `list_categories` tool
+2. **Category Loading**: MCP returns categories, system prompts, and descriptions
+3. **Classification**: For each request, router calls `classify_text` tool
+4. **Routing**: MCP response includes category, model, and reasoning settings
+
+### MCP Response Format
+
+**list_categories**:
+
+```json
+{
+  "categories": ["math", "science", "technology"],
+  "category_system_prompts": {
+    "math": "You are a mathematics expert...",
+    "science": "You are a science expert..."
+  },
+  "category_descriptions": {
+    "math": "Mathematical and computational queries",
+    "science": "Scientific concepts and queries"
+  }
+}
+```
+
+**classify_text**:
+
+```json
+{
+  "class": 3,
+  "confidence": 0.85,
+  "model": "openai/gpt-oss-20b",
+  "use_reasoning": true
+}
+```
+
+## Example MCP Server
+
+```python
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI()
+
+class ClassifyRequest(BaseModel):
+    text: str
+
+@app.post("/mcp/list_categories")
+def list_categories():
+    return {
+        "categories": ["math", "science", "general"],
+        "category_system_prompts": {
+            "math": "You are a mathematics expert.",
+            "science": "You are a science expert.",
+            "general": "You are a helpful assistant."
+        }
+    }
+
+@app.post("/mcp/classify_text")
+def classify_text(request: ClassifyRequest):
+    # Custom classification logic
+    if "equation" in request.text or "solve" in request.text:
+        return {
+            "class": 0,  # math
+            "confidence": 0.9,
+            "model": "openai/gpt-oss-20b",
+            "use_reasoning": True
+        }
+    return {
+        "class": 2,  # general
+        "confidence": 0.7,
+        "model": "openai/gpt-oss-20b",
+        "use_reasoning": False
+    }
+```
+
+## Example Requests
+
+```bash
+# Math query (MCP decides routing)
+curl -X POST http://localhost:8801/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "MoM",
+    "messages": [{"role": "user", "content": "Solve the equation: 2x + 5 = 15"}]
+  }'
+```
+
+## Benefits
+
+- **Custom Logic**: Implement domain-specific classification rules
+- **Dynamic Routing**: MCP decides model and reasoning per query
+- **Centralized Control**: Manage routing logic in external service
+- **Scalability**: Scale classification independently from router
+- **Integration**: Connect to existing ML infrastructure
+
+## Real-World Use Cases
+
+### 1. Complex Domain Classification (High Accuracy)
+**Problem**: Nuanced legal/medical queries need better accuracy than BERT/embeddings
+**Solution**: MCP uses GPT-4 with in-context examples for classification
+**Impact**: 98% accuracy vs 85% with BERT, baseline for quality comparison
+
+### 2. Proprietary Classification Logic (Private)
+**Problem**: Classification logic contains trade secrets, can't use external services
+**Solution**: MCP server runs in private VPC, keeps all logic and data internal
+**Impact**: Full data privacy, no external API calls
+
+### 3. Custom Business Rules (Extensible)
+**Problem**: Need to route based on user tier, location, time, A/B tests
+**Solution**: MCP combines LLM classification with database queries and business logic
+**Impact**: Flexible routing without modifying router code
+
+### 4. Rapid Experimentation (Extensible)
+**Problem**: Data science team needs to test new classification approaches daily
+**Solution**: MCP server updated independently, router unchanged
+**Impact**: Deploy new classification logic in minutes vs days
+
+### 5. Multi-Tenant Platform (Extensible + Private)
+**Problem**: Each customer needs custom classification, data must stay isolated
+**Solution**: MCP loads tenant-specific models/rules, enforces data isolation
+**Impact**: 1000+ tenants with custom logic, full data privacy
+
+### 6. Hybrid Approach (High Accuracy + Extensible)
+**Problem**: Need LLM accuracy for edge cases, fast routing for common queries
+**Solution**: MCP uses cached responses for common patterns, LLM for novel queries
+**Impact**: 95% cache hit rate, LLM accuracy on long tail
+
+## Advanced MCP Server Examples
+
+### Context-Aware Classification
+
+```python
+@app.post("/mcp/classify_text")
+def classify_text(request: ClassifyRequest, user_id: str = Header(None)):
+    # Check user history
+    user_history = get_user_history(user_id)
+
+    # Adjust classification based on context
+    if user_history.is_premium:
+        return {
+            "class": 0,
+            "confidence": 0.95,
+            "model": "openai/gpt-4",  # Premium model
+            "use_reasoning": True
+        }
+
+    # Free tier gets fast model
+    return {
+        "class": 0,
+        "confidence": 0.85,
+        "model": "openai/gpt-oss-20b",
+        "use_reasoning": False
+    }
+```
+
+### Time-Based Routing
+
+```python
+@app.post("/mcp/classify_text")
+def classify_text(request: ClassifyRequest):
+    current_hour = datetime.now().hour
+
+    # Peak hours: use cached responses
+    if 9 <= current_hour <= 17:
+        return {
+            "class": get_cached_category(request.text),
+            "confidence": 0.9,
+            "model": "fast-model",
+            "use_reasoning": False
+        }
+
+    # Off-peak: enable reasoning
+    return {
+        "class": classify_with_ml(request.text),
+        "confidence": 0.95,
+        "model": "reasoning-model",
+        "use_reasoning": True
+    }
+```
+
+### Risk-Based Routing
+
+```python
+@app.post("/mcp/classify_text")
+def classify_text(request: ClassifyRequest):
+    # Calculate risk score
+    risk_score = calculate_risk(request.text)
+
+    if risk_score > 0.8:
+        # High risk: human review
+        return {
+            "class": 999,  # Special category
+            "confidence": 1.0,
+            "model": "human-review-queue",
+            "use_reasoning": False
+        }
+
+    # Normal routing
+    return standard_classification(request.text)
+```
+
+## Benefits vs Built-in Classifiers
+
+| Feature | Built-in | MCP |
+|---------|----------|-----|
+| Custom Models | ❌ | ✅ |
+| Business Logic | ❌ | ✅ |
+| Dynamic Updates | ❌ | ✅ |
+| User Context | ❌ | ✅ |
+| A/B Testing | ❌ | ✅ |
+| External APIs | ❌ | ✅ |
+| Latency | 5-50ms | 50-200ms |
+| Complexity | Low | High |
+
+## Performance Considerations
+
+- **Latency**: MCP adds 50-200ms per request (network + classification)
+- **Caching**: Cache MCP responses for repeated queries
+- **Timeout**: Set appropriate timeout (30s default)
+- **Fallback**: Configure default model when MCP unavailable
+- **Monitoring**: Track MCP latency and error rates
+
+## Reference
+
+See [config-mcp-classifier.yaml](https://github.com/vllm-project/semantic-router/blob/main/config/intelligent-routing/out-tree/config-mcp-classifier.yaml) for complete configuration.
diff --git a/website/docs/tutorials/intelligent-route/overview.md b/website/docs/tutorials/intelligent-route/overview.md
deleted file mode 100644
index f1d8b769d..000000000
--- a/website/docs/tutorials/intelligent-route/overview.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# Overview
-
-Semantic Router provides intelligent routing capabilities that automatically direct user queries to the most appropriate LLM based on semantic understanding and reasoning requirements.
-
-## Core Concepts
-
-### Semantic Classification
-
-Automatically classifies queries into predefined categories using semantic understanding rather than keyword matching.
-
-### Reasoning-Aware Routing
-
-Detects queries that benefit from step-by-step reasoning and routes them to appropriate reasoning-capable models.
-
-### Performance Optimization
-
-Balances cost, latency, and quality by selecting the most suitable model for each query type.
-
-## Architecture
-
-```mermaid
-graph TB
-    A[User Query] --> B[Semantic Router]
-    B --> C[Category Classifier]
-    B --> D[Reasoning Detector]
-
-    C --> E[Category: Math]
-    C --> F[Category: Creative]
-    C --> G[Category: Code]
-
-    D --> H{Needs Reasoning?}
-    H -->|Yes| I[Reasoning Models]
-    H -->|No| J[Standard Models]
-
-    E --> K[Model Selection]
-    F --> K
-    G --> K
-    I --> K
-    J --> K
-
-    K --> L[Response]
-```
-
-## Key Features
-
-- **14+ Query Categories**: Math, creative writing, coding, analysis, and more
-- **Reasoning Detection**: Identifies complex problems requiring step-by-step thinking
-- **Model Optimization**: Routes to the most cost-effective and performant models
-- **Fallback Handling**: Graceful degradation when classification is uncertain
-    I --> K
-    J --> K
-
-    K --> L[Response]
-
-```
-
-## Key Features
-
-- **14+ Query Categories**: Math, creative writing, coding, analysis, and more
-- **Reasoning Detection**: Identifies complex problems requiring step-by-step thinking
-- **Model Optimization**: Routes to the most cost-effective and performant models
-- **Fallback Handling**: Graceful degradation when classification is uncertain
diff --git a/website/docs/tutorials/intelligent-route/reasoning.md b/website/docs/tutorials/intelligent-route/reasoning.md
deleted file mode 100644
index f75be62a2..000000000
--- a/website/docs/tutorials/intelligent-route/reasoning.md
+++ /dev/null
@@ -1,210 +0,0 @@
-# Reasoning Routing
-
-This short guide shows how to enable and verify “reasoning routing” in the Semantic Router:
-
-- Minimal config.yaml fields you need
-- Example request/response (OpenAI-compatible)
-- A comprehensive evaluation command you can run
-
-Prerequisites
-
-- A running OpenAI-compatible backend for your models (e.g., vLLM or any OpenAI-compatible server). It must be reachable at the addresses you configure under vllm_endpoints (address:port).
-- Envoy + the router (see Start the router section)
-
-1) Minimal configuration
-Put this in config/config.yaml (or merge into your existing config). It defines:
-
-- Categories that require reasoning (e.g., math)
-- Reasoning families for model syntax differences (DeepSeek/Qwen3 use chat_template_kwargs; GPT-OSS/GPT use reasoning_effort)
-- Which concrete models use which reasoning family
-- The classifier (required for category detection; without it, reasoning will not be enabled)
-
-```yaml
-# Category classifier (required for reasoning to trigger)
-classifier:
-  category_model:
-    model_id: "models/category_classifier_modernbert-base_model"
-    use_modernbert: true
-    threshold: 0.6
-    use_cpu: true
-    category_mapping_path: "models/category_classifier_modernbert-base_model/category_mapping.json"
-
-# vLLM endpoints that host your models
-vllm_endpoints:
-  - name: "endpoint1"
-    address: "127.0.0.1"
-    port: 8000
-    weight: 1
-
-# Reasoning family configurations (how to express reasoning for a family)
-reasoning_families:
-  deepseek:
-    type: "chat_template_kwargs"
-    parameter: "thinking"
-  qwen3:
-    type: "chat_template_kwargs"
-    parameter: "enable_thinking"
-  gpt-oss:
-    type: "reasoning_effort"
-    parameter: "reasoning_effort"
-  gpt:
-    type: "reasoning_effort"
-    parameter: "reasoning_effort"
-
-# Default effort used when a category doesn’t specify one
-default_reasoning_effort: medium  # low | medium | high
-
-# Map concrete model names to a reasoning family
-model_config:
-  "deepseek-v31":
-    reasoning_family: "deepseek"
-    preferred_endpoints: ["endpoint1"]
-  "qwen3-30b":
-    reasoning_family: "qwen3"
-    preferred_endpoints: ["endpoint1"]
-  "openai/gpt-oss-20b":
-    reasoning_family: "gpt-oss"
-    preferred_endpoints: ["endpoint1"]
-
-# Categories: which kinds of queries require reasoning and at what effort
-categories:
-- name: math
-  use_reasoning: true
-  reasoning_effort: high  # overrides default_reasoning_effort
-  reasoning_description: "Mathematical problems require step-by-step reasoning"
-  model_scores:
-  - model: openai/gpt-oss-20b
-    score: 1.0
-  - model: deepseek-v31
-    score: 0.8
-  - model: qwen3-30b
-    score: 0.8
-
-
-# A safe default when no category is confidently selected
-default_model: qwen3-30b
-```
-
-Notes
-
-- Reasoning is controlled by categories.use_reasoning and optionally categories.reasoning_effort.
-- A model only gets reasoning fields if it has a model_config.&lt;MODEL&gt;.reasoning_family that maps to a reasoning_families entry.
-- DeepSeek/Qwen3 (chat_template_kwargs): the router injects chat_template_kwargs only when reasoning is enabled. When disabled, no chat_template_kwargs are added.
-- GPT/GPT-OSS (reasoning_effort): when reasoning is enabled, the router sets reasoning_effort based on the category (fallback to default_reasoning_effort). When reasoning is disabled, if the request already contains reasoning_effort and the model’s family type is reasoning_effort, the router preserves the original value; otherwise it is absent.
-- Category descriptions (for example, description and reasoning_description) are informational only today; they do not affect routing or classification.
-- Categories must be from MMLU-Pro at the moment; avoid free-form categories like "general". If you want generic categories, consider opening an issue to map them to MMLU-Pro.
-
-2) Start the router
-Option A: Local build + Envoy
-
-- Download classifier models and mappings (required)
-  - make download-models
-- Build and run the router
-  - make build
-  - make run-router
-- Start Envoy (install func-e once with make prepare-envoy if needed)
-  - func-e run --config-path config/envoy.yaml --component-log-level "ext_proc:trace,router:trace,http:trace"
-
-Option B: Docker Compose
-
-- docker compose up -d
-  - Exposes Envoy at http://localhost:8801 (proxying /v1/* to backends via the router)
-
-Note: Ensure your OpenAI-compatible backend is running and reachable (e.g., http://127.0.0.1:8000) so that vllm_endpoints address:port matches a live server. Without a running backend, routing will fail at the Envoy hop.
-
-3) Send example requests
-Math (reasoning should be ON and effort high)
-
-```bash
-curl -sS http://localhost:8801/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "MoM",
-    "messages": [
-      {"role": "system", "content": "You are a math teacher."},
-      {"role": "user",   "content": "What is the derivative of f(x) = x^3 + 2x^2 - 5x + 7?"}
-    ]
-  }' | jq
-```
-
-General (reasoning should be OFF)
-
-```bash
-curl -sS http://localhost:8801/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "MoM",
-    "messages": [
-      {"role": "system", "content": "You are a helpful assistant."},
-      {"role": "user",   "content": "Who are you?"}
-    ]
-  }' | jq
-```
-
-Verify routing via response headers
-The router does not inject routing metadata into the JSON body. Instead, inspect the response headers added by the router:
-
-- X-Selected-Model
-- x-vsr-destination-endpoint
-
-Example:
-
-```bash
-curl -i http://localhost:8801/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "MoM",
-    "messages": [
-      {"role": "system", "content": "You are a math teacher."},
-      {"role": "user",   "content": "What is the derivative of f(x) = x^3 + 2x^2 - 5x + 7?"}
-    ]
-  }'
-# In the response headers, look for:
-#   X-Selected-Model: <your-selected-model>
-#   x-vsr-destination-endpoint: <address:port>
-```
-
-4) Run a comprehensive evaluation
-You can benchmark the router vs a direct vLLM endpoint across categories using the included script. This runs a ReasoningBench based on MMLU-Pro and produces summaries and plots.
-
-Quick start (router + vLLM):
-
-```bash
-SAMPLES_PER_CATEGORY=25 \
-CONCURRENT_REQUESTS=4 \
-ROUTER_MODELS="MoM" \
-VLLM_MODELS="openai/gpt-oss-20b" \
-./bench/run_bench.sh
-```
-
-Router-only benchmark:
-
-```bash
-BENCHMARK_ROUTER_ONLY=true \
-SAMPLES_PER_CATEGORY=25 \
-CONCURRENT_REQUESTS=4 \
-ROUTER_MODELS="MoM" \
-./bench/run_bench.sh
-```
-
-Direct invocation (advanced):
-
-```bash
-python bench/router_reason_bench.py \
-  --run-router \
-  --router-endpoint http://localhost:8801/v1 \
-  --router-models auto \
-  --run-vllm \
-  --vllm-endpoint http://localhost:8000/v1 \
-  --vllm-models openai/gpt-oss-20b \
-  --samples-per-category 25 \
-  --concurrent-requests 4 \
-  --output-dir results/reasonbench
-```
-
-Tips
-
-- If your math request doesn’t enable reasoning, confirm the classifier assigns the "math" category with sufficient confidence (see classifier.category_model.threshold) and that the target model has a reasoning_family.
-- For models without a reasoning_family, the router will not inject reasoning fields even when the category requires reasoning (this is by design to avoid invalid requests).
-- You can override the effort per category via categories.reasoning_effort or set a global default via default_reasoning_effort.
-- Ensure your OpenAI-compatible backend is reachable at the configured vllm_endpoints (address:port). If it’s not running, routing will fail even though the router and Envoy are up.
diff --git a/website/sidebars.ts b/website/sidebars.ts
index 7ef383342..106365c96 100644
--- a/website/sidebars.ts
+++ b/website/sidebars.ts
@@ -72,8 +72,10 @@ const sidebars: SidebarsConfig = {
           type: 'category',
           label: 'Intelligent Route',
           items: [
-            'tutorials/intelligent-route/overview',
-            'tutorials/intelligent-route/reasoning',
+            'tutorials/intelligent-route/domain-routing',
+            'tutorials/intelligent-route/embedding-routing',
+            'tutorials/intelligent-route/keyword-routing',
+            'tutorials/intelligent-route/mcp-routing',
             'tutorials/intelligent-route/lora-routing',
           ],
         },