LLM local et RGPD : coding agentique sans fuite de données

Les prix des APIs cloud IA augmentent. Google a triplé le tarif de Gemini Flash entre la version 2.5 et 3.5, avec des gains de performance marginaux. OpenAI facture désormais le code de vos projets envoyé à chaque complétion. Pour les équipes qui font du coding agentique (agents qui lisent des fichiers, génèrent des tests, refactorisent du code), la facture peut devenir significative.

Réponse directe : un LLM local tourne entièrement sur votre machine ou votre serveur, aucune donnée n'est transmise à un fournisseur externe — c'est l'option la plus souveraine. Pour les cas nécessitant la puissance d'un modèle frontier, Mistral AI (infrastructure UE, société française) est l'alternative cloud RGPD-native. Ce guide couvre les deux.

Pourquoi le coding agentique cloud pose un problème RGPD

Quand vous utilisez Claude Code, GitHub Copilot ou Cursor en mode cloud, chaque requête envoie :

• Le contenu des fichiers lus par l'agent
• L'historique de contexte (souvent 10k-100k tokens)
• Les résultats des outils exécutés (sorties de tests, logs, etc.)

Ces données partent sur des serveurs américains. L'Article 44 du RGPD interdit les transferts de données personnelles hors UE sans garanties adéquates. Le CLOUD Act (2018) permet aux autorités américaines d'accéder aux données hébergées par des entreprises US, y compris sur leurs infrastructures européennes. Si votre code contient des données personnelles (noms de clients, emails, schémas de BDD), c'est un risque réel.

Un LLM local supprime ce risque structurellement : rien ne sort de votre infrastructure.

Quelle configuration matérielle est suffisante ?

Vous n'avez pas besoin d'un serveur GPU dédié pour démarrer. Un bon laptop suffit pour des modèles de 7B à 27B paramètres en quantisation GGUF.

Pour du coding agentique en conditions réelles, le modèle recommandé est Gemma 4 26B Mixture of Experts : il supporte les outils (tool use), la vision, et le raisonnement, avec un bon rapport qualité/ressources.

Installation avec Ollama ou LM Studio

Option Ollama (terminal, scripts)

# Installation
curl -fsSL https://ollama.com/install.sh | sh
 
# Téléchargement du modèle
ollama pull gemma4:27b
 
# Lancement d'un agent en Python

import ollama
 
def coding_agent(task: str, file_content: str) -> str:
    response = ollama.chat(
        model="gemma4:27b",
        messages=[
            {
                "role": "system",
                "content": "Tu es un assistant de code expert. Analyse et modifie le code fourni."
            },
            {
                "role": "user",
                "content": f"Tâche : {task}\n\nCode :\n```\n{file_content}\n```"
            }
        ]
    )
    return response["message"]["content"]

Option LM Studio (interface graphique)

LM Studio est recommandé pour commencer : interface simple, gestion des modèles intégrée, serveur OpenAI-compatible activable en un clic. Téléchargeable sur lmstudio.ai.

Une fois le serveur local démarré (port 1234 par défaut), n'importe quel client OpenAI fonctionne :

from openai import OpenAI
 
# Client pointant vers le serveur local
client = OpenAI(base_url="http://localhost:1234/v1", api_key="local")
 
response = client.chat.completions.create(
    model="gemma-4-27b-it",
    messages=[{"role": "user", "content": "Refactore cette fonction..."}],
    max_tokens=4096
)

Configuration critique : context length et cache

Les paramètres par défaut de la plupart des runners LLM locaux sont trop conservateurs pour du coding agentique.

{
  "contextLength": 100000,
  "kCacheQuantization": "Q8_0",
  "vCacheQuantization": "Q4_0",
  "maxInputTokens": 64000,
  "maxOutputTokens": 16384
}

• Context length : monter à 100k tokens minimum. Les agents de coding envoient des fichiers entiers, des historiques de conversation, des outputs de tests.
• Cache quantization : K-cache en Q8_0 et V-cache en Q4_0 réduit l'utilisation VRAM de 30-40% avec un impact négligeable sur la qualité.

Sans ces ajustements, le premier message d'un agent (avec system prompt + définitions d'outils + contexte fichier) peut atteindre 8k-20k tokens et faire crasher l'inférence.

Intégration avec VS Code Copilot

VS Code Copilot supporte les endpoints custom depuis la version 1.95. Configuration dans settings.json :

{
  "github.copilot.advanced": {
    "debug.useNodeFetcher": true
  },
  "github.copilot.chat.localeOverride": "fr",
  "chat.extensionServiceUrl": "http://localhost:1234/v1",
  "chat.models": [
    {
      "id": "gemma-4-27b-it",
      "name": "Gemma 4 27B (local)",
      "maxInputTokens": 64000,
      "maxOutputTokens": 16384,
      "isDefault": true,
      "capabilities": {
        "vision": true,
        "toolCalling": true,
        "reasoning": true
      }
    }
  ]
}

Note importante : le premier prompt envoyé à Copilot est lourd (system prompt Copilot + définitions de tous les outils). Attendez-vous à 2-5 minutes pour la première réponse le temps que le modèle charge le contexte. Les échanges suivants sont nettement plus rapides.

Quand les LLMs locaux ne suffisent pas

Les modèles locaux restent moins performants que les modèles frontier (GPT-4o, Claude Opus, Gemini Ultra) sur certaines tâches :

• Génération de code très complexe : refactoring de codebase multi-fichiers avec contraintes architecturales précises
• Raisonnement long : problèmes nécessitant plus de 10 étapes de raisonnement enchainées
• Langages rares : Elixir, Haskell, Rust avancé — les modèles locaux ont moins de données d'entraînement

Pour ces cas, l'alternative cloud la plus solide sur le plan RGPD est Mistral AI (La Plateforme) : société française, infrastructure hébergée en UE, hors portée du CLOUD Act américain. Les modèles Mistral Large et Codestral sont compétitifs avec les modèles frontier sur les tâches de coding. C'est l'option à privilégier si vous avez besoin de puissance cloud tout en restant dans un cadre RGPD robuste.

Pour du code moins sensible, OpenRouter en mode zero-data-retention reste une option : les données ne sont pas stockées ni utilisées pour l'entraînement, mais l'hébergement reste hors UE.

TL;DR

Un LLM local (Ollama + Gemma 4 27B) reste la solution la plus souveraine pour du coding agentique conforme RGPD : aucune donnée ne quitte votre machine, zéro coût marginal, fonctionnel sur un bon laptop avec 64 GB RAM.

Quand la puissance locale ne suffit pas, Mistral AI (Codestral, Mistral Large) est l'alternative cloud RGPD-native : infrastructure UE, hors portée du CLOUD Act américain.

La config minimale viable locale : LM Studio + Gemma 4 27B + context à 100k tokens + intégration VS Code.

Vous travaillez sur un projet de coding agentique avec des contraintes de souveraineté des données ? Discutons de votre architecture.