Awesome-omni-skill llm-evaluate

Evaluate LLM models for cost/performance ratio. Fetches current pricing and recommends optimal model for your use case. Use during project init or when optimizing costs.

install

source · Clone the upstream repo

git clone https://github.com/diegosouzapw/awesome-omni-skill

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/diegosouzapw/awesome-omni-skill "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data-ai/llm-evaluate" ~/.claude/skills/diegosouzapw-awesome-omni-skill-llm-evaluate && rm -rf "$T"

manifest: skills/data-ai/llm-evaluate/SKILL.md

source content

LLM Model Evaluation

Evaluiert LLM-Modelle basierend auf aktuellem Preis/Leistungs-Verhältnis.

Wann nutzen?

Während
```
/init-project
```
bei der Komplexitätsbewertung
Bei Kosten-Optimierung bestehender Projekte
Wenn neue Modelle erscheinen (regelmäßig checken)
Vor größeren Production-Deployments

Step 1: Use Case verstehen

Falls kein Argument übergeben, frage:

Was ist dein Use Case?

Beispiele:
• "Chat-Bot für Kundenservice" (High-Volume, schnelle Antworten)
• "Dokumenten-Analyse" (Langer Context, Reasoning)
• "Code-Generierung" (Präzision wichtig)
• "GDPR-konforme EU-App" (Compliance)
• "Budget-Projekt" (Kosten minimieren)

Step 2: Aktuelle Preise holen

WICHTIG: Preise ändern sich häufig. Hole aktuelle Daten.

2.1 Web Search für aktuelle Preise

Suche nach aktuellen Preisen mit WebSearch:

Query: "[Provider] API pricing 2026"

Für jeden Provider:

Anthropic Claude pricing
OpenAI GPT pricing
Google Gemini pricing
DeepSeek pricing
xAI Grok pricing
Mistral pricing

2.2 Pricing Endpoints (falls verfügbar)

Einige Provider haben öffentliche Pricing-Pages:

Provider	Pricing URL
Anthropic	https://www.anthropic.com/pricing
OpenAI	https://openai.com/api/pricing
Google	https://ai.google.dev/pricing
DeepSeek	https://platform.deepseek.com/api-docs/pricing
Mistral	https://mistral.ai/technology/#pricing
xAI	https://x.ai/api

2.3 Fallback: Cached Reference

Falls Web-Fetch fehlschlägt, nutze

.claude/reference/llm-configuration.md

als Fallback (aber weise auf möglicherweise veraltete Daten hin).

Step 3: Modelle bewerten

3.1 Bewertungskriterien

Kriterium	Gewichtung	Beschreibung
Kosten	30%	Input + Output Tokens
Qualität	30%	Benchmark-Scores, Erfahrungswerte
Latenz	20%	Time to first token, Throughput
Context	10%	Max Context Window
Features	10%	Vision, Tools, Streaming

3.2 Use Case Mapping

Use Case	Wichtig	Unwichtig
Chat-Bot	Latenz, Kosten	Context
Dokument-Analyse	Context, Qualität	Latenz
Code-Gen	Qualität	Kosten
High-Volume	Kosten, Latenz	Qualität
GDPR	Compliance	Kosten

Step 4: Empfehlung ausgeben

4.1 Empfehlungs-Template

