Claude 모델 패밀리

Published: at 11:05 PM

들어가며

Claude를 사용하다 보면 Opus, Sonnet, Haiku라는 세 가지 모델을 선택할 수 있다. 각 모델은 성능, 속도, 비용 측면에서 서로 다른 특징을 가지고 있어, 상황에 맞게 선택하는 것이 중요하다.

“비싼 모델이 항상 좋은 것 아닌가?”라고 생각할 수 있지만, 실제로는 작업의 복잡도에 따라 적절한 모델을 선택하는 것이 비용 효율적이면서도 더 나은 결과를 가져온다.

이번 차시에서는 세 가지 모델의 차이점을 살펴보고, 각 모델이 어떤 상황에 적합한지 알아본다.

Claude 모델 패밀리 개요

Claude는 현재 세 가지 최신 모델을 제공한다:

이 세 모델은 각각 일본 시가(詩歌) 형식의 이름을 따왔다:

Claude Opus 4.6

기본 사양

항목값
API IDclaude-opus-4-6-20250629
입력 가격$5 / MTok
출력 가격$25 / MTok
컨텍스트 윈도우200K 토큰
최대 출력 토큰32,000 토큰
지식 컷오프2025년 5월

주요 특징

1. 최고 수준의 추론 능력

Opus는 Claude 모델 패밀리 중 가장 강력한 추론 능력을 갖추고 있다.

