AWS Bedrock - ThrottlingException: too many tokens per day, please wait before trying again

# fallback_client.py - multi-model fallback z automatycznym przełączaniem
import boto3
import json
from botocore.exceptions import ClientError
import time

class BedrockFallbackClient:
    """Klient Bedrock z automatycznym fallback na alternatywne modele."""

    def __init__(self, region="eu-west-1"):
        self.client = boto3.client("bedrock-runtime", region_name=region)
        # Kolejność fallback: primary → secondary → tertiary
        self.models = [
            "anthropic.claude-3-5-sonnet-20241022-v2:0",  # primary
            "anthropic.claude-3-5-haiku-20241022-v1:0",   # tańszy, szybszy
            "anthropic.claude-3-haiku-20240307-v1:0",     # starszy, osobny limit
            "amazon.nova-pro-v1:0",                        # Amazon model, osobny limit
        ]
        self.throttled_models = {}  # model_id → timestamp when throttled

    def invoke(self, messages: list, system: str = "", max_tokens: int = 1024):
        """Wywołaj model z automatycznym fallback przy throttlingu."""
        for model_id in self.models:
            # Pomiń modele throttled w ostatnich 5 minutach
            if model_id in self.throttled_models:
                if time.time() - self.throttled_models[model_id] < 300:
                    continue
                else:
                    del self.throttled_models[model_id]

            try:
                response = self.client.converse(
                    modelId=model_id,
                    messages=messages,
                    system=[{"text": system}] if system else [],
                    inferenceConfig={"maxTokens": max_tokens}
                )
                return {
                    "content": response["output"]["message"]["content"][0]["text"],
                    "model_used": model_id,
                    "input_tokens": response["usage"]["inputTokens"],
                    "output_tokens": response["usage"]["outputTokens"],
                }
            except ClientError as e:
                error_code = e.response["Error"]["Code"]
                error_msg = e.response["Error"]["Message"]

                if error_code == "ThrottlingException":
                    if "tokens per day" in error_msg.lower():
                        # Dzienny limit - oznacz model jako niedostępny
                        self.throttled_models[model_id] = time.time()
                        print(f"⚠️  Model {model_id} osiągnął dzienny limit. Fallback...")
                        continue
                    elif "too many requests" in error_msg.lower():
                        # Per-minute limit - retry z backoff
                        time.sleep(2)
                        continue
                raise  # Inny błąd - propaguj

        raise RuntimeError("Wszystkie modele osiągnęły limit dzienny. Brak dostępnych fallback.")


# Użycie:
client = BedrockFallbackClient()
result = client.invoke(
    messages=[{"role": "user", "content": [{"text": "Wyjaśnij architekturę RAG."}]}],
    system="Jesteś ekspertem od architektury chmurowej."
)
print(f"Model: {result['model_used']}, Tokeny: {result['input_tokens']}+{result['output_tokens']}")

# token_budget_tracker.py - śledzenie budżetu dziennego w aplikacji
import boto3
from datetime import datetime, timezone
import os

