Exchange API Rate Limit 처리 완전 가이드: HolySheep AI 게이트웨이 활용법

AI API를 활용한 프로덕션 환경에서 가장 흔하게遭遇하는 문제가 바로 Rate Limit이다. 429 Too Many Requests 에러는 개발자를 좌절시키지만, 이를 체계적으로 처리하지 않으면 서비스 가용성에 치명적 영향을 미친다. 이 튜토리얼에서는 HolySheep AI를 활용한 실전 Rate Limit 처리 전략과 마이그레이션 경험을 공유한다.

사례 연구: 서울의 AI 챗봇 스타트업

비즈니스 맥락

서울 성수동에 위치한 한 AI 챗봇 스타트업(가칭: 솔루션에이아이)은 호텔 예약 상담을 자동화하는 SaaS를 운영하고 있다. 하루 평균 50,000건의 API 호출을 처리하며, 기존에 단일 AI 공급자를 이용했다.

기존 공급자의 페인포인트

솔루션에이아이는 기존 공급자의 제한된 Rate Limit으로 인해 심각한 문제에 직면했다. 비즈니스 피크 타임인 주말 오후에 429 에러가 집중적으로 발생했고, 사용자들은 응답 없음 현상을 경험했다. 내부 모니터링 결과, API 응답 지연이 평균 420ms에 달했으며, 월 청구 금액은 $4,200을 초과했다.

HolySheep AI 선택 이유

솔루션에이아이가 HolySheep AI를 선택한 이유는 명확하다:

• 다중 모델 통합: 단일 API 키로 GPT-4.1, Claude Sonnet, Gemini, DeepSeek 등 모든 주요 모델 접근
• 비용 최적화: GPT-4.1 $8/MTok, Claude Sonnet 4.5 $15/MTok, Gemini 2.5 Flash $2.50/MTok, DeepSeek V3.2 $0.42/MTok
• 안정적인 Rate Limit: 게이트웨이 레벨에서 지능형 트래픽 분산
• 로컬 결제 지원: 해외 신용카드 없이 개발자 친화적 결제

마이그레이션 단계

1단계: base_url 교체

기존 코드의 base_url을 HolySheep AI 게이트웨이로 변경한다. 모든 모델 요청이 단일 엔드포인트를 통과하므로 Rate Limit 관리가 한 층 더 수월해진다.

2단계: API 키 로테이션

새로운 HolySheep AI API 키를 발급받고 환경 변수에 안전하게 저장한다. 키 로테이션은 매주 자동화 스크립트로 수행되도록 설정했다.

3단계: 카나리아 배포

전체 트래픽의 10%부터 시작하여 24시간마다 20%씩 증가시키는 카나리아 배포를 진행했다. 이를 통해 피크 타임에 발생할 수 있는 문제를 사전에 탐지했다.

마이그레이션 후 30일 실측치

Rate Limit 처리 아키텍처 설계

폴백 전략: 다중 공급자Fallback

Rate Limit에 도달했을 때 단일 공급자에 의존하면 서비스가 완전히瘫痪할 수 있다. HolySheep AI의 다중 모델 통합 기능을 활용하면 주요 모델들의 Rate Limit을 조합하여 가용성을 극대화할 수 있다.

// 다중 모델 폴백 전략 구현
const axios = require('axios');

class MultiModelFallback {
  constructor() {
    this.providers = [
      {
        name: 'deepseek',
        baseURL: 'https://api.holysheep.ai/v1',
        priority: 1,
        rpm: 2000,
        tpm: 4000000
      },
      {
        name: 'gemini',
        baseURL: 'https://api.holysheep.ai/v1',
        priority: 2,
        rpm: 1500,
        tpm: 1000000
      },
      {
        name: 'claude',
        baseURL: 'https://api.holysheep.ai/v1',
        priority: 3,
        rpm: 1000,
        tpm: 2000000
      }
    ];
    this.currentIndex = 0;
    this.requestCounts = new Map();
    this.tokenCounts = new Map();
  }

