Communitygithub.com

ASoudy/AGS

API OpenRouter - Accès unifié à plus de 400 modèles d'IA via une seule API

Qu'est-ce que AGS ?

Cette compétence offre une assistance complète pour le développement avec l'API OpenRouter, qui permet un accès unifié à des centaines de modèles d'IA via un seul point de terminaison. Elle est idéale pour les développeurs travaillant avec des SDK compatibles OpenAI, mais souhaitant cibler plusieurs fournisseurs. La compétence couvre des cas d'utilisation essentiels comme l'implémentation de stratégies de repli, le routage automatique de modèles, la configuration de paramètres d'échantillonnage avancés, la gestion des réponses en streaming, et l'obtention de sorties JSON structurées. Elle prend en charge les plateformes d'agents d'IA telles que Claude Code, Cursor et Codex en fournissant des exemples de code prêts à l'emploi en Python, JavaScript/TypeScript et cURL. Grâce à son système de routage intelligent et aux basculements automatiques entre fournisseurs, elle garantit fiabilité et flexibilité pour les applications en production.

Compatible avec✓Claude Code✓Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/ASoudy/AGS/tree/HEAD/claude_skills_libraries/landing-page-mastery/skills/openrouter

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence OpenRouter

Assistance complète pour le développement avec l'API OpenRouter, offrant un accès unifié à des centaines de modèles d'IA via un seul point de terminaison avec routage intelligent, basculements automatiques et interfaces standardisées.

Quand utiliser cette compétence

Cette compétence doit être déclenchée lorsque :

  • Vous effectuez des appels API vers plusieurs fournisseurs de modèles d'IA via une interface unifiée
  • Vous implémentez des stratégies de repli de modèle ou d'auto-routage
  • Vous travaillez avec des SDK compatibles OpenAI mais ciblez plusieurs fournisseurs
  • Vous configurez des paramètres d'échantillonnage avancés (temperature, top_p, penalités)
  • Vous mettez en place des réponses en streaming ou des sorties JSON structurées
  • Vous comparez les coûts entre différents modèles d'IA
  • Vous créez des applications nécessitant un basculement automatique entre fournisseurs
  • Vous implémentez des appels de fonctions/outils avec différents modèles
  • Vous avez des questions sur les fonctionnalités spécifiques à OpenRouter (routage, basculements, assurance zéro complétion)

Référence rapide

Complétion de chat basique (Python)

from openai import OpenAI

client = OpenAI(
  base_url="https://openrouter.ai/api/v1",
  api_key="<OPENROUTER_API_KEY>",
)

completion = client.chat.completions.create(
  model="openai/gpt-4o",
  messages=[{"role": "user", "content": "Quel est le sens de la vie ?"}]
)
print(completion.choices[0].message.content)

Complétion de chat basique (JavaScript/TypeScript)

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'https://openrouter.ai/api/v1',
  apiKey: '<OPENROUTER_API_KEY>',
});

const completion = await openai.chat.completions.create({
  model: 'openai/gpt-4o',
  messages: [{"role": 'user', "content": 'Quel est le sens de la vie ?'}],
});
console.log(completion.choices[0].message);

Requête cURL

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role": "user", "content": "Quel est le sens de la vie ?"}]
  }'

Configuration de repli de modèle (Python)

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    extra_body={
        "models": ["anthropic/claude-3.5-sonnet", "gryphe/mythomax-l2-13b"],
    },
    messages=[{"role": "user", "content": "Votre prompt ici"}]
)

Configuration de repli de modèle (TypeScript)

const completion = await client.chat.completions.create({
    model: 'openai/gpt-4o',
    models: ['anthropic/claude-3.5-sonnet', 'gryphe/mythomax-l2-13b'],
    messages: [{ role: 'user', content: 'Votre prompt ici' }],
});

Routeur automatique (Sélection dynamique de modèle)

completion = client.chat.completions.create(
    model="openrouter/auto",  # Sélectionne automatiquement le meilleur modèle pour le prompt
    messages=[{"role": "user", "content": "Votre prompt ici"}]
)

Exemple de paramètres avancés

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Écris une histoire créative"}],
    temperature=0.8,           # Plus élevé pour la créativité (0.0-2.0)
    max_tokens=500,            # Limiter la longueur de la réponse
    top_p=0.9,                 # Échantillonnage nucleus (0.0-1.0)
    frequency_penalty=0.5,     # Réduire la répétition (-2.0-2.0)
    presence_penalty=0.3       # Encourager la diversité des sujets (-2.0-2.0)
)

Réponse en streaming

stream = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Raconte-moi une histoire"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')

