Guide de l'IA (Intelligence Artificielle)

Ce guide définit l'approche de Codexia concernant l'intégration de l'IA dans le cycle de développement web, les technologies retenues et les optimisations spécifiques pour l'environnement de travail.

L'objectif est de maximiser l'efficience tout en garantissant la souveraineté technique et en maîtrisant l'impact financier.

1. Concepts et applications dans le WebDev

Dans le cadre de Codexia, l'IA n'est pas un substitut à l'expertise humaine mais un multiplicateur de forces.

Collaboration Humain-IA

• Augmentation vs Automatisation : L'IA assiste le développeur dans les tâches répétitives (boilerplate, tests unitaires, documentation) pour lui permettre de se concentrer sur l'architecture et la logique métier complexe.
• Revue de code bidirectionnelle : Utilisation de l'IA pour auditer le code (sécurité, performance, accessibilité) et, inversement, revue humaine systématique du code généré par l'IA.
• Documentation as Code assistée : Génération de squelettes de documentation, de changelogs et de tutoriels à partir du code source ou de notes de conception.

Faisabilité pour le projet

• Génération de code : Très haute faisabilité pour les composants isolés (Voters, Commandes, services simples).
• Refactoring : Haute faisabilité pour la modernisation de code legacy (ex: migration de Twig vers des composants Stimulus).
• Tests : Indispensable pour augmenter la couverture de tests sans sacrifier le temps de développement.

2. Technologies principales

Le choix des technologies repose sur un équilibre entre performance, coût et protection des données.

Modèles distants (SaaS)

• Claude (Anthropic) : Modèle privilégié pour le raisonnement complexe et la rédaction de documentation technique grâce à sa fenêtre de contexte étendue et son style de rédaction plus "humain".
• ChatGPT (OpenAI) : Utilisation ponctuelle pour des scripts rapides ou de l'exploration technologique.

Modèles locaux (Souveraineté)

• Ollama / llama.cpp : Pour l'exécution de modèles en local (Llama 3, Mistral, DeepSeek-Coder).
• Avantages : Zéro coût récurrent, confidentialité totale du code source, fonctionnement hors-ligne.
• Faisabilité : Nécessite un matériel adapté (GPU avec 8Go+ VRAM recommandé, 6Go minimum) pour une fluidité acceptable.
  • Note sur le matériel : Une carte comme la GTX 1660 Ti (6Go) permet de faire tourner des modèles de 7-8 milliards de paramètres (ex: Llama 3) s'ils sont quantifiés (compressés). Pour des modèles de code plus lourds ou une fenêtre de contexte large (plusieurs fichiers ouverts), 8Go à 12Go de VRAM sont nécessaires pour éviter les ralentissements.
  • Pourquoi la VRAM ? Les modèles d'IA (LLM) sont composés de milliards de paramètres ("poids"). Pour répondre instantanément, ces poids doivent être stockés intégralement dans la mémoire ultra-rapide de la carte graphique (VRAM). Si la VRAM est insuffisante, le modèle bascule sur la RAM classique, ce qui ralentit l'exécution de manière drastique (facteur 10 à 100).

Utilisation locale avec Ollama

