ในฐานะวิศวกรที่ดูแลระบบ AI API ระดับ enterprise หลายคนคงเคยเจอปัญหา “เผลอใช้งานเกินงบประมาณเพราะ team ใด team หนึ่งยิง API มากเกินไป” หรือ “model ที่แพงทำให้ค่าใช้จ่ายพุ่งโดยไม่รู้ตัว” บทความนี้จะพาคุณสร้างระบบ HolySheep AI การจัดการโควต้า 3 มิติ ที่ควบคุมได้ละเอียดระดับ Business Unit, Project, และ Model พร้อม monthly settlement และ budget alert ที่ทำงานจริงใน production

ทำไมต้องมีระบบ Quota Governance

จากประสบการณ์ที่ดูแลระบบหลายร้อย million requests ต่อเดือน ผมพบว่า 70% ของปัญหาค่าใช้จ่าย AI API เกิดจาก 3 สาเหตุหลัก:

HolySheep AI มี native support สำหรับ quota management 3 มิติ ที่รวมอยู่ใน base plan ทำให้คุณสร้าง governance layer ได้โดยไม่ต้องพึ่งพา third-party tools

สถาปัตยกรรมระบบ Quota Governance 3 มิติ

แนวคิดพื้นฐาน

ระบบ quota 3 มิติทำงานเป็น hierarchical structure:

{
  "quota_hierarchy": {
    "level_1_business_unit": {
      "monthly_budget_usd": 10000,
      "owner": "ฝ่ายการเงิน",
      "children": {
        "level_2_project": {
          "monthly_budget_usd": 3000,
          "priority": "high",
          "children": {
            "level_3_model": {
              "models": {
                "gpt-4.1": { "rpm_limit": 100, "daily_budget_usd": 500 },
                "deepseek-v3.2": { "rpm_limit": 500, "daily_budget_usd": 200 },
                "gemini-2.5-flash": { "rpm_limit": 300, "daily_budget_usd": 150 }
              }
            }
          }
        }
      }
    }
  }
}

Business Logic ของ Rate Limiting

#!/usr/bin/env python3
"""
HolySheep AI Quota Governance System
Production-ready 3-tier rate limiting: BU -> Project -> Model
Author: HolySheep AI Technical Team
"""

import time
import asyncio
import httpx
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from enum import Enum
from collections import defaultdict
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


============ Configuration ============

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # เปลี่ยนเป็น API key จริงของคุณ


Model pricing per 1M tokens (USD)

MODEL_PRICING = {
    "gpt-4.1": {"input": 2.0, "output": 6.0},  # $8/MTok total
    "claude-sonnet-4.5": {"input": 3.0, "output": 12.0},  # $15/MTok total
    "gemini-2.5-flash": {"input": 0.10, "output": 0.40},  # $2.50/MTok total
    "deepseek-v3.2": {"input": 0.07, "output": 0.35},  # $0.42/MTok total
}


Model rate limits (requests per minute)

MODEL_RPM = {
    "gpt-4.1": 100,
    "claude-sonnet-4.5": 80,
    "gemini-2.5-flash": 500,
    "deepseek-v3.2": 1000,
}

class QuotaTier(Enum):
    """ระดับ quota hierarchy"""
    BU = 1
    PROJECT = 2
    MODEL = 3

@dataclass
class QuotaConfig:
    """Configuration สำหรับ quota ของแต่ละ tier"""
    name: str
    monthly_budget_usd: float
    daily_budget_usd: float
    rpm_limit: int
    tier: QuotaTier
    
    # Trackers
    current_month_spend: float = 0.0
    current_day_spend: float = 0.0
    request_count_minute: int = 0
    minute_reset_time: float = 0.0

class QuotaExceededException(Exception):
    """Exception เมื่อ quota ถูกใช้หมด"""
    def __init__(self, tier: QuotaTier, quota_name: str, reason: str):
        self.tier = tier
        self.quota_name = quota_name
        self.reason = reason
        super().__init__(f"Quota exceeded at {tier.name} level '{quota_name}': {reason}")

