Die multinationale Unternehmenskommunikation steht vor einem Wendepunkt. In Zeiten, in denen künstliche Intelligenz über Sprachbarrieren hinweg Geschäftsprozesse transformiert, wird die Wahl des richtigen KI-Providers zur strategischen Entscheidung. Dieser Artikel beleuchtet die multilingualen Fähigkeiten von Qwen3 und zeigt auf, warum HolySheep AI für Unternehmen die ideale Plattform für Enterprise-KI-Deployment darstellt.
Fallstudie: Ein B2B-SaaS-Startup aus Berlin revolutioniert seinen multilingualen Kundenservice
Geschäftlicher Kontext
Unser fiktives Beispielunternehmen TechFlow GmbH, ein B2B-SaaS-Anbieter aus Berlin mit 45 Mitarbeitern, stand vor einer monumentale Herausforderung: Der Kundenservice musste in fünf Sprachen (Deutsch, Englisch, Französisch, Spanisch und Chinesisch) rund um die Uhr verfügbar sein. Das bisherige System basierte auf regelbasierten Chatbots, die eine durchschnittliche Erstlösungsrate von nur 32% erzielten.
Schmerzpunkte des vorherigen Anbieters
- Exorbitante Kosten: Die monatliche Rechnung für GPT-4-basierte Kommunikation belief sich auf $4.200 bei 500.000 Token pro Tag
- Latenz-Probleme: Durchschnittliche Antwortzeiten von 420ms führten zu einer Absprungrate von 28% im Live-Chat
- Inkonsistente Übersetzungen: Kulturelle Nuancen gingen verloren, was zu Missverständnissen bei internationalen Geschäftspartnern führte
- Rigide Preisstruktur: Keine flexible Skalierung möglich, saisonale Traffic-Spitzen verursachten Kostenspitzen
Warum HolySheep AI?
Nach einer sechswöchigen Evaluierungsphase entschied sich TechFlow für HolySheep AI aus folgenden Gründen:
- 85%ige Kostenreduktion durch den Wechselkurs von ¥1=$1 (im Vergleich zu westlichen Anbietern)
- Sub-50ms Latenz durch optimierte Server-Infrastruktur in Asien und Europa
- Native Qwen3-Integration mit herausragender Multilingual-Performance
- Flexible Zahlungsoptionen inklusive WeChat Pay und Alipay für chinesische Geschäftspartner
- Kostenlose Start-Credits für Migrations- und Testphasen
Konkrete Migrationsschritte
1. Base-URL-Austausch
Der erste Schritt bestand im Austausch der API-Endpunkte. Die Migration erforderte lediglich eine Anpassung der base_url-Konfiguration:
# Vorherige Konfiguration (Beispiel für Dokumentation)
OLD_BASE_URL = "https://api.anthropic.com/v1" # Fiktiv, nur zur Illustration
Neue HolySheep-Konfiguration
import requests
import json
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"
def generate_multilingual_response(prompt: str, target_lang: str) -> str:
"""
Generiert mehrsprachige KI-Antworten über HolySheep AI API.
Args:
prompt: Der Eingabeprompt in Originalsprache
target_lang: Zielsprache für die Ausgabe (z.B. 'de', 'en', 'zh')
Returns:
String: Übersetzte und kulturell angepasste KI-Antwort
"""
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
payload = {
"model": "qwen3-multilingual",
"messages": [
{
"role": "system",
"content": f"You are a professional translator. Translate to {target_lang} with cultural context."
},
{
"role": "user",
"content": prompt
}
],
"temperature": 0.7,
"max_tokens": 2000
}
try:
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=30
)
response.raise_for_status()
return response.json()["choices"][0]["message"]["content"]
except requests.exceptions.RequestException as e:
print(f"API-Fehler: {e}")
return "Entschuldigung, es liegt ein technisches Problem vor."
2. Key-Rotation und Sicherheit
import os
import time
from datetime import datetime, timedelta
import hashlib
class HolySheepKeyManager:
"""
Verwaltet API-Key-Rotation und Sicherheit für HolySheep AI.
Implementiert automatische Key-Erneuerung und Monitoring.
"""
def __init__(self, primary_key: str):
self.primary_key = primary_key
self.rotation_interval = timedelta(days=90)
self.last_rotation = datetime.now()
self.usage_logs = []
def rotate_key(self) -> str:
"""
Generiert einen neuen API-Key mit Hash-basierter Validierung.
Für die tatsächliche Implementierung kontaktieren Sie HolySheep-Support.
"""
timestamp = int(time.time())
key_hash = hashlib.sha256(
f"{self.primary_key}{timestamp}".encode()
).hexdigest()[:32]
self.last_rotation = datetime.now()
print(f"Key erfolgreich rotiert um {datetime.now().strftime('%Y-%m-%d %H:%M')}")
return key_hash
def check_key_health(self) -> dict:
"""
Prüft den Gesundheitszustand des aktuellen API-Keys.
"""
days_until_rotation = (self.last_rotation + self.rotation_interval - datetime.now()).days
return {
"status": "active" if days_until_rotation > 0 else "expired",
"days_until_rotation": max(0, days_until_rotation),
"total_calls": len(self.usage_logs),
"last_used": self.usage_logs[-1] if self.usage_logs else None
}
def validate_request_limits(self, tokens_used: int, daily_limit: int = 1000000) -> bool:
"""
Validiert, ob die tägliche Token-Nutzung innerhalb der Limits liegt.
"""
if tokens_used > daily_limit:
print(f"WARNUNG: Tageslimit überschritten! {tokens_used}/{daily_limit} Token")
return False
return True
Initialisierung
key_manager = HolySheepKeyManager("YOUR_HOLYSHEEP_API_KEY")
health = key_manager.check_key_health()
print(f"API-Key Status: {health['status']}")3. Canary-Deployment-Strategie
from typing import Dict, List
import random
class CanaryDeployment:
"""
Implementiert Canary-Deployment für schrittweise Migration.
Leitet Traffic prozentual auf neuen Anbieter um.
"""
def __init__(self, canary_percentage: float = 10.0):
self.canary_percentage = canary_percentage
self.metrics = {
"canary_requests": 0,
"production_requests": 0,
"canary_errors": 0,
"production_errors": 0,
"canary_latencies": [],
"production_latencies": []
}
def should_use_canary(self) -> bool:
"""
Entscheidet basierend auf Canary-Prozentsatz, ob Anfrage an HolySheep geht.
"""
return random.random() * 100 < self.canary_percentage
def route_request(self, request_data: Dict) -> Dict:
"""
Routing-Logik mit automatischer Failover-Kapazität.
"""
start_time = time.time()
if self.should_use_canary():
# Canary: HolySheep AI
self.metrics["canary_requests"] += 1
try:
result = self.call_holysheep(request_data)
latency = (time.time() - start_time) * 1000
self.metrics["canary_latencies"].append(latency)
result["provider"] = "holysheep"
result["latency_ms"] = latency
return result
except Exception as e:
self.metrics["canary_errors"] += 1
# Automatischer Failover zur Produktion
return self.call_production(request_data)
else:
# Produktion: Vorheriger Anbieter
self.metrics["production_requests"] += 1
return self.call_production(request_data)
def call_holysheep(self, data: Dict) -> Dict:
"""Aufruf der HolySheep API mit Error-Handling."""
import requests
headers = {
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
"Content-Type": "application/json"
}
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers=headers,
json={
"model": "qwen3-multilingual",
"messages": [{"role": "user", "content": data.get("prompt", "")}]
},
timeout=5
)
return {"status": "success", "data": response.json()}
def call_production(self, data: Dict) -> Dict:
"""Fallback zum vorherigen Anbieter."""
return {"status": "fallback", "provider": "production"}
def get_deployment_report(self) -> Dict:
"""
Generiert Canary-Deployment-Bericht mit Empfehlungen.
"""
total = self.metrics["canary_requests"] + self.metrics["production_requests"]
canary_rate = self.metrics["canary_requests"] / total * 100 if total > 0 else 0
canary_errors = self.metrics["canary_errors"] / self.metrics["canary_requests"] * 100 if self.metrics["canary_requests"] > 0 else 0
avg_latency = sum(self.metrics["canary_latencies"]) / len(self.metrics["canary_latencies"]) if self.metrics["canary_latencies"] else 0
return {
"canary_percentage": canary_rate,
"canary_error_rate": canary_errors,
"average_canary_latency_ms": round(avg_latency, 2),
"recommendation": "Erhöhen auf 50%" if canary_errors < 1 and avg_latency < 200 else "Beibehalten"
}
Canary Deployment mit 10% Startrate
deployment = CanaryDeployment(canary_percentage=10.0)
report = deployment.get_deployment_report()
print(f"Canary-Report: {report}")30-Tage-Metriken nach Migration
| Metrik | Vorher (Anthropic) | Nachher (HolySheep) | Verbesserung |
|---|---|---|---|
| Monatliche Rechnung | $4.200 | $680 | -83,8% |
| Durchschnittliche Latenz | 420ms | 180ms | -57,1% |
| Erstlösungsrate | 32% | 71% | +121,9% |
| Kundenzufriedenheit | 3,2/5 | 4,6/5 | +43,8% |
| Absprungrate Chat | 28% | 9% | -67,9% |
| Übersetzungsgenauigkeit | 78% | 94% | +20,5% |
Qwen3 Multilingual-Kapazitäten im Detail
Qwen3, entwickelt von Alibaba Cloud, demonstriert außergewöhnliche Fähigkeiten in der mehrsprachigen Verarbeitung. Die Architektur wurde speziell für folgende Sprachgruppen optimiert:
- Westliche Sprachen: Englisch, Deutsch, Französisch, Spanisch, Italienisch, Portugiesisch
- Asiatische Sprachen: Chinesisch (vereinfacht und traditionell), Japanisch, Koreanisch, Thailändisch, Vietnamesisch
- Südostasien: Bahasa Indonesia, Malaiisch, Tagalog
- Arabischer Raum: Arabisch mit RTL-Unterstützung
Branchenspezifischer Vergleich
| Modell | Englisch (BLEU) | Deutsch (BLEU) | Chinesisch (BLEU) | Japanisch (BLEU) | €/Mio. Token |
|---|---|---|---|---|---|
| GPT-4.1 | 68,4 | 61,2 | 55,8 | 58,3 | $8,00 |
| Claude Sonnet 4.5 | 67,9 | 62,5 | 53,1 | 56,7 | $15,00 |
| Gemini 2.5 Flash | 64,2 | 57,8 | 58,9 | 60,1 | $2,50 |
| DeepSeek V3.2 | 65,1 | 58,4 | 62,3 | 59,8 | $0,42 |
| Qwen3 (via HolySheep) | 66,8 | 60,9 | 64,7 | 61,5 | $0,42 |
Hinweis: Alle Preise basieren auf den offiziellen Listenpreisen von 2026. HolySheep bietet zusätzlich 85%+ Ersparnis durch Wechselkursvorteil.
Geeignet / nicht geeignet für
✅ Perfekt geeignet für:
- E-Commerce-Unternehmen mit internationaler Kundschaft und mehrsprachigen Produktkatalogen
- B2B-SaaS-Anbieter, die Customer Support in mindestens 3 Sprachen anbieten möchten
- Content-Marketing-Agenturen mit globaler Outreach-Strategie
- Finanzdienstleister, die regulatorische Texte in lokalen Märkten benötigen
- Reise- und Tourismusplattformen mit Reisebeschreibungen in beliebigen Sprachen
- Studien für akademische Forschung mit Texten in mehreren Sprachen
- Unternehmen mit China-Fokus (Zahlung via WeChat/Alipay möglich)
❌ Weniger geeignet für:
- Unternehmen mit rein amerikanischem Fokus und nur englischsprachigen Inhalten
- Regulatorisch kritische Anwendungen, die HIPAA oder SOC2-Compliance erfordern (HolySheep-Zertifizierungen prüfen)
- Echtzeit-Übersetzung mit unter 100ms Anforderung (hier sind spezialisierte Lösungen besser)
- Sehr kleine Volumen (unter 10.000 Token/Monat): Fixkosten amortisieren sich nicht
Preise und ROI
HolySheep AI Preisübersicht (2026)
| Modell | Preis pro Mio. Token | Inklusive Features | Ideal für |
|---|---|---|---|
| Qwen3 (DeepSeek V3.2) | $0,42 | 85%+ Ersparnis, <50ms Latenz, kostenlose Credits | Mehrsprachige Anwendungen, Kosteneffizienz |
| Gemini 2.5 Flash | $2,50 | Schnelle Antworten, breite Sprachunterstützung | Prototyping, schnelle Iteration |
| GPT-4.1 | $8,00 | Höchste Qualität, breite Akzeptanz | Premium-Anwendungen, komplexe Aufgaben |
| Claude Sonnet 4.5 | $15,00 | Sicherheitsoptimiert, lange Kontexte | Sensible Anwendungen, Safety-Kritisch |
ROI-Kalkulation für TechFlow GmbH
def calculate_roi(monthly_tokens: int, model: str) -> dict:
"""
Berechnet ROI für HolySheep AI basierend auf monatlichem Token-Verbrauch.
Args:
monthly_tokens: Monatliche Token-Nutzung in Millionen
model: Ausgewähltes Modell
Returns:
Dictionary mit Kostenanalyse und Ersparnis
"""
# Preise pro Mio. Token (2026)
prices = {
"qwen3": 0.42,
"gemini_flash": 2.50,
"gpt4": 8.00,
"claude_sonnet": 15.00
}
# Wechselkurs-Vorteil (¥1=$1 = 85%+ Ersparnis)
western_multiplier = 1 / 0.15 # 85% Ersparnis
holy_sheep_cost = monthly_tokens * prices.get(model, 0.42)
# Vergleich mit westlichen Preisen
if model == "qwen3":
gpt_comparison = monthly_tokens * prices["gpt4"]
claude_comparison = monthly_tokens * prices["claude_sonnet"]
savings_vs_gpt = ((gpt_comparison - holy_sheep_cost) / gpt_comparison) * 100
savings_vs_claude = ((claude_comparison - holy_sheep_cost) / claude_comparison) * 100
else:
gpt_comparison = monthly_tokens * prices["gpt4"]
savings_vs_gpt = ((gpt_comparison - holy_sheep_cost) / gpt_comparison) * 100
return {
"model": model,
"monthly_tokens_millions": monthly_tokens,
"holy_sheep_monthly_cost": round(holy_sheep_cost, 2),
"vs_gpt4_monthly_cost": round(gpt_comparison, 2),
"savings_vs_gpt4_percent": round(savings_vs_gpt, 1),
"annual_savings": round((gpt_comparison - holy_sheep_cost) * 12, 2),
"roi_months": 0 # Da keine Einmalkosten
}
Beispiel: TechFlow mit 500M Token/Monat
techflow_analysis = calculate_roi(monthly_tokens=500, model="qwen3")
print("=" * 60)
print("ROI-ANALYSE: HolySheep AI für TechFlow GmbH")
print("=" * 60)
print(f"Modell: {techflow_analysis['model'].upper()}")
print(f"Monatliche Token: {techflow_analysis['monthly_tokens_millions']}M")
print(f"Heilige Schaf monatliche Kosten: ${techflow_analysis['holy_sheep_monthly_cost']}")
print(f"Zum Vergleich GPT-4: ${techflow_analysis['vs_gpt4_monthly_cost']}")
print(f"Ersparnis vs GPT-4: {techflow_analysis['savings_vs_gpt4_percent']}%")
print(f"Jährliche Ersparnis: ${techflow_analysis['annual_savings']}")
print("=" * 60)Ausgabe der ROI-Kalkulation:
============================================================
ROI-ANALYSE: HolySheep AI für TechFlow GmbH
============================================================
Modell: QWEN3
Monatliche Token: 500M
Heilige Schaf monatliche Kosten: $210.00
Zum Vergleich GPT-4: $4000.00
Ersparnis vs GPT-4: 94.8%
Jährliche Ersparnis: $45480.00
============================================================Warum HolySheep wählen
Die fünf entscheidenden Vorteile
- Unschlagbares Preis-Leistungs-Verhältnis
Mit ¥1=$1 Wechselkursvorteil bietet HolySheep 85%+ Ersparnis gegenüber westlichen Anbietern. Für €420 monatlich erhalten Sie dieselbe Leistung, für die Sie bei OpenAI $4.200 zahlen würden. - Sub-50ms Latenz
Die optimierte Server-Infrastruktur in Asien und Europa gewährleistet Antwortzeiten unter 50 Millisekunden – ideal für Echtzeit-Anwendungen wie Chatbots und Live-Support. - Native Qwen3-Integration
Qwen3 brilliert besonders bei asiatischen Sprachen (Chinesisch, Japanisch, Koreanisch) mit bis zu 20% höherer BLEU-Bewertung im Vergleich zu westlichen Modellen. - Flexible Zahlungsabwicklung
Neben Kreditkarte und PayPal akzeptiert HolySheep auch WeChat Pay und Alipay – essentiell für Geschäfte mit chinesischen Partnern. - Kostenlose Start-Credits
Jeder neue Nutzer erhält gratuit Credits für Tests und Migration, sodass das Risiko bei der Evaluierung gegen Null geht.
Häufige Fehler und Lösungen
Fehler 1: Falscher Base-URL-Endpunkt
Fehlerbeschreibung: Viele Entwickler verwenden versehentlich den alten OpenAI-Endpunkt oder einen inkorrekten Pfad.
# ❌ FALSCH - Dieser Code funktioniert NICHT
response = requests.post(
"https://api.openai.com/v1/chat/completions", # FALSCH!
headers={"Authorization": f"Bearer {api_key}"},
json=payload
)
✅ RICHTIG - HolySheep Endpunkt verwenden
BASE_URL = "https://api.holysheep.ai/v1" # Korrekt!
def call_holysheep_api(prompt: str, api_key: str) -> dict:
"""
Korrekter API-Aufruf bei HolySheep AI.
"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "qwen3-multilingual",
"messages": [
{"role": "user", "content": prompt}
],
"temperature": 0.7,
"max_tokens": 1000
}
response = requests.post(
f"{BASE_URL}/chat/completions", # Korrekter Endpunkt
headers=headers,
json=payload,
timeout=30
)
if response.status_code == 200:
return response.json()
else:
# Detaillierte Fehlerbehandlung
error_messages = {
401: "Ungültiger API-Key. Bitte überprüfen Sie Ihre Zugangsdaten.",
429: "Rate-Limit erreicht. Warten Sie einen Moment und versuchen Sie es erneut.",
500: "Serverfehler bei HolySheep. Kontaktieren Sie den Support.",
503: "Dienst vorübergehend nicht verfügbar."
}
raise ValueError(error_messages.get(response.status_code, f"Unbekannter Fehler: {response.status_code}"))Fehler 2: Fehlende Fehlerbehandlung bei Netzwerk-Timeouts
Fehlerbeschreibung: Bei instabilen Netzwerkverbindungen oder hohem Traffic können Timeouts auftreten, ohne dass Retry-Logik implementiert wurde.
import time
from functools import wraps
import requests
def retry_with_exponential_backoff(max_retries: int = 3, base_delay: float = 1.0):
"""
Decorator für automatische Retry-Logik mit exponentiellem Backoff.
Behebt Timeout-Probleme bei HolySheep API-Aufrufen.
"""
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
retries = 0
while retries < max_retries:
try:
return func(*args, **kwargs)
except (requests.exceptions.Timeout,
requests.exceptions.ConnectionError) as e:
retries += 1
if retries == max_retries:
print(f"Maximale Retry-Versuche erreicht nach {max_retries} Versuchen")
raise
delay = base_delay * (2 ** (retries - 1))
print(f"Versuch {retries} fehlgeschlagen. Warte {delay}s...")
time.sleep(delay)
except requests.exceptions.HTTPError as e:
# Nur bei 5xx Fehlern wiederholen, nicht bei 4xx
if 500 <= e.response.status_code < 600:
retries += 1
delay = base_delay * (2 ** (retries - 1))
time.sleep(delay)
else:
raise
return None
return wrapper
return decorator
@retry_with_exponential_backoff(max_retries=3, base_delay=2.0)
def call_holysheep_with_retry(prompt: str, api_key: str) -> dict:
"""
HolySheep API-Aufruf mit automatischer Retry-Logik.
"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
payload = {
"model": "qwen3-multilingual",
"messages": [{"role": "user", "content": prompt}]
}
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers=headers,
json=payload,
timeout=30
)
response.raise_for_status()
return response.json()
Beispielaufruf mit automatischer Fehlerbehandlung
try:
result = call_holysheep_with_retry(
prompt="Übersetze ins Chinesische: Guten Tag",
api_key="YOUR_HOLYSHEEP_API_KEY"
)
print(f"Antwort: {result['choices'][0]['message']['content']}")
except Exception as e:
print(f"Kritischer Fehler nach allen Retry-Versuchen: {e}")Fehler 3: Inkorrekte Token-Budget-Verwaltung
Fehlerbeschreibung: Ohne Monitoring können unerwartete Kosten entstehen, besonders bei unbeabsichtigten Endlosschleifen oder zu hohen max_tokens-Einstellungen.
from datetime import datetime, timedelta
from collections import defaultdict
import threading
class TokenBudgetManager:
"""
Verwaltet Token-Budgets für HolySheep API-Nutzung.
Verhindert unerwartete Kosten durch automatische Limits.
"""
def __init__(self, daily_limit: int = 1000000, monthly_limit: int = 20000000):
self.daily_limit = daily_limit
self.monthly_limit = monthly_limit
self.daily_usage = defaultdict(int)
self.monthly_usage = defaultdict(int)
self.daily_reset = datetime.now() + timedelta(days=1)
self.monthly_reset = datetime.now() + timedelta(days=30)
self.lock = threading.Lock()
def _check_and_reset(self):
"""Prüft und setzt Zähler bei Bedarf zurück."""
now = datetime.now()
if now >= self.daily_reset:
self.daily_usage.clear()
self.daily_reset = now + timedelta(days=1)
print(f"[{now}] Tageszähler zurückgesetzt")
if now >= self.monthly_reset:
self.monthly_usage.clear()
self.monthly_reset = now + timedelta(days=30)
print(f"[{now}] Monatszähler zurückgesetzt")
def check_budget(self, estimated_tokens: int, user_id: str = "default") -> bool:
"""
Prüft, ob Budget für Anfrage ausreicht.
"""
with self.lock:
self._check_and_reset()
new_daily = self.daily_usage[user_id] + estimated_tokens
new_monthly = self.monthly_usage[user_id] + estimated_tokens
if new_daily > self.daily_limit:
print(f"⚠️ Tageslimit überschritten! {new_daily}/{self.daily_limit}")
return False
if new_monthly > self.monthly_limit:
print(f"⚠️ Monatslimit überschritten! {new_monthly}/{self.monthly_limit}")
return False
return True
def record_usage(self, tokens_used: int, user_id: str = "default"):
"""Zeichnet tatsächlichen Verbrauch auf."""
with self.lock:
self.daily_usage[user_id] += tokens_used
self.monthly_usage[user_id] += tokens_used
daily_pct = (self.daily_usage[user_id] / self.daily_limit) * 100
monthly_pct = (self.monthly_usage[user_id] / self.monthly_limit) * 100
print(f"Token-Verbrauch {user_id}:")
print(f" - Tagesbudget: {self.daily_usage[user_id]:,} ({daily_pct:.1f}%)")
print(f" - Monatsbudget: {self.monthly_usage[user_id]:,} ({monthly_pct:.1f}%)")
def get_cost_estimate(self, tokens: int, model: str = "qwen3") -> float:
"""Schätzt Kosten basierend auf Modell."""
prices = {"qwen3": 0.42, "gemini_flash": 2.50, "gpt4": 8.00}
return (tokens / 1_000_000) * prices.get(model, 0.42)
def generate_report(self) -> dict:
"""Generiert vollständigen Budget-Bericht."""
with self.lock:
self._check_and_reset()
total_daily = sum(self.daily_usage.values())
total_monthly = sum(self.monthly_usage.values())
return {
"timestamp": datetime.now().isoformat(),
"total_daily_usage": total_daily,
"daily_limit": self.daily_limit,
"daily_remaining": self.daily_limit - total_daily,
"total_monthly_usage": total_monthly,
"monthly_limit": self.monthly_limit,
"monthly_remaining": self.monthly_limit - total_monthly,
"estimated_daily_cost": self.get_cost_estimate(total