# 복잡한 추론이 필요한 작업
response = client.messages.create(
    model="claude-opus-4-6-20250629",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": """
        대규모 레거시 코드베이스의 아키텍처를 분석하고,
        마이크로서비스로 전환하기 위한 단계별 리팩토링 계획을 수립해줘.
        기존 시스템의 가용성을 유지하면서 점진적으로 전환하는 방법을 제안해줘.
        """
    }]
)

2. 에이전트 및 코딩 특화

복잡한 에이전트 워크플로우나 대규모 코드 작업에 최적화되어 있다.

# 멀티스텝 에이전트 작업
response = client.messages.create(
    model="claude-opus-4-6-20250629",
    max_tokens=8192,
    messages=[{
        "role": "user",
        "content": """
        다음 요구사항을 만족하는 REST API 서버를 설계하고 구현해줘:
        1. 사용자 인증 (JWT)
        2. 게시물 CRUD
        3. 댓글 시스템
        4. 파일 업로드
        5. 실시간 알림 (WebSocket)

        아키텍처 설계, 데이터베이스 스키마, 전체 코드를 제공해줘.
        """
    }]
)

3. 확장된 사고 (Extended Thinking)

Opus는 확장된 사고(Extended Thinking) 기능을 지원한다. 이는 응답을 생성하기 전에 더 깊이 있는 추론 과정을 거치는 기능이다.

# Extended Thinking 사용
response = client.messages.create(
    model="claude-opus-4-6-20250629",
    max_tokens=4096,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # 사고에 사용할 토큰 예산
    },
    messages=[{
        "role": "user",
        "content": "NP-완전 문제를 P로 환원할 수 있는 알고리즘을 설계할 수 있을까?"
    }]
)

# 응답에서 thinking 블록 확인
for block in response.content:
    if block.type == "thinking":
        print(f"사고 과정: {block.thinking}")
    elif block.type == "text":
        print(f"답변: {block.text}")

적합한 사용 사례

1. 복잡한 에이전트 작업

# 여러 도구를 조합하여 복잡한 작업 수행
tools = [
    {
        "name": "search_codebase",
        "description": "코드베이스에서 특정 패턴 검색"
    },
    {
        "name": "analyze_dependencies",
        "description": "의존성 그래프 분석"
    },
    {
        "name": "suggest_refactoring",
        "description": "리팩토링 제안"
    }
]

response = client.messages.create(
    model="claude-opus-4-6-20250629",
    max_tokens=8192,
    tools=tools,
    messages=[{
        "role": "user",
        "content": "레거시 코드의 순환 의존성을 찾아 해결 방안을 제시해줘."
    }]
)

2. 대규모 코드베이스 리팩토링

수천 줄의 코드를 분석하고 체계적인 리팩토링 계획을 수립할 때 Opus가 적합하다.

3. 고급 수학 및 과학 문제

복잡한 수식 유도나 알고리즘 설계가 필요한 경우.

4. 연구 및 분석 보고서 작성

심층적인 분석과 논리적인 구조가 필요한 장문의 문서 작성.

비용 예시

# 대규모 리팩토링 계획 수립
입력: 5,000 토큰 (기존 코드 + 요구사항)
출력: 8,000 토큰 (분석 + 계획 + 예제 코드)

비용 = (5,000 × $5 / 1,000,000) + (8,000 × $25 / 1,000,000)
     = $0.025 + $0.200
     = $0.225 (약 300원)

Claude Sonnet 4.5

기본 사양

항목값
API IDclaude-sonnet-4-5-20250929
입력 가격$3 / MTok
출력 가격$15 / MTok
컨텍스트 윈도우200K 토큰
최대 출력 토큰16,000 토큰
지식 컷오프2025년 4월

주요 특징

1. 속도와 지능의 최적 균형

Sonnet은 Opus의 80-90% 성능을 유지하면서 더 빠른 응답 속도와 낮은 비용을 제공한다.

# 일반적인 코딩 작업에 이상적
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": "Python으로 간단한 REST API 서버를 만들어줘. FastAPI를 사용해."
    }]
)

2. 향상된 코딩 능력

Sonnet은 코드 생성 및 이해 능력이 특히 강화되어 있어, 대부분의 개발 작업에 충분하다.

# 코드 리뷰
code = """
def calculate_total(items):
    total = 0
    for item in items:
        total = total + item['price'] * item['quantity']
    return total
"""

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": f"다음 코드를 리뷰하고 개선점을 제안해줘:\n\n{code}"
    }]
)

3. 대부분의 사용 사례에 적합

Sonnet은 Opus와 Haiku의 중간에 위치하며, 실제 프로덕션 환경에서 가장 많이 사용되는 모델이다.

적합한 사용 사례

1. 일반 코딩 작업

# 함수 작성
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": "Python으로 이진 탐색 트리를 구현해줘."
    }]
)

2. 문서 분석 및 요약

# 긴 문서 요약
with open("long_document.txt", "r") as f:
    document = f.read()

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=500,
    messages=[{
        "role": "user",
        "content": f"다음 문서를 3-5개 문장으로 요약해줘:\n\n{document}"
    }]
)

3. 고객 서비스 자동화

# 고객 문의 응대
customer_query = "주문한 상품이 아직 도착하지 않았어요. 배송 상태를 확인할 수 있나요?"

response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=300,
    system="당신은 친절한 고객 서비스 담당자입니다. 공손하고 도움이 되는 답변을 제공하세요.",
    messages=[{
        "role": "user",
        "content": customer_query
    }]
)

4. 콘텐츠 생성

블로그 포스트, 마케팅 문구, 기술 문서 등 다양한 형태의 콘텐츠 생성에 적합하다.

비용 예시

# 코드 리뷰 요청
입력: 2,000 토큰 (코드 + 요청사항)
출력: 1,000 토큰 (리뷰 결과)

비용 = (2,000 × $3 / 1,000,000) + (1,000 × $15 / 1,000,000)
     = $0.006 + $0.015
     = $0.021 (약 28원)

Opus 대비 비용 절감:

# 동일한 작업을 Opus로 수행했을 때
Opus 비용 = (2,000 × $5 / 1,000,000) + (1,000 × $25 / 1,000,000)
          = $0.010 + $0.025
          = $0.035 (약 47원)

절감액 = $0.035 - $0.021 = $0.014 (40% 절감)

Claude Haiku 4.5

기본 사양

항목값
API IDclaude-haiku-4-5-20250929
입력 가격$1 / MTok
출력 가격$5 / MTok
컨텍스트 윈도우200K 토큰
최대 출력 토큰8,000 토큰
지식 컷오프2025년 3월

주요 특징

1. 최고 속도

Haiku는 세 모델 중 가장 빠른 응답 속도를 자랑한다. 실시간 상호작용이 필요한 경우에 이상적이다.

import time

start_time = time.time()

response = client.messages.create(
    model="claude-haiku-4-5-20250929",
    max_tokens=100,
    messages=[{
        "role": "user",
        "content": "Python의 리스트 컴프리헨션을 간단히 설명해줘."
    }]
)

elapsed_time = time.time() - start_time
print(f"응답 시간: {elapsed_time:.2f}초")
# 일반적으로 1-2초 이내

2. 준프론티어 지능

“준프론티어(Near-frontier)” 지능이란, Haiku가 이전 세대의 Opus나 Sonnet 수준의 성능을 갖추고 있다는 의미다. 즉, 가볍고 빠르지만 충분히 똑똑하다.

3. 비용 효율

가장 저렴한 가격으로 충분한 품질의 결과를 얻을 수 있다.

적합한 사용 사례

1. 실시간 채팅 및 고객 응대

# 챗봇 응답
def chatbot_response(user_message):
    response = client.messages.create(
        model="claude-haiku-4-5-20250929",
        max_tokens=200,
        messages=[{
            "role": "user",
            "content": user_message
        }]
    )
    return response.content[0].text

# 빠른 응답이 중요한 실시간 채팅
user_msg = "안녕하세요! 영업 시간이 어떻게 되나요?"
print(chatbot_response(user_msg))

2. 간단한 분류 및 라벨링

# 텍스트 분류
texts = [
    "이 제품 정말 좋아요! 강력 추천합니다.",
    "배송이 너무 늦어서 실망했습니다.",
    "가격 대비 괜찮은 것 같아요."
]

for text in texts:
    response = client.messages.create(
        model="claude-haiku-4-5-20250929",
        max_tokens=50,
        messages=[{
            "role": "user",
            "content": f"다음 리뷰의 감정을 '긍정', '부정', '중립' 중 하나로 분류해줘: {text}"
        }]
    )
    print(f"{text[:30]}... → {response.content[0].text}")

3. 대량 데이터 처리

수천 건의 데이터를 빠르게 처리해야 할 때 Haiku가 적합하다.

# 1000개의 이메일 분류
emails = load_emails()  # 1000개 이메일 로드

results = []
for email in emails:
    response = client.messages.create(
        model="claude-haiku-4-5-20250929",
        max_tokens=20,
        messages=[{
            "role": "user",
            "content": f"이 이메일이 스팸인지 판단해줘 (예/아니오): {email}"
        }]
    )
    results.append(response.content[0].text)

# 비용 효율적이고 빠른 처리

4. 빠른 코드 자동완성

IDE에서 실시간으로 코드를 제안할 때 사용할 수 있다.

# 코드 자동완성
def autocomplete(code_context):
    response = client.messages.create(
        model="claude-haiku-4-5-20250929",
        max_tokens=100,
        messages=[{
            "role": "user",
            "content": f"다음 코드를 완성해줘:\n\n{code_context}"
        }]
    )
    return response.content[0].text

code = "def calculate_average(numbers):"
print(autocomplete(code))

비용 예시

# 1000개 이메일 분류
입력 (각): 100 토큰
출력 (각): 10 토큰
총 횟수: 1000

비용 = 1000 × [(100 × $1 / 1,000,000) + (10 × $5 / 1,000,000)]
     = 1000 × [$0.0001 + $0.00005]
     = 1000 × $0.00015
     = $0.15 (약 200원)

Sonnet 대비 비용 절감:

# 동일한 작업을 Sonnet으로 수행했을 때
Sonnet 비용 = 1000 × [(100 × $3 / 1,000,000) + (10 × $15 / 1,000,000)]
            = 1000 × $0.00045
            = $0.45 (약 600원)

절감액 = $0.45 - $0.15 = $0.30 (67% 절감)

모델 비교표

성능 비교

모델지능속도가격출력 토큰컨텍스트
Opus 4.6⭐⭐⭐⭐⭐⭐⭐⭐$5/$2532,000200K
Sonnet 4.5⭐⭐⭐⭐⭐⭐⭐⭐$3/$1516,000200K
Haiku 4.5⭐⭐⭐⭐⭐⭐⭐⭐$1/$58,000200K

사용 사례 비교

작업 유형OpusSonnetHaiku
복잡한 추론✓✓✓✓✓✓
일반 코딩✓✓✓✓✓✓✓✓
코드 리뷰✓✓✓✓✓✓✓
에이전트 작업✓✓✓✓✓✓
문서 분석✓✓✓✓✓✓✓✓
실시간 채팅✓✓✓✓✓✓
대량 처리✓✓✓✓✓✓
간단한 분류✓✓✓✓✓✓

응답 시간 비교

일반적인 요청(1000 토큰 입력, 500 토큰 출력)에 대한 대략적인 응답 시간:

모델평균 응답 시간
Opus 4.68-12초
Sonnet 4.54-6초
Haiku 4.51-2초

모델 선택 가이드

의사결정 플로우

다음 질문들에 답하면서 적절한 모델을 선택할 수 있다:

1. 복잡한 멀티스텝 추론이 필요한가?
   → 예: Opus 고려
   → 아니오: 2번으로

2. 실시간 응답이 필수인가?
   → 예: Haiku 고려
   → 아니오: 3번으로

3. 대량의 데이터를 처리해야 하는가?
   → 예: Haiku 고려
   → 아니오: 4번으로

4. 비용 최적화가 최우선인가?
   → 예: Haiku 고려
   → 아니오: Sonnet 권장

시나리오별 추천

Opus를 선택하는 경우:

Sonnet을 선택하는 경우 (가장 권장):

Haiku를 선택하는 경우:

하이브리드 전략

실제 애플리케이션에서는 여러 모델을 조합하여 사용하는 것이 가장 효율적이다.

def process_task(task_type, content):
    """작업 유형에 따라 적절한 모델 선택"""

    if task_type == "complex_analysis":
        model = "claude-opus-4-6-20250629"
        max_tokens = 8192
    elif task_type == "code_generation":
        model = "claude-sonnet-4-5-20250929"
        max_tokens = 4096
    elif task_type == "simple_classification":
        model = "claude-haiku-4-5-20250929"
        max_tokens = 100
    else:
        model = "claude-sonnet-4-5-20250929"  # 기본값
        max_tokens = 2048

    response = client.messages.create(
        model=model,
        max_tokens=max_tokens,
        messages=[{"role": "user", "content": content}]
    )

    return response.content[0].text

# 사용 예시
print(process_task("code_generation", "Python으로 웹 스크래퍼 작성"))
print(process_task("simple_classification", "이 리뷰는 긍정인가 부정인가?"))
print(process_task("complex_analysis", "시스템 아키텍처 리팩토링 계획 수립"))

실전 예제: 세 모델 비교

동일한 작업을 세 모델로 수행하여 차이를 비교해보자.

작업: 피보나치 함수 작성

import anthropic
import time

client = anthropic.Anthropic()

models = [
    "claude-opus-4-6-20250629",
    "claude-sonnet-4-5-20250929",
    "claude-haiku-4-5-20250929"
]

prompt = "Python으로 피보나치 수열을 계산하는 함수를 작성해줘. 메모이제이션을 사용해서."

for model in models:
    print(f"\n{'='*50}")
    print(f"모델: {model.split('-')[1].upper()}")
    print('='*50)

    start_time = time.time()

    response = client.messages.create(
        model=model,
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}]
    )

    elapsed_time = time.time() - start_time

    print(f"응답 시간: {elapsed_time:.2f}초")
    print(f"입력 토큰: {response.usage.input_tokens}")
    print(f"출력 토큰: {response.usage.output_tokens}")

    # 비용 계산 (모델별 가격 적용)
    if "opus" in model:
        cost = (response.usage.input_tokens * 5 + response.usage.output_tokens * 25) / 1_000_000
    elif "sonnet" in model:
        cost = (response.usage.input_tokens * 3 + response.usage.output_tokens * 15) / 1_000_000
    else:  # haiku
        cost = (response.usage.input_tokens * 1 + response.usage.output_tokens * 5) / 1_000_000

    print(f"비용: ${cost:.6f}")
    print(f"\n응답:\n{response.content[0].text[:200]}...")

예상 결과:

==================================================
모델: OPUS
==================================================
응답 시간: 5.23초
입력 토큰: 25
출력 토큰: 350
비용: $0.008875

응답:
물론입니다. 메모이제이션을 사용한 피보나치 함수를 작성하겠습니다.

```python
def fibonacci_memo(n, memo=None):
    """
    메모이제이션을 사용한 피보나치 수열 계산

    Args:
        n: 계산할 피보나...

==================================================
모델: SONNET
==================================================
응답 시간: 2.87초
입력 토큰: 25
출력 토큰: 280
비용: $0.004275

응답:
메모이제이션을 사용한 피보나치 함수입니다:

```python
def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n

    memo[n] = fibonacci...

==================================================
모델: HAIKU
==================================================
응답 시간: 1.15초
입력 토큰: 25
출력 토큰: 180
비용: $0.000925

응답:
```python
def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo)
    return memo[n]

