Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Pipeline di codice automatizzate

Lezione 12 di 14 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Automatizzare lo sviluppo con Codestral e un modello generico
  2. Architettura di una pipeline di codice
  3. Fase 1: Ricerca del codice con Codestral Embed
  4. Fase 2: Generazione del codice con Codestral
  5. Fase 3: Revisione del codice con Mistral Small 4
  6. Pipeline completa: dal ticket alla PR
  7. Integrazione CI/CD
  8. Variazioni comuni in produzione
  9. 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.

  1. Ricerca del codice — Trovare codice rilevante nel codebase (Codestral Embed)
  2. Generazione del codice — Generare o modificare codice (Codestral)
  3. 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