Automatiserede kode-pipelines
På denne side
- Automatisering af udvikling med Codestral og en generisk model
- Arkitekturen for en kode-pipeline
- Trin 1: Kodesøgning med Codestral Embed
- Trin 2: Kodegenerering med Codestral
- Trin 3: Kodegennemgang med Mistral Small 4
- Komplet pipeline: Fra ticket til PR
- CI/CD-integration
- Almindelige produktionsvarianter
- Vigtige pointer
Lektion opdateret 2. november 2026. Gennemgangstrinnet stolede tidligere på Devstral, som blev fjernet fra API’en den 31. juli 2026. Det bruger nu Mistral Small 4 (
mistral-small-2603). Kilde: Models.
Automatisering af udvikling med Codestral og en generisk model
Indtil videre har vi introduceret hvert Mistral AI-værktøj individuelt, hvor de opererer foran en menneskelig bruger. Deres sande værdi kommer frem, når du kæder dem sammen. Codestral Embed, Codestral og en generisk model som Mistral Small 4 danner en automatiseret udviklingspipeline, der kan søge, generere og gennemgå kode uden manuel indgriben ved hvert trin.
Arkitekturen for en kode-pipeline
En komplet pipeline opdeles i tre faser, hvor hver fase er tildelt den model, der er bedst til netop den opgave.
- Kodesøgning — Find relevant kode i kodebasen (Codestral Embed)
- Kodegenerering — Generer eller modificer kode (Codestral)
- Kodegennemgang — Verificer og valider ændringer (Mistral Small 4)
Læs datastrømmen fra toppen og ned; hver blok forbruger outputtet fra den foregående.
User Request
|
[Codestral Embed] -> Relevant Files
|
[Codestral] -> Generated/Modified Code
|
[Mistral Small 4] -> Automated Review
|
Pull Request / Commit
Trin 1: Kodesøgning med Codestral Embed
Hvis du genererer kode uden kendskab til den eksisterende kodebase, får du resultater, der slet ikke ligner resten af projektet. Det første trin er derfor at lokalisere de relevante filer ved hjælp af det indlejrede indeks, du opbyggede i den foregående lektion. Funktionen nedenfor konverterer opgavebeskrivelsen til en vektor, sammenligner den med hver indekseret fil og returnerer de fem tætteste matches.
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]]
Trin 2: Kodegenerering med Codestral
Når du har konteksten, kan Codestral generere kode. Kvaliteten af outputtet afhænger af, hvordan du præsenterer denne kontekst: sammenkæd de hentede filer i systembeskeden ledsaget af en eksplicit instruktion om at overholde eksisterende konventioner. Ved at sætte temperature=0.1 holder du outputtet tæt på deterministisk, hvilket er ønskeligt, når den genererede kode skal integreres problemfrit i et projekt i stedet for at overraske forfatteren.
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
Trin 3: Kodegennemgang med Mistral Small 4
Kontrollen kommer sidst. Mistral Small 4 modtager tilstanden før, tilstanden efter og opgavebeskrivelsen for derefter at afsige sin dom i et strengt JSON-format. Dette valg er afgørende: Gennemganger i frit formuleret prosa kan ikke bruges af efterfølgende kode, hvorimod et boolesk approved-felt giver dig mulighed for at automatisere de næste trin. De anmodede kategorier adskiller bevidst blokerende problemer, forslag til forbedringer og sikkerhedsbekymringer, da disse kræver forskellig håndtering.
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
Komplet pipeline: Fra ticket til PR
Du kan nu samle disse tre funktioner i en enkelt kæde, der starter med et ticket og producerer gennemgået kode. Behold de indflettede print-sætninger: I en automatiseret pipeline er logning af, hvad der blev fundet, genereret og gennemgået, din eneste måde at forstå senere, hvorfor et resultat skuffede dig.
def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
"""Complete pipeline: ticket -> code -> review."""
# 1. Contextual search
relevant_files = search_context(ticket, codebase_index)
print(f"Files found: {[f['path'] for f in relevant_files]}")
# 2. Code generation
generated_code = generate_code(ticket, relevant_files)
print(f"Generated code: {len(generated_code)} characters")
# 3. Automated 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-integration
Denne mekanisme når sit fulde potentiale, når den kobles til dit CI. En GitHub Actions-workflow, der udløses ved hver åbning og opdatering af en pull request, er nok til at køre gennemgangen på hver foreslået ændring uden menneskelig indblanding.
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 }}
Det kaldte script henter diffen, sender hver modificeret fil til review_code og kommenterer kun på PR’en, når gennemgangen ikke godkender ændringen. Denne betingelse er afgørende: En bot, der kommenterer på alt, bliver til støj, som teamet lærer at ignorere inden for få dage.
# 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)
Almindelige produktionsvarianter
Teams, der adopterer dette mønster, tilpasser det til flere tilbagevendende brugssager. Først automatisk testgenerering: For hver ny fil producerer pipeline’en tilhørende tests, hvilket flytter arbejdet uden at fjerne gennemgangen. Dernæst løbende dokumentation, hvor docstrings genereres og opdateres ved hvert commit i stedet for under en revision. Så regresionsdetektering, hvor gennemgangsmodellen analyserer diffs for sandsynlige sideeffekter. Endelig kodemigration, som automatiserer konvertering mellem frameworks eller versioner – her er tidsbesparelsen mest markant, fordi transformationen er repetitiv, og resultatet kan verificeres af eksisterende tests.
Én advarsel gælder for alle fire: Automatiseret gennemgang erstatter ikke menneskelig gennemgang. Den fanger mekaniske oversettelser og overlader dømmekraften omkring det, der virkelig betyder noget, til dine udviklere.
Vigtige pointer
- En AI-kodepipeline kombinerer søgning (Embed), generering (Codestral) og gennemgang (Mistral Small 4)
- Codestral Embed finder kontekst, Codestral genererer, og en generisk model verificerer
- CI/CD-integration muliggør automatiserede gennemganger og testgenerering
- Mønsteret søg -> generer -> gennemgå gælder for mange workflows
- Automatiseret gennemgang erstatter ikke menneskelig gennemgang; den supplerer den