1. Installation : Télécharger Ollama sur ollama.com.
2. Récupération d'un modèle : Dans un terminal, exécuter ollama run deepseek-coder-v2 (ou llama3, mistral).
3. Configuration IDE : Utiliser un plugin comme Continue pour interagir avec l'API locale d'Ollama (généralement sur http://localhost:11434).
4. Usage : Idéal pour l'assistance au code sans que celui-ci ne quitte la machine de développement.

Conseil

1. Ollama : Installe-le et essaie ollama run llama3:8b. Ça devrait être parfaitement fluide.
2. Quantification : Reste sur les modèles "4-bit" ou "Q4_K_M". Évite les versions "fp16" qui sont 4 fois plus lourdes sans apporter de gain majeur pour du code.
3. Usage IDE : C'est parfait pour de l'autocomplétion ou des explications de fonctions isolées.

Impact Financier

Stratégie Codexia : Privilégier le SaaS pour la phase de conception/conception et le local pour le développement quotidien si le matériel le permet.

3. Utilisation dans PhpStorm

PhpStorm est le centre névralgique de l'expertise Codexia. L'IA doit y être intégrée de manière fluide pour maximiser la productivité sans polluer l'interface.

Paramétrages recommandés

1. AI Assistant (JetBrains) :
   • Settings : Settings > Tools > AI Assistant.
   • Contexte : Cocher "Enable project context" pour que l'IA indexe la structure du projet.
   • Data Sharing : Configurer selon les exigences de confidentialité du client.
2. Plugin Continue (Open Source) :
   • Installation : Settings > Plugins > Marketplace > Continue.
   • Configuration : Éditer le fichier config.json de Continue pour pointer vers Ollama (local) ou des clés API (Anthropic/OpenAI).
   • Rôle : Permet une personnalisation totale du modèle utilisé selon la tâche.
3. Codeium / Supermaven :
   • Usage : Dédiés à l'autocomplétion "inline" ultra-rapide.
   • Paramétrage : Désactiver l'autocomplétion native de l'IA Assistant pour éviter les conflits visuels.

Optimisations avancées

• Context Pinning (Ancrage) : Dans le chat de l'IA, utiliser @file ou @folder pour forcer l'IA à lire des fichiers spécifiques (ex: specs/ui.md).
• Prompts réutilisables : Créer des "Custom Commands" dans l'AI Assistant ou des "Slash Commands" dans Continue pour les tâches récurrentes.
  • Exemple : /voter -> "Génère un Symfony Voter pour cette entité en respectant SOLID."
• Validation automatisée : Configurer un "Before Commit" hook qui lance PHPStan ou les inspections de PhpStorm sur le code généré.

Recommandations de faisabilité

• Ne jamais confier 100% d'un fichier complexe à l'IA sans découpage.
• Utiliser l'IA en mode "diff" (comparaison) pour comprendre les modifications proposées.
• Impact financier : L'abonnement JetBrains AI Assistant est un investissement rentable (~10€/mois) s'il permet de gagner 1h de productivité par mois.

4. Le protocole MCP (Model Context Protocol)

Le MCP est une innovation majeure pour l'intégration de l'IA dans le workflow de développement.

Définition et Rôle

Le MCP est un standard ouvert (initié par Anthropic) qui permet aux modèles d'IA (via des clients comme Claude Desktop ou des plugins IDE) de se connecter à des "serveurs" de données et d'outils.

• Rôle : Donner à l'IA des "mains" et des "yeux" sur le système local ou des services tiers (GitHub, Google Drive, bases de données).

Fonctionnement technique du MCP

Le MCP repose sur une architecture Client-Serveur standardisée par un protocole de messagerie léger :

• Protocole : Utilise JSON-RPC 2.0 pour l'échange de messages. L'IA (le client) envoie des requêtes structurées au serveur (ex: "Liste-moi les fichiers de ce dépôt GitHub") et reçoit des réponses formatées.
• Transports (Couche de communication) :
  • stdio : Le serveur est lancé comme un processus fils de l'IDE/Client. La communication se fait via l'entrée/sortie standard. C'est le mode le plus courant pour l'usage local.
  • SSE (Server-Sent Events) : Pour les serveurs distants ou web, permettant une communication asynchrone sur HTTP.
• SDK et Technos : Les serveurs MCP sont principalement développés en TypeScript (Node.js) ou Python, car ces écosystèmes possèdent les bibliothèques les plus matures pour l'interfaçage avec les API (GitHub, Slack, SQL, etc.).

Infrastructure et Déploiement

L'infrastructure requise dépend de l'usage :

1. Infrastructure Locale : Le serveur MCP tourne sur la même machine que l'IDE.
   • Pré-requis : Runtime Node.js ou Python installé.
   • Sécurité : Les clés API (ex: token GitHub) sont stockées localement dans les fichiers de config du client (ex: claude_desktop_config.json).
2. Infrastructure Distante (Cloud/Conteneur) : Pour partager des outils entre une équipe.
   • Déploiement : Docker est l'outil privilégié. Un serveur MCP peut être exposé via une URL sécurisée (HTTPS + Auth) pour être consommé par plusieurs développeurs.

Applications pour Codexia

• Accès Documentation : Un serveur MCP peut indexer tout le dossier inputs/legacy/ pour répondre aux questions sur l'historique sans saturer le contexte manuel.
• Exécution d'outils : Permettre à l'IA de lancer des tests unitaires ou de vérifier la syntaxe d'un fichier directement.

Mise en place

1. Client : Utiliser un IDE compatible ou un plugin (comme Continue ou l'extension MCP de Claude).
2. Serveurs : Installer des serveurs MCP pré-construits (via npm ou python).
   • Exemple : npx @modelcontextprotocol/server-github pour l'intégration GitHub.
3. Configuration : Déclarer les serveurs dans le fichier de configuration du client (ex: claude_desktop_config.json).

Ressources complémentaires

• Tutoriel d'installation MCP sur VPS

MCP & PHP (Symfony)

Bien que les SDK officiels (Anthropic) soient en Node.js et Python, le MCP est un protocole ouvert. Une intégration dans le projet Symfony du VPS est techniquement possible :

• Faisabilité : Il n'existe pas encore de SDK PHP stable, mais on peut implémenter les spécifications JSON-RPC 2.0 via un contrôleur Symfony.
• Avantages : Accès direct aux entités Doctrine, aux services métier et aux logs sans duplication de logique.
• Alternative recommandée : Utiliser un petit "pont" Node.js qui appelle les API internes de Symfony ou interroge directement la base de données MySQL du projet.
• Référence Technique : Voir Codexia MCP Bundle (Symfony).