Fluxuri de lucru automate pentru cod
Pe această pagină
- Automatizarea dezvoltării cu Codestral și un model de uz general
- Arhitectura unui flux de lucru pentru cod
- Pasul 1: Căutarea codului cu Codestral Embed
- Pasul 2: Generarea codului cu Codestral
- Pasul 3: Revizuirea codului cu Mistral Small 4
- Flux complet: de la tichet la PR
- Integrare CI/CD
- Variații comune în producție
- Puncte cheie
Lecție actualizată la 2 noiembrie 2026. Etapa de revizuire se baza anterior pe Devstral, care a fost eliminat din API la 31 iulie 2026. Acum utilizează Mistral Small 4 (
mistral-small-2603). Sursă: Models.
Automatizarea dezvoltării cu Codestral și un model de uz general
Până acum, am prezentat fiecare instrument Mistral AI individual, operând în fața unui utilizator uman. Valoarea lor reală apare atunci când le înlănțuiți. Codestral Embed, Codestral și un model de uz general, cum ar fi Mistral Small 4, formează un flux de lucru de dezvoltare automatizat capabil să caute, să genereze și să revizuiască codul fără intervenție manuală la fiecare pas.
Arhitectura unui flux de lucru pentru cod
Un flux complet se descompune în trei etape, fiecare atribuită modelului care excelează în acea sarcină specifică.
- Căutare de cod — Găsirea codului relevant în baza de cod (Codestral Embed)
- Generare de cod — Generarea sau modificarea codului (Codestral)
- Revizuire de cod — Verificarea și validarea modificărilor (Mistral Small 4)
Citiți fluxul de date de sus în jos; fiecare bloc consumă ieșirea celui anterior.
User Request
|
[Codestral Embed] -> Relevant Files
|
[Codestral] -> Generated/Modified Code
|
[Mistral Small 4] -> Automated Review
|
Pull Request / Commit
Pasul 1: Căutarea codului cu Codestral Embed
Generarea de cod fără cunoașterea bazei de cod existente produce rezultate care nu seamănă deloc cu restul proiectului. Prin urmare, primul pas este localizarea fișierelor relevante folosind indexul de embedding construit în lecția anterioară. Funcția de mai jos convertește descrierea sarcinii într-un vector, o compară cu fiecare fișier indexat și returnează cele mai apropiate cinci corespondențe.
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]]
Pasul 2: Generarea codului cu Codestral
Odată ce aveți contextul, Codestral poate genera cod. Calitatea ieșirii depinde de modul în care prezentați acel context: concatenați fișierele recuperate în mesajul de sistem, însoțite de o instrucțiune explicită de a respecta convențiile existente. Setarea temperature=0.1 menține ieșirea aproape deterministă, ceea ce este de dorit atunci când codul generat trebuie să se integreze perfect într-un proiect, mai degrabă decât să își surprindă autorul.
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
Pasul 3: Revizuirea codului cu Mistral Small 4
Controlul vine la final. Mistral Small 4 primește starea anterioară, starea ulterioară și descrierea sarcinii, apoi își emite verdictul într-un format JSON strict. Această alegere este critică: recenziile în proză liberă nu sunt utilizabile de codul din aval, în timp ce un câmp boolean approved vă permite să automatizați pașii următori. Categoriile solicitate separă deliberat problemele blocante, sugestiile de îmbunătățire și preocupările de securitate, deoarece acestea necesită o gestionare diferită.
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
Flux complet: de la tichet la PR
Puteți acum asambla aceste trei funcții într-un singur lanț care pornește de la un tichet și produce cod revizuit. Păstrați instrucțiunile print intercalate: într-un flux automatizat, jurnalizarea a ceea ce a fost găsit, generat și revizuit este singura modalitate de a înțelege ulterior de ce un rezultat v-a dezamăgit.
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,
}
Integrare CI/CD
Acest mecanism își atinge potențialul maxim atunci când este conectat la CI-ul dumneavoastră. Un flux de lucru GitHub Actions declanșat la fiecare deschidere și actualizare de pull request este suficient pentru a rula revizuirea asupra fiecărei modificări propuse, fără a fi necesară nicio intervenție umană.
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 }}
Scriptul apelat preia diff-ul, transmite fiecare fișier modificat către review_code și adaugă comentarii la PR doar atunci când revizuirea nu aprobă modificarea. Această condiție este esențială: un bot care comentează totul devine un zgomot pe care echipa învață să îl ignore în câteva zile.
# 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)
Variații comune în producție
Echipele care adoptă acest model îl adaptează la mai multe cazuri de utilizare recurente. În primul rând, generarea automată de teste: pentru fiecare fișier nou, fluxul produce testele corespunzătoare, transferând sarcina fără a elimina revizuirea. Apoi, documentarea continuă, unde docstring-urile sunt generate și actualizate la fiecare commit, mai degrabă decât în timpul unui audit. În continuare, detectarea regresiei, unde modelul de revizuire analizează diff-urile pentru efecte secundare probabile. În final, migrarea codului, care automatizează conversia între framework-uri sau versiuni – aici economiile de timp sunt cele mai semnificative, deoarece transformarea este repetitivă, iar rezultatul este verificabil prin testele existente.
O singură rezervă se aplică tuturor celor patru: revizuirea automată nu înlocuiește revizuirea umană. Aceasta surprinde scăpările mecanice și lasă judecata asupra a ceea ce contează cu adevărat în seama dezvoltatorilor dumneavoastră.
Puncte cheie
- Un flux de lucru AI pentru cod combină căutarea (Embed), generarea (Codestral) și revizuirea (Mistral Small 4)
- Codestral Embed găsește contextul, Codestral generează, iar un model de uz general verifică
- Integrarea CI/CD permite revizuiri automate și generarea de teste
- Modelul căutare -> generare -> revizuire se aplică multor fluxuri de lucru
- Revizuirea automată nu înlocuiește revizuirea umană; o completează