  async callWithFallback(messages, estimatedTokens) {
    const startTime = Date.now();
    
    for (let i = 0; i < this.providers.length; i++) {
      const provider = this.providers[(this.currentIndex + i) % this.providers.length];
      
      if (this.isRateLimited(provider, estimatedTokens)) {
        console.log(${provider.name} Rate Limit 도달, 다음 공급자로 전환);
        continue;
      }
      
      try {
        const result = await this.makeRequest(provider, messages);
        this.recordSuccess(provider, estimatedTokens);
        return result;
      } catch (error) {
        if (error.response?.status === 429) {
          console.log(${provider.name} 429 에러, 폴백 시도);
          this.recordFailure(provider);
          continue;
        }
        throw error;
      }
    }
    
    throw new Error('모든 공급자 Rate Limit 도달');
  }

  async makeRequest(provider, messages) {
    const response = await axios.post(
      ${provider.baseURL}/chat/completions,
      {
        model: this.getModelForProvider(provider.name),
        messages: messages,
        max_tokens: 2048,
        temperature: 0.7
      },
      {
        headers: {
          'Authorization': Bearer ${process.env.YOUR_HOLYSHEEP_API_KEY},
          'Content-Type': 'application/json'
        },
        timeout: 30000
      }
    );
    
    return response.data;
  }

  getModelForProvider(providerName) {
    const models = {
      deepseek: 'deepseek-chat',
      gemini: 'gemini-2.5-flash',
      claude: 'claude-sonnet-4-20250514'
    };
    return models[providerName];
  }

  isRateLimited(provider, tokens) {
    const now = Date.now();
    const rpmKey = ${provider.name}_rpm;
    const tpmKey = ${provider.name}_tpm;
    
    // 1분 윈도우 정리
    if (this.requestCounts.has(rpmKey)) {
      const data = this.requestCounts.get(rpmKey);
      if (now - data.timestamp > 60000) {
        this.requestCounts.delete(rpmKey);
      }
    }
    
    // 토큰 카운터 정리
    if (this.tokenCounts.has(tpmKey)) {
      const data = this.tokenCounts.get(tpmKey);
      if (now - data.timestamp > 60000) {
        this.tokenCounts.delete(tpmKey);
      }
    }
    
    const currentRPM = this.requestCounts.get(rpmKey)?.count || 0;
    const currentTPM = this.tokenCounts.get(tpmKey)?.count || 0;
    
    return currentRPM >= provider.rpm || currentTPM + tokens >= provider.tpm;
  }

  recordSuccess(provider, tokens) {
    const now = Date.now();
    const rpmKey = ${provider.name}_rpm;
    const tpmKey = ${provider.name}_tpm;
    
    // RPM 업데이트
    if (this.requestCounts.has(rpmKey)) {
      const data = this.requestCounts.get(rpmKey);
      data.count++;
    } else {
      this.requestCounts.set(rpmKey, { count: 1, timestamp: now });
    }
    
    // TPM 업데이트
    if (this.tokenCounts.has(tpmKey)) {
      const data = this.tokenCounts.get(tpmKey);
      data.count += tokens;
    } else {
      this.tokenCounts.set(tpmKey, { count: tokens, timestamp: now });
    }
  }

  recordFailure(provider) {
    this.currentIndex = (this.currentIndex + 1) % this.providers.length;
  }
}

module.exports = MultiModelFallback;

지수 백오프 (Exponential Backoff)

Rate Limit 에러 발생 시 단순 재시도는 효과적이지 않다. 지수 백오프를 구현하면 서버 부하를 줄이면서 성공 확률을 높일 수 있다.

// 지수 백오프 및 재시도 로직
const axios = require('axios');

class ResilientAPI {
  constructor() {
    this.maxRetries = 5;
    this.baseDelay = 1000; // 1초
    this.maxDelay = 32000; // 32초
    this.baseURL = 'https://api.holysheep.ai/v1';
  }