**관찰 결과**:
- **Opus**: 가장 상세한 설명과 문서화, 가장 비쌈
- **Sonnet**: 적절한 설명과 코드 품질, 균형잡힌 비용
- **Haiku**: 간결하지만 정확한 구현, 가장 저렴

### 작업: 코드 리뷰

```python
code = """
def calculate_total(items):
    total = 0
    for i in range(len(items)):
        total = total + items[i]['price'] * items[i]['quantity']
    return total

def apply_discount(total, discount_percent):
    return total - (total * discount_percent / 100)
"""

prompt = f"다음 코드를 리뷰하고 개선점을 제안해줘:\n\n{code}"

# 각 모델로 리뷰 요청
# (위와 동일한 비교 코드)

Opus 결과:

Sonnet 결과:

Haiku 결과:

비용 최적화 전략

1. 작업별로 모델 분리

class AIAssistant:
    def __init__(self):
        self.client = anthropic.Anthropic()

    def simple_task(self, prompt):
        """간단한 작업은 Haiku"""
        return self._call_model("claude-haiku-4-5-20250929", prompt, 500)

    def standard_task(self, prompt):
        """일반 작업은 Sonnet"""
        return self._call_model("claude-sonnet-4-5-20250929", prompt, 2048)

    def complex_task(self, prompt):
        """복잡한 작업은 Opus"""
        return self._call_model("claude-opus-4-6-20250629", prompt, 8192)

    def _call_model(self, model, prompt, max_tokens):
        response = self.client.messages.create(
            model=model,
            max_tokens=max_tokens,
            messages=[{"role": "user", "content": prompt}]
        )
        return response.content[0].text

# 사용
assistant = AIAssistant()

# 간단한 질문 → Haiku
assistant.simple_task("Python의 리스트란?")

# 코드 작성 → Sonnet
assistant.standard_task("REST API 서버 작성")

# 복잡한 설계 → Opus
assistant.complex_task("마이크로서비스 아키텍처 설계")

2. 단계적 에스컬레이션

먼저 저렴한 모델로 시도하고, 만족스럽지 않으면 상위 모델로 에스컬레이션한다.

def escalate_if_needed(prompt):
    """Haiku → Sonnet → Opus 순으로 시도"""

    models = [
        ("claude-haiku-4-5-20250929", 1024),
        ("claude-sonnet-4-5-20250929", 2048),
        ("claude-opus-4-6-20250629", 4096)
    ]

    for model, max_tokens in models:
        response = client.messages.create(
            model=model,
            max_tokens=max_tokens,
            messages=[{"role": "user", "content": prompt}]
        )

        result = response.content[0].text

        # 응답 품질 평가 (실제로는 더 정교한 로직 필요)
        if is_satisfactory(result):
            print(f"모델 {model.split('-')[1]}로 만족스러운 결과 얻음")
            return result

    return result  # 마지막 모델 결과 반환

def is_satisfactory(result):
    """응답 품질 평가 (예시)"""
    # 실제로는 더 복잡한 평가 로직
    return len(result) > 100 and "error" not in result.lower()

3. 배치 처리로 비용 절감

대량의 간단한 작업은 Haiku + 배치 API를 조합한다.

# 1000개의 텍스트 분류를 배치로 처리
requests = []
for i, text in enumerate(texts[:1000]):
    requests.append({
        "custom_id": f"request-{i}",
        "params": {
            "model": "claude-haiku-4-5-20250929",
            "max_tokens": 10,
            "messages": [{
                "role": "user",
                "content": f"이 텍스트의 감정은? (긍정/부정/중립): {text}"
            }]
        }
    })

# 배치 생성 (50% 할인)
batch = client.messages.batches.create(requests=requests)

# 비용: Haiku 가격에서 50% 추가 할인
# 일반 Haiku: $0.15
# 배치 Haiku: $0.075 (50% 절감)

정리

핵심 요점

  1. Opus 4.6: 최고 성능, 복잡한 추론, 에이전트 작업에 적합
  2. Sonnet 4.5: 가장 균형잡힌 선택, 대부분의 실무 작업에 권장
  3. Haiku 4.5: 최고 속도, 실시간 응답, 대량 처리에 이상적
  4. 하이브리드 전략: 작업 유형에 따라 모델을 조합하여 사용
  5. 비용 최적화: 단순 작업은 Haiku, 복잡한 작업만 Opus 사용

모델 선택 체크리스트

다음 질문에 답하면서 모델을 선택하자:

다음 단계

다음 차시에서는 Claude의 컨텍스트 윈도우(Context Window)에 대해 알아본다. 200K 토큰과 1M 토큰의 차이, 그리고 긴 문서를 효율적으로 처리하는 전략을 학습한다.

참고 자료

Next Post
AI 모델과 토큰 개념