Automatisées de pipelines de code
Šiame puslapyje
- Automatiser le développement avec Codestral et un modèle polyvalent
- Architecture d’un pipeline de code
- Étape 1 : Recherche de code avec Codestral Embed
- Étape 2 : Génération de code avec Codestral
- Étape 3 : Révision de code avec Mistral Small 4
- Pipeline complet : du ticket à la PR
- Intégration CI/CD
- Variantes courantes en production
- Svarbiausi punktai
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 tu les enchaînes. 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.
- Recherche de code — Trouver le code pertinent dans la base de code (Codestral Embed)
- Génération de code — Générer ou modifier du code (Codestral)
- Révision de code — Vérifier et valider les changements (Mistral Small 4)
Lis 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, le 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 façon dont tu présentes ce contexte : concatène 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 te 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
Tu peux maintenant assembler ces trois fonctions en une seule chaîne qui commence par un ticket et produit du code révisé. Conserve les instructions print intercalées : dans un pipeline automatisé, journaliser ce qui a été trouvé, généré et révisé est ton seul moyen de comprendre plus tard pourquoi un résultat t’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é à ton 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 modèle 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 à tes développeurs.
Svarbiausi punktai
- Un pipeline de code IA combine la recherche (Embed), la génération (Codestral) et la 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 modèle recherche -> génération -> révision s’applique à de nombreux flux de travail
- La révision automatisée ne remplace pas la révision humaine ; elle la complète