class HolySheepQuotaManager:
    """
    HolySheep AI Quota Governance Manager
    จัดการ rate limiting 3 มิติ: BU -> Project -> Model
    """
    
    def __init__(self, api_key: str = HOLYSHEEP_API_KEY):
        self.api_key = api_key
        self.quotas: Dict[str, QuotaConfig] = {}
        self.hierarchy: Dict[str, List[str]] = defaultdict(list)
        self._init_default_quotas()
    
    def _init_default_quotas(self):
        """Initialize default quota structure"""
        
        # Level 1: Business Units
        self.add_quota("BU_FINANCE", QuotaConfig(
            name="BU_FINANCE",
            monthly_budget_usd=10000,
            daily_budget_usd=500,
            rpm_limit=200,
            tier=QuotaTier.BU
        ))
        
        self.add_quota("BU_MARKETING", QuotaConfig(
            name="BU_MARKETING",
            monthly_budget_usd=5000,
            daily_budget_usd=250,
            rpm_limit=150,
            tier=QuotaTier.BU
        ))
        
        self.add_quota("BU_AI_RESEARCH", QuotaConfig(
            name="BU_AI_RESEARCH",
            monthly_budget_usd=15000,
            daily_budget_usd=750,
            rpm_limit=300,
            tier=QuotaTier.BU
        ))
        
        # Level 2: Projects (children of BU)
        self.add_quota("BU_FINANCE/REPORT_GEN", QuotaConfig(
            name="BU_FINANCE/REPORT_GEN",
            monthly_budget_usd=3000,
            daily_budget_usd=150,
            rpm_limit=100,
            tier=QuotaTier.PROJECT
        ))
        self.hierarchy["BU_FINANCE"].append("BU_FINANCE/REPORT_GEN")
        
        self.add_quota("BU_AI_RESEARCH/EXPERIMENTAL", QuotaConfig(
            name="BU_AI_RESEARCH/EXPERIMENTAL",
            monthly_budget_usd=5000,
            daily_budget_usd=300,
            rpm_limit=200,
            tier=QuotaTier.PROJECT
        ))
        self.hierarchy["BU_AI_RESEARCH"].append("BU_AI_RESEARCH/EXPERIMENTAL")
        
        # Level 3: Model quotas
        for model, price in MODEL_PRICING.items():
            model_quota_name = f"MODEL_{model.upper().replace('-', '_')}"
            daily_budget = 200 if "4.1" in model or "sonnet" in model else 100
            self.add_quota(model_quota_name, QuotaConfig(
                name=model_quota_name,
                monthly_budget_usd=daily_budget * 30,
                daily_budget_usd=daily_budget,
                rpm_limit=MODEL_RPM.get(model, 100),
                tier=QuotaTier.MODEL
            ))
    
    def add_quota(self, name: str, config: QuotaConfig):
        """เพิ่ม quota ใหม่"""
        self.quotas[name] = config
        logger.info(f"Added quota: {name} - ${config.monthly_budget_usd}/month, "
                   f"${config.daily_budget_usd}/day, {config.rpm_limit} RPM")
    
    def _check_rate_limit(self, quota: QuotaConfig) -> bool:
        """ตรวจสอบ rate limit รายนาที"""
        current_time = time.time()
        
        # Reset counter if minute has passed
        if current_time - quota.minute_reset_time >= 60:
            quota.request_count_minute = 0
            quota.minute_reset_time = current_time
        
        if quota.request_count_minute >= quota.rpm_limit:
            return False
        
        quota.request_count_minute += 1
        return True
    
    def _check_budget(self, quota: QuotaConfig, estimated_cost: float) -> bool:
        """ตรวจสอบ budget รายวันและรายเดือน"""
        if quota.current_day_spend + estimated_cost > quota.daily_budget_usd:
            logger.warning(f"Daily budget exceeded for {quota.name}: "
                         f"${quota.current_day_spend + estimated_cost:.2f} > ${quota.daily_budget_usd:.2f}")
            return False
        
        if quota.current_month_spend + estimated_cost > quota.monthly_budget_usd:
            logger.warning(f"Monthly budget exceeded for {quota.name}: "
                         f"${quota.current_month_spend + estimated_cost:.2f} > ${quota.monthly_budget_usd:.2f}")
            return False
        
        return True
    
    def _get_ancestor_quotas(self, quota_name: str) -> List[QuotaConfig]:
        """ดึง quota ของ ancestor tiers"""
        ancestors = []
        parts = quota_name.split("/")
        
        # Add BU level
        if parts[0] in self.quotas:
            ancestors.append(self.quotas[parts[0]])
        
        # Add Project level if exists
        if len(parts) >= 2:
            parent_name = "/".join(parts[:2])
            if parent_name in self.quotas:
                ancestors.append(self.quotas[parent_name])
        
        return ancestors
    
    def check_quota(self, project_name: str, model: str, estimated_tokens: int) -> bool:
        """
        ตรวจสอบ quota ทั้ง 3 tier
        Returns: True ถ้าผ่านทุก tier
        """
        model_key = f"MODEL_{model.upper().replace('-', '_')}"
        quota_key = f"{project_name}/{model_key}"
        
        # Calculate estimated cost
        input_tokens = estimated_tokens * 0.7  # 70% input
        output_tokens = estimated_tokens * 0.3  # 30% output
        price = MODEL_PRICING.get(model, MODEL_PRICING["deepseek-v3.2"])
        estimated_cost = (input_tokens / 1_000_000 * price["input"] + 
                         output_tokens / 1_000_000 * price["output"])
        
        # Check model-level quota
        if model_key in self.quotas:
            model_quota = self.quotas[model_key]
            if not self._check_rate_limit(model_quota):
                raise QuotaExceededException(
                    QuotaTier.MODEL, model_quota.name,
                    f"Rate limit: {model_quota.rpm_limit} RPM"
                )
            if not self._check_budget(model_quota, estimated_cost):
                raise QuotaExceededException(
                    QuotaTier.MODEL, model_quota.name,
                    f"Budget exceeded"
                )
        
        # Check project-level and BU-level quotas
        ancestors = self._get_ancestor_quotas(project_name)
        for ancestor in ancestors:
            if not self._check_rate_limit(ancestor):
                raise QuotaExceededException(
                    ancestor.tier, ancestor.name,
                    f"Rate limit exceeded"
                )
            if not self._check_budget(ancestor, estimated_cost):
                raise QuotaExceededException(
                    ancestor.tier, ancestor.name,
                    f"Budget exceeded"
                )
        
        return True
    
    def update_spend(self, quota_name: str, actual_cost: float):
        """อัพเดท spend tracker"""
        if quota_name in self.quotas:
            quota = self.quotas[quota_name]
            quota.current_day_spend += actual_cost
            quota.current_month_spend += actual_cost
    
    def get_quota_status(self) -> Dict:
        """ดึงสถานะ quota ทั้งหมด"""
        status = {}
        for name, quota in self.quotas.items():
            status[name] = {
                "monthly_used_usd": quota.current_month_spend,
                "monthly_budget_usd": quota.monthly_budget_usd,
                "monthly_pct": (quota.current_month_spend / quota.monthly_budget_usd * 100) if quota.monthly_budget_usd > 0 else 0,
                "daily_used_usd": quota.current_day_spend,
                "daily_budget_usd": quota.daily_budget_usd,
                "daily_pct": (quota.current_day_spend / quota.daily_budget_usd * 100) if quota.daily_budget_usd > 0 else 0,
                "rpm_current": quota.request_count_minute,
                "rpm_limit": quota.rpm_limit,
                "tier": quota.tier.name
            }
        return status
    
    async def call_holysheep_api(self, project_name: str, model: str, 
                                  prompt: str, max_tokens: int = 1000) -> Dict:
        """
        เรียก HolySheep AI API พร้อม quota check
        """
        estimated_tokens = max_tokens + len(prompt.split())
        
        # Check quota before calling
        self.check_quota(project_name, model, estimated_tokens)
        
        # Prepare request
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": max_tokens,
            "temperature": 0.7
        }
        
        # Call HolySheep API
        async with httpx.AsyncClient(timeout=30.0) as client:
            response = await client.post(
                f"{HOLYSHEEP_BASE_URL}/chat/completions",
                headers=headers,
                json=payload
            )
            response.raise_for_status()
            result = response.json()
            
            # Calculate actual cost
            usage = result.get("usage", {})
            input_tokens = usage.get("prompt_tokens", 0)
            output_tokens = usage.get("completion_tokens", 0)
            total_tokens = usage.get("total_tokens", input_tokens + output_tokens)
            
            price = MODEL_PRICING.get(model, MODEL_PRICING["deepseek-v3.2"])
            actual_cost = (input_tokens / 1_000_000 * price["input"] + 
                          output_tokens / 1_000_000 * price["output"])
            
            # Update spend tracking
            model_key = f"MODEL_{model.upper().replace('-', '_')}"
            self.update_spend(model_key, actual_cost)
            self.update_spend(f"{project_name}/{model_key}", actual_cost)
            
            # Update parent quotas
            ancestors = self._get_ancestor_quotas(project_name)
            for ancestor in ancestors:
                self.update_spend(ancestor.name, actual_cost)
            
            return {
                "response": result,
                "tokens_used": total_tokens,
                "cost_usd": actual_cost,
                "quota_remaining": self.get_quota_status()
            }