  async executeWithRetry(messages, options = {}) {
    const {
      model = 'deepseek-chat',
      temperature = 0.7,
      maxTokens = 2048,
      onRetry = null
    } = options;

    let lastError;
    
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        const response = await this.makeRequest(messages, {
          model,
          temperature,
          max_tokens: maxTokens
        });
        
        return {
          success: true,
          data: response.data,
          attempts: attempt + 1,
          latency: response.latency
        };
        
      } catch (error) {
        lastError = error;
        
        if (error.response?.status === 429) {
          const retryAfter = error.response?.headers?.['retry-after'];
          const delay = retryAfter 
            ? parseInt(retryAfter) * 1000 
            : this.calculateBackoff(attempt);
          
          console.log(Rate Limit 도달: ${delay}ms 대기 후 재시도 (${attempt + 1}/${this.maxRetries}));
          
          if (onRetry) {
            onRetry({
              attempt: attempt + 1,
              delay,
              maxRetries: this.maxRetries,
              error: 'Rate Limit'
            });
          }
          
          await this.sleep(delay);
          continue;
        }
        
        // 5xx 서버 에러만 재시도
        if (error.response?.status >= 500) {
          const delay = this.calculateBackoff(attempt);
          console.log(서버 에러 (${error.response.status}): ${delay}ms 대기 후 재시도);
          await this.sleep(delay);
          continue;
        }
        
        // 4xx (Rate Limit 제외)는 재시도하지 않음
        throw error;
      }
    }
    
    return {
      success: false,
      error: lastError.message,
      attempts: this.maxRetries
    };
  }

  async makeRequest(messages, params) {
    const startTime = Date.now();
    
    const response = await axios.post(
      ${this.baseURL}/chat/completions,
      {
        model: params.model,
        messages: messages,
        max_tokens: params.max_tokens,
        temperature: params.temperature
      },
      {
        headers: {
          'Authorization': Bearer ${process.env.YOUR_HOLYSHEEP_API_KEY},
          'Content-Type': 'application/json'
        },
        timeout: 60000
      }
    );
    
    return {
      data: response.data,
      latency: Date.now() - startTime
    };
  }

  calculateBackoff(attempt) {
    // 지수 백오프: 1초, 2초, 4초, 8초, 16초...
    // 최대 32초
    const delay = Math.min(
      this.baseDelay * Math.pow(2, attempt),
      this.maxDelay
    );
    
    // 제이itter 추가 (0.5초 ~ 1초 랜덤)
    const jitter = Math.random() * 500 + 500;
    
    return Math.floor(delay + jitter);
  }

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

// 사용 예시
async function main() {
  const api = new ResilientAPI();
  
  const messages = [
    { role: 'system', content: '당신은 도움이 되는 어시스턴트입니다.' },
    { role: 'user', content: '서울의 유명한 관광 명소를 추천해 주세요.' }
  ];
  
  const result = await api.executeWithRetry(messages, {
    model: 'gemini-2.5-flash',
    temperature: 0.8,
    maxTokens: 1000,
    onRetry: (info) => {
      console.log([재시도 콜백] ${info.attempt}/${info.maxRetries}차 시도, ${info.delay}ms 대기);
    }
  });
  
  if (result.success) {
    console.log(성공: ${result.attempts}회 시도, ${result.latency}ms 소요);
    console.log(result.data.choices[0].message.content);
  } else {
    console.error(실패: ${result.error});
  }
}

module.exports = ResilientAPI;

Rate Limit 모니터링 및 알림 시스템

실시간 메트릭 수집

Rate Limit을 효과적으로 관리하려면 실시간 모니터링이 필수적이다. HolySheep AI의 응답 헤더를 활용하면 현재 사용량을 추적할 수 있다.

// Rate Limit 모니터링 미들웨어
const axios = require('axios');
const { EventEmitter } = require('events');

class RateLimitMonitor extends EventEmitter {
  constructor() {
    super();
    this.baseURL = 'https://api.holysheep.ai/v1';
    this.metrics = {
      requests: { total: 0, success: 0, rateLimited: 0, errors: 0 },
      tokens: { input: 0, output: 0, total: 0 },
      latency: { sum: 0, count: 0, p50: [], p95: [], p99: [] },
      rateLimits: new Map()
    };
  }

  async trackRequest(requestFn) {
    const startTime = Date.now();
    this.metrics.requests.total++;
    
    try {
      const result = await requestFn();
      const latency = Date.now() - startTime;
      
      this.metrics.requests.success++;
      this.metrics.latency.sum += latency;
      this.metrics.latency.count++;
      
      this.updateLatencyPercentiles(latency);
      this.updateTokenMetrics(result);
      
      return result;
      
    } catch (error) {
      if (error.response?.status === 429) {
        this.metrics.requests.rateLimited++;
        this.updateRateLimitInfo(error.response.headers);
        
        this.emit('rateLimit', {
          remaining: error.response.headers['x-ratelimit-remaining'],
          reset: error.response.headers['x-ratelimit-reset'],
          retryAfter: error.response.headers['retry-after']
        });
      } else {
        this.metrics.requests.errors++;
      }
      
      throw error;
    }
  }

