API 추상화 레이어

// 1. 벤더 종속성
• Claude API 사용 중 → OpenAI로 전환 시 코드 전면 수정
• 각 API마다 다른 인터페이스, 파라미터, 에러 처리

// 2. 유지보수 부담
• API 변경 시 모든 코드 수정 필요
• 다중 LLM 사용 시 중복 코드 증가

// 3. 전환 비용
• 더 나은 모델 출시 시 전환 어려움
• 가격/성능 비교 실험 복잡

// 4. 안정성
• 단일 벤더 장애 시 서비스 중단
• 폴백 구현 복잡

// 예시: Claude와 OpenAI의 다른 API
# Claude
import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-",
    max_tokens=1024,
    messages=[{"role": "user", "content": "..."}]
)
result = message.content[0].text

# OpenAI
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "..."}]
)
result = response.choices[0].message.content

// 1. 통합 인터페이스
• 단일 API로 모든 LLM 접근
• 코드 변경 없이 모델 전환 가능

// 2. 벤더 독립성
• 특정 벤더에 종속되지 않음
• 언제든지 최적의 모델 선택 가능

// 3. 고급 기능
• 자동 폴백 (Fallback)
• 로드 밸런싱
• 캐싱
• 비용 추적

// 4. 간편한 실험
• 여러 모델 빠르게 비교
• A/B 테스트 용이

// 예시: LiteLLM 사용
from litellm import completion

# Claude 사용
response = completion(
    model="claude-",
    messages=[{"role": "user", "content": "..."}]
)

# OpenAI로 전환 (코드 변경 최소)
response = completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "..."}]
)

# 통일된 인터페이스
result = response.choices[0].message.content

LiteLLM이란?
• 100+ LLM을 OpenAI 형식으로 통합
• Python 라이브러리 (오픈소스)
• 동일한 입출력 형식
• 스트리밍, 함수 호출 지원

지원 모델:
• Anthropic (Claude)
• OpenAI (GPT-4o, o1)
• Google (Gemini)
• Cohere, Mistral, AI21
• Azure OpenAI
• Bedrock (AWS)
• VertexAI (Google Cloud)
• Ollama (로컬 LLM)
• HuggingFace
• 기타 100+

GitHub: https://github.com/BerriAI/litellm

# 설치
$ pip install litellm

# API 키 설정
$ export ANTHROPIC_API_KEY="sk-ant-..."
$ export OPENAI_API_KEY="sk-..."
$ export GEMINI_API_KEY="AIzaSy..."

from litellm import completion