============ Usage Example ============

async def main():
    """ตัวอย่างการใช้งาน"""
    manager = HolySheepQuotaManager()
    
    try:
        # เรียก API ผ่าน Quota Manager
        result = await manager.call_holysheep_api(
            project_name="BU_FINANCE",
            model="deepseek-v3.2",  # ใช้ model ราคาถูกสำหรับงานทั่วไป
            prompt="สรุปรายงานการเงินประจำเดือนนี้",
            max_tokens=500
        )
        
        print(f"✅ Success! Tokens: {result['tokens_used']}, Cost: ${result['cost_usd']:.4f}")
        
        # แสดงสถานะ quota
        status = manager.get_quota_status()
        print("\n📊 Quota Status:")
        for name, info in status.items():
            if info["monthly_pct"] > 50:  # แสดงเฉพาะ quota ที่ใช้เกิน 50%
                print(f"  {name}: {info['monthly_pct']:.1f}% ({info['monthly_used_usd']:.2f}/{info['monthly_budget_usd']:.2f})")
                
    except QuotaExceededException as e:
        print(f"❌ Quota Exceeded: {e}")
        # ส่ง alert หรือ fallback ที่นี่

if __name__ == "__main__":
    asyncio.run(main())

Monthly Settlement และ Budget Alert System

