@relayplane/sdk/examples/global-optimization-example.js

RelayPlane SDK with zero-config AI access, intelligent model selection, built-in examples, and contextual error handling. The easiest way to add AI to your app with automatic optimization and fallback.

/**
 * RelayPlane SDK - Global Optimization Settings Example
 * 
 * This example demonstrates the enhanced global optimization settings including:
 * - Cache strategy configuration (memory, disk, hybrid)
 * - Batch processing global settings
 * - Parallel execution configuration
 * - Comprehensive timeout settings
 * - Rate limiting strategies
 * 
 * Usage: node examples/global-optimization-example.js
 */

const RelayPlane = require('@relayplane/sdk');

async function demonstrateGlobalOptimization() {
  console.log('🔧 RelayPlane SDK - Global Optimization Settings Demo\n');

  // Example 1: Memory Cache Strategy
  console.log('--- Example 1: Memory Cache Strategy ---');
  await testCacheStrategy('memory');

  // Example 2: Hybrid Cache Strategy
  console.log('\n--- Example 2: Hybrid Cache Strategy ---');
  await testCacheStrategy('hybrid');

  // Example 3: Batch Processing Configuration
  console.log('\n--- Example 3: Batch Processing Global Settings ---');
  await testBatchProcessingSettings();

  // Example 4: Parallel Execution Configuration
  console.log('\n--- Example 4: Parallel Execution Settings ---');
  await testParallelExecutionSettings();

  // Example 5: Comprehensive Timeout Settings
  console.log('\n--- Example 5: Comprehensive Timeout Settings ---');
  await testTimeoutSettings();

  // Example 6: Rate Limiting Strategies
  console.log('\n--- Example 6: Rate Limiting Strategies ---');
  await testRateLimitingStrategies();

  // Example 7: Complete Configuration
  console.log('\n--- Example 7: Complete Optimization Configuration ---');
  await testCompleteOptimization();

  console.log('\n🎉 Global optimization examples completed!');
}

async function testCacheStrategy(cacheType) {
  try {
    console.log(`🗄️ Testing ${cacheType} cache strategy...`);
    
    const config = await RelayPlane.configure({
      debug: true,
      defaultOptimization: {
        enabled: true,
        strategy: 'balanced',
        cacheStrategy: {
          type: cacheType,
          maxSize: cacheType === 'memory' ? 50 : 200, // MB
          evictionPolicy: 'lru',
          compression: cacheType !== 'memory',
          encryption: cacheType === 'hybrid'
        }
      }
    });

    console.log(`✅ Cache strategy configured: ${cacheType}`);
    console.log(`   Max size: ${config.features?.costTracking ? '50MB' : '200MB'}`);
    console.log(`   Compression: ${cacheType !== 'memory'}`);
    console.log(`   Encryption: ${cacheType === 'hybrid'}`);

    // Test with cache
    const result = await RelayPlane.ask("What is 2+2?");
    console.log(`   Response: ${result.response.body.substring(0, 50)}...`);

  } catch (error) {
    console.log(`❌ Cache strategy test failed: ${error.message}`);
  }
}

async function testBatchProcessingSettings() {
  try {
    console.log('📦 Testing batch processing global settings...');
    
    await RelayPlane.configure({
      debug: true,
      defaultOptimization: {
        enabled: true,
        batchProcessing: {
          enabled: true,
          defaultConcurrency: 8,
          maxBatchSize: 25,
          autoGrouping: true,
          timeoutMs: 45000
        }
      }
    });

    console.log('✅ Batch processing configured:');
    console.log('   Enabled: true');
    console.log('   Default concurrency: 8');
    console.log('   Max batch size: 25');
    console.log('   Auto-grouping: true');
    console.log('   Timeout: 45 seconds');

    // Simulate batch processing
    const requests = [
      'What is the capital of France?',
      'What is the capital of Germany?',
      'What is the capital of Italy?'
    ];

    console.log(`   Processing ${requests.length} requests...`);
    for (const request of requests) {
      try {
        const result = await RelayPlane.ask(request);
        console.log(`   ✓ ${request} → ${result.response.body.substring(0, 30)}...`);
      } catch (error) {
        console.log(`   ✗ ${request} → Error: ${error.message}`);
      }
    }

  } catch (error) {
    console.log(`❌ Batch processing test failed: ${error.message}`);
  }
}

async function testParallelExecutionSettings() {
  try {
    console.log('⚡ Testing parallel execution settings...');
    
    await RelayPlane.configure({
      debug: true,
      defaultOptimization: {
        enabled: true,
        parallelExecution: {
          enabled: true,
          maxConcurrentRequests: 15,
          requestPooling: true,
          loadBalancing: 'least_latency'
        }
      }
    });

    console.log('✅ Parallel execution configured:');
    console.log('   Enabled: true');
    console.log('   Max concurrent requests: 15');
    console.log('   Request pooling: true');
    console.log('   Load balancing: least_latency');

    // Test parallel execution
    const startTime = Date.now();
    const promises = [
      RelayPlane.ask("Count to 3"),
      RelayPlane.ask("Count to 5"),
      RelayPlane.ask("Count to 7")
    ];

    const results = await Promise.allSettled(promises);
    const duration = Date.now() - startTime;

    console.log(`   Parallel execution completed in ${duration}ms`);
    console.log(`   Successful requests: ${results.filter(r => r.status === 'fulfilled').length}/3`);

  } catch (error) {
    console.log(`❌ Parallel execution test failed: ${error.message}`);
  }
}