# Claude
response = completion(
    model="claude-20260101",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# OpenAI
response = completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# Google Gemini
response = completion(
    model="gemini/gemini-1.5-flash",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# Ollama (로컬)
response = completion(
    model="ollama/llama3",
    messages=[{"role": "user", "content": "안녕하세요!"}],
    api_base="http://localhost:11434"
)
print(response.choices[0].message.content)

from litellm import completion

# 폴백 리스트 정의
def completion_with_fallback(messages, models):
    for model in models:
        try:
            print(f"Trying {model}...")
            response = completion(
                model=model,
                messages=messages
            )
            print(f"Success with {model}")
            return response
        except Exception as e:
            print(f"Failed with {model}: {e}")
            continue

    raise Exception("All models failed")

# 사용
response = completion_with_fallback(
    messages=[{"role": "user", "content": "안녕!"}],
    models=[
        "claude-20260101",  # 1순위
        "gpt-4o",                    # 2순위
        "gemini/gemini-1.5-flash"   # 3순위
    ]
)

print(response.choices[0].message.content)

from litellm import completion

# 모든 모델에서 동일한 스트리밍 인터페이스
response = completion(
    model="claude-20260101",  # 또는 gpt-4o, gemini/...
    messages=[{"role": "user", "content": "긴 이야기를 들려줘."}],
    stream=True
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()

# Proxy 서버 설치
$ pip install 'litellm[proxy]'

# 설정 파일 (config.yaml)
$ cat > config.yaml << 'EOF'
model_list:
  - model_name: gpt-4o
    litellm_params:
      model: gpt-4o
      api_key: sk-...
  - model_name: claude
    litellm_params:
      model: claude-20260101
      api_key: sk-ant-...
  - model_name: gemini
    litellm_params:
      model: gemini/gemini-1.5-flash
      api_key: AIzaSy...
EOF

# Proxy 서버 시작
$ litellm --config config.yaml --port 8000

# OpenAI 형식으로 호출
$ curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude",
    "messages": [{"role": "user", "content": "안녕!"}]
  }'

# litellm-hybrid-config.yaml
model_list:
  # Claude 모델 (클라우드)
  - model_name: "smart"
    litellm_params:
      model: "anthropic/claude-sonnet-4-20250514"
      api_key: "os.environ/ANTHROPIC_API_KEY"
      max_tokens: 4096

  # Ollama 모델 (로컬) — smart의 폴백
  - model_name: "smart"
    litellm_params:
      model: "ollama/llama3.2"
      api_base: "http://ollama:11434"

  # 로컬 전용 (프라이버시·대량 처리)
  - model_name: "local"
    litellm_params:
      model: "ollama/llama3.2"
      api_base: "http://ollama:11434"

router_settings:
  routing_strategy: "simple-shuffle"
  num_retries: 2
  timeout: 120
  fallbacks: [{"smart": ["local"]}]

# LiteLLM 프록시 + Ollama 통합 운영
version: "3.8"
services:
  ollama:
    image: ollama/ollama
    ports: ["11434:11434"]
    volumes: ["ollama_data:/root/.ollama"]
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports: ["4000:4000"]
    volumes: ["./litellm-hybrid-config.yaml:/app/config.yaml"]
    command: "--config /app/config.yaml --port 4000"
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    depends_on: [ollama]

volumes:
  ollama_data:

# 클라이언트: 하나의 엔드포인트로 Claude + Ollama 사용
from openai import OpenAI

client = OpenAI(base_url="http://localhost:4000", api_key="any")

# "smart" → Claude 호출 (실패 시 자동 Ollama 폴백)
resp = client.chat.completions.create(
    model="smart",
    messages=[{"role": "user", "content": "복잡한 시스템 설계"}]
)

# "local" → 항상 Ollama (민감 데이터용)
resp = client.chat.completions.create(
    model="local",
    messages=[{"role": "user", "content": "고객 데이터 분석"}]
)

Portkey란?
• AI 게이트웨이 플랫폼
• 다중 LLM 통합 및 관리
• 캐싱, 폴백, 로드 밸런싱
• 로깅, 모니터링, 분석
• 프로덕션 환경에 최적화

주요 기능:
• Gateway: 통합 엔드포인트
• Fallbacks: 자동 폴백
• Load Balancing: 트래픽 분산
• Caching: 시맨틱 캐싱
• Rate Limiting: 사용량 제한
• Analytics: 상세 분석 대시보드
• Virtual Keys: API 키 관리

Website: https://portkey.ai
GitHub: https://github.com/Portkey-AI/portkey-python-sdk

# 설치
$ pip install portkey-ai

# 계정 생성 (https://app.portkey.ai)
# API 키 발급 (Portkey API Key)
$ export PORTKEY_API_KEY="..."

from portkey_ai import Portkey

# Portkey 클라이언트 생성
portkey = Portkey(
    api_key="YOUR_PORTKEY_API_KEY"
)

# Claude 사용
response = portkey.chat.completions.create(
    messages=[{"role": "user", "content": "안녕하세요!"}],
    model="claude-20260101",
    virtual_key="anthropic-virtual-key"  # Portkey에서 생성한 Virtual Key
)

print(response.choices[0].message.content)

# OpenAI 사용 (동일한 인터페이스)
response = portkey.chat.completions.create(
    messages=[{"role": "user", "content": "안녕하세요!"}],
    model="gpt-4o",
    virtual_key="openai-virtual-key"
)

print(response.choices[0].message.content)

from portkey_ai import Portkey

portkey = Portkey(api_key="...")

# Config 정의 (Portkey 대시보드에서도 가능)
config = {
    "strategy": {
        "mode": "fallback"
    },
    "targets": [
        {
            "virtual_key": "anthropic-key",
            "override_params": {
                "model": "claude-20260101"
            }
        },
        {
            "virtual_key": "openai-key",
            "override_params": {
                "model": "gpt-4o"
            }
        }
    ]
}

# 자동 폴백 실행
response = portkey.chat.completions.create(
    messages=[{"role": "user", "content": "안녕!"}],
    config=config
)

print(response.choices[0].message.content)

# 라운드 로빈 방식
config = {
    "strategy": {
        "mode": "loadbalance"
    },
    "targets": [
        {
            "virtual_key": "anthropic-key",
            "override_params": {"model": "claude-"},
            "weight": 0.6  # 60%
        },
        {
            "virtual_key": "openai-key",
            "override_params": {"model": "gpt-4o"},
            "weight": 0.4  # 40%
        }
    ]
}

# 가중치에 따라 자동 분산
for i in range(10):
    response = portkey.chat.completions.create(
        messages=[{"role": "user", "content": f"요청 {i}"}],
        config=config
    )
    print(f"{i}: {response.model}")  # 사용된 모델 확인

# Semantic Caching (의미 기반 캐싱)
portkey = Portkey(
    api_key="...",
    cache_force_refresh=False,  # 캐시 사용
)

# 첫 요청 (캐시 생성)
response1 = portkey.chat.completions.create(
    messages=[{"role": "user", "content": "Python이란 무엇인가?"}],
    model="gpt-4o",
    virtual_key="openai-key"
)
print("Cache status:", response1.headers.get("x-portkey-cache-status"))  # MISS

# 유사한 요청 (캐시 히트)
response2 = portkey.chat.completions.create(
    messages=[{"role": "user", "content": "파이썬이 뭐야?"}],
    model="gpt-4o",
    virtual_key="openai-key"
)
print("Cache status:", response2.headers.get("x-portkey-cache-status"))  # HIT
print("Response time reduced!")

OpenRouter란?
• 단일 API로 100+ LLM 접근
• OpenAI 호환 API 형식
• 자동 라우팅 및 폴백
• 투명한 가격 (마진 포함)
• 사용한 만큼만 지불

지원 모델:
• GPT-4o, Claude 4, Gemini 1.5
• Llama 3, Mixtral, Qwen
• 오픈소스 모델 다수
• 실시간 모델 추가

Website: https://openrouter.ai
Pricing: https://openrouter.ai/models

# OpenRouter는 OpenAI SDK 사용
$ pip install openai

# API 키 발급 (https://openrouter.ai/keys)
$ export OPENROUTER_API_KEY="sk-or-..."

from openai import OpenAI

# OpenRouter를 OpenAI 클라이언트로 사용
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-..."
)

# Claude 사용
response = client.chat.completions.create(
    model="anthropic/claude-",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# GPT-4o 사용
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# Gemini 사용
response = client.chat.completions.create(
    model="google/gemini-1.5-flash",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# 오픈소스 모델
response = client.chat.completions.create(
    model="meta-llama/llama-3-70b-instruct",
    messages=[{"role": "user", "content": "안녕하세요!"}]
)
print(response.choices[0].message.content)

# OpenRouter가 최적의 모델 자동 선택
response = client.chat.completions.create(
    model="openrouter/auto",  # 자동 선택
    messages=[{"role": "user", "content": "Python 퀵소트"}]
)

# 사용된 모델 확인
print(f"사용된 모델: {response.model}")
print(response.choices[0].message.content)

┌──────────────┬─────────┬─────────┬────────────┬──────────┐
│ 기능         │ LiteLLM │ Portkey │ OpenRouter │ 직접구현 │
├──────────────┼─────────┼─────────┼────────────┼──────────┤
│ 통합인터페이스│ ✓       │ ✓       │ ✓          │ ✗        │
│ 폴백         │ 수동    │ ✓       │ ✓          │ 수동     │
│ 로드밸런싱   │ ✗       │ ✓       │ ✗          │ 수동     │
│ 캐싱         │ ✗       │ ✓       │ ✗          │ 수동     │
│ 분석대시보드│ ✗       │ ✓       │ ✓          │ ✗        │
│ 셀프호스팅   │ ✓       │ ✓       │ ✗          │ ✓        │
│ 오픈소스     │ ✓       │ 부분    │ ✗          │ N/A      │
│ 가격         │ 무료    │ 유료    │ 마진추가   │ 원가     │
│ 설치용이성   │ 쉬움    │ 보통    │ 쉬움       │ 어려움   │
└──────────────┴─────────┴─────────┴────────────┴──────────┘

// 사용 사례별 추천

// LiteLLM
✓ 빠른 프로토타이핑
✓ 오픈소스 선호
✓ 셀프 호스팅 필요
✓ 기본적인 폴백만 필요

// Portkey
✓ 프로덕션 환경
✓ 고급 기능 필요 (캐싱, 로드밸런싱)
✓ 상세한 분석 필요
✓ 팀 협업

// OpenRouter
✓ 다양한 모델 실험
✓ 간단한 시작
✓ 오픈소스 모델 접근
✓ 투명한 가격

// 직접 구현
✓ 최대 제어 필요
✓ 커스터마이징 필요
✓ 비용 최소화
✓ 특수 요구사항

// 1. 모델 선택 전략
• 주력 모델 + 백업 모델 조합
• 가격/성능 균형 고려
• 폴백 순서 최적화

// 2. 폴백 구성
• 유사 성능 모델로 폴백
• 최소 2개 이상 백업
• 타임아웃 설정

// 3. 캐싱 활용
• 반복 쿼리 캐싱
• 적절한 TTL 설정
• 민감 정보 캐싱 주의

// 4. 모니터링
• 모델별 성공률 추적
• 비용 모니터링
• 응답 시간 측정
• 에러 패턴 분석

// 5. 점진적 도입
• 소규모 트래픽부터 시작
• A/B 테스트
• 단계적 롤아웃
• 롤백 계획 수립

// 6. 비용 최적화
• 저렴한 모델 우선 시도
• 캐싱으로 중복 호출 방지
• 배치 처리 활용
• 사용량 제한 설정