LLM Optimization Tools

from toon import encode
from openai import OpenAI
import json

client = OpenAI()

# Sample product catalog (could be 100s of products)
products = [
    {"id": 1, "name": "Laptop Pro", "price": 1299, "stock": 45, "category": "Electronics"},
    {"id": 2, "name": "Magic Mouse", "price": 79, "stock": 120, "category": "Accessories"},
    {"id": 3, "name": "USB-C Hub", "price": 49, "stock": 200, "category": "Accessories"},
    {"id": 4, "name": "4K Monitor", "price": 599, "stock": 30, "category": "Electronics"},
    {"id": 5, "name": "Keyboard", "price": 129, "stock": 85, "category": "Accessories"},
    # ... potentially hundreds more
]

# Measure token reduction
json_str = json.dumps(products)
toon_str = encode(products)

print(f"JSON size: {len(json_str)} bytes")
print(f"TOON size: {len(toon_str)} bytes")
print(f"Reduction: {((len(json_str) - len(toon_str)) / len(json_str) * 100):.1f}%")

# Send optimized data to LLM
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{
        "role": "user",
        "content": f"""
        Analyze this product catalog and provide:
        1. Total inventory value
        2. Low stock items (< 50 units)
        3. Average price by category
        
        Data:
        {toon_str}
        """
    }]
)

print(response.choices[0].message.content)

import streamlit as st
import json
from toon import encode, decode
import tiktoken

st.title("🎯 Toonify Token Optimizer")

# Token counter
enc = tiktoken.encoding_for_model("gpt-4")

def count_tokens(text):
    return len(enc.encode(text))

# Input data
data_input = st.text_area(
    "Paste your JSON data",
    value=json.dumps({
        "products": [
            {"id": 1, "name": "Laptop", "price": 1299},
            {"id": 2, "name": "Mouse", "price": 79},
        ]
    }, indent=2),
    height=200
)

if data_input:
    try:
        # Parse JSON
        data = json.loads(data_input)
        
        # Convert to TOON
        toon_str = encode(data)
        
        # Calculate metrics
        json_tokens = count_tokens(data_input)
        toon_tokens = count_tokens(toon_str)
        reduction = ((json_tokens - toon_tokens) / json_tokens) * 100
        
        # Display results
        col1, col2 = st.columns(2)
        
        with col1:
            st.subheader("JSON Format")
            st.code(data_input, language="json")
            st.metric("Tokens", json_tokens)
            st.metric("Bytes", len(data_input))
        
        with col2:
            st.subheader("TOON Format")
            st.code(toon_str, language="text")
            st.metric("Tokens", toon_tokens)
            st.metric("Bytes", len(toon_str))
        
        # Savings
        st.success(f"Token Reduction: {reduction:.1f}%")
        
        # Cost calculator
        st.subheader("Cost Savings Calculator")
        requests = st.number_input("Number of API requests", value=1000, step=1000)
        
        gpt4_cost_per_1k = 0.03
        json_cost = (json_tokens / 1000) * gpt4_cost_per_1k * requests
        toon_cost = (toon_tokens / 1000) * gpt4_cost_per_1k * requests
        savings = json_cost - toon_cost
        
        st.write(f"**JSON cost**: ${json_cost:.2f}")
        st.write(f"**TOON cost**: ${toon_cost:.2f}")
        st.write(f"**💰 Savings**: ${savings:.2f}")
        
    except Exception as e:
        st.error(f"Error: {e}")

Tokens: 10,144
Cost: $0.30
Response time: 4.8s
Answer: ✅ Correct (payment-gateway, PG-5523, increase max_connections)

Tokens: 1,260 (87.6% reduction)
Cost: $0.04 (86.7% savings)
Response time: 1.2s (75% faster)
Answer: ✅ Correct (same details)

import streamlit as st

st.title("LLM Optimization Cost Calculator")

# Inputs
col1, col2 = st.columns(2)

with col1:
    avg_tokens = st.number_input("Average tokens per request", value=5000, step=100)
    requests_per_day = st.number_input("Requests per day", value=1000, step=100)
    
with col2:
    model = st.selectbox("Model", ["GPT-4", "GPT-4o", "Claude 3.5 Sonnet"])
    optimization = st.slider("Token reduction %", 0, 95, 60)

# Pricing
pricing = {
    "GPT-4": 0.03,
    "GPT-4o": 0.0025,
    "Claude 3.5 Sonnet": 0.003
}

cost_per_1k = pricing[model]

# Calculate
monthly_requests = requests_per_day * 30
yearly_requests = requests_per_day * 365

# Baseline
baseline_monthly = (avg_tokens / 1000) * cost_per_1k * monthly_requests
baseline_yearly = (avg_tokens / 1000) * cost_per_1k * yearly_requests

# Optimized
optimized_tokens = avg_tokens * (1 - optimization / 100)
optimized_monthly = (optimized_tokens / 1000) * cost_per_1k * monthly_requests
optimized_yearly = (optimized_tokens / 1000) * cost_per_1k * yearly_requests

# Display
st.subheader("Cost Analysis")

col1, col2, col3 = st.columns(3)

with col1:
    st.metric("Monthly Baseline", f"${baseline_monthly:.2f}")
    st.metric("Monthly Optimized", f"${optimized_monthly:.2f}")
    st.metric("Monthly Savings", f"${baseline_monthly - optimized_monthly:.2f}", delta=f"-{optimization}%")

with col2:
    st.metric("Yearly Baseline", f"${baseline_yearly:.2f}")
    st.metric("Yearly Optimized", f"${optimized_yearly:.2f}")
    st.metric("Yearly Savings", f"${baseline_yearly - optimized_yearly:.2f}", delta=f"-{optimization}%")

with col3:
    st.metric("3-Year Baseline", f"${baseline_yearly * 3:.2f}")
    st.metric("3-Year Optimized", f"${optimized_yearly * 3:.2f}")
    st.metric("3-Year Savings", f"${(baseline_yearly - optimized_yearly) * 3:.2f}", delta=f"-{optimization}%")