ระบบ settlement ที่ดีต้องสามารถ track ค่าใช้จ่ายแบบ real-time และส่ง alert ก่อนที่จะเกินงบประมาณ โค้ดด้านล่างแสดงการสร้าง settlement dashboard และ alert system ที่ทำงานร่วมกับ HolySheep AI API

#!/usr/bin/env python3
"""
HolySheep AI Monthly Settlement & Budget Alert System
Real-time tracking with multi-channel alerts
"""

import asyncio
import httpx
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import List, Dict, Callable
import json
import logging
from collections import defaultdict

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"


Pricing configuration

MODEL_PRICING = {
    "gpt-4.1": {"input": 2.0, "output": 6.0},
    "claude-sonnet-4.5": {"input": 3.0, "output": 12.0},
    "gemini-2.5-flash": {"input": 0.10, "output": 0.40},
    "deepseek-v3.2": {"input": 0.07, "output": 0.35},
}

@dataclass
class BudgetThreshold:
    """Alert threshold configuration"""
    warning_pct: float  # เตือนเมื่อถึง % ของ budget
    critical_pct: float  # Critical alert เมื่อถึง %
    emergency_pct: float  # หยุดการใช้งานเมื่อถึง %

@dataclass
class SettlementRecord:
    """บันทึกการใช้งานแต่ละครั้ง"""
    timestamp: datetime
    project: str
    model: str
    input_tokens: int
    output_tokens: int
    cost_usd: float
    bu_name: str

class AlertChannel:
    """Abstract alert channel"""
    async def send(self, title: str, message: str, severity: str):
        raise NotImplementedError

class SlackAlertChannel(AlertChannel):
    def __init__(self, webhook_url: str):
        self.webhook_url = webhook_url
    
    async def send(self, title: str, message: str, severity: str):
        color = {"warning": "warning", "critical": "danger", "emergency": "danger"}.get(severity, "good")
        payload = {
            "attachments": [{
                "color": color,
                "title": title,
                "text": message,
                "footer": f"HolySheep AI • {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
            }]
        }
        async with httpx.AsyncClient() as client:
            await client.post(self.webhook_url, json=payload)
            logger.info(f"Slack alert sent: {title}")

