Agents IA locaux : libérez-vous des APIs payantes avec Ollama et Qwen

Depuis quelques semaines, le paysage des outils IA pour développeurs se transforme rapidement — et pas forcément dans le bon sens pour votre budget. Anthropic envisage de retirer Claude Code de ses offres abordables, et Microsoft a déjà basculé GitHub Copilot vers un modèle purement à l'usage. Pour un projet hobby ou une petite équipe, la facture peut vite grimper.

Bonne nouvelle : vous n'avez pas besoin de dépendre de ces APIs pour coder avec l'aide d'un agent IA. Des alternatives locales, performantes et gratuites (matériel mis à part) existent. Cet article vous explique comment les mettre en place dans un contexte de développement PHP/Symfony.

Cet article s'inspire d'un tutoriel publié par The Register le 2 mai 2026.

Pourquoi passer à un LLM local ?

Le modèle économique des grands fournisseurs d'IA évolue vers la facturation à l'usage (usage-based pricing). Ce changement a des implications concrètes :

• Coûts imprévisibles : chaque appel API consomme des tokens, et une session de refactoring intensive peut rapidement coûter plusieurs euros.
• Dépendance fournisseur (vendor lock-in) : si l'API change, vos outils s'arrêtent.
• Confidentialité des données : votre code source transite par des serveurs tiers.

Un modèle local tourne entièrement sur votre machine. Les requêtes ne quittent jamais votre réseau, et le coût marginal est nul une fois le matériel amorti.

La contrepartie est réelle : un modèle local sera souvent plus lent et légèrement moins précis qu'un GPT-4o ou un Claude Sonnet. Mais pour une grande partie des tâches quotidiennes — génération de tests, documentation, refactoring de méthodes, création de services Symfony — c'est largement suffisant.

Choisir son modèle : le cas Qwen3-27B

Alibaba a récemment publié Qwen3-27B, un modèle open-source de 27 milliards de paramètres qui offre un excellent rapport qualité/ressources. Il est particulièrement performant sur les tâches de code, y compris PHP.

Pour le faire tourner localement, deux approches selon votre matériel :

Quantization Q4 (recommandée) : réduit la précision numérique du modèle pour diminuer la mémoire nécessaire. Un Qwen3-27B en Q4 tourne avec environ 16 Go de VRAM ou de RAM unifiée (Apple Silicon M2/M3 Pro par exemple). La perte de qualité est marginale pour du code.

Quantization Q8 : plus précise, nécessite ~28 Go de VRAM. Réservée aux machines bien équipées.

D'autres modèles méritent d'être mentionnés selon vos besoins :

• Llama 3.1 8B : très léger, tourne sur des machines modestes (8 Go RAM), idéal pour l'autocomplétion.
• DeepSeek Coder V2 : spécialisé code, excellent pour PHP.
• Mistral 7B : polyvalent et rapide.

Mise en place avec Ollama

Ollama est l'outil de référence pour gérer et exécuter des LLMs locaux. Il expose une API REST compatible avec le format OpenAI, ce qui facilite l'intégration avec la plupart des agents existants.

Installation

# macOS / Linux
curl -fsSL https://ollama.com/install.sh | sh

# Vérification
ollama --version

Téléchargement et lancement du modèle

# Télécharger Qwen3 27B quantifié Q4
ollama pull qwen3:27b-q4_K_M

# Lancer une session interactive
ollama run qwen3:27b-q4_K_M

Ollama expose automatiquement une API sur http://localhost:11434. Vous pouvez l'interroger comme une API OpenAI classique :

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3:27b-q4_K_M",
    "messages": [{"role": "user", "content": "Génère un service Symfony pour valider un email"}]
  }'

Intégrer un agent IA dans votre workflow Symfony

Une fois Ollama en marche, plusieurs solutions permettent de créer un véritable agent de développement autonome.

Option 1 : Continue.dev (extension VS Code / JetBrains)

Continue est une extension open-source qui transforme votre éditeur en assistant IA. Pour le connecter à Ollama, éditez ~/.continue/config.json :

{
  "models": [
    {
      "title": "Qwen3 Local",
      "provider": "ollama",
      "model": "qwen3:27b-q4_K_M",
      "apiBase": "http://localhost:11434"
    }
  ]
}

Vous bénéficiez alors de l'autocomplétion, de la génération de code à la demande et de l'explication de code — le tout en local.

Option 2 : Aider (agent en ligne de commande)

Aider est un agent CLI qui peut modifier directement vos fichiers, créer des commits Git et raisonner sur l'ensemble de votre codebase.

pip install aider-chat

# Lancer sur votre projet Symfony
cd mon-projet-symfony
aider --openai-api-base http://localhost:11434/v1 \
      --openai-api-key ollama \
      --model ollama/qwen3:27b-q4_K_M

Exemple de session :

> Crée un ValueObject Email avec validation dans src/Domain/ValueObject/
aider: Je vais créer le fichier Email.php avec une validation RFC et ses tests unitaires...

L'agent analyse le contexte de votre projet, propose des modifications et les applique avec votre accord.

Option 3 : Script PHP maison

Si vous préférez intégrer l'IA directement dans vos outils internes, l'API Ollama est consommable depuis PHP :

$client = new \GuzzleHttp\Client();
$response = $client->post('http://localhost:11434/v1/chat/completions', [
    'json' => [
        'model' => 'qwen3:27b-q4_K_M',
        'messages' => [
            ['role' => 'system', 'content' => 'Tu es un expert Symfony. Réponds uniquement en PHP valide.'],
            ['role' => 'user', 'content' => $prompt],
        ],
    ],
]);

$data = json_decode($response->getBody(), true);
echo $data['choices'][0]['message']['content'];

Cela ouvre la porte à des outils de génération de code intégrés à votre pipeline CI/CD ou à des commandes Symfony Console dédiées.

Conclusion

Le virage vers la facturation à l'usage des grandes APIs IA est une opportunité de reprendre le contrôle. Les modèles locaux comme Qwen3-27B, associés à des outils comme Ollama et Aider, offrent aujourd'hui un niveau de qualité tout à fait adapté au développement quotidien en PHP/Symfony.

Vous gagnez en autonomie, en confidentialité et en prévisibilité des coûts — au prix d'un peu de configuration initiale et d'un matériel suffisant. Pour les projets professionnels nécessitant des capacités avancées de raisonnement, les APIs cloud restent pertinentes. Mais pour le travail courant, l'outillage local est désormais mature.

💡 À retenir : commencez par Ollama + Continue.dev sur un projet de test. Une demi-heure suffit pour avoir un assistant IA fonctionnel, sans dépenser un centime.