Production Deployment

# docker-compose.prod.yml
version: '3.8'
services:
  app:
    image: your-app:latest
    environment:
      NODE_ENV: production
      RODGER_API_KEY: ${RODGER_API_KEY}
      RODGER_API_URL: https://api.rodger.ai
      REDIS_URL: redis://redis:6379
      DATABASE_URL: ${DATABASE_URL}
    
    # Health checks
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    
    # Resource limits
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G
        reservations:
          cpus: '1'
          memory: 2G
    
    # Scaling configuration
    scale: 3

  redis:
    image: redis:7-alpine
    command: redis-server --maxmemory 512mb --maxmemory-policy allkeys-lru
    
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl

// Production-ready client with caching and resilience
class ProductionRodgerClient {
  constructor() {
    this.client = new RodgerClient({
      apiKey: process.env.RODGER_API_KEY,
      apiUrl: process.env.RODGER_API_URL,
      timeout: 30000,
      retries: 3
    });

    // Redis for caching
    this.cache = new Redis(process.env.REDIS_URL);
    
    // Circuit breaker for resilience
    this.circuitBreaker = new CircuitBreaker(this.client.query, {
      timeout: 30000,
      errorThresholdPercentage: 50,
      resetTimeout: 60000
    });
  }

  async query(agentId: string, message: string, options: any = {}) {
    // Check cache first for repeated queries
    const cacheKey = `query:${agentId}:${hashMessage(message)}`;
    const cached = await this.cache.get(cacheKey);
    
    if (cached && !options.skipCache) {
      return JSON.parse(cached);
    }

    try {
      // Use circuit breaker for resilient queries
      const response = await this.circuitBreaker.fire(agentId, {
        message,
        ...options
      });

      // Cache successful responses
      if (response && !options.skipCache) {
        await this.cache.setex(cacheKey, 300, JSON.stringify(response)); // 5min cache
      }

      return response;
    } catch (error) {
      // Fallback strategies
      if (error.code === 'CIRCUIT_OPEN') {
        return this.handleFallbackResponse(agentId, message);
      }
      throw error;
    }
  }

  async handleFallbackResponse(agentId: string, message: string) {
    // Use cached similar responses or default fallback
    const fallback = await this.findSimilarCachedResponse(message);
    
    if (fallback) {
      return {
        ...fallback,
        metadata: { source: 'cache_fallback' }
      };
    }

    return {
      message: "I'm experiencing technical difficulties. Please try again in a moment.",
      metadata: { source: 'default_fallback' }
    };
  }
}