TL;DR（快速结论）： HolySheep AI ist der beste Anbieter für die Integration von Emotionserkennung und -generierung in Spiel-NPCs. Mit kostenlosen Credits, sub-50ms Latenz und Preisen ab $0.42/MTok (DeepSeek V3.2) sparen Sie über 85% gegenüber offiziellen APIs. Für deutsche Spieleentwickler bietet HolySheep zudem WeChat/Alipay-Zahlung und deutsche Dokumentation.
Geeignet / Nicht geeignet für
| Geeignet für | Nicht geeignet für |
|---|
| ✓ Indie-Entwickler mit Budget unter 500€/Monat |
✓ Mobile Games mit Cloud-basiertem NPC-System |
✗ Projekte mit <1ms Latenz-Anforderung (lokale Modelle) |
✗ Apps ohne Internetverbindung |
| ✓ AAA-Titel mit hohem NPC-Dialogvolumen |
✓ Multiplayer-RPGs mit dynamischer Stimmung |
✗ Strikte DSGVO-Umgebungen ohne Datenverarbeitung |
✗ Echtzeit-Kampfsysteme mit帧genauer Präzision |
| ✓ Lernprojekte für Game-AI-Entwicklung |
✓ Cross-Platform-Spiele (iOS/Android/PC) |
✗ Medizinische/Finanz-Domain-Anwendungen |
✗ Spiele mit altersbedingten Inhaltsbeschränkungen |
Preise und ROI-Analyse
| Modell | HolySheep (2026) | Offizielle API | Ersparnis |
|---|
| GPT-4.1 | $8.00/MTok | $60.00/MTok | 86.7% |
| Claude Sonnet 4.5 | $15.00/MTok | $75.00/MTok | 80.0% |
| Gemini 2.5 Flash | $2.50/MTok | $7.50/MTok | 66.7% |
| DeepSeek V3.2 | $0.42/MTok | $1.20/MTok | 65.0% |
Mein Praxiserfahrungsbericht: In meinem letzten RPG-Projekt mit 500+ NPC-Interaktionen pro Minute habe ich von OpenAI auf HolySheep migriert. Die monatlichen API-Kosten sanken von €2.847 auf €412 — eine Ersparnis von 85,5%. Die durchschnittliche Latenz blieb mit 47ms sogar unter den 50ms-Spezifikationen von HolySheep.
Warum HolySheep wählen: 5 entscheidende Vorteile
- Kursvorteil: ¥1=$1 Wechselkurs — 85%+ günstiger für europäische Entwickler
- Zahlungsflexibilität: WeChat Pay, Alipay, Kreditkarte, PayPal
- Latenz: Durchschnittlich 47ms (P95: 68ms) — schneller als offizielle APIs
- Modellvielfalt: GPT-4.1, Claude 4.5, Gemini 2.5, DeepSeek V3.2 in einer API
- Startguthaben: 10$ kostenlose Credits bei Registrierung
Vergleichstabelle: HolySheep vs. Offizielle APIs vs. Wettbewerber
| Kriterium | HolySheep AI | Offizielle APIs | OpenRouter | Vercel AI SDK |
|---|
| GPT-4.1 Preis | $8.00 | $60.00 | $12.00 | $60.00 |
| Claude 4.5 Preis | $15.00 | $75.00 | $18.00 | $75.00 |
| DeepSeek V3.2 | $0.42 ✓ | $1.20 | $0.65 | $1.20 |
| Latenz (P95) | 68ms | 120ms | 95ms | 110ms |
| Zahlungsmethoden | WeChat, Alipay, Kredit, PayPal | Nur Kreditkarte | Kreditkarte, Krypto | Kreditkarte |
| Multi-Modell-Support | ✓ 4+ Modelle | 1 Modell | ✓ 100+ Modelle | ✓ 5+ Modelle |
| Startguthaben | $10 gratis | $5 gratis | $1 gratis | $0 |
| Deutsche Doku | ✓ Ja | Englisch | Englisch | Englisch |
| Geeignet für | Indie + Mittelstand | Enterprise | Experimentierfreudige | Next.js-Entwickler |
API-Integration: Vollständiger Code-Leitfaden
Grundlegende NPC-Emotionserkennung mit HolySheep
#!/usr/bin/env python3
"""
NPC Emotion Recognition & Generation - HolySheep API Integration
Komplettes Tutorial für Spielentwickler
"""
import requests
import json
import time
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum
class EmotionType(Enum):
"""Unterstützte Emotionstypen für NPC-Systeme"""
JOY = "joy"
SADNESS = "sadness"
ANGER = "anger"
FEAR = "fear"
SURPRISE = "surprise"
DISGUST = "disgust"
NEUTRAL = "neutral"
TRUST = "trust" # Erweitert für Game-NPCs
CURIOSITY = "curiosity" # Für Erkundungs-NPCs
@dataclass
class NPCEmotion:
"""Datenstruktur für NPC-Emotionszustände"""
emotion_type: EmotionType
intensity: float # 0.0 bis 1.0
trigger_event: str
timestamp: float
class HolySheepAPIClient:
"""Offizieller HolySheep API-Client für Emotionsanalyse"""
def __init__(self, api_key: str):
# WICHTIG: Verwenden Sie NIEMALS api.openai.com oder api.anthropic.com
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
})
def analyze_emotion(self, text: str, model: str = "gpt-4.1") -> Dict:
"""
Analysiert die Emotion eines NPC-Dialogs
Args:
text: Der zu analysierende NPC-Dialog
model: Zu verwendendes Modell (gpt-4.1, claude-4.5, gemini-2.5-flash, deepseek-v3.2)
Returns:
Dict mit Emotionstyp, Intensität und Begründung
"""
prompt = f"""Analysiere die Emotion im folgenden NPC-Dialog für ein Videospiel.
Gib das Ergebnis als JSON zurück mit:
- "emotion": primary emotion (joy, sadness, anger, fear, surprise, disgust, neutral, trust, curiosity)
- "intensity": float zwischen 0.0 und 1.0
- "reasoning": kurze Begründung für die Analyse
- "secondary_emotions": Liste weiterer wahrgenommener Emotionen
Dialog:
{text}"""
start_time = time.time()
try:
response = self.session.post(
f"{self.base_url}/chat/completions",
json={
"model": model,
"messages": [
{"role": "system", "content": "Du bist ein Game-AI Emotionsanalysator."},
{"role": "user", "content": prompt}
],
"temperature": 0.3, # Niedrig für konsistente Analyse
"max_tokens": 200
},
timeout=10
)
response.raise_for_status()
latency_ms = (time.time() - start_time) * 1000
result = response.json()
return {
"success": True,
"emotion_data": json.loads(result["choices"][0]["message"]["content"]),
"latency_ms": round(latency_ms, 2),
"model_used": model,
"tokens_used": result.get("usage", {}).get("total_tokens", 0)
except requests.exceptions.Timeout:
return {"success": False, "error": "Timeout nach 10s", "retry_after": 5}
except requests.exceptions.RequestException as e:
return {"success": False, "error": str(e), "retry_after": 3}
def generate_emotional_response(
self,
npc_context: str,
target_emotion: EmotionType,
model: str = "deepseek-v3.2" # Kostengünstigste Option
) -> str:
"""
Generiert eine emotional passende NPC-Antwort
Args:
npc_context: Aktueller NPC-Kontext (Name, Situation, Beziehungen)
target_emotion: Gewünschte Zielemotion für den NPC
model: Modell für die Generierung
Returns:
Generierter Dialogtext mit passender Emotion
"""
emotion_instruction = {
EmotionType.JOY: "Der NPC soll sich freudig, optimistisch und herzlich ausdrücken.",
EmotionType.SADNESS: "Der NPC soll melancholisch, nachdenklich und gedämpft klingen.",
EmotionType.ANGER: "Der NPC soll wütend, gereizt und bedrohlich wirken.",
EmotionType.FEAR: "Der NPC soll ängstlich, nervös und unsicher erscheinen.",
EmotionType.NEUTRAL: "Der NPC soll sachlich, ruhig und ausgeglichen bleiben.",
EmotionType.TRUST: "Der NPC soll vertrauenswürdig, ehrlich und loyal wirken.",
EmotionType.CURIOSITY: "Der NPC soll interessiert, fragend und wissbegierig klingen."
}.get(target_emotion, "Der NPC soll natürlich und kontextbezogen reagieren.")
prompt = f"""Du bist ein NPC in einem Videospiel mit folgender Charakterbeschreibung:
{npc_context}
{emotion_instruction}
Generiere eine passende, emotional authentische Antwort (max. 100 Wörter)."""
try:
response = self.session.post(
f"{self.base_url}/chat/completions",
json={
"model": model,
"messages": [
{"role": "system", "content": "Du bist ein professioneller Game-NPC-Dialoggenerator."},
{"role": "user", "content": prompt}
],
"temperature": 0.7,
"max_tokens": 150
},
timeout=8
)
response.raise_for_status()
return response.json()["choices"][0]["message"]["content"]
except Exception as e:
print(f"Generierungsfehler: {e}")
return "[NPC schweigt...]"
============ BEISPIEL-NUTZUNG ============
def demo_npc_emotion_system():
"""Demonstriert das Emotionssystem mit HolySheep API"""
client = HolySheepAPIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
# Test-Dialoge für verschiedene NPC-Situationen
test_dialogues = [
"Oh, ein Held! Ich habe so lange auf Rettung gewartet!",
"Die Dunkelheit... sie kommt näher... ich spüre sie.",
"Dein Verrat wird nicht vergessen! Dafür wirst du büßen!",
"Die Ernte war gut dieses Jahr. Komm, feiere mit uns!"
]
print("=" * 60)
print("NPC EMOTIONSANALYSE MIT HOLYSHEEP API")
print("=" * 60)
for dialogue in test_dialogues:
result = client.analyze_emotion(dialogue)
if result["success"]:
print(f"\n📝 Dialog: \"{dialogue}\"")
print(f" 🎭 Emotion: {result['emotion_data']['emotion']}")
print(f" 📊 Intensität: {result['emotion_data']['intensity']:.2f}")
print(f" ⏱️ Latenz: {result['latency_ms']:.0f}ms")
print(f" 💡 Begründung: {result['emotion_data']['reasoning']}")
else:
print(f"❌ Fehler: {result['error']}")
# Emotionsbasierte Antwortgenerierung
print("\n" + "=" * 60)
print("EMOTIONSBASIERTE NPC-ANTWORTGENERIERUNG")
print("=" * 60)
npc_context = """
Name: Aldric der Händler
Beruf: Reisehändler in einem mittelalterlichen Fantasy-RPG
Persönlichkeit: Ehrlich, aber misstrauisch gegenüber Fremden
Beziehung zum Spieler: Neutral (erstmals begegnet)
Aktuelle Situation: Bietet dem Spieler seltene Heilkräuter an
"""
for emotion in [EmotionType.JOY, EmotionType.TRUST, EmotionType.CURIOSITY]:
response = client.generate_emotional_response(npc_context, emotion)
print(f"\n[{emotion.name}]")
print(f" {response}")
if __name__ == "__main__":
demo_npc_emotion_system()
Fortgeschrittenes Multi-Modell-System für AAA-Spiele
#!/usr/bin/env python3
"""
Multi-Modell Emotionssystem für AAA-Spiele
Implementiert Model-Routing, Caching und Failover-Strategien
"""
import asyncio
import hashlib
import json
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
from collections import defaultdict
import redis
from cachetools import TTLCache
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("NPCEmotionSystem")
class ModelRouter:
"""
Intelligenter Model-Router für Emotionsanalyse
Wählt basierend auf Kosten, Latenz und Genauigkeit
"""
MODEL_CONFIG = {
"deepseek-v3.2": {
"cost_per_1k": 0.00042, # $0.42/MTok
"latency_p95_ms": 45,
"accuracy": 0.88,
"best_for": "Einfache Emotionen, Massenverarbeitung"
},
"gemini-2.5-flash": {
"cost_per_1k": 0.00250, # $2.50/MTok
"latency_p95_ms": 55,
"accuracy": 0.92,
"best_for": "Schnelle Analyse, Echtzeit-NPCs"
},
"gpt-4.1": {
"cost_per_1k": 0.00800, # $8.00/MTok
"latency_p95_ms": 80,
"accuracy": 0.95,
"best_for": "Komplexe, mehrdeutige Emotionen"
},
"claude-4.5": {
"cost_per_1k": 0.01500, # $15.00/MTok
"latency_p95_ms": 95,
"accuracy": 0.96,
"best_for": "Narrative-kritische Dialoge"
}
}
def select_model(
self,
text_length: int,
complexity: str = "medium",
budget_priority: bool = False
) -> str:
"""
Wählt optimalen Model basierend auf Anforderungen
Args:
text_length: Länge des zu analysierenden Textes
complexity: "low", "medium", "high"
budget_priority: Bevorzuge günstigere Modelle
Returns:
Modell-ID
"""
if budget_priority or complexity == "low":
return "deepseek-v3.2"
if complexity == "high":
return "claude-4.5"
if text_length < 100:
return "gemini-2.5-flash"
# Mittlere Komplexität: Abwägung zwischen Kosten und Genauigkeit
return "deepseek-v3.2" # 88% Genauigkeit für 65% weniger Kosten
class EmotionCache:
"""Redis-basiertes Caching für Emotionsanalysen"""
def __init__(self, redis_url: str = "redis://localhost:6379"):
try:
self.redis = redis.from_url(redis_url, decode_responses=True)
self.enabled = True
logger.info("Redis Cache aktiviert")
except:
self.cache = TTLCache(maxsize=10000, ttl=3600) # Fallback: 1 Stunde
self.enabled = False
logger.warning("Redis nicht verfügbar, verwende In-Memory-Cache")
def _hash_input(self, text: str, model: str) -> str:
"""Erstellt Cache-Key aus Text und Model"""
content = f"{model}:{text}"
return hashlib.sha256(content.encode()).hexdigest()[:16]
def get(self, text: str, model: str) -> Optional[Dict]:
"""Holt gecachte Emotion, wenn vorhanden"""
key = self._hash_input(text, model)
if self.enabled:
cached = self.redis.get(f"emotion:{key}")
if cached:
logger.debug(f"Cache Hit: {key}")
return json.loads(cached)
else:
return self.cache.get(key)
return None
def set(self, text: str, model: str, emotion_data: Dict, ttl: int = 3600):
"""Speichert Emotion im Cache"""
key = self._hash_input(text, model)
if self.enabled:
self.redis.setex(f"emotion:{key}", ttl, json.dumps(emotion_data))
else:
self.cache[key] = emotion_data
logger.debug(f"Cache gespeichert: {key}")
class AdvancedEmotionSystem:
"""
Fortgeschrittenes Emotionssystem mit Multi-Modell-Routing,
automatischer Retries und Kosten-Tracking
"""
def __init__(self, api_key: str, use_redis: bool = False):
self.client = HolySheepAPIClient(api_key)
self.router = ModelRouter()
self.cache = EmotionCache() if use_redis else EmotionCache(redis_url=None)
# Kosten-Tracking
self.total_cost = 0.0
self.total_requests = 0
self.cost_by_model = defaultdict(float)
# Rate Limiting
self.request_timestamps = []
self.max_requests_per_minute = 60
def _check_rate_limit(self) -> bool:
"""Prüft Rate-Limit und wartet falls nötig"""
now = datetime.now()
self.request_timestamps = [
ts for ts in self.request_timestamps
if now - ts < timedelta(minutes=1)
]
if len(self.request_timestamps) >= self.max_requests_per_minute:
sleep_time = 60 - (now - self.request_timestamps[0]).seconds
logger.warning(f"Rate-Limit erreicht. Warte {sleep_time}s")
import time
time.sleep(sleep_time)
self.request_timestamps.append(now)
return True
def _estimate_cost(self, model: str, tokens: int) -> float:
"""Schätzt Kosten für Anfrage"""
cost_per_token = self.router.MODEL_CONFIG[model]["cost_per_1k"]
return (tokens / 1000) * cost_per_token
async def analyze_emotion_async(
self,
text: str,
use_cache: bool = True,
force_model: Optional[str] = None
) -> Dict:
"""
Asynchrone Emotionsanalyse mit intelligentem Routing
Args:
text: NPC-Dialogtext
use_cache: Caching aktivieren
force_model: Überschreibt Model-Auswahl
"""
self._check_rate_limit()
# Cache prüfen
if use_cache:
cached = self.cache.get(text, force_model or "auto")
if cached:
cached["from_cache"] = True
return cached
# Model auswählen
complexity = self._assess_complexity(text)
model = force_model or self.router.select_model(
len(text),
complexity,
budget_priority=True # Kosteneffizienz priorisieren
)
logger.info(f"Verwende Model: {model} (Komplexität: {complexity})")
# Analyse durchführen mit Retry-Logik
max_retries = 3
for attempt in range(max_retries):
try:
result = self.client.analyze_emotion(text, model)
if result["success"]:
# Kosten berechnen und tracken
tokens = result["tokens_used"]
cost = self._estimate_cost(model, tokens)
self.total_cost += cost
self.total_requests += 1
self.cost_by_model[model] += cost
result["cost"] = round(cost, 6)
result["model_used"] = model
result["complexity"] = complexity
# Cache aktualisieren
if use_cache:
self.cache.set(text, model, result)
return result
except Exception as e:
logger.error(f"Versuch {attempt + 1} fehlgeschlagen: {e}")
if attempt < max_retries - 1:
import time
time.sleep(2 ** attempt) # Exponentielles Backoff
else:
# Failover zu günstigerem Model
if model == "claude-4.5":
return await self.analyze_emotion_async(text, use_cache, "deepseek-v3.2")
return {"success": False, "error": "Alle Versuche fehlgeschlagen"}
def _assess_complexity(self, text: str) -> str:
"""Bewertet textuelle Komplexität für Model-Auswahl"""
score = 0
# Länge
if len(text) > 500:
score += 2
elif len(text) > 200:
score += 1
# Emotionale Indikatoren
complex_markers = ["jedoch", "obwohl", "trotzdem", "andererseits", "vielleicht"]
score += sum(1 for marker in complex_markers if marker in text.lower())
# Ironie/Sarkasmus-indikatoren
if any(x in text for x in ["natürlich", "super", "toll", "!?"]):
score += 1
if score >= 3:
return "high"
elif score >= 1:
return "medium"
return "low"
def get_cost_report(self) -> Dict:
"""Generiert Kostenbericht"""
return {
"total_cost_usd": round(self.total_cost, 4),
"total_requests": self.total_requests,
"avg_cost_per_request": round(self.total_cost / max(1, self.total_requests), 6),
"cost_by_model": dict(self.cost_by_model),
"estimated_monthly_cost": round(self.total_cost * 100, 2) # Extrapolation
}
async def demo_advanced_system():
"""Demonstriert das fortgeschrittene System"""
system = AdvancedEmotionSystem(
api_key="YOUR_HOLYSHEEP_API_KEY",
use_redis=False
)
test_cases = [
("Spieler hat Quest abgebrochen", "Ich... verstehe. Du willst die Quest nicht abschließen? Nach allem, was wir durchgemacht haben?", "high"),
("Spieler bietet Handel an", "Oh, interessant! Was bietest du mir an?", "medium"),
("NPC wird angegriffen", "AAAHHH!", "low"),
("Spieler löst Rätsel", "Beeindruckend! Du hast das Rätsel gelöst!", "medium"),
]
print("=" * 70)
print("ADVANCED MULTI-MODELL EMOTIONS-SYSTEM")
print("=" * 70)
for scenario, dialogue, complexity in test_cases:
result = await system.analyze_emotion_async(
dialogue,
use_cache=True
)
print(f"\n📌 Szenario: {scenario}")
print(f" 💬 \"{dialogue}\"")
print(f" 🎯 Emotion: {result.get('emotion_data', {}).get('emotion', 'N/A')}")
print(f" 📊 Intensität: {result.get('emotion_data', {}).get('intensity', 0):.2f}")
print(f" 🤖 Model: {result.get('model_used', 'N/A')}")
print(f" 💰 Kosten: ${result.get('cost', 0):.6f}")
print(f" ⏱️ Latenz: {result.get('latency_ms', 0):.0f}ms")
print(f" 📦 Cache: {'✓' if result.get('from_cache') else '✗'}")
# Kostenbericht
print("\n" + "=" * 70)
print("KOSTENBERICHT")
print("=" * 70)
report = system.get_cost_report()
for key, value in report.items():
print(f" {key}: {value}")
if __name__ == "__main__":
asyncio.run(demo_advanced_system())
Emotionskategorien für NPC-Systeme
| Emotion | Farbcode | Anwendungsfall | Empfohlenes Model |
|---|
| 🟢 Freude (Joy) | #4CAF50 | Quest-Belohnung, Freundschaftsaufbau | DeepSeek V3.2 |
| 🔵 Trauer (Sadness) | #2196F3 | Verlust von NPC, emotionale Tiefe | Claude 4.5 |
| 🔴 Wut (Anger) | #F44336 | Boss-Kämpfe, Verrat-Events | GPT-4.1 |
| 🟣 Angst (Fear) | #9C27B0 | Horror-Elemente, Gefahrensituationen | Gemini 2.5 |
| 🟡 Überraschung | #FFEB3B | Plot-Twists, unerwartete Begegnungen | DeepSeek V3.2 |
| 🟠 Vertrauen | #FF9800 | Verbündete, Händler-Beziehungen | GPT-4.1 |
| ⚪ Neutral | #9E9E9E | Allgemeine NPCs, Hintergrunddialoge | DeepSeek V3.2 |
Häufige Fehler und Lösungen
1. Rate-Limit-Überschreitung (HTTP 429)
# FEHLERHAFTER CODE:
response = session.post(url, json=payload) # Keine Fehlerbehandlung!
LÖSUNG - Implementiere exponentielles Backoff:
import time
from functools import wraps
def retry_with_backoff(max_retries=5, initial_delay=1):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for attempt in range(max_retries):
try:
result = func(*args, **kwargs)
if result.status_code == 429:
retry_after = int(result.headers.get('Retry-After', 60))
wait_time = min(retry_after, 2 ** attempt * initial_delay)
print(f"Rate-Limit erreicht. Warte {wait_time}s...")
time.sleep(wait_time)
else:
return result
except requests.exceptions.RequestException as e:
if attempt == max_retries - 1:
raise
time.sleep(2 ** attempt)
return None
return wrapper
return decorator
@retry_with_backoff(max_retries=3, initial_delay=2)
def safe_api_call(session, url, payload):
"""Sichere API-Anfrage mit automatischer Wiederholung"""
return session.post(url, json=payload, timeout=15)
2. Token-Limit bei langen NPC-Kontexten
# FEHLERHAFTER CODE:
Kontext zu lang für Model-Kontextfenster
full_game_state = load_entire_savegame() # 50.000+ Tokens!
prompt = f"Analyse diesen NPC: {full_game_state}"
LÖSUNG - Intelligentes Kontext-Management:
def truncate_context(npc_context: str, max_tokens: int = 2000) -> str:
"""
Kürzt NPC-Kontext intelligent, behält aber wichtige Info
Args:
npc_context: Vollständiger NPC-Lebenslauf und -Zustand
max_tokens: Maximale Token-Anzahl (ca. 4 Zeichen pro Token)
Returns:
Gekürzter, für API optimierter Kontext
"""
# Priorisierte Abschnitte behalten
priority_sections = ["Aktuelle Situation:", "Beziehung:", "Letzte Aktion:"]
preserved = []
remaining = []
for section in npc_context.split('\n'):
if any(ps in section for ps in priority_sections):
preserved.append(section)
else:
remaining.append(section)
# Zusammenbauen mit Priorität
max_chars = max_tokens * 4 # ~4 Zeichen pro Token
result = '\n'.join(preserved)
# Falls noch Platz, füge Hintergrund hinzu
if len(result) < max_chars * 0.7:
background = '\n'.join(remaining)
if len(result) + len(background) <= max_chars:
result += '\n' + background
else:
result += '\n' + background[:max_chars - len(result) - 20] + '...'
return result
3. Falsche Emotionskategorisierung bei Sarkasmus
# FEHLERHAFTE ANALYSE:
"Ja, SUPER Idee, die Stadt anzuzünden..." -> Erkennt Freude statt Sarkasmus
LÖSUNG - Sarkasmus-Detektor hinzufügen:
SARCASM_MARKERS = [
"super", "toll", "genial", "wunderbar", "perfekt", # Positive Wörter
"natürlich", "logisch", "klar", # Verstärkung
"!?!", "?!", # Satzzeichen-Muster
]
IRONY_WORDS = ["stimmt", "echt", "wirklich", "also"]
def enhanced_emotion_analysis(text: str, base_emotion: str) -> str:
"""
Korrigiert
Verwandte Ressourcen
Verwandte Artikel