Aller au contenu principal

Pipelines de Code Automatisés

Automatiser le développement avec Codestral et Devstral

Les outils de Mistral AI ne servent pas uniquement à l’assistance interactive. Combinés intelligemment, Codestral, Devstral et Codestral Embed forment une pipeline de développement automatisée capable de rechercher, générer, et revoir du code de manière programmatique.

Architecture d’une pipeline de code

Une pipeline de code IA complète se compose de trois étapes :

  1. Code Search — trouver le code pertinent dans le codebase (Codestral Embed)
  2. Code Generation — générer ou modifier du code (Codestral ou Devstral)
  3. Code Review — vérifier et valider les changements (Devstral)

Flux de données

Requête utilisateur
    |
[Codestral Embed] -> Fichiers pertinents
    |
[Codestral / Devstral] -> Code généré/modifié
    |
[Devstral] -> Review automatique
    |
Pull Request / Commit

Étape 1 : Code Search avec Codestral Embed

Avant de générer du code, il faut comprendre le contexte existant. Codestral Embed permet de trouver les fichiers et fonctions pertinents :

from mistralai import Mistral
import numpy as np

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def rechercher_contexte(description_tache: str, index_codebase: list) -> list:
    """Trouve les fichiers pertinents pour une tâche donnée."""
    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=[description_tache],
    )
    vecteur = np.array(response.data[0].embedding)

    scores = []
    for fichier in index_codebase:
        vec_fichier = np.array(fichier["embedding"])
        score = np.dot(vecteur, vec_fichier) / (
            np.linalg.norm(vecteur) * np.linalg.norm(vec_fichier)
        )
        scores.append((fichier, score))

    scores.sort(key=lambda x: x[1], reverse=True)
    return [f for f, s in scores[:5]]

Étape 2 : Code Generation avec Codestral

Une fois le contexte trouvé, Codestral génère le code demandé :

def generer_code(tache: str, contexte: list[dict]) -> str:
    """Génère du code en tenant compte du contexte existant."""
    fichiers_contexte = "\n\n---\n\n".join([
        f"# {f['chemin']}\n{f['contenu']}"
        for f in contexte
    ])

    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "system",
                "content": f"""Vous êtes un développeur senior. Voici le code existant du projet :

{fichiers_contexte}

Respectez les conventions de code existantes (nommage, style, patterns)."""
            },
            {
                "role": "user",
                "content": tache
            }
        ],
        temperature=0.1,
        max_tokens=2000,
    )

    return response.choices[0].message.content

Étape 3 : Code Review avec Devstral

Devstral vérifie le code généré avant de le soumettre :

def reviewer_code(code_original: str, code_modifie: str, description: str) -> dict:
    """Review automatique du code généré."""
    response = client.chat.complete(
        model="devstral-small-latest",
        messages=[
            {
                "role": "system",
                "content": """Vous êtes un reviewer de code senior. Analysez le diff et retournez un JSON :
{
    "approuve": true/false,
    "problemes": ["liste des problèmes trouvés"],
    "suggestions": ["liste des améliorations possibles"],
    "securite": ["problèmes de sécurité éventuels"]
}"""
            },
            {
                "role": "user",
                "content": f"Tâche : {description}\n\nCode original :\n{code_original}\n\nCode modifié :\n{code_modifie}"
            }
        ],
        temperature=0,
    )

    return response.choices[0].message.content

Pipeline complète : du ticket à la PR

Voici un exemple de pipeline end-to-end qui prend un ticket et produit une modification validée :

def pipeline_ticket_to_code(ticket: str, codebase_index: list) -> dict:
    """Pipeline complète : ticket -> code -> review."""

    # 1. Recherche contextuelle
    fichiers_pertinents = rechercher_contexte(ticket, codebase_index)
    print(f"Fichiers trouvés : {[f['chemin'] for f in fichiers_pertinents]}")

    # 2. Génération de code
    code_genere = generer_code(ticket, fichiers_pertinents)
    print(f"Code généré : {len(code_genere)} caractères")

    # 3. Review automatique
    review = reviewer_code(
        code_original=fichiers_pertinents[0]["contenu"],
        code_modifie=code_genere,
        description=ticket,
    )
    print(f"Review : {review}")

    return {
        "ticket": ticket,
        "fichiers_modifies": fichiers_pertinents,
        "code": code_genere,
        "review": review,
    }

Intégration CI/CD

Cette pipeline peut s’intégrer dans votre workflow CI/CD :

GitHub Actions

name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run AI Review
        env:
          MISTRAL_API_KEY: $\{{ secrets.MISTRAL_API_KEY }}
        run: |
          python scripts/ai_review.py --pr $\{{ github.event.pull_request.number }}

Workflow automatisé

# scripts/ai_review.py
def review_pull_request(pr_number: int):
    """Review automatique d'une PR avec Devstral."""
    # 1. Récupérer le diff de la PR
    diff = obtenir_diff_pr(pr_number)

    # 2. Analyser chaque fichier modifié
    for fichier in diff.fichiers:
        review = reviewer_code(
            code_original=fichier.avant,
            code_modifie=fichier.apres,
            description=diff.titre,
        )

        # 3. Poster un commentaire sur la PR
        if not review["approuve"]:
            poster_commentaire_pr(pr_number, fichier.chemin, review)

Cas d’usage en production

  • Génération automatique de tests — à chaque nouveau fichier, la pipeline génère les tests correspondants
  • Documentation continue — les docstrings sont générées et mises à jour automatiquement
  • Détection de régressions — Devstral analyse les diffs pour détecter les régressions potentielles
  • Migration de code — automatiser la conversion entre frameworks ou versions

Points clés à retenir

  • Une pipeline de code IA combine recherche (Embed), génération (Codestral), et review (Devstral)
  • Codestral Embed trouve le contexte, Codestral génère, Devstral vérifie
  • L’intégration CI/CD permet d’automatiser les reviews et la génération de tests
  • Le pattern recherche -> génération -> review est applicable à de nombreux workflows
  • La review automatique ne remplace pas la review humaine, mais la complète
← Lecon precedenteCodestral Embed : Embeddings de CodeLecon suivante →Héberger Devstral en Local