Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Pipelines de code automatisées

Lektion 12 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Automatiser le développement avec Codestral et un modèle polyvalent
  2. Architecture d’un pipeline de code
  3. Étape 1 : Recherche de code avec Codestral Embed
  4. Étape 2 : Génération de code avec Codestral
  5. Étape 3 : Révision de code avec Mistral Small 4
  6. Pipeline complet : du ticket à la PR
  7. Intégration CI/CD
  8. Variantes courantes en production
  9. Viktiga punkter

Leçon mise à jour le 2 novembre 2026. L’étape de révision s’appuyait auparavant sur Devstral, qui a été retiré de l’API le 31 juillet 2026. Elle utilise désormais Mistral Small 4 (mistral-small-2603). Source : Modèles.

Automatiser le développement avec Codestral et un modèle polyvalent

Jusqu’à présent, nous avons présenté chaque outil Mistral AI individuellement, fonctionnant devant un utilisateur humain. Leur véritable valeur apparaît lorsque vous les enchaînez. Codestral Embed, Codestral et un modèle polyvalent comme Mistral Small 4 forment un pipeline de développement automatisé capable de rechercher, générer et réviser du code sans intervention manuelle à chaque étape.

Architecture d’un pipeline de code

Un pipeline complet se décompose en trois étapes, chacune confiée au modèle qui excelle dans cette tâche spécifique.

  1. Recherche de code — Trouver le code pertinent dans la base de code (Codestral Embed)
  2. Génération de code — Générer ou modifier du code (Codestral)
  3. Révision de code — Vérifier et valider les changements (Mistral Small 4)

Lisez le flux de données de haut en bas ; chaque bloc consomme la sortie du précédent.

User Request
    |
[Codestral Embed] -> Relevant Files
    |
[Codestral] -> Generated/Modified Code
    |
[Mistral Small 4] -> Automated Review
    |
Pull Request / Commit

Étape 1 : Recherche de code avec Codestral Embed

Générer du code sans connaissance de la base de code existante produit des résultats qui ne ressemblent en rien au reste du projet. La première étape consiste donc à localiser les fichiers pertinents en utilisant l’index d’embedding construit lors de la leçon précédente. La fonction ci-dessous convertit la description de la tâche en un vecteur, la compare à chaque fichier indexé et renvoie les cinq correspondances les plus proches.

from mistralai.client import Mistral
import numpy as np

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

def search_context(task_description: str, codebase_index: list) -> list:
    """Finds relevant files for a given task."""
    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=[task_description],
    )
    vector = np.array(response.data[0].embedding)

    scores = []
    for file in codebase_index:
        file_vec = np.array(file["embedding"])
        score = np.dot(vector, file_vec) / (
            np.linalg.norm(vector) * np.linalg.norm(file_vec)
        )
        scores.append((file, score))

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

Étape 2 : Génération de code avec Codestral

Une fois le contexte obtenu, Codestral peut générer du code. La qualité du résultat dépend de la manière dont vous présentez ce contexte : concaténez les fichiers récupérés dans le message système, accompagnés d’une instruction explicite de respecter les conventions existantes. Définir temperature=0.1 maintient la sortie proche du déterministe, ce qui est souhaitable lorsque le code généré doit s’intégrer parfaitement dans un projet plutôt que de surprendre son auteur.

def generate_code(task: str, context: list[dict]) -> str:
    """Generates code taking existing context into account."""
    context_files = "\n\n---\n\n".join([
        f"# {f['path']}\n{f['content']}"
        for f in context
    ])

    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "system",
                "content": f"""You are a senior developer. Here is the existing project code:

{context_files}

Respect existing code conventions (naming, style, patterns)."""
            },
            {
                "role": "user",
                "content": task
            }
        ],
        temperature=0.1,
        max_tokens=2000,
    )

    return response.choices[0].message.content

Étape 3 : Révision de code avec Mistral Small 4

Le contrôle vient en dernier. Mistral Small 4 reçoit l’état avant, l’état après et la description de la tâche, puis rend son verdict dans un format JSON strict. Ce choix est crucial : les révisions en prose libre ne sont pas exploitables par le code en aval, tandis qu’un champ booléen approved permet d’automatiser les étapes suivantes. Les catégories demandées séparent délibérément les problèmes bloquants, les suggestions d’amélioration et les préoccupations de sécurité, car elles nécessitent des traitements différents.

