pip install tenacity anthropic

import anthropic
from tenacity import (
    retry,
    stop_after_attempt,
    wait_exponential,
    wait_random_exponential,
    retry_if_exception_type,
    before_sleep_log,
)
import logging

logger = logging.getLogger(__name__)
client = anthropic.Anthropic()

# ── Basic retry with exponential backoff ──────────────
@retry(
    retry=retry_if_exception_type((
        anthropic.RateLimitError,
        anthropic.APIStatusError,       # 5xx errors
        anthropic.APIConnectionError,   # network errors
    )),
    wait=wait_exponential(multiplier=1, min=4, max=60),  # 4s, 8s, 16s, 32s, 60s
    stop=stop_after_attempt(5),
    before_sleep=before_sleep_log(logger, logging.WARNING),
)
def call_claude_with_retry(messages: list, **kwargs) -> str:
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=messages,
        **kwargs
    )
    return response.content[0].text

# ── With jitter — prevents thundering herd ────────────
# When many requests fail at once, jitter spreads retries randomly
@retry(
    retry=retry_if_exception_type(anthropic.RateLimitError),
    wait=wait_random_exponential(multiplier=1, max=60),  # random jitter
    stop=stop_after_attempt(6),
)
async def call_claude_async_retry(messages: list) -> str:
    response = await async_client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=messages
    )
    return response.content[0].text

import anthropic, logging, time, hashlib, json
from tenacity import retry, stop_after_attempt, wait_random_exponential, retry_if_exception_type
from functools import lru_cache
from typing import Optional

logger = logging.getLogger(__name__)

class ProductionLLMClient:
    def __init__(
        self,
        model: str = "claude-3-5-sonnet-20241022",
        daily_budget_usd: float = 10.0,
        max_input_length: int = 50_000,
        enable_cache: bool = True,
    ):
        self.client           = anthropic.Anthropic()
        self.model            = model
        self.daily_budget_usd = daily_budget_usd
        self.max_input_length = max_input_length
        self.enable_cache     = enable_cache
        self._cache: dict     = {}
        self._total_cost: float = 0.0
        self._call_count: int = 0

    def _validate_input(self, text: str) -> None:
        if len(text) > self.max_input_length:
            raise ValueError(f"Input too long: {len(text)} chars > {self.max_input_length}")
        if check_injection(text):
            raise ValueError("Potential prompt injection detected")

    def _cache_key(self, messages: list) -> str:
        return hashlib.md5(json.dumps(messages, sort_keys=True).encode()).hexdigest()

    def _log_usage(self, response) -> float:
        cost = calculate_cost(self.model,
                              response.usage.input_tokens,
                              response.usage.output_tokens)
        self._total_cost += cost
        self._call_count += 1
        logger.info(f"API call #{self._call_count}: ${cost:.4f} | total: ${self._total_cost:.4f}")
        if self._total_cost > self.daily_budget_usd:
            logger.error(f"Budget exceeded: ${self._total_cost:.4f} > ${self.daily_budget_usd}")
            raise RuntimeError(f"Daily budget of ${self.daily_budget_usd} exceeded")
        return cost

    @retry(
        retry=retry_if_exception_type((anthropic.RateLimitError, anthropic.APIConnectionError)),
        wait=wait_random_exponential(multiplier=1, max=60),
        stop=stop_after_attempt(5),
        before_sleep=before_sleep_log(logger, logging.WARNING),
    )
    def call(self, messages: list, system: str = "",
             max_tokens: int = 1024, temperature: float = 0.0) -> str:
        # Validate all inputs
        for msg in messages:
            self._validate_input(msg.get("content", ""))

        # Check cache
        if self.enable_cache and temperature == 0.0:
            key = self._cache_key(messages)
            if key in self._cache:
                logger.debug("Cache hit")
                return self._cache[key]

        # Make API call
        response = self.client.messages.create(
            model=self.model,
            max_tokens=max_tokens,
            temperature=temperature,
            system=system,
            messages=messages
        )
        self._log_usage(response)
        result = response.content[0].text

        # Cache deterministic responses
        if self.enable_cache and temperature == 0.0:
            self._cache[self._cache_key(messages)] = result

        return result

    @property
    def stats(self) -> dict:
        return {
            "total_calls": self._call_count,
            "total_cost_usd": round(self._total_cost, 4),
            "budget_remaining_usd": round(self.daily_budget_usd - self._total_cost, 4),
            "cache_size": len(self._cache)
        }