Pipeline di codice automatizzate
In questa pagina
- Automatizzare lo sviluppo con Codestral e un modello generico
- Architettura di una pipeline di codice
- Fase 1: Ricerca del codice con Codestral Embed
- Fase 2: Generazione del codice con Codestral
- Fase 3: Revisione del codice con Mistral Small 4
- Pipeline completa: dal ticket alla PR
- Integrazione CI/CD
- Variazioni comuni in produzione
- Punti chiave
Lezione aggiornata il 2 novembre 2026. Il passaggio di revisione si basava in precedenza su Devstral, rimosso dalle API il 31 luglio 2026. Ora utilizza Mistral Small 4 (
mistral-small-2603). Fonte: Modelli.
Automatizzare lo sviluppo con Codestral e un modello generico
Finora abbiamo presentato ogni strumento di Mistral AI singolarmente, operando davanti a un utente umano. Il loro vero valore emerge quando li colleghi in catena. Codestral Embed, Codestral e un modello generico come Mistral Small 4 formano una pipeline di sviluppo automatizzata capace di cercare, generare e revisionare codice senza intervento manuale a ogni passo.
Architettura di una pipeline di codice
Una pipeline completa si suddivide in tre fasi, ciascuna affidata al modello che eccelle in quel compito specifico.
- Ricerca del codice — Trovare codice rilevante nel codebase (Codestral Embed)
- Generazione del codice — Generare o modificare codice (Codestral)
- Revisione del codice — Verificare e convalidare le modifiche (Mistral Small 4)
Leggi il flusso dei dati dall’alto verso il basso; ogni blocco consuma l’output del precedente.
User Request
|
[Codestral Embed] -> Relevant Files
|
[Codestral] -> Generated/Modified Code
|
[Mistral Small 4] -> Automated Review
|
Pull Request / Commit
Fase 1: Ricerca del codice con Codestral Embed
Generare codice senza conoscere il codebase esistente produce risultati che non assomigliano per nulla al resto del progetto. Il primo passo, quindi, è individuare i file pertinenti utilizzando l’indice di embedding costruito nella lezione precedente. La funzione seguente converte la descrizione del task in un vettore, lo confronta con ogni file indicizzato e restituisce i cinque risultati più vicini.
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]]
Fase 2: Generazione del codice con Codestral
Una volta ottenuto il contesto, Codestral può generare codice. La qualità dell’output dipende da come presenti quel contesto: concatena i file recuperati nel messaggio di sistema, accompagnandoli da un’istruzione esplicita a rispettare le convenzioni esistenti. Impostare temperature=0.1 mantiene l’output vicino al deterministico, cosa desiderabile quando il codice generato deve integrarsi perfettamente in un progetto invece di sorprendere il suo autore.
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
Fase 3: Revisione del codice con Mistral Small 4
Il controllo arriva per ultimo. Mistral Small 4 riceve lo stato precedente, quello successivo e la descrizione del task, quindi emette il suo verdetto in un formato JSON rigoroso. Questa scelta è critica: le revisioni in prosa libera non sono utilizzabili dal codice a valle, mentre un campo booleano approved ti permette di automatizzare i passi successivi. Le categorie richieste separano deliberatamente problemi bloccanti, suggerimenti di miglioramento e preoccupazioni di sicurezza, poiché richiedono gestioni diverse.
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 completa: dal ticket alla PR
Ora puoi assemblare queste tre funzioni in un’unica catena che parte da un ticket e produce codice revisionato. Mantieni le istruzioni print intercalate: in una pipeline automatizzata, registrare ciò che è stato trovato, generato e revisionato è l’unico modo per capire in seguito perché un risultato ti ha deluso.
def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
"""Complete pipeline: ticket -> code -> review."""
# 1. Ricerca contestuale
relevant_files = search_context(ticket, codebase_index)
print(f"Files found: {[f['path'] for f in relevant_files]}")
# 2. Generazione del codice
generated_code = generate_code(ticket, relevant_files)
print(f"Generated code: {len(generated_code)} characters")
# 3. Revisione automatizzata
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,
}
Integrazione CI/CD
Questo meccanismo raggiunge il suo pieno potenziale quando connesso alla tua CI. Un workflow di GitHub Actions attivato ad ogni apertura e aggiornamento di una pull request è sufficiente per eseguire la revisione su ogni modifica proposta, senza richiedere alcun intervento umano.
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 }}
Lo script chiamato recupera il diff, passa ogni file modificato a review_code e commenta la PR solo quando la revisione non approva. Questa condizione è essenziale: un bot che commenta tutto diventa rumore che il team impara a ignorare nel giro di pochi giorni.
# scripts/ai_review.py
def review_pull_request(pr_number: int):
"""Automated PR review with Mistral Small 4."""
# 1. Recupera il diff della PR
diff = get_pr_diff(pr_number)
# 2. Analizza ogni file modificato
for file in diff.files:
review = review_code(
original_code=file.before,
modified_code=file.after,
description=diff.title,
)
# 3. Pubblica un commento sulla PR
if not review["approved"]:
post_pr_comment(pr_number, file.path, review)
Variazioni comuni in produzione
I team che adottano questo pattern lo adattano a diversi casi d’uso ricorrenti. Innanzitutto, la generazione automatica di test: per ogni nuovo file, la pipeline produce i test corrispondenti, spostando l’onere senza eliminare la revisione. Poi, la documentazione continua, dove i docstring vengono generati e aggiornati a ogni commit invece che durante un audit. Quindi, il rilevamento delle regressioni, dove il modello di revisione analizza i diff per possibili effetti collaterali. Infine, la migrazione del codice, che automatizza la conversione tra framework o versioni: è qui che il risparmio di tempo è più significativo, perché la trasformazione è ripetitiva e il risultato è verificabile dai test esistenti.
Un avvertimento vale per tutti e quattro i casi: la revisione automatizzata non sostituisce la revisione umana. Cattura sviste meccaniche e lascia il giudizio su ciò che conta davvero ai tuoi sviluppatori.
Punti chiave
- Una pipeline di codice AI combina ricerca (Embed), generazione (Codestral) e revisione (Mistral Small 4)
- Codestral Embed trova il contesto, Codestral genera e un modello generico verifica
- L’integrazione CI/CD abilita revisioni automatizzate e generazione di test
- Il pattern ricerca -> generazione -> revisione si applica a molti flussi di lavoro
- La revisione automatizzata non sostituisce quella umana; la complementa