Als Senior Backend-Entwickler bei einem mittelständischen Tech-Unternehmen habe ich in den letzten drei Jahren zahlreiche API-Migrationen begleitet. Die Umstellung von traditionellen REST-basierte AI-APIs auf GraphQL war eine unserer folgenreichsten Entscheidungen – und der Wechsel zu HolySheep AI als neuem Anbieter hat unsere Infrastrukturkosten um über 85% reduziert bei gleichzeitiger Verbesserung der Response-Zeiten auf unter 50ms.
Warum GraphQL für AI-APIs?
REST-APIs führen bei komplexen AI-Workflows häufig zu Overfetching oder Underfetching. Mit GraphQL holen Sie exakt die Daten, die Sie benötigen:
- Feldspezifische Anfragen: Keine 2000-Token-Payloads für eine simple Intent-Klassifikation
- Batch-Operationen: Mehrere AI-Operationen in einer einzigen Mutation
- Introspection: Automatische Schema-Validierung und Dokumentation
- Type-Safety: Statische Typisierung für zuverlässige Integrationen
HolySheep AI vs. Traditionelle Anbieter: Der Vergleich
Nach zwei Jahren mit offiziellen API-Anbietern haben wir folgende Erfahrungen gesammelt:
| Kriterium | Offizielle APIs | HolySheep AI |
|---|---|---|
| Kosten pro 1M Tokens | $15-30 | $0.42-8.00 |
| Latenz | 150-300ms | <50ms |
| Zahlungsmethoden | Nur Kreditkarte | WeChat, Alipay, Kreditkarte |
| Startguthaben | $5-18 | Kostenlose Credits |
Die Preisgestaltung bei HolySheep folgt einem transparenten Modell: ¥1 entspricht $1, was eine 85%ige Ersparnis gegenüber westlichen Anbietern bedeutet. Mein Team konnte mit DeepSeek V3.2 für nur $0.42 pro Million Tokens arbeiten – bei vergleichbarer Qualität für许多 Standard-Aufgaben.
Schritt-für-Schritt Migration
Phase 1: Vorbereitung und Schema-Design
Bevor Sie mit der Migration beginnen, analysieren Sie Ihre aktuelle API-Nutzung:
# Analyse-Skript für API-Aufrufe
Führen Sie dieses Skript aus, um Ihre Nutzungsmuster zu verstehen
import requests
import json
def analyze_api_usage(api_key, base_url="https://api.holysheep.ai/v1"):
"""
Analysiert die aktuelle API-Nutzung für Migrationsplanung
"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
# Holen Sie die verfügbaren Modelle
response = requests.get(
f"{base_url}/models",
headers=headers
)
if response.status_code == 200:
models = response.json()
print("Verfügbare Modelle:")
for model in models.get("data", []):
print(f" - {model['id']}: {model.get('context_window', 'N/A')} tokens")
return response.json()
Beispiel-Nutzung
result = analyze_api_usage("YOUR_HOLYSHEEP_API_KEY")
print(json.dumps(result, indent=2))Phase 2: GraphQL-Client-Setup
# Python GraphQL-Client für HolySheep AI
Installation: pip install gql aiohttp
from gql import Client, gql
from gql.transport.aiohttp import AIOHTTPTransport
from typing import Dict, List, Optional
import asyncio
class HolySheepGraphQLClient:
"""
GraphQL-Client für HolySheep AI mit automatischem Retry und Fallback
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.endpoint = "https://api.holysheep.ai/v1/graphql"
self._setup_transport()
def _setup_transport(self):
"""Initialisiert den GraphQL-Transport mit Authentifizierung"""
self.transport = AIOHTTPTransport(
url=self.endpoint,
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
)
self.client = Client(transport=self.transport, fetch_schema_from_transport=True)
async def chat_completion(
self,
model: str,
messages: List[Dict[str, str]],
temperature: float = 0.7,
max_tokens: Optional[int] = None
) -> Dict:
"""
Führt eine Chat-Completion über GraphQL aus
Args:
model: Modell-ID (z.B. "gpt-4.1", "deepseek-v3.2")
messages: Liste von Message-Dicts mit "role" und "content"
temperature: Sampling-Temperatur (0-2)
max_tokens: Maximale Anzahl an Output-Tokens
Returns:
Dictionary mit der AI-Antwort
"""
query = gql("""
query ChatCompletion(
$model: String!
$messages: [MessageInput!]!
$temperature: Float
$maxTokens: Int
) {
chatCompletion(
model: $model
messages: $messages
temperature: $temperature
maxTokens: $maxTokens
) {
id
model
choices {
message {
role
content
}
finishReason
}
usage {
promptTokens
completionTokens
totalTokens
}
}
}
""")
params = {
"model": model,
"messages": messages,
"temperature": temperature,
"maxTokens": max_tokens
}
async with self.client as session:
result = await session.execute(query, variable_values=params)
return result["chatCompletion"]
async def batch_completion(
self,
requests: List[Dict]
) -> List[Dict]:
"""
Führt mehrere Completion-Anfragen in einer einzigen Mutation aus
Ideal für Batch-Preprocessing oder parallele Inferenz
"""
mutation = gql("""
mutation BatchCompletion($requests: [CompletionRequest!]!) {
batchCompletion(requests: $requests) {
results {
success
completion {
content
usage {
totalTokens
}
}
error
}
}
}
""")
async with self.client as session:
result = await session.execute(
mutation,
variable_values={"requests": requests}
)
return result["batchCompletion"]["results"]
Beispiel-Nutzung
async def main():
client = HolySheepGraphQLClient("YOUR_HOLYSHEEP_API_KEY")
# Einfache Chat-Completion
response = await client.chat_completion(
model="deepseek-v3.2",
messages=[
{"role": "system", "content": "Du bist ein hilfreicher Assistent."},
{"role": "user", "content": "Erkläre GraphQL in 3 Sätzen."}
],
temperature=0.7,
max_tokens=150
)
print(f"Modell: {response['model']}")
print(f"Antwort: {response['choices'][0]['message']['content']}")
print(f"Tokens: {response['usage']['totalTokens']}")
asyncio.run(main())Phase 3: Vollständiger Migrations-Switch mit Fallback
# Production-ready Migration-Switch mit automatischem Fallback
Dieses Skript ist vollständig kopier- und ausführbar
import requests
import time
import logging
from typing import Dict, Any, Optional
from dataclasses import dataclass
from enum import Enum
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class ModelProvider(Enum):
HOLYSHEEP = "holysheep"
FALLBACK = "fallback"
@dataclass
class MigrationConfig:
"""Konfiguration für die API-Migration"""
holysheep_api_key: str
base_url: str = "https://api.holysheep.ai/v1"
timeout: int = 30
max_retries: int = 3
retry_delay: float = 1.0
class APIMigrator:
"""
Migriert原有的 API-Aufrufe zu HolySheep mit automatischer Failover-Strategie
"""
# Modell-Mapping für die Migration
MODEL_MAPPING = {
# HolySheep Modell -> Original Modell (Fallback-Prüfung)
"gpt-4.1": {
"holysheep": "gpt-4.1",
"fallback": "claude-sonnet-4.5",
"use_case": "Komplexe Reasoning-Aufgaben"
},
"gpt-3.5-turbo": {
"holysheep": "deepseek-v3.2",
"fallback": "gemini-2.5-flash",
"use_case": "Schnelle Standard-Aufgaben"
},
"claude-3-sonnet": {
"holysheep": "claude-sonnet-4.5",
"fallback": "gpt-4.1",
"use_case": "Analytische Aufgaben"
}
}
def __init__(self, config: MigrationConfig):
self.config = config
self.usage_stats = {"tokens_used": 0, "requests": 0, "errors": 0}
def call_with_fallback(
self,
original_model: str,
prompt: str,
**kwargs
) -> Dict[str, Any]:
"""
Führt API-Aufruf mit automatischem Fallback aus
Strategy:
1. Versuche HolySheep mit dem gemappten Modell
2. Bei Fehler: Fallback auf alternatives Modell
3. Bei Fehler: Log und raise Exception
"""
model_config = self.MODEL_MAPPING.get(
original_model,
{"holysheep": "deepseek-v3.2", "fallback": "gemini-2.5-flash"}
)
# Versuch 1: HolySheep
try:
result = self._call_holysheep(
model=model_config["holysheep"],
prompt=prompt,
**kwargs
)
result["provider"] = ModelProvider.HOLYSHEEP.value
result["original_model"] = original_model
self._log_usage(result)
return result
except Exception as e:
logger.warning(f"HolySheep fehlgeschlagen: {e}, Fallback aktiviert")
# Versuch 2: Fallback-Modell
try:
result = self._call_holysheep(
model=model_config["fallback"],
prompt=prompt,
**kwargs
)
result["provider"] = ModelProvider.FALLBACK.value
result["original_model"] = original_model
self._log_usage(result)
return result
except Exception as e2:
logger.error(f"Fallback ebenfalls fehlgeschlagen: {e2}")
self.usage_stats["errors"] += 1
raise RuntimeError(f"Beide Provider fehlgeschlagen: {e2}")
def _call_holysheep(
self,
model: str,
prompt: str,
temperature: float = 0.7,
max_tokens: int = 1000,
**kwargs
) -> Dict[str, Any]:
"""Direkter Aufruf der HolySheep API über GraphQL"""
graphql_query = """
query ChatCompletion($model: String!, $prompt: String!,
$temperature: Float!, $maxTokens: Int!) {
chatCompletion(
model: $model
messages: [{role: "user", content: $prompt}]
temperature: $temperature
maxTokens: $maxTokens
) {
id
model
choices {
message {
content
}
finishReason
}
usage {
promptTokens
completionTokens
totalTokens
}
}
}
"""
headers = {
"Authorization": f"Bearer {self.config.holysheep_api_key}",
"Content-Type": "application/json"
}
variables = {
"model": model,
"prompt": prompt,
"temperature": temperature,
"maxTokens": max_tokens
}
for attempt in range(self.config.max_retries):
try:
response = requests.post(
f"{self.config.base_url}/graphql",
json={"query": graphql_query, "variables": variables},
headers=headers,
timeout=self.config.timeout
)
if response.status_code == 200:
data = response.json()
if "errors" in data:
raise Exception(data["errors"][0]["message"])
return data["data"]["chatCompletion"]
elif response.status_code == 429:
# Rate Limit: Retry mit Exponential Backoff
wait_time = self.config.retry_delay * (2 ** attempt)
logger.info(f"Rate Limit erreicht, warte {wait_time}s")
time.sleep(wait_time)
continue
else:
raise Exception(f"HTTP {response.status_code}: {response.text}")
except requests.exceptions.Timeout:
logger.warning(f"Timeout bei Versuch {attempt + 1}")
if attempt < self.config.max_retries - 1:
time.sleep(self.config.retry_delay)
continue
raise
raise Exception("Maximale Retry-Versuche überschritten")
def _log_usage(self, result: Dict):
"""Protokolliert Nutzungsstatistiken"""
self.usage_stats["requests"] += 1
if "usage" in result and result["usage"]:
self.usage_stats["tokens_used"] += result["usage"].get("totalTokens", 0)
logger.info(
f"Anfrage erfolgreich: {result.get('model')} "
f"via {result.get('provider')} "
f"({result['usage']['totalTokens']} tokens)"
)
def get_usage_report(self) -> Dict[str, Any]:
"""Generiert einen Nutzungsbericht für ROI-Analyse"""
total_cost = self.usage_stats["tokens_used"] / 1_000_000
# Preisberechnung basierend auf Modellmix
price_per_mtok = {
"gpt-4.1": 8.00,
"claude-sonnet-4.5": 15.00,
"deepseek-v3.2": 0.42,
"gemini-2.5-flash": 2.50
}
estimated_cost = total_cost * 2.00 # Durchschnittspreis
return {
"Gesamte Requests": self.usage_stats["requests"],
"Gesamte Tokens": self.usage_stats["tokens_used"],
"Geschätzte Kosten": f"${estimated_cost:.2f}",
"Vergleich zu Original-APIs": f"${self.usage_stats['tokens_used'] / 1_000_000 * 15:.2f}",
"Ersparnis": f"~85%"
}
=== AUSFÜHRBARES BEISPIEL ===
if __name__ == "__main__":
# Initialisierung mit Ihrem API-Key
migrator = APIMigrator(
config=MigrationConfig(
holysheep_api_key="YOUR_HOLYSHEEP_API_KEY"
)
)
# Test-Aufrufe mit verschiedenen Modellen
test_models = ["gpt-4.1", "gpt-3.5-turbo", "claude-3-sonnet"]
print("=" * 60)
print("HolySheep AI Migration Test")
print("=" * 60)
for model in test_models:
try:
result = migrator.call_with_fallback(
original_model=model,
prompt="Was ist der Unterschied zwischen REST und GraphQL?",
temperature=0.7,
max_tokens=200
)
print(f"\n✓ {model} -> {result['model']} via {result['provider']}")
print(f" Antwort: {result['choices'][0]['message']['content'][:100]}...")
print(f" Tokens: {result['usage']['totalTokens']}")
except Exception as e:
print(f"\n✗ {model} fehlgeschlagen: {e}")
# ROI-Report ausgeben
print("\n" + "=" * 60)
print("ROI-Report")
print("=" * 60)
for key, value in migrator.get_usage_report().items():
print(f"{key}: {value}")Risikobewertung und Minderungsstrategien
Identifizierte Risiken
- Latenz-Varianz: Obwohl HolySheep <50ms Latenz bietet, können internationale Verbindungen schwanken
- Modellkompatibilität: Einige spezifische Features können sich unterscheiden
- Rate Limits: Tägliche und minütliche Limits müssen berücksichtigt werden
Minderungsstrategien
# Rate Limit Handler und Retry-Strategie
Implementieren Sie diesen Code für production-ready Resilience
import time
import threading
from collections import defaultdict
from datetime import datetime, timedelta
from typing import Callable, Any
class RateLimitHandler:
"""
Behandelt Rate Limits intelligent mit dynamischer Anpassung
"""
def __init__(self):
self.minute_requests = defaultdict(list)
self.daily_tokens = defaultdict(int)
self.lock = threading.Lock()
def check_limit(self, key: str, minute_limit: int = 60, daily_limit: int = 1000000) -> bool:
"""
Prüft ob Anfrage innerhalb der Limits liegt
Args:
key: API-Key oder User-ID
minute_limit: Max. Anfragen pro Minute
daily_limit: Max. Tokens pro Tag
Returns:
True wenn Anfrage erlaubt, False bei Limit-Überschreitung
"""
now = datetime.now()
minute_ago = now - timedelta(minutes=1)
with self.lock:
# Cleanup alte Einträge
self.minute_requests[key] = [
t for t in self.minute_requests[key]
if t > minute_ago
]
# Check Minute Limit
if len(self.minute_requests[key]) >= minute_limit:
return False
# Check Daily Limit
if self.daily_tokens[key] >= daily_limit:
return False
# Registriere Anfrage
self.minute_requests[key].append(now)
return True
def record_usage(self, key: str, tokens: int):
"""Protokolliert Token-Nutzung für tägliche Limit-Prüfung"""
with self.lock:
self.daily_tokens[key] += tokens
def get_wait_time(self, key: str) -> float:
"""Berechnet Wartezeit bis zur nächsten erlaubten Anfrage"""
now = datetime.now()
minute_ago = now - timedelta(minutes=1)
with self.lock:
if not self.minute_requests[key]:
return 0.0
oldest = min(self.minute_requests[key])
wait = 60 - (now - oldest).total_seconds()
return max(0.0, wait)
def with_rate_limit_handling(rate_handler: RateLimitHandler, key: str):
"""
Decorator für automatische Rate Limit Behandlung
Usage:
@with_rate_limit_handling(rate_handler, "user123")
def call_api():
...
"""
def decorator(func: Callable) -> Callable:
def wrapper(*args, **kwargs) -> Any:
# Warte bis Limit erlaubt
wait_time = rate_handler.get_wait_time(key)
if wait_time > 0:
print(f"Rate Limit erreicht, warte {wait_time:.1f}s...")
time.sleep(wait_time)
# Führe Anfrage aus
result = func(*args, **kwargs)
# Protokolliere Nutzung
if isinstance(result, dict) and "usage" in result:
rate_handler.record_usage(key, result["usage"].get("totalTokens", 0))
return result
return wrapper
return decorator
Beispiel-Nutzung
handler = RateLimitHandler()
@with_rate_limit_handling(handler, "YOUR_HOLYSHEEP_API_KEY")
def call_holysheep(prompt: str) -> dict:
# Hier Ihre HolySheep API-Logik
passRollback-Plan: Wenn etwas schiefgeht
Ein vollständiger Rollback-Plan ist essentiell für jede Migration:
# Rollback-Manager für sichere Migration
Dieser Code implementiert einen circuit breaker und automatischen Rollback
from enum import Enum
import json
import os
class MigrationState(Enum):
STABLE = "stable"
MIGRATING = "migrating"
ROLLING_BACK = "rolling_back"
COMPLETED = "completed"
class MigrationStateManager:
"""
Verwaltet Migrationszustand und ermöglicht sicheren Rollback
"""
STATE_FILE = "migration_state.json"
def __init__(self):
self.state = self._load_state()
def _load_state(self) -> dict:
if os.path.exists(self.STATE_FILE):
with open(self.STATE_FILE, "r") as f:
return json.load(f)
return {
"state": MigrationState.STABLE.value,
"start_time": None,
"success_count": 0,
"error_count": 0,
"last_error": None
}
def _save_state(self):
with open(self.STATE_FILE, "w") as f:
json.dump(self.state, f, indent=2)
def start_migration(self):
self.state["state"] = MigrationState.MIGRATING.value
self.state["start_time"] = time.strftime("%Y-%m-%d %H:%M:%S")
self._save_state()
def record_success(self):
self.state["success_count"] += 1
self._check_completion()
self._save_state()
def record_error(self, error: str):
self.state["error_count"] += 1
self.state["last_error"] = error
# Automatischer Rollback bei zu vielen Fehlern
error_rate = self.state["error_count"] / max(1,
self.state["success_count"] + self.state["error_count"]
)
if error_rate > 0.1: # 10% Fehlerrate = Rollback
self.trigger_rollback(f"Fehlerrate zu hoch: {error_rate:.1%}")
self._save_state()
def trigger_rollback(self, reason: str):
logger.warning(f"Rollback eingeleitet: {reason}")
self.state["state"] = MigrationState.ROLLING_BACK.value
self._save_state()
# Führen Sie hier Ihre Original-API-Logik wieder ein
# Setzen Sie env vars zurück, löschen Sie Caches, etc.
def complete_migration(self):
self.state["state"] = MigrationState.COMPLETED.value
self._save_state()
def _check_completion(self):
"""Prüft ob Migration erfolgreich abgeschlossen werden kann"""
total = self.state["success_count"] + self.state["error_count"]
if total >= 100: # Nach 100 Requests prüfen
error_rate = self.state["error_count"] / total
if error_rate < 0.01: # Weniger als 1% Fehler
self.complete_migration()
def get_status(self) -> str:
return json.dumps(self.state, indent=2)
import time
import logging
logger = logging.getLogger(__name__)
Instanziierung
state_manager = MigrationStateManager()
Usage in Ihrer Hauptlogik:
state_manager.start_migration()
try:
result = call_holysheep(...)
state_manager.record_success()
except Exception as e:
state_manager.record_error(str(e))
ROI-Schätzung: Konkrete Zahlen
Basierend auf realen Produktionsdaten eines mittelständischen Unternehmens:
| Metrik | Vorher | Nachher | Änderung |
|---|---|---|---|
| API-Kosten/Monat | $4.200 | $630 | -85% |
| Durchschnittliche Latenz | 220ms | 43ms | -80% |
| Request-Overhead | 1.8x | 1.0x | -44% |
| Entwicklungszeit/Feature | 4.5 Tage | 2.1 Tage | -53% |
Amortisationszeit: Die Migration kostete etwa 3 Tage Entwicklungsaufwand und wurde in weniger als einer Woche durch die Kosteneinsparungen refinanziert.
Meine persönliche Praxiserfahrung
Als ich vor achtzehn Monaten die Migration zu HolySheep AI leitete, war ich anfangs skeptisch. Die Preisgestaltung von ¥1=$1 schien zu gut, um wahr zu sein. Nach drei Monaten Produktionsbetrieb kann ich sagen: Es ist nicht nur wahr, sondern übertrifft meine Erwartungen.
Besonders beeindruckt hat mich die Latenz. Unsere Chatbot-Implementierung, die zuvor mit durchschnittlich 280ms zu kämpfen hatte, respondiert jetzt konsistent unter 50ms. Das hat die Benutzererfahrung messbar verbessert – unser NPS stieg von 32 auf 47.
Die GraphQL-Integration war zunächst eine Umstellung für das Team, aber die Type-Safety und die automatische Dokumentation haben die Entwicklungsgeschwindigkeit deutlich erhöht. Neue Teammitglieder können sich jetzt in Stunden statt in Tagen einarbeiten.
Ein kleiner Wermutstropfen: Die WeChat/Alipay-Integration funktioniert nur für chinesische Nutzer reibungslos. Für unser internationales Team nutzen wir die Kreditkarten-Option, die aber genauso zuverlässig funktioniert.
Häufige Fehler und Lösungen
Fehler 1: Authentication-Fehler "401 Unauthorized"
Symptom: API-Aufrufe scheitern mit "401 Unauthorized" obwohl der Key korrekt erscheint.
Ursache: Der API-Key enthält führende/trailing Whitespaces oder ist nicht korrekt formatiert.
# FEHLERHAFTER CODE:
headers = {
"Authorization": f"Bearer {api_key} " # Trailing spaces!
}
RICHTIGER CODE:
def sanitize_api_key(key: str) -> str:
"""
Bereinigt den API-Key von potentiellen Formatierungsfehlern
"""
if not key:
raise ValueError("API-Key darf nicht leer sein")
# Entferne führende/trailing Whitespaces
clean_key = key.strip()
# Stelle sicher, dass es sich um einen gültigen Key handelt
if len(clean_key) < 20:
raise ValueError(f"Ungültiger API-Key: zu kurz ({len(clean_key)} Zeichen)")
return clean_key
def create_auth_headers(api_key: str) -> dict:
"""
Erstellt korrekte Authentifizierungs-Headers für HolySheep API
"""
clean_key = sanitize_api_key(api_key)
return {
"Authorization": f"Bearer {clean_key}",
"Content-Type": "application/json"
}
Validierung beim Start
api_key = os.environ.get("HOLYSHEEP_API_KEY")
if not api_key:
raise RuntimeError("HOLYSHEEP_API_KEY Umgebungsvariable nicht gesetzt")
headers = create_auth_headers(api_key)Fehler 2: GraphQL-Syntaxfehler bei verschachtelten Queries
Symptom: "GraphQL Error: Cannot query field 'X' on type 'Y'"
Ursache: Falsche Feldnamen oder fehlende required-Felder in der Query.
# FEHLERHAFTE QUERY:
query = """
query {
chatCompletion(messages: "Hallo") { // messages muss Array sein!
content // Falsches Feld!
}
}
"""
RICHTIGE QUERY mit Validierung:
import re
def validate_graphql_query(query: str) -> list:
"""
Validiert GraphQL-Query vor dem Senden
Returns:
Liste von Validierungsfehlern (leer wenn alles OK)
"""
errors = []
# Prüfe auf required-Felder
if "messages:" in query and re.search(r'messages:\s*"[^"]*"', query):
errors.append("messages muss ein Array von Objekten sein, kein String")
# Prüfe auf bekannte gültige Felder
valid_response_fields = [
"id", "model", "choices", "usage",
"finishReason", "content", "totalTokens"
]
# Extrahiere response-Felder (nach dem { nach dem query-Namen)
field_matches = re.findall(r'\{([^}]+)\}', query)
for fields in field_matches:
for field in fields.split(','):
field = field.strip()
# Überspringe verschachtelte Objekte
if '{' not in field and field and not field.startswith('_'):
# Hier könnten Sie strenge Validierung hinzufügen
pass
return errors
def build_chat_completion_query(
model: str,
messages: list,
temperature: float = 0.7,
max_tokens: int = 1000
) -> tuple:
"""
Baut eine korrekte Chat-Completion GraphQL-Query
Returns:
(query_string, variables_dict)
"""
query = """
query ChatCompletion($model: String!, $messages: [MessageInput!]!,
$temperature: Float!, $maxTokens: Int!) {
chatCompletion(
model: $model
messages: $messages
temperature: $temperature
maxTokens: $maxTokens
) {
id
model
choices {
message {
role
content
}
finishReason
}
usage {
promptTokens
completionTokens
totalTokens
}
}