  updateRateLimitInfo(headers) {
    const limit = headers['x-ratelimit-limit'];
    const remaining = headers['x-ratelimit-remaining'];
    const reset = headers['x-ratelimit-reset'];
    const model = headers['x-ratelimit-model'];
    
    if (limit !== undefined) {
      this.metrics.rateLimits.set(model || 'default', {
        limit: parseInt(limit),
        remaining: parseInt(remaining),
        reset: parseInt(reset),
        usagePercent: ((parseInt(limit) - parseInt(remaining)) / parseInt(limit)) * 100,
        updatedAt: Date.now()
      });
      
      // 80% 이상 사용 시 경고
      const usagePercent = ((parseInt(limit) - parseInt(remaining)) / parseInt(limit)) * 100;
      if (usagePercent >= 80) {
        this.emit('rateLimitWarning', {
          model: model || 'default',
          usagePercent,
          remaining: parseInt(remaining)
        });
      }
    }
  }

  updateLatencyPercentiles(latency) {
    this.metrics.latency.p50.push(latency);
    this.metrics.latency.p95.push(latency);
    this.metrics.latency.p99.push(latency);
    
    // 100개 샘플만 유지
    if (this.metrics.latency.p50.length > 100) {
      this.metrics.latency.p50.shift();
      this.metrics.latency.p95.shift();
      this.metrics.latency.p99.shift();
    }
  }

  updateTokenMetrics(result) {
    if (result.usage) {
      this.metrics.tokens.input += result.usage.prompt_tokens || 0;
      this.metrics.tokens.output += result.usage.completion_tokens || 0;
      this.metrics.tokens.total += (result.usage.prompt_tokens || 0) + (result.usage.completion_tokens || 0);
    }
  }

  getMetrics() {
    const avgLatency = this.metrics.latency.count > 0 
      ? Math.round(this.metrics.latency.sum / this.metrics.latency.count)
      : 0;
    
    const sortedP50 = [...this.metrics.latency.p50].sort((a, b) => a - b);
    const p50Latency = sortedP50[Math.floor(sortedP50.length * 0.5)] || 0;
    
    const sortedP95 = [...this.metrics.latency.p95].sort((a, b) => a - b);
    const p95Latency = sortedP95[Math.floor(sortedP95.length * 0.95)] || 0;
    
    const sortedP99 = [...this.metrics.latency.p99].sort((a, b) => a - b);
    const p99Latency = sortedP99[Math.floor(sortedP99.length * 0.99)] || 0;
    
    return {
      requests: this.metrics.requests,
      tokens: this.metrics.tokens,
      latency: {
        average: avgLatency,
        p50: p50Latency,
        p95: p95Latency,
        p99: p99Latency
      },
      rateLimits: Object.fromEntries(this.metrics.rateLimits),
      timestamp: new Date().toISOString()
    };
  }

  getHealthScore() {
    const total = this.metrics.requests.total;
    if (total === 0) return 100;
    
    const errorRate = (this.metrics.requests.rateLimited + this.metrics.requests.errors) / total;
    const latencyScore = Math.max(0, 100 - (this.metrics.latency.sum / this.metrics.latency.count / 10));
    
    return Math.round((1 - errorRate) * latencyScore);
  }
}

// 사용 예시
const monitor = new RateLimitMonitor();

monitor.on('rateLimit', (info) => {
  console.log('Rate Limit 도달:', info);
  // 슬랙, 텔레그램 등으로 알림 발송
});

monitor.on('rateLimitWarning', (info) => {
  console.warn(경고: ${info.model} Rate Limit ${info.usagePercent.toFixed(1)}% 사용 중);
});