Mode JSON (Sortie structurée)

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{
        "role": "user",
        "content": "Extrais le nom, l'âge et la ville de la personne : John a 30 ans et vit à Paris"
    }],
    response_format={"type": "json_object"}
)

Sortie déterministe avec seed

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Génère un nombre aléatoire"}],
    seed=42,            # Même seed = même sortie (lorsque supporté)
    temperature=0.0     # Échantillonnage déterministe
)

Concepts clés

Routage de modèles

OpenRouter offre des capacités de routage intelligent :

  • Routeur automatique (openrouter/auto) : Sélectionne automatiquement le meilleur modèle en fonction de votre prompt via NotDiamond
  • Modèles de repli : Spécifiez plusieurs modèles qui réessayent automatiquement si le principal échoue
  • Routage fournisseur : Route automatiquement entre les fournisseurs pour plus de fiabilité

Authentification

  • Utilise l'authentification par jeton Bearer avec des clés API
  • Les clés API peuvent être gérées par programmation
  • Compatible avec les schémas d'authentification du SDK OpenAI

Convention de nommage des modèles

Les modèles utilisent le format fournisseur/nom-du-modèle :

  • openai/gpt-4o - GPT-4 Optimisé d'OpenAI
  • anthropic/claude-3.5-sonnet - Claude 3.5 Sonnet d'Anthropic
  • google/gemini-2.0-flash-exp:free - Modèle gratuit Gemini de Google
  • openrouter/auto - Système d'auto-routage

Paramètres d'échantillonnage

Température (0.0-2.0, défaut : 1.0)

  • Plus bas = réponses plus prévisibles et ciblées
  • Plus élevé = réponses plus créatives et diverses
  • Utilisez faible (0.0-0.3) pour les tâches factuelles, élevé (0.8-1.5) pour le travail créatif

Top P (0.0-1.0, défaut : 1.0)

  • Limite les choix à un pourcentage de tokens probables
  • Filtrage dynamique des options improbables
  • Équilibre entre cohérence et variété

Pénalités de fréquence/présence (-2.0-2.0, défaut : 0.0)

  • Fréquence : Décourage la répétition des tokens proportionnellement à leur utilisation
  • Présence : Pénalité plus simple non proportionnelle au nombre
  • Valeurs positives réduisent la répétition, les négatives encouragent la réutilisation

Max Tokens (entier)

  • Définit la longueur maximale de la réponse
  • Ne peut pas dépasser la longueur du contexte moins la longueur du prompt
  • Utilisez pour contrôler les coûts et imposer des réponses concises

Formats de réponse

  • JSON standard : Format de complétion de chat par défaut
  • Streaming : Événements envoyés par le serveur (SSE) avec stream: true
  • Mode JSON : JSON valide garanti avec response_format : {"type": "json_object"}
  • Sorties structurées : Réponses JSON validées par schéma

Fonctionnalités avancées

  • Appel d'outils/fonctions : Connectez les modèles à des API externes
  • Entrées multimodales : Prise en charge des images, PDF, audio
  • Mise en cache des prompts : Réduit les coûts pour les prompts répétés
  • Intégration de recherche Web : Réponses enrichies avec des données web
  • Assurance zéro complétion : Protection contre les réponses échouées
  • Logprobs : Accédez aux probabilités des tokens pour l'analyse de la confiance

Fichiers de référence

Cette compétence inclut une documentation complète dans references/ :

  • llms-full.md - Liste complète des modèles disponibles avec métadonnées
  • llms-small.md - Sous-ensemble organisé de modèles populaires
  • llms.md - Listes de modèles standard

Utilisez view pour lire des fichiers de référence spécifiques lorsque des informations détaillées sur les modèles sont nécessaires.

Travailler avec cette compétence

Pour les débutants

  1. Commencez par les exemples de complétion de chat basiques (Python/JavaScript/cURL ci-dessus)
  2. Utilisez le SDK OpenAI standard pour une intégration facile
  3. Essayez des noms de modèles simples comme openai/gpt-4o ou anthropic/claude-3.5-sonnet
  4. Gardez les paramètres simples au début (juste le modèle et les messages)

Pour les utilisateurs intermédiaires

  1. Implémentez des tableaux de modèles de repli pour la fiabilité
  2. Expérimentez avec les paramètres d'échantillonnage (temperature, top_p)
  3. Utilisez le streaming pour une meilleure UX dans les applications conversationnelles
  4. Essayez openrouter/auto pour la sélection automatique de modèle
  5. Implémentez le mode JSON pour l'extraction de données structurées