class TokenBudgetTracker:
    """Śledzi zużycie tokenów i ostrzega przed osiągnięciem limitu."""

    def __init__(self, daily_limit: int = 2_000_000):
        self.daily_limit = daily_limit
        self.cloudwatch = boto3.client("cloudwatch")
        self._cache_timestamp = None
        self._cached_usage = 0

    def get_daily_usage(self, model_id: str) -> int:
        """Pobierz bieżące dzienne zużycie tokenów z CloudWatch."""
        now = datetime.now(timezone.utc)
        start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)

        # Cache na 5 minut
        if self._cache_timestamp and (now - self._cache_timestamp).seconds < 300:
            return self._cached_usage

        input_resp = self.cloudwatch.get_metric_statistics(
            Namespace="AWS/Bedrock",
            MetricName="InputTokenCount",
            Dimensions=[{"Name": "ModelId", "Value": model_id}],
            StartTime=start_of_day,
            EndTime=now,
            Period=86400,
            Statistics=["Sum"],
        )
        output_resp = self.cloudwatch.get_metric_statistics(
            Namespace="AWS/Bedrock",
            MetricName="OutputTokenCount",
            Dimensions=[{"Name": "ModelId", "Value": model_id}],
            StartTime=start_of_day,
            EndTime=now,
            Period=86400,
            Statistics=["Sum"],
        )

        input_tokens = input_resp["Datapoints"][0]["Sum"] if input_resp["Datapoints"] else 0
        output_tokens = output_resp["Datapoints"][0]["Sum"] if output_resp["Datapoints"] else 0

        self._cached_usage = int(input_tokens + output_tokens)
        self._cache_timestamp = now
        return self._cached_usage

    def remaining_budget(self, model_id: str) -> dict:
        """Sprawdź ile tokenów zostało do limitu."""
        used = self.get_daily_usage(model_id)
        remaining = max(0, self.daily_limit - used)
        pct_used = (used / self.daily_limit) * 100
        return {
            "used": used,
            "remaining": remaining,
            "limit": self.daily_limit,
            "pct_used": round(pct_used, 1),
            "should_fallback": pct_used > 80,
        }

# Redukcja input tokens - kluczowe techniki

# 1. Skróć system prompt (największy wpływ)
# PRZED: 4000 tokenów system prompt × 1000 zapytań = 4M tokenów/dzień
# PO: 800 tokenów (zwięzły) × 1000 zapytań = 800K tokenów/dzień

# 2. Prompt caching (Bedrock wspiera dla Claude 3.5+)
# System prompt wysyłany raz, cache'owany przez 5 minut
response = client.converse(
    modelId="anthropic.claude-3-5-sonnet-20241022-v2:0",
    messages=messages,
    system=[{
        "text": long_system_prompt,
        "cacheControl": {"type": "ephemeral"}  # Cache na 5 min
    }],
)
# Cache hit = 90% redukcja kosztów i zużycia tokenów dla system prompt

# 3. Ogranicz max_tokens w odpowiedzi
# Nie ustawiaj max_tokens=4096 jeśli potrzebujesz 200-tokenowej odpowiedzi
response = client.converse(
    modelId="anthropic.claude-3-5-sonnet-20241022-v2:0",
    messages=messages,
    inferenceConfig={"maxTokens": 512}  # Nie 4096
)

# 4. Filtruj kontekst RAG - wysyłaj tylko top 3 chunks, nie top 10
# PRZED: 10 chunks × 500 tokenów = 5000 tokenów kontekstu
# PO: 3 chunks × 500 tokenów = 1500 tokenów kontekstu

# Bedrock limity są per-region. Użyj drugiego regionu jako overflow.
import boto3
import random

class MultiRegionBedrockClient:
    """Rozkłada ruch między regionami aby podwoić efektywny limit."""

    def __init__(self, model_id: str):
        self.model_id = model_id
        self.regions = ["eu-west-1", "us-east-1"]  # Uwaga na data residency!
        self.clients = {
            region: boto3.client("bedrock-runtime", region_name=region)
            for region in self.regions
        }
        self.region_index = 0

    def invoke(self, messages, system="", max_tokens=1024):
        """Round-robin między regionami."""
        for attempt in range(len(self.regions)):
            region = self.regions[self.region_index % len(self.regions)]
            self.region_index += 1
            try:
                response = self.clients[region].converse(
                    modelId=self.model_id,
                    messages=messages,
                    system=[{"text": system}] if system else [],
                    inferenceConfig={"maxTokens": max_tokens}
                )
                return response
            except self.clients[region].exceptions.ThrottlingException as e:
                if "tokens per day" in str(e):
                    continue  # Spróbuj następny region
                raise
        raise RuntimeError("Limit dzienny osiągnięty we wszystkich regionach")