agentic-flow 1.9.0 → 1.9.1

package/agentic-flow/docs/guides/ONNX_OPTIMIZATION_GUIDE.md

@@ -1,665 +0,0 @@
-# ONNX Phi-4 Optimization Guide
-
-## Performance & Quality Improvements
-
-You can dramatically improve ONNX Phi-4 performance and output quality through:
-
-1. **Better Prompting Techniques** - 30-50% quality improvement
-2. **Memory/Context Management** - 2-3x speed improvement
-3. **GPU Acceleration** - 10-50x speed improvement
-4. **Model Quantization Options** - Trade speed/quality
-5. **Advanced Generation Parameters** - Better outputs
-
----
-
-## 1. Better Prompting Techniques
-
-### Problem: Generic Prompts = Generic Output
-
-**❌ Bad Prompt (Low Quality):**
-```bash
-npx agentic-flow --agent coder --task "Write a function" --provider onnx
-```
-
-**Output Quality:** 6/10 - Generic, missing edge cases
-
-**✅ Optimized Prompt (High Quality):**
-```bash
-npx agentic-flow --agent coder --task "Write a Python function called is_prime(n: int) -> bool that checks if n is prime. Include: 1) Type hints 2) Docstring 3) Handle edge cases (negative, 0, 1) 4) Optimal algorithm. Return ONLY code, no explanation." --provider onnx
-```
-
-**Output Quality:** 8.5/10 - Specific, handles edge cases
-
-### Prompt Engineering Best Practices
-
-#### A. Use Specific Instructions
-
-```bash
-# Generic (Poor)
---task "Create an API"
-
-# Specific (Better)
---task "Create a REST API endpoint for user registration with email validation, password hashing (bcrypt), error handling for duplicate emails, and return JSON response. Use Express.js."
-```
-
-#### B. Request Structured Output
-
-```bash
-# Vague (Poor)
---task "Review this code"
-
-# Structured (Better)
---task "Review this code and provide: 1. Security issues 2. Performance problems 3. Code quality improvements 4. Specific fixes with code examples. List each issue with severity (HIGH/MED/LOW)."
-```
-
-#### C. Few-Shot Examples
-
-```bash
---task "Write a function to validate emails. Example format: def validate_email(email: str) -> bool: ... Include edge cases like 'user@domain.co.uk', 'user+tag@domain.com'."
-```
-
-#### D. Role-Based Prompting
-
-```bash
-# Generic
---agent coder --task "Write secure code"
-
-# Role-based (Better)
---agent coder --task "You are a senior security engineer. Write authentication code following OWASP guidelines. Include input sanitization, SQL injection prevention, XSS protection."
-```
-
-### Quality Improvement: 6/10 → 8.5/10 (42% improvement)
-
----
-
-## 2. Memory & Context Management
-
-### Problem: Long Context = Slow Inference
-
-Phi-4 has 4K token context limit. Optimize for speed:
-
-#### A. Context Pruning
-
-**❌ Inefficient (Slow):**
-```typescript
-const messages = [
-  { role: 'system', content: 'You are a helpful assistant...' },
-  { role: 'user', content: 'Write a function...' },
-  { role: 'assistant', content: '...' },
-  { role: 'user', content: 'Now modify it...' },
-  // ... 20 more messages (3000 tokens)
-];
-```
-
-**Speed:** ~60 seconds for 100 token response
-
-**✅ Optimized (Fast):**
-```typescript
-// Only keep last 2-3 exchanges
-const messages = [
-  { role: 'user', content: 'Write a function to calculate fibonacci. Use memoization for O(n) time.' }
-];
-```
-
-**Speed:** ~16 seconds for 100 token response (4x faster)
-
-#### B. Sliding Window Context
-
-```typescript
-function optimizeContext(messages: Message[], maxTokens = 1000) {
-  let totalTokens = 0;
-  const optimized = [];
-
-  // Keep system message
-  if (messages[0]?.role === 'system') {
-    optimized.push(messages[0]);
-    totalTokens += estimateTokens(messages[0].content);
-  }
-
-  // Add recent messages from end
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    const tokens = estimateTokens(msg.content);
-
-    if (totalTokens + tokens > maxTokens) break;
-
-    optimized.unshift(msg);
-    totalTokens += tokens;
-  }
-
-  return optimized;
-}
-```
-
-#### C. Batch Processing
-
-**❌ Sequential (Slow):**
-```bash
-for task in task1 task2 task3; do
-  npx agentic-flow --agent coder --task "$task" --provider onnx
-done
-# Total: 3 x 30s = 90 seconds
-```
-
-**✅ Parallel (Fast):**
-```bash
-npx agentic-flow --agent coder --task "task1" --provider onnx &
-npx agentic-flow --agent coder --task "task2" --provider onnx &
-npx agentic-flow --agent coder --task "task3" --provider onnx &
-wait
-# Total: max(30s) = 30 seconds (3x faster)
-```
-
-### Speed Improvement: 4x faster with context optimization
-
----
-
-## 3. GPU Acceleration
-
-### Problem: CPU Inference is Slow (6 tokens/sec)
-
-**Solution:** Enable GPU acceleration
-
-#### A. NVIDIA CUDA (10-50x faster)
-
-```json
-// router.config.json
-{
-  "providers": {
-    "onnx": {
-      "executionProviders": ["cuda", "cpu"],
-      "gpuAcceleration": true,
-      "cudaOptions": {
-        "deviceId": 0,
-        "cudnnConvAlgoSearch": "EXHAUSTIVE"
-      }
-    }
-  }
-}
-```
-
-**Performance:**
-- CPU: 6 tokens/sec
-- CUDA: 60-300 tokens/sec (10-50x faster)
-
-**Setup:**
-```bash
-# Install CUDA toolkit
-# https://developer.nvidia.com/cuda-downloads
-
-# Install onnxruntime-node with CUDA
-npm install onnxruntime-node@gpu
-```
-
-#### B. DirectML (Windows GPU)
-
-```json
-{
-  "providers": {
-    "onnx": {
-      "executionProviders": ["dml", "cpu"],
-      "gpuAcceleration": true
-    }
-  }
-}
-```
-
-**Performance:** 30-100 tokens/sec (5-15x faster)
-
-#### C. CoreML (macOS Apple Silicon)
-
-```json
-{
-  "providers": {
-    "onnx": {
-      "executionProviders": ["coreml", "cpu"],
-      "gpuAcceleration": true
-    }
-  }
-}
-```
-
-**Performance:** 40-120 tokens/sec (7-20x faster)
-
-### Speed Improvement: 10-50x faster with GPU
-
----
-
-## 4. Advanced Generation Parameters
-
-### A. Temperature Tuning
-
-**Temperature affects output creativity/randomness:**
-
-```typescript
-// Deterministic code (low temperature)
-const config = {
-  temperature: 0.2,  // More focused, consistent
-  maxTokens: 200
-};
-
-// Creative writing (high temperature)
-const config = {
-  temperature: 0.9,  // More diverse, creative
-  maxTokens: 500
-};
-```
-
-**Recommended Settings:**
-
-| Task Type | Temperature | Top-P | Why |
-|-----------|-------------|-------|-----|
-| Code generation | 0.2-0.4 | 0.9 | Deterministic, correct syntax |
-| Refactoring | 0.3-0.5 | 0.9 | Some creativity, but safe |
-| Documentation | 0.5-0.7 | 0.95 | Clear but varied language |
-| Brainstorming | 0.7-0.9 | 0.95 | Creative, diverse ideas |
-| Math/Logic | 0.1-0.2 | 0.8 | Precise, deterministic |
-
-### B. Top-K and Top-P (Nucleus Sampling)
-
-```typescript
-const config = {
-  temperature: 0.7,
-  topK: 50,        // Consider top 50 tokens
-  topP: 0.9,       // Consider top 90% probability mass
-  repetitionPenalty: 1.1  // Reduce repetition
-};
-```
-
-### C. Length Penalties
-
-```typescript
-const config = {
-  maxTokens: 200,
-  minTokens: 50,           // Ensure minimum length
-  lengthPenalty: 1.0,      // Neutral
-  earlyStopping: true      // Stop at natural ending
-};
-```
-
----
-
-## 5. KV Cache Optimization
-
-### Problem: Recomputing Previous Tokens Wastes Time
-
-**Current Implementation:** Stores KV cache, but can be optimized
-
-```typescript
-// Optimized KV cache with pre-allocation
-class OptimizedONNXProvider extends ONNXLocalProvider {
-  private kvCachePool: Map<string, ort.Tensor> = new Map();
-
-  private reuseKVCache(batchSize: number, seqLength: number) {
-    const cacheKey = `${batchSize}-${seqLength}`;
-
-    if (this.kvCachePool.has(cacheKey)) {
-      return this.kvCachePool.get(cacheKey)!;
-    }
-
-    const cache = this.initializeKVCache(batchSize, seqLength);
-    this.kvCachePool.set(cacheKey, cache);
-    return cache;
-  }
-}
-```
-
-### Benefits:
-- 20-30% faster token generation
-- Reduced memory allocation overhead
-- Better cache locality
-
----
-
-## 6. Model Variants & Quantization
-
-### Available Phi-4 Variants
-
-| Variant | Size | Speed | Quality | Use Case |
-|---------|------|-------|---------|----------|
-| **INT4** (current) | 4.9GB | Fast | Good | General use, CPU |
-| FP16 | 7.5GB | Medium | Better | GPU with VRAM |
-| FP32 | 14GB | Slow | Best | Research, accuracy |
-| INT8 | 3.5GB | Faster | Decent | Mobile, edge devices |
-
-### Switching Variants
-
-```bash
-# Download FP16 model (better quality, needs GPU)
-export ONNX_MODEL_VARIANT=fp16
-npx agentic-flow --agent coder --task "test" --provider onnx
-
-# Download INT8 model (faster, lower quality)
-export ONNX_MODEL_VARIANT=int8
-npx agentic-flow --agent coder --task "test" --provider onnx
-```
-
----
-
-## 7. Prompt Caching & Reuse
-
-### Problem: Repeated System Prompts Waste Compute
-
-**❌ Inefficient:**
-```typescript
-// Every request reprocesses the same system prompt
-const messages = [
-  { role: 'system', content: 'You are a Python expert...' },  // 200 tokens
-  { role: 'user', content: 'Task 1' }
-];
-
-// Request 2
-const messages2 = [
-  { role: 'system', content: 'You are a Python expert...' },  // 200 tokens (redundant!)
-  { role: 'user', content: 'Task 2' }
-];
-```
-
-**✅ Optimized with Caching:**
-```typescript
-class CachedONNXProvider {
-  private systemPromptCache: Map<string, ort.Tensor> = new Map();
-
-  async chatWithCache(messages: Message[]) {
-    const systemMsg = messages.find(m => m.role === 'system');
-
-    if (systemMsg) {
-      const cacheKey = hashString(systemMsg.content);
-
-      if (this.systemPromptCache.has(cacheKey)) {
-        // Reuse cached embeddings (instant!)
-        return this.generateWithCachedSystem(cacheKey, messages);
-      }
-    }
-
-    return this.chat(messages);
-  }
-}
-```
-
-### Speed Improvement: 30-40% faster on repeated prompts
-
----
-
-## 8. Batching Strategies
-
-### Process Multiple Tasks Efficiently
-
-```typescript
-class BatchedONNXProvider {
-  async processBatch(tasks: string[], batchSize = 4) {
-    const results = [];
-
-    for (let i = 0; i < tasks.length; i += batchSize) {
-      const batch = tasks.slice(i, i + batchSize);
-
-      // Process batch in parallel
-      const promises = batch.map(task =>
-        this.chat({ messages: [{ role: 'user', content: task }] })
-      );
-
-      const batchResults = await Promise.all(promises);
-      results.push(...batchResults);
-    }
-
-    return results;
-  }
-}
-```
-
-### Throughput: 4x higher with batch processing
-
----
-
-## 9. Optimized Provider Configuration
-
-### Complete Optimized Config
-
-```json
-{
-  "providers": {
-    "onnx": {
-      "modelPath": "./models/phi-4-mini/cpu_and_mobile/cpu-int4-rtn-block-32-acc-level-4/model.onnx",
-
-      // GPU Acceleration (choose one)
-      "executionProviders": ["cuda", "cpu"],  // NVIDIA
-      // "executionProviders": ["dml", "cpu"],   // Windows DirectML
-      // "executionProviders": ["coreml", "cpu"], // macOS Apple Silicon
-
-      "gpuAcceleration": true,
-
-      // Memory Optimization
-      "enableMemPattern": true,
-      "enableCpuMemArena": true,
-      "graphOptimizationLevel": "all",
-
-      // Session Options
-      "intraOpNumThreads": 4,      // Parallel ops within layer
-      "interOpNumThreads": 2,      // Parallel layers
-
-      // Generation Parameters
-      "maxTokens": 200,
-      "temperature": 0.3,           // Lower for code (deterministic)
-      "topP": 0.9,
-      "topK": 50,
-      "repetitionPenalty": 1.1,
-
-      // Context Management
-      "maxContextTokens": 2048,     // Keep under 4K limit
-      "slidingWindow": true,
-
-      // Caching
-      "enableKVCache": true,
-      "cacheSystemPrompts": true
-    }
-  }
-}
-```
-
----
-
-## 10. Real-World Performance Comparison
-
-### Before Optimization (Baseline)
-
-**Setup:**
-- CPU: Intel i7 (no GPU)
-- Context: 3000 tokens
-- Temperature: 0.7
-- No caching
-
-**Performance:**
-- Speed: 6 tokens/sec
-- Latency: 100 token response = 16.6 seconds
-- Quality: 6.5/10
-
-### After Optimization (Full Stack)
-
-**Setup:**
-- GPU: NVIDIA RTX 3080 (CUDA enabled)
-- Context: Optimized to 1000 tokens (pruned)
-- Temperature: 0.3 (code-specific)
-- KV cache enabled
-- Prompt engineering
-
-**Performance:**
-- Speed: 180 tokens/sec (30x faster)
-- Latency: 100 token response = 0.55 seconds (30x faster)
-- Quality: 8.5/10 (31% better)
-
-### Combined Improvement: 30x speed + 31% quality
-
----
-
-## 11. Practical Implementation
-
-### Quick Wins (5 minutes)
-
-```bash
-# 1. Optimize prompts (30% quality boost)
-export ONNX_PROMPT_PREFIX="You are an expert programmer. Provide concise, correct code with error handling."
-
-# 2. Reduce context (2x speed boost)
-export ONNX_MAX_CONTEXT=1000
-
-# 3. Lower temperature for code (20% quality boost)
-export ONNX_TEMPERATURE=0.3
-
-# 4. Increase max tokens for complete answers
-export ONNX_MAX_TOKENS=300
-```
-
-### Medium Effort (30 minutes)
-
-```typescript
-// Implement context pruning
-import { optimizeContext } from './utils/context-optimizer';
-
-const messages = optimizeContext(rawMessages, 1000);
-const response = await onnxProvider.chat({ messages });
-```
-
-### High Effort (2 hours)
-
-```bash
-# Install CUDA support
-sudo apt-get install nvidia-cuda-toolkit
-npm install onnxruntime-node@gpu
-
-# Update router config
-# Add "executionProviders": ["cuda", "cpu"]
-
-# Test GPU acceleration
-npx agentic-flow --agent coder --task "test" --provider onnx
-# Should see: 🔧 Execution providers: cuda, cpu
-```
-
----
-
-## 12. Quality Benchmarks
-
-### Task: Generate Prime Number Checker
-
-| Optimization Level | Quality Score | Speed | Code Works? |
-|-------------------|---------------|-------|-------------|
-| **Baseline** (generic prompt) | 6.5/10 | 6 tok/s | ✅ Yes (basic) |
-| **+ Prompt Engineering** | 8.2/10 | 6 tok/s | ✅ Yes (comprehensive) |
-| **+ Context Pruning** | 8.2/10 | 12 tok/s | ✅ Yes |
-| **+ Temperature Tuning** | 8.5/10 | 12 tok/s | ✅ Yes (optimal) |
-| **+ GPU Acceleration** | 8.5/10 | 180 tok/s | ✅ Yes |
-
-### Task: Complex Architecture Design
-
-| Optimization Level | Quality Score | Speed | Recommendation |
-|-------------------|---------------|-------|----------------|
-| **Baseline ONNX** | 4.0/10 | 6 tok/s | ❌ Don't use |
-| **Optimized ONNX** | 5.5/10 | 180 tok/s | ⚠️ Still not great |
-| **Claude 3.5** | 9.8/10 | 100 tok/s | ✅ Use this instead |
-
-**Conclusion:** Optimization helps simple tasks, but complex reasoning still needs Claude.
-
----
-
-## 13. Recommended Optimization Strategy
-
-### Tier 1: Everyone (Free, 5 min)
-1. ✅ Use specific, detailed prompts
-2. ✅ Set temperature to 0.2-0.4 for code
-3. ✅ Keep context under 1500 tokens
-4. ✅ Request structured output
-
-**Result:** 30-50% quality improvement, 2x speed
-
-### Tier 2: Power Users (30 min)
-1. ✅ Implement context pruning
-2. ✅ Enable KV cache optimization
-3. ✅ Use batch processing for multiple tasks
-4. ✅ Cache common system prompts
-
-**Result:** 3-4x speed improvement
-
-### Tier 3: Performance Critical (2 hours)
-1. ✅ Enable GPU acceleration (CUDA/DirectML/CoreML)
-2. ✅ Optimize inference parameters
-3. ✅ Implement advanced caching
-4. ✅ Consider FP16 model for quality
-
-**Result:** 10-50x speed improvement, 10-20% quality boost
-
----
-
-## 14. When Optimization Isn't Enough
-
-**Even with full optimization, ONNX Phi-4 struggles with:**
-
-❌ Complex system architecture
-❌ Security vulnerability analysis
-❌ Multi-step reasoning chains
-❌ Research & synthesis
-❌ Advanced algorithm design
-
-**For these tasks, use:**
-- Claude 3.5 Sonnet (premium quality)
-- DeepSeek V3 via OpenRouter (excellent quality, cheap)
-- Llama 3.1 70B via OpenRouter (good quality, very cheap)
-
-**Optimization Matrix:**
-
-```
-Simple Tasks (CRUD, templates):     ONNX optimized → 8.5/10 quality ✅
-Medium Tasks (business logic):      OpenRouter DeepSeek → 9.2/10 ✅
-Complex Tasks (architecture):       Claude 3.5 → 9.8/10 ✅
-```
-
----
-
-## 15. Monitoring & Debugging
-
-### Enable Performance Metrics
-
-```typescript
-const config = {
-  enableProfiling: true,
-  logPerformance: true
-};
-
-// Outputs:
-// ⏱️  Token generation: 5.5ms/token
-// 📊 KV cache hit rate: 85%
-// 🧠 Memory usage: 2.3GB
-// 🔄 Context pruning saved: 1200 tokens
-```
-
-### Quality Monitoring
-
-```typescript
-// Test output quality
-const qualityCheck = {
-  hasSyntaxErrors: false,
-  handlesEdgeCases: true,
-  includesDocumentation: true,
-  passesTests: true
-};
-
-// Log to improve prompts
-if (!qualityCheck.passesTests) {
-  console.log('Prompt needs improvement');
-}
-```
-
----
-
-## Bottom Line
-
-**Optimized ONNX Phi-4 can achieve:**
-- 8.5/10 quality (vs 6.5 baseline) - **31% improvement**
-- 180 tokens/sec (vs 6 baseline) - **30x faster**
-- Still $0 cost
-- Perfect for 70-80% of coding tasks
-
-**But complex tasks still need Claude/DeepSeek** - no amount of optimization makes Phi-4 match GPT-4 class models for reasoning.
-
-**Use the hybrid strategy:**
-- 80% simple tasks → Optimized ONNX (free, 8.5/10)
-- 20% complex tasks → Claude/DeepSeek (paid, 9.8/10)
-- Total cost: 80% savings vs all-Claude