// 30초마다 메트릭 출력
setInterval(() => {
  const metrics = monitor.getMetrics();
  console.log('\n=== Rate Limit 모니터링 ===');
  console.log(요청 성공률: ${(metrics.requests.success / metrics.requests.total * 100).toFixed(1)}%);
  console.log(Rate Limit 에러: ${metrics.requests.rateLimited}건);
  console.log(평균 지연: ${metrics.latency.average}ms);
  console.log(P95 지연: ${metrics.latency.p95}ms);
  console.log(`헬스 스코어: ${monitor.getHealthScore()}/100');
  console.log('==============================\n');
}, 30000);

Rate Limit 최적화 기법

요청 배치 처리

개별 요청 대신 배치로 처리하면 Rate Limit 호출 횟수를 줄이고 처리량을 늘릴 수 있다. HolySheep AI의 배치 처리 기능을 활용하면 비용도 절감된다.

캐싱 전략

반복되는 요청은 Redis나 Memcached를 활용하여 캐싱하면 API 호출 횟수를 획기적으로 줄일 수 있다. Embedding 기반 유사 검색으로 캐시 히트율을 높이는 방법도 효과적이다.

토큰 사용량 최적화

시스템 프롬프트를 최소화하고, 불필요한 컨텍스트를 제거하면 토큰 사용량을 줄일 수 있다. DeepSeek V3.2의 경우 $0.42/MTok으로 가장 경제적이므로 반복 작업에 적합하다.

자주 발생하는 오류와 해결책

1. 429 Too Many Requests 에러

증상: API 호출 시 429 상태 코드와 함께 "Rate limit exceeded" 메시지 반환

원인: RPM(Requests Per Minute) 또는 TPM(Tokens Per Minute) 제한 초과

해결 코드:

// 429 에러 핸들링 심화
async function handle429Error(error, retryCount = 0) {
  if (error.response?.status !== 429) {
    throw error;
  }
  
  const headers = error.response.headers;
  const retryAfter = headers['retry-after'];
  const xRateLimitRemaining = headers['x-ratelimit-remaining'];
  const xRateLimitReset = headers['x-ratelimit-reset'];
  
  // 명시적 retry-after가 있으면 그 값 사용
  let waitTime;
  if (retryAfter) {
    waitTime = parseInt(retryAfter) * 1000;
  } else if (xRateLimitReset) {
    // Unix timestamp에서 현재 시간 빼기
    waitTime = Math.max(0, parseInt(xRateLimitReset) * 1000 - Date.now());
  } else {
    // 기본값: 60초
    waitTime = 60000;
  }
  
  console.log(Rate Limit 도달);
  console.log(- 남은 호출 수: ${xRateLimitRemaining});
  console.log(- 다음 리셋: ${new Date(parseInt(xRateLimitReset) * 1000).toISOString()});
  console.log(- 대기 시간: ${waitTime}ms);
  
  if (retryCount >= 5) {
    throw new Error('최대 재시도 횟수 초과');
  }
  
  await sleep(waitTime);
  
  return true; // 재시도 가능
}

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

2. Request Timeout 에러

증상: API 호출이 타임아웃되어 응답을 받지 못함

원인: 네트워크 지연, 서버 과부하, 또는 요청 페이로드 과대

해결 코드:

// 타임아웃 및 장기 실행 요청 핸들링
const axios = require('axios');

async function robustRequest(messages, options = {}) {
  const {
    timeout = 120000, // 2분 기본 타임아웃
    model = 'gemini-2.5-flash',
    stream = false
  } = options;
  
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);
  
  try {
    const response = await axios.post(
      'https://api.holysheep.ai/v1/chat/completions',
      {
        model,
        messages,
        stream,
        max_tokens: 4096
      },
      {
        headers: {
          'Authorization': Bearer ${process.env.YOUR_HOLYSHEEP_API_KEY},
          'Content-Type': 'application/json'
        },
        signal: controller.signal
      }
    );
    
    return response.data;
    
  } catch (error) {
    if (axios.isCancel(error)) {
      console.error(요청 타임아웃: ${timeout}ms 초과);
      throw new Error('REQUEST_TIMEOUT');
    }
    
    if (error.code === 'ECONNABORTED') {
      console.error('네트워크 연결 시간 초과');
      throw new Error('CONNECTION_TIMEOUT');
    }
    
    throw error;
    
  } finally {
    clearTimeout(timeoutId);
  }
}

// 스트리밍 응답 처리 (긴 응답용)
async function streamingRequest(messages, onChunk) {
  const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': Bearer ${process.env.YOUR_HOLYSHEEP_API_KEY},
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'deepseek-chat',
      messages,
      stream: true,
      max_tokens: 8192
    })
  });
  
  if (!response.ok) {
    throw new Error(HTTP ${response.status});
  }
  
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';
  
  while (true) {
    const { done, value } = await reader.read();
    
    if (done) break;
    
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split('\n');
    buffer = lines.pop();
    
    for (const line of lines) {
      if (line.startsWith('data: ')) {
        const data = line.slice(6);
        if (data === '[DONE]') {
          return;
        }
        try {
          const parsed = JSON.parse(data);
          onChunk(parsed);
        } catch (e) {
          // 무시
        }
      }
    }
  }
}

// 토큰 제한 사전 검증 및 분할 처리
const axios = require('axios');

class TokenAwareProcessor {
  constructor() {
    this.modelLimits = {
      'gpt-4.1': { contextWindow: 128000, maxOutput: 16384 },
      'claude-sonnet-4-20250514': { contextWindow: 200000, maxOutput: 8192 },
      'gemini-2.5-flash': { contextWindow: 1000000, maxOutput: 8192 },
      'deepseek-chat': { contextWindow: 64000, maxOutput: 4096 }
    };
  }

  estimateTokens(text) {
    // 대략적인 토큰估算 (한글 기준 1토큰 ≈ 1.5글자)
    return Math.ceil(text.length / 1.5);
  }

  validateRequest(messages, model, maxTokens) {
    const limits = this.modelLimits[model] || this.modelLimits['deepseek-chat'];
    
    // 입력 토큰 합산
    const inputTokens = messages.reduce((sum, msg) => {
      return sum + this.estimateTokens(msg.content || '');
    }, 0);
    
    // 컨텍스트 윈도우 초과 체크
    if (inputTokens + maxTokens > limits.contextWindow) {
      return {
        valid: false,
        reason: 'CONTEXT_WINDOW_EXCEEDED',
        suggestion: 입력 토큰(${inputTokens}) + 요청 max_tokens(${maxTokens})가 컨텍스트 윈도우(${limits.contextWindow})를 초과합니다.
      };
    }
    
    // 출력 토큰 제한 체크
    if (maxTokens > limits.maxOutput) {
      return {
        valid: false,
        reason: 'MAX_OUTPUT_EXCEEDED',
        suggestion: max_tokens(${maxTokens})가 모델 최대 출력(${limits.maxOutput})을 초과합니다.
      };
    }
    
    return { valid: true, inputTokens, maxTokens };
  }

  // 긴 문서를 청크로 분할하여 처리
  async processLongContent(content, model, options = {}) {
    const { chunkSize = 3000, overlap = 200 } = options;
    const limits = this.modelLimits[model] || this.modelLimits['deepseek-chat'];
    
    const chunks = this.splitWithOverlap(content, chunkSize, overlap);
    const results = [];
    
    for (let i = 0; i < chunks.length; i++) {
      console.log(청크 ${i + 1}/${chunks.length} 처리 중...);
      
      const validation = this.validateRequest(
        [{ role: 'user', content: chunks[i] }],
        model,
        Math.min(limits.maxOutput, chunkSize)
      );
      
      if (!validation.valid) {
        console.warn(청크 ${i + 1} 검증 실패: ${validation.reason});
        continue;
      }
      
      try {
        const response = await axios.post(
          'https://api.holysheep.ai/v1/chat/completions',
          {
            model,
            messages: [{ role: 'user', content: chunks[i] }],
            max_tokens: limits.maxOutput
          },
          {
            headers: {
              'Authorization': Bearer ${process.env.YOUR_HOLYSHEEP_API_KEY},
              'Content-Type': 'application/json'
            },
            timeout: 60000
          }
        );
        
        results.push({
          chunkIndex: i,
          content: response.data.choices[0].message.content,
          usage: response.data.usage
        });
        
      } catch (error) {
        console.error(청크 ${i + 1} 처리 실패:, error.message);
      }
      
      // Rate Limit 방지 위한 딜레이
      if (i < chunks.length - 1) {
        await sleep(500);
      }
    }
    
    return results;
  }

  splitWithOverlap(text, chunkSize, overlap) {
    const chunks = [];
    let start = 0;
    
    while (start < text.length) {
      let end = start + chunkSize;
      
      // 단어 경계에서 분할
      if (end < text.length) {
        const spaceIndex = text.lastIndexOf(' ', end);
        if (spaceIndex > start + chunkSize / 2) {
          end = spaceIndex;
        }
      }
      
      chunks.push(text.slice(start, end));
      start = end - overlap;
    }
    
    return chunks;
  }
}

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

// 사용 예시
const processor = new TokenAwareProcessor();

const longContent = `
  매우 긴 문서 내용이 들어갑니다...
  여러 페이지에 걸친 내용을 처리해야 할 때 유용합니다.
`;

const validation = processor.validateRequest(
  [{ role: 'user', content: longContent }],
  'deepseek-chat',
  2048
);

console.log('검증 결과:', validation);