6장: 비용 관리와 최적화 아키텍처

interface TokenBudget {
  maxInputTokens: number;
  maxOutputTokens: number;
  periodMs: number;
  currentUsage: number;
}
 
interface BudgetConfig {
  request: TokenBudget;
  user: TokenBudget;
  system: TokenBudget;
}
 
class TokenBudgetManager {
  private store: Map<string, { usage: number; resetAt: number }> = new Map();
 
  async checkBudget(
    userId: string,
    estimatedTokens: number,
    config: BudgetConfig
  ): Promise<{ allowed: boolean; remainingBudget: number; suggestedModel?: string }> {
    // 요청 수준 검사
    if (estimatedTokens > config.request.maxInputTokens) {
      return {
        allowed: false,
        remainingBudget: 0,
        suggestedModel: undefined,
      };
    }
 
    // 사용자 수준 검사
    const userKey = `user:${userId}`;
    const userUsage = this.getUsage(userKey, config.user.periodMs);
 
    if (userUsage + estimatedTokens > config.user.maxInputTokens) {
      // 예산 초과 임박 시 경량 모델로 라우팅 제안
      const remaining = config.user.maxInputTokens - userUsage;
      return {
        allowed: remaining > 0,
        remainingBudget: remaining,
        suggestedModel: "haiku",
      };
    }
 
    // 시스템 수준 검사
    const systemUsage = this.getUsage("system:global", config.system.periodMs);
    if (systemUsage + estimatedTokens > config.system.maxInputTokens) {
      return {
        allowed: false,
        remainingBudget: 0,
        suggestedModel: undefined,
      };
    }
 
    return {
      allowed: true,
      remainingBudget: config.user.maxInputTokens - userUsage - estimatedTokens,
    };
  }
 
  recordUsage(userId: string, actualTokens: number): void {
    const userKey = `user:${userId}`;
    this.incrementUsage(userKey, actualTokens);
    this.incrementUsage("system:global", actualTokens);
  }
 
  private getUsage(key: string, periodMs: number): number {
    const entry = this.store.get(key);
    if (!entry || Date.now() > entry.resetAt) {
      return 0;
    }
    return entry.usage;
  }
 
  private incrementUsage(key: string, tokens: number): void {
    const entry = this.store.get(key);
    if (entry && Date.now() < entry.resetAt) {
      entry.usage += tokens;
    } else {
      this.store.set(key, {
        usage: tokens,
        resetAt: Date.now() + 86400000, // 24시간
      });
    }
  }
}

type ModelTier = "haiku" | "sonnet" | "opus";
 
interface RoutingDecision {
  model: ModelTier;
  reason: string;
  estimatedCostMultiplier: number;
}
 
interface RequestContext {
  taskType: string;
  inputLength: number;
  userTier: "free" | "pro" | "enterprise";
  qualityRequired: "low" | "medium" | "high";
  latencyBudgetMs: number;
}
 
function routeToModel(context: RequestContext): RoutingDecision {
  // 규칙 1: 짧은 입력 + 단순 작업 -> 경량 모델
  if (context.inputLength < 500 && isSimpleTask(context.taskType)) {
    return {
      model: "haiku",
      reason: "단순 작업, 경량 모델로 충분",
      estimatedCostMultiplier: 1,
    };
  }
 
  // 규칙 2: 높은 품질 요구 + 엔터프라이즈 -> 최상위 모델
  if (context.qualityRequired === "high" && context.userTier === "enterprise") {
    return {
      model: "opus",
      reason: "높은 품질 요구, 엔터프라이즈 등급",
      estimatedCostMultiplier: 60,
    };
  }
 
  // 규칙 3: 실시간 응답 필요 -> 경량 또는 중간 모델
  if (context.latencyBudgetMs < 2000) {
    return {
      model: "haiku",
      reason: "실시간 지연 시간 제약",
      estimatedCostMultiplier: 1,
    };
  }
 
  // 기본값: 중간 모델
  return {
    model: "sonnet",
    reason: "범용 작업, 중간 등급 모델",
    estimatedCostMultiplier: 12,
  };
}
 
function isSimpleTask(taskType: string): boolean {
  const simpleTasks = [
    "classification",
    "extraction",
    "sentiment",
    "translation",
    "summarization-short",
  ];
  return simpleTasks.includes(taskType);
}

interface CostAlert {
  type: "threshold" | "anomaly" | "budget-warning";
  severity: "info" | "warning" | "critical";
  message: string;
  currentCost: number;
  threshold: number;
}
 
function evaluateCostAlerts(
  dailyCost: number,
  monthlyBudget: number,
  historicalAvgDaily: number
): CostAlert[] {
  const alerts: CostAlert[] = [];
  const dayOfMonth = new Date().getDate();
  const projectedMonthlyCost = dailyCost * 30;
 
  // 일간 비용이 이력 평균의 2배 초과
  if (dailyCost > historicalAvgDaily * 2) {
    alerts.push({
      type: "anomaly",
      severity: "warning",
      message: `일간 비용이 평균 대비 ${Math.round((dailyCost / historicalAvgDaily) * 100)}% 수준입니다`,
      currentCost: dailyCost,
      threshold: historicalAvgDaily * 2,
    });
  }
 
  // 월간 예산의 80% 도달 경고
  const monthlyUsed = dailyCost * dayOfMonth;
  if (monthlyUsed > monthlyBudget * 0.8) {
    alerts.push({
      type: "budget-warning",
      severity: "critical",
      message: `월간 예산의 ${Math.round((monthlyUsed / monthlyBudget) * 100)}%를 사용했습니다`,
      currentCost: monthlyUsed,
      threshold: monthlyBudget,
    });
  }
 
  // 추정 월간 비용이 예산 초과 전망
  if (projectedMonthlyCost > monthlyBudget) {
    alerts.push({
      type: "threshold",
      severity: "warning",
      message: `현재 추세로 월 예산을 ${Math.round(((projectedMonthlyCost - monthlyBudget) / monthlyBudget) * 100)}% 초과할 것으로 예상됩니다`,
      currentCost: projectedMonthlyCost,
      threshold: monthlyBudget,
    });
  }
 
  return alerts;
}