┌─────────────────────────────────────────────────────────────────────────────┐
│  LLM EVALUATION - [Use Case]                                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  📅 Preise Stand: [Datum der Abfrage]                                       │
│                                                                             │
│  TOP 3 EMPFEHLUNGEN:                                                        │
│                                                                             │
│  🥇 #1: [Modell]                                                            │
│      Provider: [Provider]                                                   │
│      Input:    $[X]/1M tokens                                               │
│      Output:   $[X]/1M tokens                                               │
│      Context:  [X]K                                                         │
│      Score:    [X]/100 (basierend auf Use Case)                             │
│      Warum:    [Begründung]                                                 │
│                                                                             │
│  🥈 #2: [Modell]                                                            │
│      ...                                                                    │
│                                                                             │
│  🥉 #3: [Modell]                                                            │
│      ...                                                                    │
│                                                                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  KOSTEN-SCHÄTZUNG (bei 1M Requests/Monat, 1000 Tokens avg):                │
│                                                                             │
│  Modell #1: ~$[X]/Monat                                                     │
│  Modell #2: ~$[X]/Monat                                                     │
│  Modell #3: ~$[X]/Monat                                                     │
│                                                                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  FALLBACK-STRATEGIE:                                                        │
│                                                                             │
│  Primary:  [Modell #1]                                                      │
│  Fallback: [Modell #2]                                                      │
│  Budget:   [Modell #3]                                                      │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

4.2 Portkey Config generieren

Falls gewünscht, generiere die Portkey-Konfiguration:

// Empfohlene Portkey Konfiguration für [Use Case]
const config = {
  strategy: {
    mode: 'fallback',
  },
  targets: [
    { provider: '[primary]', model: '[model]' },
    { provider: '[fallback]', model: '[model]' },
  ],
  cache: {
    mode: 'semantic',
    ttl: 3600,
  },
};

Step 5: Dokumentation aktualisieren

Falls signifikante Preisänderungen gefunden wurden:

Weise den User darauf hin
Frage ob
```
.claude/reference/llm-configuration.md
```
aktualisiert werden soll
Bei "Ja": Update die Preistabellen

Automatische Intervall-Checks

Weekly Reminder

Dieser Skill sollte regelmäßig genutzt werden:

Empfehlung: Führe /llm-evaluate monatlich aus um:
- Neue Modelle zu entdecken
- Preisänderungen zu berücksichtigen
- Kosten-Optimierung zu prüfen

Bei Projekt-Init

Während

/init-project

wird dieser Skill automatisch bei der Komplexitätsbewertung (Step 0.2) aufgerufen um das optimale Modell für den Use Case zu empfehlen.

Modell-Datenbank (Referenz)

Anthropic

Modell	Input/1M	Output/1M	Context	Stärken
Claude Opus 4.5	$15	$75	200K	Best reasoning
Claude Sonnet 4	$3	$15	200K	Best coding
Claude Haiku 3.5	$0.25	$1.25	200K	Fast, cheap

OpenAI

Modell	Input/1M	Output/1M	Context	Stärken
GPT-4o	$5	$15	128K	Multimodal
GPT-4o-mini	$0.15	$0.60	128K	Budget GPT-4
o1	$15	$60	200K	Deep reasoning

Google

Modell	Input/1M	Output/1M	Context	Stärken
Gemini 2.0 Pro	$7	$21	1M	Long context
Gemini 2.0 Flash	$0.10	$0.40	1M	Fast, cheap
Gemini Flash 8B	$0.04	$0.15	1M	Ultra cheap

DeepSeek

Modell	Input/1M	Output/1M	Context	Stärken
DeepSeek V3	$0.27	$1.10	64K	Open-weight
DeepSeek R1	$0.55	$2.19	64K	Reasoning

xAI

Modell	Input/1M	Output/1M	Context	Stärken
Grok 2	$2	$10	128K	Realtime data
Grok 2 Vision	$2	$10	32K	Image understanding

Mistral

Modell	Input/1M	Output/1M	Context	Stärken
Mistral Large	$2	$6	128K	EU-hosted
Codestral	$0.30	$0.90	256K	Code
Mistral Small	$0.20	$0.60	128K	Budget

Beispiel-Ausführung

User: /llm-evaluate Chat-Bot für Kundenservice

Claude:
┌─────────────────────────────────────────────────────────────────────────────┐
│  LLM EVALUATION - Customer Service Chat Bot                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  📅 Preise Stand: Januar 2026                                               │
│                                                                             │
│  TOP 3 EMPFEHLUNGEN:                                                        │
│                                                                             │
│  🥇 #1: Claude Haiku 3.5                                                    │
│      Provider: Anthropic                                                    │
│      Input:    $0.25/1M tokens                                              │
│      Output:   $1.25/1M tokens                                              │
│      Context:  200K                                                         │
│      Score:    92/100                                                       │
│      Warum:    Schnell, günstig, gute Qualität für Chat                     │
│                                                                             │
│  🥈 #2: Gemini 2.0 Flash                                                    │
│      Provider: Google                                                       │
│      Input:    $0.10/1M tokens                                              │
│      Output:   $0.40/1M tokens                                              │
│      Context:  1M                                                           │
│      Score:    88/100                                                       │
│      Warum:    Noch günstiger, aber weniger konsistent                      │
│                                                                             │
│  🥉 #3: DeepSeek V3                                                         │
│      Provider: DeepSeek                                                     │
│      Input:    $0.27/1M tokens                                              │
│      Output:   $1.10/1M tokens                                              │
│      Context:  64K                                                          │
│      Score:    82/100                                                       │
│      Warum:    Sehr günstig, aber China-based (Compliance?)                 │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Integration mit init-project

Dieser Skill wird automatisch während

/init-project

aufgerufen:

User beschreibt Projekt (Step 0.1)
Komplexitätsstufe wird ermittelt (Step 0.2)
/llm-evaluate
läuft im Hintergrund
Stack-Empfehlung inkl. LLM-Empfehlung (Step 0.3)

Version: 1.0 Last Updated: January 2026