Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Geautomatiseerde Code-pipelines

Les 12 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Ontwikkeling automatiseren met Codestral en een algemeen model
  2. Architectuur van een code-pipeline
  3. Stap 1: Code zoeken met Codestral Embed
  4. Stap 2: Code genereren met Codestral
  5. Stap 3: Code review met Mistral Small 4
  6. Volledige pipeline: van ticket naar PR
  7. CI/CD-integratie
  8. Veelvoorkomende productievariaties
  9. Belangrijkste punten

Les bijgewerkt op 2 november 2026. De reviewstap vertrouwde eerder op Devstral, dat op 31 juli 2026 uit de API is verwijderd. Deze maakt nu gebruik van Mistral Small 4 (mistral-small-2603). Bron: Modellen.

Ontwikkeling automatiseren met Codestral en een algemeen model

Tot nu toe hebben we elk Mistral AI-hulpmiddel afzonderlijk geïntroduceerd, waarbij een menselijke gebruiker centraal stond. De ware waarde komt naar voren wanneer u ze aan elkaar koppelt. Codestral Embed, Codestral en een algemeen model zoals Mistral Small 4 vormen een geautomatiseerde ontwikkelingspipeline die code kan zoeken, genereren en reviewen zonder bij elke stap handmatige tussenkomst.

Architectuur van een code-pipeline

Een volledige pipeline bestaat uit drie fasen, waarbij elke fase is toegewezen aan het model dat daar het beste in uitblinkt.

  1. Code zoeken — Vind relevante code in de codebase (Codestral Embed)
  2. Code genereren — Genereer of wijzig code (Codestral)
  3. Code review — Verifieer en valideer wijzigingen (Mistral Small 4)

Lees de datastroom van boven naar beneden; elk blok consumeert de uitvoer van het vorige.

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

Stap 1: Code zoeken met Codestral Embed

Code genereren zonder kennis van de bestaande codebase levert resultaten op die in niets lijken op de rest van het project. De eerste stap is daarom het lokaliseren van de relevante bestanden met behulp van de embedding-index die in de vorige les is opgebouwd. De onderstaande functie zet de taakbeschrijving om in een vector, vergelijkt deze met elk geïndexeerd bestand en retourneert de vijf beste overeenkomsten.

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

Stap 2: Code genereren met Codestral

Zodra u de context heeft, kan Codestral code genereren. De kwaliteit van de uitvoer hangt af van hoe u die context presenteert: voeg de opgehaalde bestanden samen in het systeembericht, vergezeld van een expliciete instructie om bestaande conventies te respecteren. Het instellen van temperature=0.1 houdt de uitvoer dicht bij deterministisch, wat wenselijk is wanneer de gegenereerde code naadloos in een project moet integreren in plaats van de auteur te verrassen.

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

Stap 3: Code review met Mistral Small 4

Controle komt als laatste. Mistral Small 4 ontvangt de staat vooraf, de staat afterward en de taakbeschrijving, en velt vervolgens zijn oordeel in een strikt JSON-formaat. Deze keuze is cruciaal: reviews in vrije tekst zijn niet bruikbaar voor downstream-code, terwijl een booleaanse approved-veld u in staat stelt de volgende stappen te automatiseren. De gevraagde categorieën scheiden bewust blokkerende problemen, suggesties voor verbetering en beveiligingskwesties, aangezien deze een verschillende aanpak vereisen.

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

Volledige pipeline: van ticket naar PR

U kunt deze drie functies nu samenvoegen tot één keten die begint met een ticket en eindigt met gereviewde code. Houd de verweven print-statements aan: in een geautomatiseerde pipeline is het loggen van wat er is gevonden, gegenereerd en gereviewd uw enige manier om later te begrijpen waarom een resultaat teleurstelde.

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

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

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

    # 3. Geautomatiseerde 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,
    }

CI/CD-integratie

Dit mechanisme bereikt zijn volle potentieel wanneer het is verbonden met uw CI. Een GitHub Actions-workflow die wordt geactiveerd bij elk geopend en bijgewerkt pull request is voldoende om de review op elke voorgestelde wijziging uit te voeren, zonder dat menselijk nadenken vereist is.

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

Het aangeroepen script haalt de diff op, geeft elk gewijzigd bestand door aan review_code en plaatst alleen een commentaar op de PR wanneer de review niet wordt goedgekeurd. Deze voorwaarde is essentieel: een bot die overal commentaar op geeft, wordt ruis die het team binnen enkele dagen leert negeren.

# 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)

Veelvoorkomende productievariaties

Teams die dit patroon overnemen, passen het aan voor verschillende terugkerende use-cases. Ten eerste automatische testgeneratie: voor elk nieuw bestand produceert de pipeline bijbehorende tests, waardoor de last verschuift zonder de review te elimineren. Vervolgens continue documentatie, waarbij docstrings worden gegenereerd en bijgewerkt bij elke commit in plaats van tijdens een audit. Daarna regressiedetectie, waarbij het reviewmodel diffs analyseert op waarschijnlijke neveneffecten. Tot slot codemigratie, die conversie tussen frameworks of versies automatiseert; hier zijn de tijdwinsten het grootst, omdat de transformatie repetitief is en het resultaat verifieerbaar is door bestaande tests.

Eén waarschuwing geldt voor alle vier: geautomatiseerde review vervangt geen menselijke review. Het vangt mechanische vergissingen op en laat het oordeel over wat er echt toe doet over aan uw ontwikkelaars.

Belangrijkste punten

  • Een AI-code-pipeline combineert zoeken (Embed), genereren (Codestral) en reviewen (Mistral Small 4)
  • Codestral Embed vindt context, Codestral genereert en een algemeen model verifieert
  • CI/CD-integratie maakt geautomatiseerde reviews en testgeneratie mogelijk
  • Het patroon zoeken -> genereren -> reviewen is van toepassing op veel workflows
  • Geautomatiseerde review vervangt geen menselijke review; het vult deze aan