Why BAML?

1
import openai
2
3
def extract_resume(text):
4
    response = openai.chat.completions.create(
5
        model="gpt-4o",
6
        messages=[{"role": "user", "content": f"Extract name and skills from: {text}"}]
7
    )
8
    return response.choices[0].message.content

1
from pydantic import BaseModel
2
import json
3
4
class Resume(BaseModel):
5
    name: str
6
    skills: list[str]
7
8
def extract_resume(text):
9
    prompt = f"""Extract resume data as JSON:
10
{text}
11
12
Return JSON with fields: name (string), skills (array of strings)"""
13
    
14
    response = openai.chat.completions.create(
15
        model="gpt-4o",
16
        messages=[{"role": "user", "content": prompt}],
17
        response_format={"type": "json_object"}
18
    )
19
    
20
    data = json.loads(response.choices[0].message.content)
21
    return Resume(**data)

1
class Education(BaseModel):
2
    school: str
3
    degree: str
4
    year: int
5
6
class Resume(BaseModel):
7
    name: str
8
    skills: list[str]
9
    education: list[Education]
10
    location: str
11
    years_experience: int

1
# This burns tokens every time you run tests!
2
def test_resume_extraction():
3
    test_resume = "John Doe, Python expert, MIT 2020..."
4
    result = extract_resume(test_resume)  # API call = $$$
5
    assert result.name == "John Doe"

1
import re
2
import time
3
4
def extract_resume(text, max_retries=3):
5
    for attempt in range(max_retries):
6
        try:
7
            response = openai.chat.completions.create(...)
8
            content = response.choices[0].message.content
9
            
10
            # Try to fix common JSON issues
11
            content = fix_json(content)
12
            
13
            data = json.loads(content)
14
            return Resume(**data)
15
        except (json.JSONDecodeError, ValidationError) as e:
16
            if attempt == max_retries - 1:
17
                raise
18
            time.sleep(2 ** attempt)  # Exponential backoff
19
20
def fix_json(content):
21
    # Remove text before/after JSON
22
    json_match = re.search(r'\{.*\}', content, re.DOTALL)
23
    if json_match:
24
        content = json_match.group(0)
25
    
26
    # Fix common issues
27
    content = content.replace(',}', '}')
28
    content = content.replace(',]', ']')
29
    # ... more fixes
30
    
31
    return content

1
def extract_resume(text, provider="openai", model="gpt-4o"):
2
    if provider == "openai":
3
        import openai
4
        client = openai.OpenAI()
5
        response = client.chat.completions.create(model=model, ...)
6
    elif provider == "anthropic":
7
        import anthropic
8
        client = anthropic.Anthropic()
9
        # Different API! Need to rewrite everything
10
        response = client.messages.create(model=model, ...)
11
    # ... handle different response formats

1
# What prompt was generated? How many tokens did it use?
2
# Why did this specific resume fail?
3
# How do I optimize for cost?
4
5
# You can't easily see:
6
# - The exact prompt that was sent
7
# - How the schema was formatted  
8
# - Token usage breakdown
9
# - Why specific fields were missed

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
prompt = f"""Extract resume data as JSON:
2
3
Seniority levels:
4
- junior: 0-2 years experience
5
- mid: 2-5 years experience  
6
- senior: 5-10 years experience
7
- staff: 10+ years experience
8
9
{text}
10
11
Return JSON with fields: name, skills, education, seniority..."""

1
class ResumeExtractor:
2
    def __init__(self):
3
        self.primary_client = openai.OpenAI()
4
        self.fallback_client = anthropic.Anthropic()
5
        self.token_tracker = TokenTracker()
6
        self.error_monitor = ErrorMonitor()
7
        
8
    async def extract_with_fallback(self, text):
9
        try:
10
            return await self._extract_openai(text)
11
        except RateLimitError:
12
            return await self._extract_anthropic(text)
13
        except Exception as e:
14
            self.error_monitor.log(e)
15
            raise
16
            
17
    def _extract_openai(self, text):
18
        # 50+ lines of OpenAI-specific logic
19
        pass
20
        
21
    def _extract_anthropic(self, text):  
22
        # 50+ lines of Anthropic-specific logic
23
        pass

1
from baml_client import baml as b
2
3
# Fully typed, works in Python, TypeScript, Java, Go
4
resume = await b.ExtractResume(resume_text)
5
print(resume.seniority)  # Type: SeniorityLevel