Comparing OpenAI SDK

1
from pydantic import BaseModel
2
from openai import OpenAI
3
4
class Resume(BaseModel):
5
    name: str
6
    skills: list[str]
7
8
client = OpenAI()
9
completion = client.beta.chat.completions.parse(
10
    model="gpt-4o",
11
    messages=[
12
        {"role": "user", "content": "John Doe, Python, Rust"}
13
    ],
14
    response_format=Resume,
15
)
16
resume = completion.choices[0].message.parsed

1
# What prompt is actually being sent?
2
completion = client.beta.chat.completions.parse(
3
    model="gpt-4o",
4
    messages=[{"role": "user", "content": resume_text}],
5
    response_format=Resume,
6
)
7
8
# You can't see:
9
# - How the schema is formatted
10
# - What instructions the model receives
11
# - Why certain fields are misunderstood

1
completion = client.beta.chat.completions.parse(
2
    model="gpt-4o",
3
    messages=[
4
        {"role": "system", "content": "Extract resume information accurately."},
5
        {"role": "user", "content": resume_text}
6
    ],
7
    response_format=Resume,
8
)
9
10
# But what if you need more specific instructions?
11
# How do you tell it to handle edge cases?

1
from enum import Enum
2
3
class SeniorityLevel(str, Enum):
4
    JUNIOR = "junior"
5
    MID = "mid"
6
    SENIOR = "senior"
7
    STAFF = "staff"
8
9
class Resume(BaseModel):
10
    name: str
11
    skills: list[str]
12
    education: list[Education]
13
    seniority: SeniorityLevel

1
class Resume(BaseModel):
2
    """Resume with seniority classification.
3
    
4
    Seniority levels:
5
    - junior: 0-2 years experience
6
    - mid: 2-5 years experience
7
    - senior: 5-10 years experience
8
    - staff: 10+ years experience
9
    """
10
    name: str
11
    skills: list[str]
12
    education: list[Education]
13
    seniority: SeniorityLevel

1
messages = [
2
    {"role": "system", "content": """Extract resume information.
3
    
4
Classify seniority as:
5
- junior: 0-2 years experience
6
- mid: 2-5 years experience  
7
- senior: 5-10 years experience
8
- staff: 10+ years experience"""},
9
    {"role": "user", "content": resume_text}
10
]

1
# With OpenAI SDK, you're stuck with OpenAI
2
from openai import OpenAI
3
client = OpenAI()
4
5
# Want to try Claude? Start over with a different SDK
6
from anthropic import Anthropic
7
anthropic_client = Anthropic()
8
9
# Completely different API
10
message = anthropic_client.messages.create(
11
    model="claude-3-opus-20240229",
12
    messages=[{"role": "user", "content": resume_text}],
13
    # No structured outputs support!
14
)
15
16
# Now you need custom parsing
17
import json
18
resume_data = json.loads(message.content)
19
resume = Resume(**resume_data)  # Hope it matches!

1
# How do you test without burning tokens?
2
def test_resume_extraction():
3
    completion = client.beta.chat.completions.parse(
4
        model="gpt-4o",
5
        messages=[{"role": "user", "content": test_resume}],
6
        response_format=Resume,
7
    )
8
    # This costs money every time!
9
10
# Mock the OpenAI client?
11
from unittest.mock import Mock
12
mock_client = Mock()
13
mock_client.beta.chat.completions.parse.return_value = ...
14
# You're not really testing the extraction logic
15
16
# Track token usage?
17
completion = client.beta.chat.completions.parse(...)
18
print(completion.usage.total_tokens)  # At least this exists!
19
20
# But how many tokens does the schema formatting use?
21
# Could you optimize it?

1
class ResumeExtractor:
2
    def __init__(self):
3
        self.client = OpenAI()
4
        self.fallback_client = OpenAI()  # Different API key?
5
        
6
    def extract_with_retries(self, text: str, max_retries: int = 3):
7
        for attempt in range(max_retries):
8
            try:
9
                return self._extract(text, model="gpt-4o")
10
            except RateLimitError:
11
                if attempt == max_retries - 1:
12
                    # Try fallback model
13
                    return self._extract(text, model="gpt-3.5-turbo")
14
                time.sleep(2 ** attempt)
15
                
16
    def _extract(self, text: str, model: str):
17
        messages = self._build_messages(text)
18
        
19
        completion = self.client.beta.chat.completions.parse(
20
            model=model,
21
            messages=messages,
22
            response_format=Resume,
23
        )
24
        
25
        self._log_usage(completion, model)
26
        return completion.choices[0].message.parsed
27
        
28
    # ... more infrastructure code

1
from baml_client import baml as b
2
3
# Default model
4
resume = await b.ExtractResume(resume_text)
5
6
# Use different models for different scenarios
7
cheap_extraction = await b.ExtractResume(simple_text, {"client": "GPT35"})
8
quality_extraction = await b.ExtractResume(complex_text, {"client": "Claude"})
9
private_extraction = await b.ExtractResume(sensitive_text, {"client": "Llama"})
10
11
# Same interface, same types, different models!