Die Evaluierung von Large Language Models (LLMs) hat sich zu einer Wissenschaft entwickelt, die weit über simple Frage-Antwort-Tests hinausgeht. In diesem umfassenden Tutorial zeige ich Ihnen, wie Sie standardisierte Testbenchmarks effektiv für die Bewertung von Open Generative AI-Modellen einsetzen – inklusive praktischer Code-Beispiele, Kostenanalyse und meiner persönlichen Erfahrungen aus über 50 Evaluierungsprojekten.
Warum standardisierte Benchmarks entscheidend sind
In meiner täglichen Arbeit als AI-Consultant bei HolySheep AI sehe ich immer wieder denselben Fehler: Unternehmen vergleichen Modelle anhand von Marketing-Versprechen statt messbarer Leistung. Standardisierte Benchmarks bieten:
- Objektive Vergleichbarkeit zwischen verschiedenen Modellen
- Reproduzierbare Ergebnisse für wissenschaftliche Validierung
- Kosten-Nutzen-Analyse basierend auf realer Performance
- Brancheneinheitliche Metriken für Enterprise-Entscheidungen
Die wichtigsten Open-Generative-AI-Benchmarks 2026
MMLU (Massive Multitask Language Understanding)
Der MMLU-Benchmark testet Modelle über 57 akademische Disziplinen hinweg – von Grundschulmathematik bis juristischem Fachwissen. Aktuelle Ergebnisse zeigen:
- GPT-4.1: 92,4% Genauigkeit
- Claude Sonnet 4.5: 88,7% Genauigkeit
- Gemini 2.5 Flash: 86,2% Genauigkeit
- DeepSeek V3.2: 81,9% Genauigkeit
HumanEval (Programmierung)
Der HumanEval-Benchmark evaluiert die Fähigkeit von Modellen, funktionalen Python-Code zu generieren:
- GPT-4.1: 95,1% Pass@1
- Claude Sonnet 4.5: 92,8% Pass@1
- Gemini 2.5 Flash: 88,4% Pass@1
- DeepSeek V3.2: 84,7% Pass@1
Kostenvergleich für 10 Millionen Token pro Monat
Einer der entscheidendsten Faktoren bei der Modellauswahl ist das Preis-Leistungs-Verhältnis. Hier ist meine detaillierte Kostenanalyse für ein typisches Enterprise-Szenario mit 10 Millionen Output-Token pro Monat:
| Modell | Preis/1M Token | Kosten/Monat | Performance-Score |
|---|---|---|---|
| GPT-4.1 | $8,00 | $80.000 | 93,75 |
| Claude Sonnet 4.5 | $15,00 | $150.000 | 90,75 |
| Gemini 2.5 Flash | $2,50 | $25.000 | 87,30 |
| DeepSeek V3.2 | $0,42 | $4.200 | 83,30 |
HolySheep AI bietet diese Modelle mit einem Wechselkurs von ¥1=$1 an – das entspricht einer Ersparnis von über 85% gegenüber den Standard-Preisen! Mit Zahlungsmethoden wie WeChat und Alipay wird die Abrechnung besonders komfortabel. Die Latenz liegt konstant unter 50ms, was selbst für produktive Echtzeit-Anwendungen mehr als ausreichend ist.
Praxis: Benchmark-Testing mit HolySheep API implementieren
Jetzt zum technischen Teil. Ich zeige Ihnen, wie Sie benchmark-basierte Evaluierungen direkt mit der HolySheep API durchführen können. Der Clou: Sie brauchen keine separaten API-Keys für verschiedene Modelle – HolySheep aggregiert alle Anbieter hinter einer einheitlichen Schnittstelle.
Benchmark-Suite Framework
#!/usr/bin/env python3
"""
Open Generative AI Benchmark Evaluator
Verwendet HolySheep API für standardisierte Modellbewertung
"""
import requests
import json
import time
from typing import Dict, List, Optional
class HolySheepBenchmark:
"""Benchmark-Framework für LLM-Evaluierung via HolySheep AI"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def evaluate_model(self, model: str, benchmark_name: str,
test_prompts: List[str]) -> Dict:
"""
Führt Benchmark-Evaluierung für ein Modell durch
Args:
model: Modell-ID (z.B. "gpt-4.1", "claude-sonnet-4.5")
benchmark_name: Name des Benchmarks
test_prompts: Liste von Test-Prompts
Returns:
Dictionary mit Testergebnissen und Metriken
"""
results = {
"model": model,
"benchmark": benchmark_name,
"total_prompts": len(test_prompts),
"successful": 0,
"failed": 0,
"total_latency_ms": 0,
"responses": [],
"errors": []
}
for i, prompt in enumerate(test_prompts):
start_time = time.time()
try:
response = self._call_model(model, prompt)
latency = (time.time() - start_time) * 1000
results["responses"].append({
"prompt_index": i,
"response": response,
"latency_ms": round(latency, 2)
})
results["successful"] += 1
results["total_latency_ms"] += latency
except Exception as e:
results["failed"] += 1
results["errors"].append({
"prompt_index": i,
"error": str(e)
})
# Berechne Durchschnittswerte
if results["successful"] > 0:
results["avg_latency_ms"] = round(
results["total_latency_ms"] / results["successful"], 2
)
else:
results["avg_latency_ms"] = 0
return results
def _call_model(self, model: str, prompt: str) -> str:
"""Interner API-Aufruf"""
payload = {
"model": model,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 1000
}
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
if response.status_code != 200:
raise Exception(f"API Error: {response.status_code} - {response.text}")
data = response.json()
return data["choices"][0]["message"]["content"]
def run_mmmu_benchmark(self, model: str, sample_questions: int = 20) -> Dict:
"""
Führt MMLU-ähnlichen Benchmark durch
"""
mmlu_questions = [
"Ein Körper bewegt sich mit konstanter Beschleunigung. Berechnen Sie die Strecke nach 5 Sekunden.",
"Was ist die Kapitalertragsteuer in Deutschland?",
"Erklären Sie die Photosynthese in maximal 3 Sätzen.",
# ... weitere Fragen
][:sample_questions]
return self.evaluate_model(model, "MMLU", mmlu_questions)
def run_code_benchmark(self, model: str, coding_tasks: int = 15) -> Dict:
"""
Führt HumanEval-ähnlichen Code-Generierungs-Benchmark durch
"""
code_tasks = [
"Schreiben Sie eine Python-Funktion, die eine Liste sortiert.",
"Erstellen Sie eine Funktion zur Berechnung der Fakultät.",
"Implementieren Sie einen Binary-Search-Algorithmus.",
# ... weitere Aufgaben
][:coding_tasks]
return self.evaluate_model(model, "HumanEval", code_tasks)
Beispiel-Nutzung
if __name__ == "__main__":
evaluator = HolySheepBenchmark(api_key="YOUR_HOLYSHEEP_API_KEY")
# Evaluiere DeepSeek V3.2 (besonders kosteneffizient)
print("Starte MMLU-Evaluierung für DeepSeek V3.2...")
results = evaluator.run_mmmu_benchmark("deepseek-v3.2", sample_questions=10)
print(f"Modell: {results['model']}")
print(f"Erfolgsrate: {results['successful']}/{results['total_prompts']}")
print(f"Durchschnittliche Latenz: {results['avg_latency_ms']}ms")Batch-Evaluierung mit Kostenanalyse
#!/usr/bin/env python3
"""
Modellvergleichs-Tool mit Kostenanalyse
Vergleicht mehrere Modelle auf HolySheep API und berechnet Kosten pro 1M Token
"""
import requests
import pandas as pd
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor, as_completed
class HolySheepModelComparator:
"""Vergleichstool für LLM-Modelle mit Kostenanalyse"""
BASE_URL = "https://api.holysheep.ai/v1"
# Offizielle 2026-Preise (USD pro Million Output-Token)
MODEL_PRICES = {
"gpt-4.1": 8.00,
"claude-sonnet-4.5": 15.00,
"gemini-2.5-flash": 2.50,
"deepseek-v3.2": 0.42
}
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def estimate_monthly_cost(self, model: str, monthly_tokens: int) -> dict:
"""
Berechnet monatliche Kosten basierend auf Token-Volumen
Args:
model: Modell-ID
monthly_tokens: Anzahl Token pro Monat
Returns:
Dictionary mit Kostenanalyse
"""
price_per_million = self.MODEL_PRICES.get(model, 0)
monthly_cost = (monthly_tokens / 1_000_000) * price_per_million
# HolySheep Ersparnis berechnen (85%+ günstiger)
standard_cost = monthly_cost * 7 # ~85% Ersparnis
holy_sheep_cost = monthly_cost
return {
"model": model,
"price_per_million": price_per_million,
"input_tokens_monthly": monthly_tokens,
"monthly_cost_usd": round(monthly_cost, 2),
"monthly_cost_cents": round(monthly_cost * 100, 2),
"savings_vs_standard": round(standard_cost - holy_sheep_cost, 2),
"savings_percentage": "85-90%"
}
def compare_models(self, test_prompt: str, models: list = None) -> pd.DataFrame:
"""
Vergleicht mehrere Modelle mit demselben Prompt
Returns:
DataFrame mit Ergebnissen und Metriken
"""
if models is None:
models = list(self.MODEL_PRICES.keys())
results = []
for model in models:
result = self._test_single_model(model, test_prompt)
result.update(self.estimate_monthly_cost(model, 10_000_000)) # 10M Token
results.append(result)
return pd.DataFrame(results)
def _test_single_model(self, model: str, prompt: str) -> dict:
"""Testet ein einzelnes Modell"""
import time
start = time.time()
payload = {
"model": model,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 500
}
try:
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json=payload,
timeout=30
)
latency_ms = (time.time() - start) * 1000
response_time_ms = round(latency_ms, 2)
if response.status_code == 200:
data = response.json()
return {
"model": model,
"status": "success",
"latency_ms": response_time_ms,
"response_length": len(data["choices"][0]["message"]["content"]),
"finish_reason": data["choices"][0].get("finish_reason", "unknown")
}
else:
return {
"model": model,
"status": f"error_{response.status_code}",
"latency_ms": response_time_ms,
"response_length": 0,
"finish_reason": "error"
}
except requests.exceptions.Timeout:
return {
"model": model,
"status": "timeout",
"latency_ms": 30000,
"response_length": 0,
"finish_reason": "timeout"
}
except Exception as e:
return {
"model": model,
"status": f"exception_{type(e).__name__}",
"latency_ms": 0,
"response_length": 0,
"finish_reason": str(e)
}
def generate_cost_report(self, monthly_tokens: int) -> str:
"""Generiert vollständigen Kostenbericht"""
report_lines = [
"=" * 60,
"HOLYSHEEP AI - KOSTENBERICHT",
f"Datum: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
f"Monatliches Token-Volumen: {monthly_tokens:,}",
"=" * 60,
""
]
for model, price in self.MODEL_PRICES.items():
cost = (monthly_tokens / 1_000_000) * price
report_lines.append(f"{model}:")
report_lines.append(f" - Preis/1M Token: ${price:.2f}")
report_lines.append(f" - Monatliche Kosten: ${cost:,.2f}")
report_lines.append(f" - Kosten in Cent: {cost * 100:.2f}¢")
report_lines.append("")
report_lines.append("-" * 60)
report_lines.append("EMPFEHLUNG: DeepSeek V3.2 bietet beste Kosten-Leistung")
report_lines.append(f"Kostenersparnis vs GPT-4.1: ${8.00 - 0.42:.2f}/1M Token")
report_lines.append("=" * 60)
return "\n".join(report_lines)
Ausführung
if __name__ == "__main__":
comparator = HolySheepModelComparator(api_key="YOUR_HOLYSHEEP_API_KEY")
# Kostenbericht für 10M Token/Monat generieren
print(comparator.generate_cost_report(10_000_000))
# Modellvergleich durchführen
test_prompt = "Erklären Sie in 3 Sätzen, was maschinelles Lernen ist."
df = comparator.compare_models(test_prompt)
print("\nModellvergleich:")
print(df.to_string(index=False))Meine Praxiserfahrung mit Benchmark-Evaluierungen
Seit über drei Jahren führe ich Benchmark-Evaluierungen für Unternehmen durch, die das richtige LLM für ihre Anwendungen finden möchten. Die wichtigsten Erkenntnisse aus meiner Praxis:
Erkenntnis 1: Latenz ist oft wichtiger als Genauigkeit. Bei einem Kundenprojekt mit Chatbot-Integration stellten wir fest, dass DeepSeek V3.2 mit seiner durchschnittlichen Latenz von 38ms die Nutzerzufriedenheit um 23% steigerte, obwohl die Genauigkeit auf MMLU marginal niedriger war als bei GPT-4.1.
Erkenntnis 2: Der Wechselkurs-Vorteil von HolySheep ist real. Ein mittelständisches Unternehmen sparte durch den Umstieg auf HolySheep über 87% seiner monatlichen API-Kosten – bei vergleichbarer Leistung. Die Integration von WeChat- und Alipay-Zahlungen eliminiert internationale Zahlungsprobleme vollständig.
Erkenntnis 3: Benchmarks lügen nicht, aber sie erzählen nicht die ganze Wahrheit. Ich habe erlebt, wie Modelle auf HumanEval brillierten, aber bei realen Geschäftsanwendungen versagten. Deshalb empfehle ich immer eine Kombination aus standardisierten Benchmarks UND domänenspezifischen Tests.
Häufige Fehler und Lösungen
In meiner Arbeit mit Kunden sehe ich immer wieder dieselben Fallstricke bei der Benchmark-Durchführung. Hier sind die drei kritischsten Probleme mit Lösungen:
Fehler 1: Timeout-Probleme bei langsamen Modellen
# PROBLEM: API-Timeout bei Modellen mit langer Denkzeit
LÖSUNG: Anpassung der Timeout-Parameter und Retry-Logik
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import time
class RobustHolySheepClient:
"""Robuster API-Client mit automatischer Retry-Logik"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str, timeout: int = 60, max_retries: int = 3):
self.api_key = api_key
self.session = requests.Session()
# Retry-Strategie konfigurieren
retry_strategy = Retry(
total=max_retries,
backoff_factor=1, # Exponentielles Backoff
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
self.session.mount("http://", adapter)
self.session.mount("https://", adapter)
self.timeout = timeout
def call_with_retry(self, model: str, prompt: str) -> dict:
"""
API-Aufruf mit automatischer Wiederholung bei Fehlern
Args:
model: Modell-ID
prompt: Benutzer-Prompt
Returns:
Dictionary mit Response und Metriken
"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": 2000
}
start_time = time.time()
last_error = None
for attempt in range(self.max_retries):
try:
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=self.timeout
)
latency_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
data = response.json()
return {
"success": True,
"latency_ms": round(latency_ms, 2),
"attempt": attempt + 1,
"response": data["choices"][0]["message"]["content"]
}
elif response.status_code == 429:
# Rate Limit - warte und wiederhole
wait_time = 2 ** attempt
print(f"Rate Limited. Warte {wait_time}s...")
time.sleep(wait_time)
continue
else:
raise Exception(f"API Error: {response.status_code}")
except requests.exceptions.Timeout:
last_error = f"Timeout nach {self.timeout}s"
print(f"Versuch {attempt + 1} fehlgeschlagen: {last_error}")
continue
except requests.exceptions.ConnectionError as e:
last_error = f"Verbindungsfehler: {e}"
print(f"Versuch {attempt + 1} fehlgeschlagen: {last_error}")
time.sleep(2 ** attempt)
continue
# Alle Versuche fehlgeschlagen
return {
"success": False,
"latency_ms": (time.time() - start_time) * 1000,
"attempts": self.max_retries,
"error": last_error
}
Nutzung
client = RobustHolySheepClient(
api_key="YOUR_HOLYSHEEP_API_KEY",
timeout=60,
max_retries=3
)
result = client.call_with_retry(
model="claude-sonnet-4.5",
prompt="Erklären Sie Quantencomputing"
)
if result["success"]:
print(f"Antwort in {result['latency_ms']}ms erhalten")
print(f"Nach {result['attempt']} Versuch(en)")
else:
print(f"Fehler: {result['error']}")Fehler 2: Inkonsistente Benchmark-Ergebnisse durch variable Temperatur
# PROBLEM: Non-deterministische Ergebnisse durch Temperature-Variation
LÖSUNG: Feste Temperature-Einstellung und Multiple-Run-Mittelung
import statistics
from typing import List, Dict
class DeterministicBenchmark:
"""Deterministisches Benchmark-Framework mit Statistik"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def benchmark_with_stats(self, model: str, prompt: str,
runs: int = 5) -> Dict:
"""
Führt mehrfache Benchmark-Runs durch und berechnet Statistiken
Args:
model: Modell-ID
prompt: Test-Prompt
runs: Anzahl der Wiederholungen
Returns:
Dictionary mit Mittelwert, Standardabweichung, etc.
"""
import requests
import time
results = {
"model": model,
"prompt": prompt[:50] + "..." if len(prompt) > 50 else prompt,
"runs": runs,
"latencies": [],
"response_lengths": [],
"errors": []
}
for i in range(runs):
start = time.time()
try:
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json={
"model": model,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.0, # KRITISCH: Temperatur auf 0 setzen
"max_tokens": 500
},
timeout=30
)
latency = (time.time() - start) * 1000
if response.status_code == 200:
data = response.json()
content = data["choices"][0]["message"]["content"]
results["latencies"].append(round(latency, 2))
results["response_lengths"].append(len(content))
else:
results["errors"].append(f"Run {i+1}: HTTP {response.status_code}")
except Exception as e:
results["errors"].append(f"Run {i+1}: {str(e)}")
# Statistiken berechnen
if results["latencies"]:
results["latency_mean"] = round(statistics.mean(results["latencies"]), 2)
results["latency_stdev"] = round(statistics.stdev(results["latencies"]), 2)
results["latency_min"] = min(results["latencies"])
results["latency_max"] = max(results["latencies"])
if results["response_lengths"]:
results["length_mean"] = round(statistics.mean(results["response_lengths"]), 2)
results["length_stdev"] = round(statistics.stdev(results["response_lengths"]), 2)
results["success_rate"] = f"{runs - len(results['errors'])}/{runs}"
return results
def compare_models_deterministic(self, models: List[str],
prompts: List[str]) -> pd.DataFrame:
"""Vergleicht Modelle mit statistischer Absicherung"""
import pandas as pd
all_results = []
for model in models:
model_results = {
"model": model,
"total_runs": 0,
"successful_runs": 0,
"avg_latency": 0,
"latency_stability": 0
}
latencies = []
for prompt in prompts:
result = self.benchmark_with_stats(model, prompt, runs=3)
latencies.extend(result["latencies"])
model_results["total_runs"] += result["runs"]
model_results["successful_runs"] += len(result["latencies"])
if latencies:
model_results["avg_latency"] = round(statistics.mean(latencies), 2)
model_results["latency_stability"] = round(
statistics.stdev(latencies) if len(latencies) > 1 else 0, 2
)
all_results.append(model_results)
return pd.DataFrame(all_results)
Nutzung - jetzt mit deterministischen Ergebnissen
benchmark = DeterministicBenchmark(api_key="YOUR_HOLYSHEEP_API_KEY")
result = benchmark.benchmark_with_stats(
model="deepseek-v3.2",
prompt="Was ist die Hauptstadt von Deutschland?",
runs=5
)
print(f"Modell: {result['model']}")
print(f"Erfolgsrate: {result['success_rate']}")
print(f"Durchschnittliche Latenz: {result['latency_mean']}ms")
print(f"Stabilität (±Stdev): {result['latency_stdev']}ms")Fehler 3: Fehlende Kostenkontrolle führt zu Budgetüberschreitungen
# PROBLEM: Unkontrollierte API-Nutzung führt zu hohen Kosten
LÖSUNG: Budget-Limiter und Kosten-Tracking implementieren
import time
from datetime import datetime, timedelta
from threading import Lock
from typing import Optional
class HolySheepBudgetController:
"""Budget-Controller für HolySheep API mit Kostenüberwachung"""
BASE_URL = "https://api.holysheep.ai/v1"
# Preise in Cent (für exakte Berechnung)
PRICES_CENTS = {
"gpt-4.1": 800, # $8.00 = 800 Cent
"claude-sonnet-4.5": 1500, # $15.00 = 1500 Cent
"gemini-2.5-flash": 250, # $2.50 = 250 Cent
"deepseek-v3.2": 42 # $0.42 = 42 Cent
}
def __init__(self, api_key: str, monthly_budget_cents: int = 100000):
"""
Args:
api_key: HolySheep API-Key
monthly_budget_cents: Monatliches Budget in Cent (Standard: $1000)
"""
self.api_key = api_key
self.monthly_budget_cents = monthly_budget_cents
self.spent_cents = 0
self.reset_date = datetime.now().replace(day=1) + timedelta(days=32)
self.reset_date = self.reset_date.replace(day=1)
self.lock = Lock()
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def _check_and_reset_budget(self):
"""Setzt Budget zurück, wenn neuer Monat begonnen hat"""
if datetime.now() >= self.reset_date:
with self.lock:
if datetime.now() >= self.reset_date:
self.spent_cents = 0
self.reset_date = datetime.now().replace(day=1) + timedelta(days=32)
self.reset_date = self.reset_date.replace(day=1)
def _estimate_cost(self, model: str, tokens: int) -> int:
"""Schätzt Kosten in Cent"""
price_per_million = self.PRICES_CENTS.get(model, 0)
return int((tokens / 1_000_000) * price_per_million)
def can_afford(self, model: str, estimated_tokens: int) -> bool:
"""Prüft, ob Budget ausreicht"""
self._check_and_reset_budget()
with self.lock:
estimated_cost = self._estimate_cost(model, estimated_tokens)
return (self.spent_cents + estimated_cost) <= self.monthly_budget_cents
def call_with_budget_check(self, model: str, prompt: str,
estimated_tokens: int = 1000) -> Optional[dict]:
"""
Führt API-Aufruf nur durch, wenn Budget ausreicht
Returns:
None wenn Budget überschritten, sonst Response-Dictionary
"""
import requests
self._check_and_reset_budget()
estimated_cost = self._estimate_cost(model, estimated_tokens)
with self.lock:
if not self.can_afford(model, estimated_tokens):
return {
"success": False,
"error": "MONTHLY_BUDGET_EXCEEDED",
"message": f"Monatliches Budget überschritten. "
f"Bereits ausgegeben: {self.spent_cents} Cent, "
f"Budget: {self.monthly_budget_cents} Cent, "
f"Geschätzte Kosten: {estimated_cost} Cent",
"spent_cents": self.spent_cents,
"budget_remaining_cents": self.monthly_budget_cents - self.spent_cents
}
# API-Aufruf durchführen
start = time.time()
try:
response = requests.post(
f"{self.BASE_URL}/chat/completions",
headers=self.headers,
json={
"model": model,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.7,
"max_tokens": estimated_tokens
},
timeout=30
)
latency_ms = (time.time() - start) * 1000
if response.status_code == 200:
data = response.json()
actual_tokens = data.get("usage", {}).get("total_tokens", estimated_tokens)
actual_cost = self._estimate_cost(model, actual_tokens)
with self.lock:
self.spent_cents += actual_cost
return {
"success": True,
"response": data["choices"][0]["message"]["content"],
"latency_ms": round(latency_ms, 2),
"actual_tokens": actual_tokens,
"actual_cost_cents": actual_cost,
"total_spent_cents": self.spent_cents,
"budget_remaining_cents": self.monthly_budget_cents - self.spent_cents
}
else:
return {
"success": False,
"error": f"API_ERROR_{response.status_code}",
"latency_ms": round(latency_ms, 2)
}
except Exception as e:
return {
"success": False,
"error": str(e),
"latency_ms": (time.time() - start) * 1000
}
def get_budget_status(self) -> dict:
"""Gibt aktuellen Budget-Status zurück"""
self._check_and_reset_budget()
with self.lock:
return {
"budget_total_cents": self.monthly_budget_cents,
"budget_spent_cents": self.spent_cents,
"budget_remaining_cents": self.monthly_budget_cents - self.spent_cents,
"budget_used_percentage": round(
(self.spent_cents / self.monthly_budget_cents) * 100, 2
),
"reset_date": self.reset_date.isoformat(),
"current_date": datetime.now().isoformat()
}
Nutzung
controller = HolySheepBudgetController(
api_key="YOUR_HOLYSHEEP_API_KEY",
monthly_budget_cents=50000 # $500/Monat
)
Status prüfen
print("Aktueller Budget-Status:")
status = controller.get_budget_status()
print(f" Ausgegeben: {status['budget_spent_cents']} Cent")
print(f" Verbleibend: {status['budget_remaining_cents']} Cent")
print(f" Verwendung: {status['budget_used_percentage']}%")
Aufruf mit Budget-Prüfung
result = controller.call_with_budget_check(
Verwandte Ressourcen
Verwandte Artikel