☁️ OpenRouter Enterprise

📅 2026-06-03  ·  📖 ~14 000 mots  ·  🔗 Source originale

Résumé Exécutif

Suite au passage de GitHub Copilot à la facturation totale (usage-based), les coûts explosent. Cette analyse explore les alternatives pour une entreprise de 12 utilisateurs en UE : réduire les coûts via des modèles moins chers (DeepSeek, Qwen, Kimi) tout en maintenant un niveau de confidentialité au moins égal à Copilot Enterprise — avec ZDR (Zero Data Retention) et routing Europe.

01 — OpenRouter Enterprise

Modèles ZDR recommandés pour le coding

• Claude Sonnet 4 (via Bedrock/Vertex) → ZDR + EU possible
• DeepSeek V3 / V3.1 / V3.2 / Coder → excellents en coding
• Qwen3 32B / Qwen3 Coder → meilleur rapport qualité/prix
• Kimi K2.5 / K2.6 → très forts en coding et raisonnement

02 — Comparatif Privacy : OpenRouter vs GitHub Copilot

03 — Architecture recommandée

                    ┌─────────────────────────┐
                    │    OpenRouter            │
                    │    (Enterprise)          │
                    │    ZDR + EU routing      │
                    └──────────┬──────────────┘
                               │ 1 clé API
                    ┌──────────▼──────────────┐
                    │    LiteLLM Proxy        │
                    │    (VPS / Docker)        │
                    │                         │
                    │  • Caching (Redis)       │
                    │  • Budgets par user      │
                    │  • Fallbacks             │
                    │  • Virtual Keys          │
                    └──────────┬──────────────┘
                               │ Virtual Keys (1 par user)
         ┌─────────────────────┼─────────────────────┐
         ▼                     ▼                     ▼
   ┌─────────────┐      ┌─────────────┐      ┌─────────────┐
   │ User 1      │      │ User 2      │      │ User 12     │
   │ VS Code +   │      │ VS Code +   │      │ OpenCode    │
   │ Continue    │      │ Continue    │      │             │
   └─────────────┘      └─────────────┘      └─────────────┘

04 — Stratégies de réduction des coûts

05 — Continue.dev

Continue.dev est une extension open-source pour VS Code / JetBrains. C'est bien plus qu'un autocomplete — c'est un vrai AI Coding Agent :

• Autocomplete (Tab)
• Chat latéral — conversation avec l'IA
• Edit / Inline Edit — refactoring, ajout de tests
• Agent Mode — travail autonome multi-fichiers
• Context Providers — indexation codebase, docs, Git
• Multi-modèles — switch facile entre modèles

Configuration avec OpenRouter + ZDR

{
  "models": [
    {
      "title": "Claude Sonnet 4 (ZDR + EU)",
      "provider": "openrouter",
      "model": "anthropic/claude-sonnet-4",
      "extra": { "zdr": true }
    },
    {
      "title": "DeepSeek V3 (ZDR)",
      "provider": "openrouter",
      "model": "deepseek/deepseek-chat",
      "extra": { "zdr": true }
    }
  ]
}

06 — LiteLLM : Proxy central

Pourquoi LiteLLM ?

• Clés virtuelles : 1 clé OpenRouter + Virtual Keys par utilisateur
• Budgets individuels : limite par personne (ex: 30-50$/mois)
• Semantic Caching : jusqu'à 70% d'économie sur réponses similaires
• Fallbacks : si un modèle échoue, bascule automatiquement
• Routing avancé : par type de tâche, coût, performance
• Ollama + modèles locaux : tâches simples sans coût API
• Logging centralisé : qui consomme quoi

07 — Plan de déploiement

08 — Budget test recommandé

10 — Plugins de réduction de tokens (RTK, Graphify, Caveman)

Au-delà du simple choix de modèles, des outils spécialisés permettent de réduire considérablement la consommation de tokens.

RTK-AI (Rust Token Killer)

RTK est un proxy CLI haute performance écrit en Rust (58.2k★, MIT) qui filtre la sortie des commandes shell avant qu'elle n'entre dans le contexte du modèle.

Comment ça marche :

• Interception des commandes CLI lourdes en tokens (git status, pytest, cargo test, find, grep, docker logs)
• 4 stratégies : filtrage intelligent, groupement, troncature, déduplication
• rtk init -g : hook auto-rewrite transparent

Impact financier : Équipe de 10 → ~1 750 $/mois de bruit éliminé.

Installation : brew install rtk ou cargo install rtk — rtk-ai.app

Graphify

Graphify indexe le codebase en un graphe de connaissances requêtable. Il remplace les appels coûteux de grep/glob/read par des requêtes ciblées contre le graphe.

Caveman

Compresse le langage des réponses LLM (output tokens) et les fichiers d'instruction (input tokens) tout en gardant le sens technique. Niveaux : lite / full / ultra. Réduction jusqu'à ~75% des tokens de sortie.

LSP (Language Server Protocol)

Remplace la lecture de fichiers entiers par des requêtes symboliques ciblées. Une requête LSP = quelques dizaines de tokens au lieu de milliers.

Stratégie combinée

LiteLLM (proxy central)
├── Semantic Caching → -30-70%
├── Budgets / Fallbacks
│
RTK (wrapper CLI)
├── rtk init -g → -89% sur commandes CLI
│
Graphify (indexation codebase)
├── Graphe connaissances → -71× sur navigation code
│
Caveman (compression sortie)
├── Output tokens -75%
│
LSP (navigation symbolique)
├── Requêtes symboliques

Réduction totale estimée : 50-80% selon les usages.

Liens & Sources

• OpenRouter Enterprise
• OpenRouter ZDR
• OpenRouter Privacy / Provider Logging
• OpenRouter Trust Center
• OpenRouter Endpoints ZDR (API)
• GitHub Copilot Enterprise
• OpenCode
• Continue.dev
• LiteLLM
• Nudge Security — OpenRouter Profile