Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Automatisierte Code-Pipelines

Lektion 12 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Automatisierung der Entwicklung mit Codestral und einem allgemeinen Modell
  2. Architektur einer Code-Pipeline
  3. Schritt 1: Code-Suche mit Codestral Embed
  4. Schritt 2: Code-Generierung mit Codestral
  5. Schritt 3: Code-Überprüfung mit Mistral Small 4
  6. Komplett-Pipeline: Von Ticket bis PR
  7. Integration in CI/CD
  8. Häufige Produktionsvariationen
  9. Kernaussagen

Lektion aktualisiert am 2. November 2026. Der Überprüfungsschritt stützte sich zuvor auf Devstral, das am 31. Juli 2026 aus der API entfernt wurde. Er nutzt nun Mistral Small 4 (mistral-small-2603). Quelle: Modelle.

Automatisierung der Entwicklung mit Codestral und einem allgemeinen Modell

Bisher haben wir jedes Werkzeug von Mistral AI einzeln vorgestellt, wobei es vor einem menschlichen Nutzer operiert. Sein wahrender Wert entsteht, wenn Sie sie miteinander verknüpfen. Codestral Embed, Codestral und ein allgemeines Modell wie Mistral Small 4 bilden eine automatisierte Entwicklungspipeline, die Code suchen, generieren und überprüfen kann, ohne dass bei jedem Schritt manuelle Intervention erforderlich ist.

Architektur einer Code-Pipeline

Eine vollständige Pipeline gliedert sich in drei Stufen, die jeweils dem Modell zugewiesen werden, das bei dieser spezifischen Aufgabe am besten abschneidet.

  1. Code-Suche — Relevanten Code im Codebase finden (Codestral Embed)
  2. Code-Generierung — Code generieren oder ändern (Codestral)
  3. Code-Überprüfung — Änderungen verifizieren und validieren (Mistral Small 4)

Lesen Sie den Datenfluss von oben nach unten; jeder Block verbraucht die Ausgabe des vorherigen.

Benutzeranfrage
    |
[Codestral Embed] -> Relevante Dateien
    |
[Codestral] -> Generierter/Geänderter Code
    |
[Mistral Small 4] -> Automatisierte Überprüfung
    |
Pull Request / Commit

Schritt 1: Code-Suche mit Codestral Embed

Code zu generieren, ohne Kenntnis des bestehenden Codebases, führt zu Ergebnissen, die dem Rest des Projekts nichts Ähnliches haben. Der erste Schritt besteht daher darin, die relevanten Dateien zu finden, indem Sie den Embedding-Index verwenden, der in der vorherigen Lektion erstellt wurde. Die folgende Funktion wandelt die Aufgabenbeschreibung in einen Vektor um, vergleicht ihn mit jeder indizierten Datei und gibt die fünf nächsten Übereinstimmungen zurück.

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:
    """Findet relevante Dateien für eine gegebene Aufgabe."""
    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]]

Schritt 2: Code-Generierung mit Codestral

Sobald Sie den Kontext haben, kann Codestral Code generieren. Die Qualität der Ausgabe hängt davon ab, wie Sie diesen Kontext präsentieren: Fügen Sie die abgerufenen Dateien dem Systemnachrichtinhalt an und geben Sie eine explizite Anweisung, die bestehenden Konventionen zu respektieren. Das Setzen von temperature=0.1 hält die Ausgabe nah an der Deterministik, was wünschenswert ist, wenn der generierte Code nahtlos in ein Projekt integriert werden muss, anstatt den Autor zu überraschen.

def generate_code(task: str, context: list[dict]) -> str:
    """Generiert Code unter Berücksichtigung des bestehenden Kontexts."""
    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"""Sie sind ein Senior-Entwickler. Hier ist der bestehende Projektkode:

{context_files}

Respektieren Sie bestehende Code-Konventionen (Namensgebung, Stil, Muster)."""
            },
            {
                "role": "user",
                "content": task
            }
        ],
        temperature=0.1,
        max_tokens=2000,
    )

    return response.choices[0].message.content

Schritt 3: Code-Überprüfung mit Mistral Small 4

Die Kontrolle kommt zuletzt. Mistral Small 4 erhält den Zustand vor der Änderung, den Zustand nach der Änderung und die Aufgabenbeschreibung, rendert dann sein Urteil in einem strengen JSON-Format. Diese Wahl ist entscheidend: Freitext-Überprüfungen sind für nachgelagerten Code nicht nutzbar, wohingegen ein boolesches Feld approved Ihnen ermöglicht, die nächsten Schritte zu automatisieren. Die angeforderten Kategorien trennen absichtlich blockierende Probleme, Verbesserungsvorschläge und Sicherheitsbedenken, da diese unterschiedliche Handhabung erfordern.

def review_code(original_code: str, modified_code: str, description: str) -> dict:
    """Automatisierte Code-Überprüfung."""
    response = client.chat.complete(
        model="mistral-small-2603",
        messages=[
            {
                "role": "system",
                "content": """Sie sind ein Senior-Code-Reviewer. Analysieren Sie den Diff und geben Sie JSON zurück:
{
    "approved": true/false,
    "issues": ["Liste der gefundenen Probleme"],
    "suggestions": ["Liste möglicher Verbesserungen"],
    "security": ["Potenzielle Sicherheitsprobleme"]
}"""
            },
            {
                "role": "user",
                "content": f"Aufgabe: {description}\n\nUrsprünglicher Code:\n{original_code}\n\nGeänderter Code:\n{modified_code}"
            }
        ],
        temperature=0,
    )

    return response.choices[0].message.content

Komplett-Pipeline: Von Ticket bis PR

Sie können nun diese drei Funktionen in einer einzigen Kette zusammenfügen, die mit einem Ticket beginnt und geprüften Code ausgibt. Behalten Sie die ineinander verschachtelten print-Anweisungen bei: In einer automatisierten Pipeline ist das Protokollieren dessen, was gefunden, generiert und überprüft wurde, der einzige Weg, später zu verstehen, warum ein Ergebnis Sie enttäuscht hat.

def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
    """Komplette Pipeline: Ticket -> Code -> Überprüfung."""

    # 1. Kontextsuche
    relevante_dateien = search_context(ticket, codebase_index)
    print(f"Gefundene Dateien: {[f['path'] for f in relevante_dateien]}")

    # 2. Code-Generierung
    generierter_code = generate_code(ticket, relevante_dateien)
    print(f"Generierter Code: {len(generierter_code)} Zeichen")

    # 3. Automatisierte Überprüfung
    review = review_code(
        original_code=relevante_dateien[0]["content"],
        modified_code=generierter_code,
        description=ticket,
    )
    print(f"Überprüfung: {review}")

    return {
        "ticket": ticket,
        "modifizierte_dateien": relevante_dateien,
        "code": generierter_code,
        "review": review,
    }

Integration in CI/CD

Dieser Mechanismus erreicht sein volles Potenzial, wenn er mit Ihrer CI verbunden wird. Ein GitHub Actions-Workflow, der bei jedem geöffneten und aktualisierten Pull Request ausgelöst wird, reicht aus, um die Überprüfung für jede vorgeschlagene Änderung durchzuführen, ohne dass menschliches Nachdenken erforderlich ist.

name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: AI-Überprüfung ausführen
        env:
          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
        run: |
          python scripts/ai_review.py --pr ${{ github.event.pull_request.number }}

Der aufgerufene Skript holt den Diff ab, übergibt jede geänderte Datei an review_code und kommentiert den PR nur, wenn die Überprüfung nicht genehmigt. Diese Bedingung ist essenziell: Ein Bot, der bei allem kommentiert, wird zu Lärm, den das Team innerhalb weniger Tage zu ignorieren lernt.

# scripts/ai_review.py
def review_pull_request(pr_number: int):
    """Automatisierte PR-Überprüfung mit Mistral Small 4."""
    # 1. PR-Diff abrufen
    diff = get_pr_diff(pr_number)

    # 2. Jede geänderte Datei analysieren
    for file in diff.files:
        review = review_code(
            original_code=file.before,
            modified_code=file.after,
            description=diff.title,
        )

        # 3. Kommentar im PR posten
        if not review["approved"]:
            post_pr_comment(pr_number, file.path, review)

Häufige Produktionsvariationen

Teams, die dieses Muster übernehmen, passen es an mehrere wiederkehrende Anwendungsfälle an. Erstens, automatische Testgenerierung: Für jede neue Datei erzeugt die Pipeline entsprechende Tests und verschiebt die Arbeit, ohne die Überprüfung zu eliminieren. Zweitens, kontinuierliche Dokumentation, bei der Docstrings mit jedem Commit generiert und aktualisiert werden, nicht während einer Prüfung. Drittens, Regressionserkennung, bei der das Review-Modell Diffs auf wahrscheinliche Nebenwirkungen analysiert. Viertens, Code-Migration, die die Konvertierung zwischen Frameworks oder Versionen automatisiert – hier sind die Zeiteinsparungen am größten, da die Transformation repetitiv ist und das Ergebnis durch bestehende Tests überprüfbar ist.

Ein Vorbehalt gilt für alle vier: Automatisierte Überprüfung ersetzt die menschliche Überprüfung nicht. Sie erfasst mechanische Übersehen und hinterlässt das Urteil darüber, was für Ihre Entwickler wirklich wichtig ist.

Kernaussagen

  • Eine AI-Code-Pipeline kombiniert Suche (Embed), Generierung (Codestral) und Überprüfung (Mistral Small 4)
  • Codestral Embed findet Kontext, Codestral generiert und ein allgemeines Modell verifiziert
  • Integration in CI/CD ermöglicht automatisierte Überprüfungen und Testgenerierung
  • Das Muster Suche -> Generierung -> Überprüfung gilt für viele Workflows
  • Automatisierte Überprüfung ersetzt die menschliche Überprüfung nicht; sie ergänzt sie