Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Automatizované kódové pipeline

Lekce 12 z 14 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Automatizace vývoje s Codestral a modelem všeobecného určení
  2. Architektura kódové pipeline
  3. Krok 1: Vyhledávání kódu s Codestral Embed
  4. Krok 2: Generování kódu s Codestral
  5. Krok 3: Revize kódu s Mistral Small 4
  6. Kompletní pipeline: Od ticketu po PR
  7. Integrace CI/CD
  8. Běžné produkční variace
  9. Klíčové poznatky

Lekce aktualizována 2. listopadu 2026. Krok revize dříve spoléhal na model Devstral, který byl z API odstraněn 31. července 2026. Nyní využívá Mistral Small 4 (mistral-small-2603). Zdroj: Models.

Automatizace vývoje s Codestral a modelem všeobecného určení

Doposud jsme představili každý nástroj Mistral AI samostatně, přičemž každý fungoval před lidským uživatelem. Jejich skutečná hodnota se projeví, když je propojíš do řetězce. Codestral Embed, Codestral a model všeobecného určení, jako je Mistral Small 4, tvoří automatizovanou vývojovou pipeline schopnou vyhledávat, generovat a recenzovat kód bez nutnosti manuálního zásahu v každém kroku.

Architektura kódové pipeline

Kompletní pipeline se dělí na tři fáze, přičemž každá je přiřazena modelu, který exceluje právě v tomto konkrétním úkolu.

  1. Vyhledávání kódu – Najdi relevantní kód v codebase (Codestral Embed)
  2. Generování kódu – Vygeneruj nebo uprav kód (Codestral)
  3. Revize kódu – Ověř a validuj změny (Mistral Small 4)

Datový tok čti shora dolů; každý blok spotřebovává výstup toho předchozího.

User Request
    |
[Codestral Embed] -> Relevant Files
    |
[Codestral] -> Generated/Modified Code
    |
[Mistral Small 4] -> Automated Review
    |
Pull Request / Commit

Krok 1: Vyhledávání kódu s Codestral Embed

Generování kódu bez znalosti stávajícího codebase produkuje výsledky, které nijak nepřipomínají zbytek projektu. Prvním krokem je proto lokalizace relevantních souborů pomocí indexu vnoření (embedding index), který jsme vytvořili v předchozí lekci. Následující funkce převede popis úkolu na vektor, porovná jej s každým indexovaným souborem a vrátí pět nejbližších shod.

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]]

Krok 2: Generování kódu s Codestral

Jakmile máš kontext, Codestral může generovat kód. Kvalita výstupu závisí na tom, jak tento kontext prezentuješ: spojte načtené soubory do systémové zprávy a přidej explicitní pokyn k dodržování stávajících konvencí. Nastavení temperature=0.1 udržuje výstup blízko determinismu, což je žádoucí, když se generovaný kód musí bez problémů integrovat do projektu, místo aby svého autora překvapoval.

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

Krok 3: Revize kódu s Mistral Small 4

Kontrola přichází jako poslední. Mistral Small 4 obdrží stav před změnou, stav po změně a popis úkolu, poté vynese svůj verdikt v přísném formátu JSON. Tato volba je kritická: recenze ve formě volného textu nejsou pro následný kód použitelné, zatímco boolean pole approved ti umožňuje automatizovat další kroky. Požadované kategorie záměrně oddělují blokující problémy, návrhy na vylepšení a bezpečnostní rizika, protože každá z nich vyžaduje odlišné zacházení.

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

Kompletní pipeline: Od ticketu po PR

Nyní můžeš tyto tři funkce sestavit do jediného řetězce, který začíná ticketem a končí zrecenzovaným kódem. Ponech si vložené příkazy print: v automatizované pipeline je logování toho, co bylo nalezeno, vygenerováno a zrecenzováno, jediným způsobem, jak později pochopit, proč tě výsledek zklamal.

def ticket_to_code_pipeline(ticket: str, codebase_index: list) -> dict:
    """Complete pipeline: ticket -> code -> review."""

    # 1. Kontextové vyhledávání
    relevant_files = search_context(ticket, codebase_index)
    print(f"Files found: {[f['path'] for f in relevant_files]}")

    # 2. Generování kódu
    generated_code = generate_code(ticket, relevant_files)
    print(f"Generated code: {len(generated_code)} characters")

    # 3. Automatizovaná revize
    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,
    }

Integrace CI/CD

Tento mechanismus dosahuje svého plného potenciálu, když je připojen k tvému CI. Workflow GitHub Actions spuštěné při každém otevření a aktualizaci pull requestu stačí k tomu, aby spustilo revizi u každé navržené změny bez nutnosti lidského zásahu.

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 }}

Volaný skript získá diff, předá každý upravený soubor funkci review_code a okomentuje PR pouze tehdy, pokud revize neschválí změny. Tato podmínka je zásadní: bot, který komentuje vše, se stane šumem, který tým během několika dnů přestane vnímat.

# scripts/ai_review.py
def review_pull_request(pr_number: int):
    """Automated PR review with Mistral Small 4."""
    # 1. Získání diffu PR
    diff = get_pr_diff(pr_number)

    # 2. Analýza každého upraveného souboru
    for file in diff.files:
        review = review_code(
            original_code=file.before,
            modified_code=file.after,
            description=diff.title,
        )

        # 3. Publikování komentáře na PR
        if not review["approved"]:
            post_pr_comment(pr_number, file.path, review)

Běžné produkční variace

Týmy, které tento vzorec adoptují, jej přizpůsobují několika opakujícím se případům použití. Zaprvé, automatické generování testů: pro každý nový soubor pipeline vytvoří odpovídající testy, čímž přesune rutinní práci, aniž by eliminovala revizi. Zadruhé, průběžná dokumentace, kde se docstringy generují a aktualizují s každým commitm místo během auditu. Zatřetí, detekce regrese, kde model pro revizi analyzuje diffy na pravděpodobné vedlejší efekty. Nakonec migrace kódu, která automatizuje převod mezi frameworky nebo verzemi – zde jsou úspory času nejvýznamnější, protože transformace je repetitivní a výsledek ověřitelný stávajícími testy.

Pro všechny čtyři případy platí jedno upozornění: automatizovaná revize nenahrazuje lidskou revizi. Zachytí mechanická opomenutí a úsudek nad tím, co je skutečně důležité, ponechává na tvých vývojářích.

Klíčové poznatky

  • AI kódová pipeline kombinuje vyhledávání (Embed), generování (Codestral) a revizi (Mistral Small 4)
  • Codestral Embed najde kontext, Codestral generuje a model všeobecného určení ověřuje
  • Integrace CI/CD umožňuje automatizované revize a generování testů
  • Vzorec vyhledávání -> generování -> revize se aplikuje na mnoho workflow
  • Automatizovaná revize nenahrazuje lidskou revizi; doplňuje ji