제한사항 (Limitations)

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=100,
    messages=[{"role": "user", "content": "Hi"}]
)

# 응답 헤더에 rate limit 정보 포함
# anthropic-ratelimit-requests-limit: 1000
# anthropic-ratelimit-requests-remaining: 999
# anthropic-ratelimit-tokens-limit: 80000
# anthropic-ratelimit-tokens-remaining: 79900

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hi"}]
)

# 응답 헤더에 rate limit 정보 포함
# x-ratelimit-limit-requests: 500
# x-ratelimit-remaining-requests: 499
# x-ratelimit-limit-tokens: 30000
# x-ratelimit-remaining-tokens: 29900

import time
import random
import anthropic

def call_anthropic_with_retry(client, max_retries=5, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.messages.create(**kwargs)

        except anthropic.RateLimitError as e:
            if attempt == max_retries - 1:
                raise

            # 지수 백오프 + 지터
            wait_time = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limit 도달. {wait_time:.1f}초 대기...")
            time.sleep(wait_time)

import time
import random
from openai import OpenAI, RateLimitError

def call_openai_with_retry(client, max_retries=5, **kwargs):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(**kwargs)

        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise

            # Retry-After 헤더가 있으면 활용
            retry_after = getattr(e, "headers", {}).get("Retry-After")
            if retry_after:
                wait_time = float(retry_after)
            else:
                wait_time = (2 ** attempt) + random.uniform(0, 1)
            print(f"Rate limit 도달. {wait_time:.1f}초 대기...")
            time.sleep(wait_time)

입력 토큰: 150,000
출력 요청: max_tokens=60000

합계: 150,000 + 60,000 = 210,000 > 200,000 ❌

해결: max_tokens=50000으로 줄이기 ✅

tools = [
    {
        "name": "get_current_weather",
        "description": "현재 날씨 정보를 가져옵니다",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {"type": "string"}
            }
        }
    }
]

# Claude가 날씨 API를 호출하도록 지시
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "서울 날씨 어때?"}]
)

# ❌ 서버가 대화를 기억하지 않음
client.messages.create(messages=[{"role": "user", "content": "안녕"}])
client.messages.create(messages=[{"role": "user", "content": "내 이름 뭐야?"}])
# Claude는 이전 대화를 모름

# ✅ 클라이언트가 히스토리 관리
history = []
history.append({"role": "user", "content": "내 이름은 철수야"})
msg1 = client.messages.create(messages=history)
history.append({"role": "assistant", "content": msg1.content[0].text})

history.append({"role": "user", "content": "내 이름 뭐야?"})
msg2 = client.messages.create(messages=history)
# 이제 Claude가 "철수"라고 답함

from anthropic import (
    Anthropic,
    APIError,
    RateLimitError,
    APIConnectionError,
    AuthenticationError
)

def safe_call(client, **kwargs):
    try:
        return client.messages.create(**kwargs)

    except RateLimitError:
        # 재시도 로직
        print("Rate limit 도달. 재시도 중...")
        return call_with_retry(client, **kwargs)

    except AuthenticationError:
        print("API 키 오류")
        return None

    except APIConnectionError:
        print("연결 오류. 네트워크 확인")
        return None

    except APIError as e:
        print(f"API 오류: {e}")
        return None

class TokenTracker:
    def __init__(self):
        self.total_input = 0
        self.total_output = 0

    def track(self, message):
        self.total_input += message.usage.input_tokens
        self.total_output += message.usage.output_tokens

    def report(self):
        print(f"총 입력: {self.total_input:,} 토큰")
        print(f"총 출력: {self.total_output:,} 토큰")

tracker = TokenTracker()
message = client.messages.create(...)
tracker.track(message)