Automatizált kódcsővezetékek
Ezen az oldalon
- Fejlesztés automatizálása Codestrallal és egy általános célú modellel
- Egy kódcsővezeték architektúrája
- 1. lépés: Kódkeresés Codestral Embeddel
- 2. lépés: Kódgenerálás Codestrallal
- 3. lépés: Kódellenőrzés Mistral Small 4-gyel
- Teljes csővezeték: Jegytől a PR-ig
- CI/CD integráció
- Gyakori éles környezeti variációk
- Főbb megállapítások
Lecke frissítve: 2026. november 2. Az ellenőrzési lépés korábban a Devstralra támaszkodott, amelyet 2026. július 31-én eltávolítottak az API-ból. Most a Mistral Small 4 (
mistral-small-2603) modellt használja. Forrás: Models.
Fejlesztés automatizálása Codestrallal és egy általános célú modellel
Eddig minden Mistral AI eszközt külön-külön mutattunk be, emberi felhasználó előtt működve. Az igazi értékük akkor mutatkozik meg, ha láncba fűzöd őket. A Codestral Embed, a Codestral és egy általános célú modell, mint például a Mistral Small 4, egy olyan automatizált fejlesztési csővezetéket alkot, amely képes kódot keresni, generálni és ellenőrizni anélkül, hogy minden lépésnél emberi beavatkozásra lenne szükség.
Egy kódcsővezeték architektúrája
Egy teljes csővezeték három szakaszra bontható, ahol mindegyiket az arra a feladatra legalkalmasabb modell végzi el.
- Kódkeresés – Releváns kód megtalálása a kódbázisban (Codestral Embed)
- Kódgenerálás – Kód létrehozása vagy módosítása (Codestral)
- Kódellenőrzés – Változtatások ellenőrzése és validálása (Mistral Small 4)
Az adatfolyamot felülről lefelé olvasd; minden blokk az előző kimenetét használja fel.
User Request
|
[Codestral Embed] -> Relevant Files
|
[Codestral] -> Generated/Modified Code
|
[Mistral Small 4] -> Automated Review
|
Pull Request / Commit
1. lépés: Kódkeresés Codestral Embeddel
Ha a meglévő kódbázis ismerete nélkül generálsz kódot, az eredmény semmiben sem fog hasonlítani a projekt többi részére. Ezért az első lépés a releváns fájlok megtalálása az előző leckében felépített beágyazási (embedding) index segítségével. Az alábbi függvény a feladatleírást vektorrá alakítja, összehasonlítja az összes indexelt fájllal, és visszaadja az öt legközelebbi találatot.
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]]
2. lépés: Kódgenerálás Codestrallal
Ha megvan a kontextus, a Codestral képes kódot generálni. A kimenet minősége attól függ, hogyan adod meg ezt a kontextust: fűzd össze a lekért fájlokat a rendszerüzenetben, és egészítsd ki egy explicit utasítással a meglévő konvenciók betartására. A temperature=0.1 beállítás közel determinisztikussá teszi a kimenetet, ami akkor kívánatos, ha a generált kódnak zökkenőmentesen illeszkednie kell a projektbe, ahelyett, hogy meglepné a szerzőjét.
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
3. lépés: Kódellenőrzés Mistral Small 4-gyel
Az ellenőrzés jön utoljára. A Mistral Small 4 megkapja az előző állapotot, az új állapotot és a feladatleírást, majd szigorú JSON formátumban hozza meg ítéletét. Ez a választás kritikus fontosságú: a szabad szöveges ellenőrzések nem használhatók fel a további kód által, míg egy boolean approved mező lehetővé teszi a következő lépések automatizálását. A kért kategóriák szándékosan választják szét a blokkoló problémákat, a fejlesztési javaslatokat és a biztonsági aggályokat, mivel ezek eltérő kezelést igényelnek.
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
Teljes csővezeték: Jegytől a PR-ig
Most már összeállíthatod ezt a három függvényt egyetlen lánccá, amely egy jeggyel indul és ellenőrzött kóddal végződik. Tartsd meg a közbeiktatott print utasításokat: egy automatizált csővezetékben a naplózás, hogy mit találtál, generáltál és ellenőriztél, az egyetlen módja annak, hogy később megértsd, miért csalódott egy eredményben.
def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
"""Complete pipeline: ticket -> code -> review."""
# 1. Kontextuális keresés
relevant_files = search_context(ticket, codebase_index)
print(f"Files found: {[f['path'] for f in relevant_files]}")
# 2. Kódgenerálás
generated_code = generate_code(ticket, relevant_files)
print(f"Generated code: {len(generated_code)} characters")
# 3. Automatizált ellenőrzés
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 integráció
Ez a mechanizmus akkor éri el teljes potenciálját, ha összekötöd a CI rendszereddel. Egy GitHub Actions munkafolyamat, amely minden pull request megnyitásakor és frissítésekor elindul, elegendő ahhoz, hogy minden javasolt változtatást lefuttasson az ellenőrzésen, emberi beavatkozás nélkül.
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 }}
A meghívott script lekéri a diffet, átadja az egyes módosított fájlokat a review_code függvénynek, és csak akkor fűz kommentárt a PR-hoz, ha az ellenőrzés nem hagyta jóvá. Ez a feltétel elengedhetetlen: egy bot, amely mindent kommentel, zajjá válik, amit a csapat napokon belül megtanul figyelmen kívül hagyni.
# scripts/ai_review.py
def review_pull_request(pr_number: int):
"""Automated PR review with Mistral Small 4."""
# 1. PR diff lekérése
diff = get_pr_diff(pr_number)
# 2. Az egyes módosított fájlok elemzése
for file in diff.files:
review = review_code(
original_code=file.before,
modified_code=file.after,
description=diff.title,
)
# 3. Komment hozzáadása a PR-hoz
if not review["approved"]:
post_pr_comment(pr_number, file.path, review)
Gyakori éles környezeti variációk
Az ezt a mintázatot alkalmazó csapatok több visszatérő használati esethez igazítják azt. Először is az automatikus tesztgenerálás: minden új fájlhoz a csővezeték megfelelő teszteket készít, áthárítva a macerát anélkül, hogy megszüntetné az ellenőrzést. Ezt követi a folyamatos dokumentáció, ahol a docstringeket minden commit során generálják és frissítik, nem pedig egy audit során. Majd a regresszióészlelés, ahol az ellenőrző modell a diffelemzést végzi a valószínű mellékhatások miatt. Végül a kód migráció, amely automatizálja az átalakítást keretrendszerek vagy verziók között – itt a legnagyobb az időmegtakarítás, mert az átalakítás ismétlődő, az eredmény pedig a meglévő tesztekkel ellenőrizhető.
Egy figyelmeztetés mind a négy esetre vonatkozik: az automatizált ellenőrzés nem helyettesíti az emberi ellenőrzést. Csak a mechanikus figyelmetlenségeket szűri ki, és a fejlesztőkre hagyja a döntést arról, ami igazán számít.
Főbb megállapítások
- Egy AI kódcsővezeték egyesíti a keresést (Embed), a generálást (Codestral) és az ellenőrzést (Mistral Small 4)
- A Codestral Embed megtalálja a kontextust, a Codestral generál, egy általános célú modell pedig ellenőriz
- A CI/CD integráció lehetővé teszi az automatizált ellenőrzéseket és tesztgenerálást
- A keresés -> generálás -> ellenőrzés mintázat számos munkafolyamatra alkalmazható
- Az automatizált ellenőrzés nem helyettesíti az emberi ellenőrzést; kiegészíti azt