{
  "usage": {
    "prompt_tokens": 25,
    "completion_tokens": 100,
    "total_tokens": 125
  }
}

import tiktoken

def count_tokens(text, model="llama-3.1-8b"):
    # Use cl100k_base encoding (similar to Llama)
    encoding = tiktoken.get_encoding("cl100k_base")
    return len(encoding.encode(text))

# Example
text = "What is the meaning of life?"
tokens = count_tokens(text)
print(f"Estimated tokens: {tokens}")  # ~7 tokens

def count_message_tokens(messages):
    encoding = tiktoken.get_encoding("cl100k_base")

    total = 0
    for message in messages:
        # Message overhead (role, formatting)
        total += 4

        # Content tokens
        total += len(encoding.encode(message.get("content", "")))

        # Name (if present)
        if "name" in message:
            total += len(encoding.encode(message["name"]))
            total += 1  # Name field overhead

    # Conversation overhead
    total += 2

    return total

# Example
messages = [
    {"role": "system", "content": "You are helpful."},
    {"role": "user", "content": "Hello!"}
]
print(f"Total: {count_message_tokens(messages)} tokens")

Cost = (prompt_tokens + completion_tokens) × price_per_million / 1,000,000

# Llama 3.1 8B pricing: $0.10 per million tokens

prompt_tokens = 500
completion_tokens = 1000
total_tokens = 1500

price_per_million = 0.10
cost = total_tokens * price_per_million / 1_000_000

print(f"Cost: ${cost:.6f}")  # $0.000150

def estimate_monthly_cost(requests_per_day, avg_tokens_per_request, price_per_million):
    daily_tokens = requests_per_day * avg_tokens_per_request
    monthly_tokens = daily_tokens * 30
    monthly_cost = monthly_tokens * price_per_million / 1_000_000

    return {
        "daily_tokens": daily_tokens,
        "monthly_tokens": monthly_tokens,
        "monthly_cost": monthly_cost
    }

# Example: 1000 requests/day, 500 tokens each, $0.10/M
estimate = estimate_monthly_cost(1000, 500, 0.10)
print(f"Monthly cost: ${estimate['monthly_cost']:.2f}")  # $1.50

response = client.chat.completions.create(
    model="llama-3.1-8b",
    messages=[{"role": "user", "content": "Write an essay"}],
    max_tokens=500  # Limit response length
)

def trim_messages(messages, max_tokens=4000):
    encoding = tiktoken.get_encoding("cl100k_base")

    # Always keep system message
    result = []
    if messages and messages[0]["role"] == "system":
        result.append(messages[0])
        messages = messages[1:]

    current_tokens = count_message_tokens(result)

    # Add messages from most recent, stop when limit reached
    for msg in reversed(messages):
        msg_tokens = len(encoding.encode(msg["content"])) + 4
        if current_tokens + msg_tokens > max_tokens:
            break
        result.insert(len([m for m in result if m["role"] == "system"]), msg)
        current_tokens += msg_tokens

    return result

def summarize_if_long(text, max_tokens=2000):
    tokens = count_tokens(text)

    if tokens <= max_tokens:
        return text

    # Summarize with AI
    response = client.chat.completions.create(
        model="llama-3.1-8b",
        messages=[
            {"role": "system", "content": "Summarize concisely:"},
            {"role": "user", "content": text}
        ],
        max_tokens=max_tokens // 2
    )

    return response.choices[0].message.content

# Verbose (more tokens)
messages = [{
    "role": "user",
    "content": "I would like you to please provide me with a comprehensive and detailed explanation of what machine learning is and how it works in general terms."
}]

# Concise (fewer tokens)
messages = [{
    "role": "user",
    "content": "Explain machine learning briefly."
}]

from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
def cached_completion(prompt_hash):
    # Implementation
    pass

def get_completion(messages):
    # Create hash of messages for cache key
    msg_str = str(messages)
    prompt_hash = hashlib.md5(msg_str.encode()).hexdigest()

    return cached_completion(prompt_hash)

class UsageTracker:
    def __init__(self):
        self.total_tokens = 0
        self.total_cost = 0
        self.request_count = 0

    def record(self, usage, price_per_million):
        tokens = usage.total_tokens
        cost = tokens * price_per_million / 1_000_000

        self.total_tokens += tokens
        self.total_cost += cost
        self.request_count += 1

    def report(self):
        return {
            "requests": self.request_count,
            "tokens": self.total_tokens,
            "cost": f"${self.total_cost:.4f}"
        }

# Usage
tracker = UsageTracker()

response = client.chat.completions.create(...)
tracker.record(response.usage, price_per_million=0.10)

print(tracker.report())