# Check your current usage pattern
claude-monitor --analyze

# Output shows:
# - Average tokens per request: 2,847
# - Peak usage time: 10am-12pm
# - Limit hit frequency: 3x daily
# - Reset wait time: 2-3 hours

// Production-ready Claude 429 error solution
class ClaudeRateLimitHandler {
  constructor() {
    this.maxRetries = 5;
    this.baseDelay = 1000;
    this.maxDelay = 60000;
  }

  async makeRequest(requestData, attempt = 1) {
    try {
      const response = await fetch('https://api.anthropic.com/v1/messages', {
        method: 'POST',
        headers: {
          'x-api-key': process.env.CLAUDE_API_KEY,
          'anthropic-version': '2023-06-01',
          'content-type': 'application/json'
        },
        body: JSON.stringify(requestData)
      });

      // Handle 429 errors specifically
      if (response.status === 429) {
        if (attempt <= this.maxRetries) {
          // Check for retry-after header
          const retryAfter = response.headers.get('retry-after');
          
          // Calculate delay with exponential backoff + jitter
          const exponentialDelay = Math.min(
            this.baseDelay * Math.pow(2, attempt - 1),
            this.maxDelay
          );
          
          // Add 10% jitter to prevent thundering herd
          const jitter = exponentialDelay * 0.1 * Math.random();
          const totalDelay = retryAfter 
            ? parseInt(retryAfter) * 1000
            : exponentialDelay + jitter;
          
          console.log(`429 error - retrying in ${totalDelay}ms`);
          await this.sleep(totalDelay);
          return this.makeRequest(requestData, attempt + 1);
        }
        throw new Error('Max retries exceeded for 429 errors');
      }
      
      return await response.json();
    } catch (error) {
      console.error('Request failed:', error);
      throw error;
    }
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage:
const handler = new ClaudeRateLimitHandler();
const response = await handler.makeRequest(yourRequest);

# Claude usage limits optimization with caching
import anthropic

client = anthropic.Anthropic()

def optimize_claude_usage(task_type, prompt):
    """Reduce usage limits impact by 60-70%"""
    
    # Model selection based on task complexity
    if task_type == 'simple':
        # Use Haiku - 50% fewer tokens
        model = "claude-3-haiku-20240307"
        max_tokens = 512
    elif task_type == 'moderate':
        # Use Sonnet - balanced performance
        model = "claude-3-5-sonnet-20241022"
        max_tokens = 1024
    else:
        # Reserve Opus only for critical tasks
        model = "claude-3-opus-20240229"
        max_tokens = 2048
    
    # Implement prompt caching for 90% token savings
    response = client.messages.create(
        model=model,
        max_tokens=max_tokens,
        system=[
            {
                "type": "text",
                "text": "You are a helpful assistant.",
                "cache_control": {"type": "ephemeral"}
            }
        ],
        messages=[
            {"role": "user", "content": prompt}
        ]
    )
    
    return response

# Token reduction techniques:
# 1. Use /compact to reduce context by 30-50%
# 2. Clear conversation with /clear for new topics
# 3. Bundle multiple questions in single messages
# 4. Avoid re-uploading files - Claude retains context

// Advanced Claude API rate limit handling
class TokenBucketRateLimiter {
  constructor(options = {}) {
    this.bucketSize = options.bucketSize || 50; // Tier 1: 50 RPM
    this.refillRate = options.refillRate || 50/60; // tokens per second
    this.tokens = this.bucketSize;
    this.lastRefill = Date.now();
    
    // Circuit breaker configuration
    this.failureThreshold = 5;
    this.failureCount = 0;
    this.circuitState = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.nextAttempt = 0;
  }

  async executeRequest(requestFn) {
    // Check circuit breaker
    if (this.circuitState === 'OPEN') {
      if (Date.now() < this.nextAttempt) {
        throw new Error('Circuit breaker is OPEN - too many failures');
      }
      this.circuitState = 'HALF_OPEN';
    }

    // Refill tokens based on time elapsed
    this.refillTokens();
    
    // Check if tokens available
    if (this.tokens < 1) {
      const waitTime = (1 - this.tokens) / this.refillRate * 1000;
      console.log(`Rate limited - waiting ${waitTime}ms`);
      await this.sleep(waitTime);
      this.refillTokens();
    }
    
    // Consume token and execute
    this.tokens--;
    
    try {
      const result = await requestFn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure(error);
      throw error;
    }
  }

  refillTokens() {
    const now = Date.now();
    const timePassed = (now - this.lastRefill) / 1000;
    const tokensToAdd = timePassed * this.refillRate;
    
    this.tokens = Math.min(this.bucketSize, this.tokens + tokensToAdd);
    this.lastRefill = now;
  }

  onSuccess() {
    this.failureCount = 0;
    if (this.circuitState === 'HALF_OPEN') {
      this.circuitState = 'CLOSED';
    }
  }

  onFailure(error) {
    if (error.status === 429) {
      this.failureCount++;
      
      if (this.failureCount >= this.failureThreshold) {
        this.circuitState = 'OPEN';
        this.nextAttempt = Date.now() + 30000; // 30 second cooldown
        console.log('Circuit breaker OPENED due to repeated 429 errors');
      }
    }
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage for API rate limit handling:
const limiter = new TokenBucketRateLimiter({
  bucketSize: 50,  // Adjust based on your API tier
  refillRate: 50/60 // 50 requests per minute
});

const response = await limiter.executeRequest(async () => {
  return await makeClaudeAPICall(request);
});