class EmailAlertChannel(AlertChannel):
    def __init__(self, smtp_config: Dict, recipients: List[str]):
        self.smtp_config = smtp_config
        self.recipients = recipients
    
    async def send(self, title: str, message: str, severity: str):
        # ใช้ aiosmtplib หรือ smtplib สำหรับส่ง email
        logger.info(f"Email alert to {self.recipients}: {title}")
        # Implementation จริงจะใช้ aiosmtplib

class HolySheepSettlementManager:
    """
    ระบบจัดการ Settlement และ Budget Alert
    """
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.settlement_records: List[SettlementRecord] = []
        self.alert_channels: List[AlertChannel] = []
        
        # Default thresholds
        self.thresholds: Dict[str, BudgetThreshold] = {
            "default": BudgetThreshold(warning_pct=50, critical_pct=75, emergency_pct=90),
            "BU_FINANCE": BudgetThreshold(warning_pct=40, critical_pct=60, emergency_pct=80),
            "BU_AI_RESEARCH": BudgetThreshold(warning_pct=60, critical_pct=80, emergency_pct=95),
        }
        
        # Budget configuration per BU
        self.bu_budgets: Dict[str, Dict] = {
            "BU_FINANCE": {"monthly_usd": 10000, "current_spend": 0},
            "BU_MARKETING": {"monthly_usd": 5000, "current_spend": 0},
            "BU_AI_RESEARCH": {"monthly_usd": 15000, "current_spend": 0},
        }
        
        # Project budgets
        self.project_budgets: Dict[str, Dict] = defaultdict(lambda: {"monthly_usd": 1000, "current_spend": 0})
        
        # Model budgets
        self.model_budgets: Dict[str, Dict] = {
            "gpt-4.1": {"monthly_usd": 500, "current_spend": 0},
            "claude-sonnet-4.5": {"monthly_usd": 500, "current_spend": 0},
            "gemini-2.5-flash": {"monthly_usd": 200, "current_spend": 0},
            "deepseek-v3.2": {"monthly_usd": 100, "current_spend": 0},
        }
        
        self.alerted_thresholds: set = set()  # ป้องกันส่ง alert ซ้ำ
    
    def add_alert_channel(self, channel: AlertChannel):
        """เพิ่ม alert channel"""
        self.alert_channels.append(channel)
    
    async def _send_alert(self, title: str, message: str, severity: str):
        """ส่ง alert ไปทุก channel"""
        for channel in self.alert_channels:
            try:
                await channel.send(title, message, severity)
            except Exception as e:
                logger.error(f"Failed to send alert via {type(channel).__name__}: {e}")
    
    async def record_usage(self, project: str, model: str, input_tokens: int, 
                          output_tokens: int, bu_name: str):
        """บันทึกการใช้งานและตรวจสอบ budget"""
        
        # Calculate cost
        price = MODEL_PRICING.get(model, MODEL_PRICING["deepseek-v3.2"])
        cost = (input_tokens / 1_000_000 * price["input"] + 
                output_tokens / 1_000_000 * price["output"])
        
        # Create settlement record
        record = SettlementRecord(
            timestamp=datetime.now(),
            project=project,
            model=model,
            input_tokens=input_tokens,
            output_tokens=output_tokens,
            cost_usd=cost,
            bu_name=bu_name
        )
        self.settlement_records.append(record)
        
        # Update budgets
        self.bu_budgets[bu_name]["current_spend"] += cost
        self.project_budgets[project]["current_spend"] += cost
        self.model_budgets[model]["current_spend"] += cost
        
        # Check thresholds and send alerts
        await self._check_budget_alerts(bu_name)
        await self._check_project_alerts(project)
        await self._check_model_alerts(model)
    
    async def _check_budget_alerts(self, bu_name: str):
        """ตรวจสอบ alert ระดับ BU"""
        if bu_name not in self.bu_budgets:
            return
        
        budget = self.bu_budgets[bu_name]
        threshold_config = self.thresholds.get(bu_name, self.thresholds["default"])
        usage_pct = (budget["current_spend"] / budget["monthly_usd"]) * 100
        
        alert_key = f"{bu_name}_{usage_pct:.0f}"
        
        if usage_pct >= threshold_config.emergency_pct and f"emergency_{bu_name}" not in self.alerted_thresholds:
            await self._send_alert(
                f"🚨 EMERGENCY: {bu_name} Budget ถึง {usage_pct:.1f}%",
                f"งบประมาณ BU {bu_name} ใช้ไป ${budget['current_spend']:.2f} / ${budget['monthly_usd']:.2f}\n"
                f"⚠️ ระบบจะหยุดทำงานเมื่อถึง 100%",
                "emergency"
            )
            self.alerted_thresholds.add(f"emergency_{bu_name}")
            
        elif usage_pct >= threshold_config.critical_pct and f"critical_{bu_name}" not in self.alerted_thresholds:
            await self._send_alert(
                f"⚠️ CRITICAL: {bu_name} Budget ถึง {usage_pct:.1f}%",
                f"งบประมาณ BU {bu_name} ใช้ไป ${budget['current_spend']:.2f} / ${budget['monthly_usd']:.2f}\n"
                f"🔴 กรุณาตรวจสอบการใช้งานด่วน",
                "critical"
            )
            self.alerted_thresholds.add(f"critical_{bu_name}")
            
        elif usage_pct >= threshold_config.warning_pct and f"warning_{bu_name}" not in self.alerted_thresholds:
            await self._send_alert(
                f"📊 WARNING: {bu_name} Budget ถึง {usage_pct:.1f}%",
                f"งบประมาณ BU {bu_name} ใช้ไป ${budget['current_spend']:.2f} / ${budget['monthly_usd']:.2f}\n"
                f"💡 แนะนำติดตามการใช้งานอย่างใกล้ชิด",
                "warning"
            )
            self.alerted_thresholds.add(f"warning_{bu_name}")
    
    async def _check_project_alerts(self, project: str):
        """ตรวจสอบ alert ระดับ Project"""
        budget = self.project_budgets[project]
        if budget["current_spend"] >= budget["monthly_usd"]:
            await self._send_alert(
                f"🔴 Project {project} ใช้งบเกิน",
                f"Project {project} ใช้ไป ${budget['current_spend']:.2f} เกินกว่า ${budget['monthly_usd']:.2f}",
                "critical"
            )
    
    async def _check_model_alerts(self, model: str):
        """ตรวจสอบ alert ระดับ Model"""
        budget = self.model_budgets[model]
        if budget["current_spend"] >= budget["monthly_usd"]:
            await self._send_alert(
                f"🔴 Model {model} ใช้งบเกิน",
                f"Model {model} ใช้ไป ${budget['current_spend']:.2f} เกินกว่า ${budget['monthly_usd']:.2f}\n"
                f"💡 พิจารณาใช้ model ทางเลือกที่ประหยัดกว่า",
                "critical"
            )
    
    def generate_settlement_report(self) -> Dict:
        """สร้างรายงาน settlement รายเดือน"""
        
        # Group by BU
        bu_summary = defaultdict(lambda: {"total_cost": 0, "requests": 0, "tokens": 0, "by_model": defaultdict(lambda: {"cost": 0, "tokens": 0})})
        
        for record in self.settlement_records:
            bu_summary[record.bu_name]["total_cost"] += record.cost_usd
            bu_summary[record.bu_name]["requests"] += 1
            bu_summary[record.bu_name]["tokens"] += record.input_tokens + record.output_tokens
            bu_summary[record.bu_name]["by_model"][record.model]["cost"] += record.cost_usd
            bu_summary[record.bu_name]["by_model"][record.model]["tokens"] += record.input_tokens + record.output_tokens
        
        return {
            "report_date": datetime.now().isoformat(),
            "total_spend_usd": sum(r.cost_usd for r in self.settlement_records),
            "total_requests": len(self.settlement_records),
            "total_tokens": sum(r.input_tokens + r.output_tokens for r in self.settlement_records),
            "bu_breakdown": dict(bu_summary),
            "budget_vs_actual": {
                "bu": {k: {"budget": v["monthly_usd"], "actual": v["current_spend"], 
                          "remaining": v["monthly_usd"] - v["current_spend"]} 
                       for k, v in self

แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง