Automatisierte Code-Pipelines
Auf dieser Seite
- Automatisierung der Entwicklung mit Codestral und einem allgemeinen Modell
- Architektur einer Code-Pipeline
- Schritt 1: Code-Suche mit Codestral Embed
- Schritt 2: Code-Generierung mit Codestral
- Schritt 3: Code-Überprüfung mit Mistral Small 4
- Komplett-Pipeline: Von Ticket bis PR
- Integration in CI/CD
- Häufige Produktionsvariationen
- 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.
- Code-Suche — Relevanten Code im Codebase finden (Codestral Embed)
- Code-Generierung — Code generieren oder ändern (Codestral)
- 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