def review_code(original_code: str, modified_code: str, description: str) -> dict:
    """Automated code review."""
    response = client.chat.complete(
        model="mistral-small-2603",
        messages=[
            {
                "role": "system",
                "content": """You are a senior code reviewer. Analyze the diff and return JSON:
{
    "approved": true/false,
    "issues": ["list of found issues"],
    "suggestions": ["list of possible improvements"],
    "security": ["potential security issues"]
}"""
            },
            {
                "role": "user",
                "content": f"Task: {description}\n\nOriginal code:\n{original_code}\n\nModified code:\n{modified_code}"
            }
        ],
        temperature=0,
    )

    return response.choices[0].message.content

Pipeline complet : du ticket à la PR

Vous pouvez maintenant assembler ces trois fonctions en une seule chaîne qui commence par un ticket et produit du code révisé. Conservez les instructions print intercalées : dans un pipeline automatisé, journaliser ce qui a été trouvé, généré et révisé est votre seul moyen de comprendre plus tard pourquoi un résultat vous a déçu.

def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
    """Complete pipeline: ticket -> code -> review."""

    # 1. Contextual search
    relevant_files = search_context(ticket, codebase_index)
    print(f"Files found: {[f['path'] for f in relevant_files]}")

    # 2. Code generation
    generated_code = generate_code(ticket, relevant_files)
    print(f"Generated code: {len(generated_code)} characters")

    # 3. Automated review
    review = review_code(
        original_code=relevant_files[0]["content"],
        modified_code=generated_code,
        description=ticket,
    )
    print(f"Review: {review}")

    return {
        "ticket": ticket,
        "modified_files": relevant_files,
        "code": generated_code,
        "review": review,
    }

Intégration CI/CD

Ce mécanisme atteint son plein potentiel lorsqu’il est connecté à votre CI. Un workflow GitHub Actions déclenché à chaque ouverture et mise à jour de pull request suffit pour exécuter la révision sur chaque changement proposé, sans nécessiter de réflexion humaine.

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 }}

Le script appelé récupère le diff, passe chaque fichier modifié à review_code et commente la PR uniquement lorsque la révision n’approuve pas. Cette condition est essentielle : un bot qui commente tout devient du bruit que l’équipe apprend à ignorer en quelques jours.

# scripts/ai_review.py
def review_pull_request(pr_number: int):
    """Automated PR review with Mistral Small 4."""
    # 1. Retrieve PR diff
    diff = get_pr_diff(pr_number)

    # 2. Analyze each modified file
    for file in diff.files:
        review = review_code(
            original_code=file.before,
            modified_code=file.after,
            description=diff.title,
        )

        # 3. Post comment on PR
        if not review["approved"]:
            post_pr_comment(pr_number, file.path, review)

Variantes courantes en production

Les équipes qui adoptent ce schéma l’adaptent à plusieurs cas d’usage récurrents. D’abord, la génération automatique de tests : pour chaque nouveau fichier, le pipeline produit les tests correspondants, déplaçant la corvée sans éliminer la révision. Ensuite, la documentation continue, où les docstrings sont générées et mises à jour à chaque commit plutôt que lors d’un audit. Puis, la détection de régression, où le modèle de révision analyse les diffs pour d’éventuels effets de bord. Enfin, la migration de code, qui automatise la conversion entre frameworks ou versions — c’est là que le gain de temps est le plus significatif, car la transformation est répétitive et le résultat vérifiable par les tests existants.

Une mise en garde s’applique aux quatre cas : la révision automatisée ne remplace pas la révision humaine. Elle attrape les oublis mécaniques et laisse le jugement sur ce qui compte vraiment à vos développeurs.

Viktiga punkter

  • Un pipeline de code IA combine recherche (Embed), génération (Codestral) et révision (Mistral Small 4)
  • Codestral Embed trouve le contexte, Codestral génère, et un modèle polyvalent vérifie
  • L’intégration CI/CD permet des révisions automatisées et la génération de tests
  • Le schéma recherche -> génération -> révision s’applique à de nombreux workflows
  • La révision automatisée ne remplace pas la révision humaine ; elle la complète