Pour les utilisateurs avancés

  1. Ajustez plusieurs paramètres d'échantillonnage ensemble
  2. Implémentez une logique de routage personnalisée avec des chaînes de secours
  3. Utilisez les logprobs pour le score de confiance
  4. Exploitez les capacités d'appel d'outils/fonctions
  5. Optimisez les coûts en sélectionnant les modèles appropriés par tâche
  6. Implémentez des stratégies de mise en cache des prompts
  7. Utilisez le paramètre seed pour des tests reproductibles

Modèles courants

Gestion des erreurs avec replis

try:
    completion = client.chat.completions.create(
        model="openai/gpt-4o",
        extra_body={
            "models": [
                "anthropic/claude-3.5-sonnet",
                "google/gemini-2.0-flash-exp:free"
            ]
        },
        messages=[{"role": "user", "content": "Votre prompt"}]
    )
except Exception as e:
    print(f"Tous les modèles ont échoué : {e}")

Routage optimisé pour les coûts

# Utilisez des modèles moins chers pour les tâches simples
simple_completion = client.chat.completions.create(
    model="google/gemini-2.0-flash-exp:free",
    messages=[{"role": "user", "content": "Question simple"}]
)

# Utilisez des modèles premium pour les tâches complexes
complex_completion = client.chat.completions.create(
    model="openai/o1",
    messages=[{"role": "user", "content": "Tâche de raisonnement complexe"}]
)

Température contextuelle

# Faible température pour les réponses factuelles
factual = client.chat.completions.create(
    model="openai/gpt-4o",
    temperature=0.2,
    messages=[{"role": "user", "content": "Quelle est la capitale de la France ?"}]
)

# Haute température pour le contenu créatif
creative = client.chat.completions.create(
    model="openai/gpt-4o",
    temperature=1.2,
    messages=[{"role": "user", "content": "Écris un début d'histoire unique"}]
)

Ressources

Documentation officielle

Points de terminaison clés

  • Complétions de chat : POST https://openrouter.ai/api/v1/chat/completions
  • Lister les modèles : GET https://openrouter.ai/api/v1/models
  • Informations de génération : GET https://openrouter.ai/api/v1/generation

Notes

  • OpenRouter normalise les schémas API sur tous les fournisseurs
  • Utilise un format d'API compatible OpenAI pour une migration facile
  • Basculement automatique du fournisseur si les modèles sont limités en débit ou indisponibles
  • Tarification basée sur le modèle réellement utilisé (important pour les replis)
  • La réponse inclut des métadonnées sur le modèle qui a traité la requête
  • Tous les modèles supportent le streaming via Server-Sent Events
  • Compatible avec les frameworks populaires (LangChain, Vercel AI SDK, etc.)

Bonnes pratiques

  1. Implémentez toujours des replis pour les applications de production
  2. Utilisez une température appropriée en fonction du type de tâche (faible pour factuel, élevé pour créatif)
  3. Définissez max_tokens pour contrôler les coûts et la longueur des réponses
  4. Activez le streaming pour une meilleure expérience utilisateur dans les applications de chat
  5. Utilisez le mode JSON lorsque vous avez besoin d'une sortie structurée garantie
  6. Testez avec le paramètre seed pour des résultats reproductibles pendant le développement
  7. Surveillez les coûts en sélectionnant les modèles appropriés par tâche
  8. Utilisez l'auto-routage lorsque vous n'êtes pas sûr du meilleur modèle
  9. Implémentez une gestion des erreurs appropriée pour les limites de débit et les échecs
  10. Mettez en cache les prompts pour les requêtes répétées afin de réduire les coûts

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ASoudy/AGS

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

ASoudy/AGS

Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

ASoudy/AGS

Build content-focused websites with Astro — zero JS by default, islands architecture, multi-framework components, and Markdown/MDX support.

ASoudy/AGS

One sentence - what this skill does and when to invoke it

ASoudy/AGS

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

ASoudy/AGS

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

ASoudy/AGS

Pull a YouTube video transcript into a queryable markdown vault with yt-dlp subtitle discovery, VTT cleanup, metadata frontmatter, and capture-seed stubs.

ASoudy/AGS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

ASoudy/AGS

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

ASoudy/AGS

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

ASoudy/AGS

CRITICAL: Use for Makepad animation system. Triggers on: makepad animation, makepad animator, makepad hover, makepad state, makepad transition, "from: { all: Forward", makepad pressed, makepad 动画, makepad 状态, makepad 过渡, makepad 悬停效果

ASoudy/AGS

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

ASoudy/AGS

Next.js App Router principles. Server Components, data fetching, routing patterns.

ASoudy/AGS

Expert integration of Supabase Auth with Next.js App Router

ASoudy/AGS

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

ASoudy/AGS

Best practices for Remotion - Video creation in React

ASoudy/AGS

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

ASoudy/AGS

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

ASoudy/AGS

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

ASoudy/AGS

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Skills associés