Cache savings calculation

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))

# First request: cache write
response_1 = client.chat.completions.create(
    model='gpt-4o',
    messages=[
        {
            'role': 'user',
            'content': [
                {
                    'type': 'text',
                    'text': 'You are a legal document analyzer. Respond concisely.',
                    'cache_control': {'type': 'ephemeral'}
                },
                {
                    'type': 'text',
                    'text': 'DOCUMENT: ' + ('X' * 10000),  # Large cached context
                    'cache_control': {'type': 'ephemeral'}
                },
                {
                    'type': 'text',
                    'text': 'Question: What is the main subject?'
                }
            ]
        }
    ]
)

first_cost = (
    response_1.usage.prompt_tokens * 0.003 / 1000 +
    response_1.usage.completion_tokens * 0.06 / 1000
)

cache_creation = response_1.usage.cache_creation_input_tokens or 0
first_input = response_1.usage.prompt_tokens

print(f'First request (cache write):')
print(f'  Input tokens: {first_input}')
print(f'  Cache creation: {cache_creation}')
print(f'  Cost: ${first_cost:.4f}')
print()

# Second request: cache read (identical prefix)
response_2 = client.chat.completions.create(
    model='gpt-4o',
    messages=[
        {
            'role': 'user',
            'content': [
                {
                    'type': 'text',
                    'text': 'You are a legal document analyzer. Respond concisely.',
                    'cache_control': {'type': 'ephemeral'}
                },
                {
                    'type': 'text',
                    'text': 'DOCUMENT: ' + ('X' * 10000),
                    'cache_control': {'type': 'ephemeral'}
                },
                {
                    'type': 'text',
                    'text': 'Question: Who are the parties involved?'
                }
            ]
        }
    ]
)

cache_read = response_2.usage.cache_read_input_tokens or 0
second_input = response_2.usage.prompt_tokens

# Cache read tokens cost 10% of normal input rate
cached_token_cost = cache_read * 0.003 / 1000 * 0.1
uncached_token_cost = (second_input - cache_read) * 0.003 / 1000
second_cost = cached_token_cost + uncached_token_cost + response_2.usage.completion_tokens * 0.06 / 1000

print(f'Second request (cache hit):')
print(f'  Cache read: {cache_read}')
print(f'  New input tokens: {second_input - cache_read}')
print(f'  Cost: ${second_cost:.4f}')
print()

# Savings calculation
without_cache_cost = (first_input + second_input) * 0.003 / 1000 + (response_1.usage.completion_tokens + response_2.usage.completion_tokens) * 0.06 / 1000
with_cache_cost = first_cost + second_cost

savings = without_cache_cost - with_cache_cost
savings_percent = (savings / without_cache_cost) * 100

print(f'Total cost comparison (2 requests):')
print(f'  Without cache: ${without_cache_cost:.4f}')
print(f'  With cache: ${with_cache_cost:.4f}')
print(f'  Savings: ${savings:.4f} ({savings_percent:.1f}%)')
print()

# Break-even analysis: how many requests to recover cache overhead?
overhead = first_cost - (first_input * 0.003 / 1000 + response_1.usage.completion_tokens * 0.06 / 1000)
savings_per_hit = (cache_read * 0.003 / 1000) - (cache_read * 0.003 / 1000 * 0.1)
if savings_per_hit > 0:
    breakeven_requests = int(overhead / savings_per_hit) + 1
    print(f'Break-even analysis:')
    print(f'  Cache write overhead: ${overhead:.4f}')
    print(f'  Savings per cache hit: ${savings_per_hit:.4f}')
    print(f'  Break-even at request: #{breakeven_requests}')
else:
    print(f'No savings per hit (cache read tokens = {cache_read}, check cache control setup)')