async function testTimeoutSettings() {
  try {
    console.log('⏱️ Testing comprehensive timeout settings...');
    
    await RelayPlane.configure({
      debug: true,
      defaultOptimization: {
        enabled: true,
        timeoutSettings: {
          requestTimeoutMs: 20000,    // 20 seconds for request
          connectionTimeoutMs: 3000,  // 3 seconds to connect
          readTimeoutMs: 15000,       // 15 seconds to read response
          totalTimeoutMs: 45000,      // 45 seconds total operation
          retryTimeoutMs: 8000        // 8 seconds for retry attempts
        }
      }
    });

    console.log('✅ Timeout settings configured:');
    console.log('   Request timeout: 20 seconds');
    console.log('   Connection timeout: 3 seconds');
    console.log('   Read timeout: 15 seconds');
    console.log('   Total timeout: 45 seconds');
    console.log('   Retry timeout: 8 seconds');

    // Test with timeout-sensitive request
    const startTime = Date.now();
    try {
      const result = await RelayPlane.ask("Write a very brief hello message");
      const duration = Date.now() - startTime;
      console.log(`   Request completed in ${duration}ms`);
      console.log(`   Response: ${result.response.body.substring(0, 50)}...`);
    } catch (error) {
      console.log(`   Request timed out or failed: ${error.message}`);
    }

  } catch (error) {
    console.log(`❌ Timeout settings test failed: ${error.message}`);
  }
}

async function testRateLimitingStrategies() {
  try {
    console.log('🚦 Testing rate limiting strategies...');
    
    // Test graceful backoff strategy
    await RelayPlane.configure({
      debug: true,
      defaultOptimization: {
        enabled: true,
        rateLimitingStrategy: {
          strategy: 'graceful_backoff',
          backoffMultiplier: 1.5,
          maxBackoffMs: 20000,
          jitterEnabled: true,
          respectProviderLimits: true,
          globalRateLimit: {
            requestsPerMinute: 120,
            requestsPerSecond: 5
          }
        }
      }
    });

    console.log('✅ Rate limiting strategy configured:');
    console.log('   Strategy: graceful_backoff');
    console.log('   Backoff multiplier: 1.5x');
    console.log('   Max backoff: 20 seconds');
    console.log('   Jitter enabled: true');
    console.log('   Global limit: 120/min, 5/sec');

    // Test rate limiting
    console.log('   Testing rate limiting with multiple requests...');
    for (let i = 1; i <= 3; i++) {
      try {
        const result = await RelayPlane.ask(`Request ${i}: What is ${i} + ${i}?`);
        console.log(`   ✓ Request ${i} completed`);
      } catch (error) {
        console.log(`   ✗ Request ${i} failed: ${error.message}`);
      }
      
      // Small delay between requests
      await new Promise(resolve => setTimeout(resolve, 200));
    }

  } catch (error) {
    console.log(`❌ Rate limiting test failed: ${error.message}`);
  }
}

async function testCompleteOptimization() {
  try {
    console.log('🔄 Testing complete optimization configuration...');
    
    const config = await RelayPlane.configure({
      debug: true,
      defaultOptimization: {
        enabled: true,
        strategy: 'balanced',
        maxCost: 5.0,
        costLimitPerRequest: 0.50,
        latencyLimitMs: 25000,
        cacheStrategy: {
          type: 'hybrid',
          maxSize: 150,
          evictionPolicy: 'lru',
          compression: true,
          encryption: true
        },
        batchProcessing: {
          enabled: true,
          defaultConcurrency: 6,
          maxBatchSize: 20,
          autoGrouping: true,
          timeoutMs: 30000
        },
        parallelExecution: {
          enabled: true,
          maxConcurrentRequests: 12,
          requestPooling: true,
          loadBalancing: 'least_cost'
        },
        timeoutSettings: {
          requestTimeoutMs: 25000,
          connectionTimeoutMs: 4000,
          readTimeoutMs: 20000,
          totalTimeoutMs: 50000,
          retryTimeoutMs: 10000
        },
        rateLimitingStrategy: {
          strategy: 'provider_switching',
          backoffMultiplier: 2.0,
          maxBackoffMs: 25000,
          jitterEnabled: true,
          respectProviderLimits: true,
          globalRateLimit: {
            requestsPerMinute: 200,
            requestsPerSecond: 8
          }
        }
      }
    });

    console.log('✅ Complete optimization configuration applied:');
    console.log(`   Mode: ${config.mode}`);
    console.log(`   Detected providers: ${config.detectedProviders.length}`);
    console.log(`   Features available: ${Object.keys(config.features || {}).filter(k => config.features[k]).length}`);
    
    // Test the complete configuration
    const result = await RelayPlane.ask("Test the complete optimization setup");
    console.log(`   Test request successful: ${result.response.body.substring(0, 50)}...`);
    console.log(`   Model used: ${result.reasoning.selectedModel}`);

  } catch (error) {
    console.log(`❌ Complete optimization test failed: ${error.message}`);
  }
}

// Helper function for delays
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Run the demonstration
if (require.main === module) {
  demonstrateGlobalOptimization().catch(console.error);
}

module.exports = { 
  demonstrateGlobalOptimization,
  testCacheStrategy,
  testBatchProcessingSettings,
  testParallelExecutionSettings,
  testTimeoutSettings,
  testRateLimitingStrategies,
  testCompleteOptimization
};