Przejdź do głównej treści
Polski— Wybierz język
Menu

Zautomatyzowane potoki kodu

Lekcja 12 z 14 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Automatyzacja rozwoju oprogramowania dzięki Codestral i modelowi ogólnego przeznaczenia
  2. Architektura potoku kodu
  3. Krok 1: Wyszukiwanie kodu za pomocą Codestral Embed
  4. Krok 2: Generowanie kodu za pomocą Codestral
  5. Krok 3: Recenzja kodu za pomocą Mistral Small 4
  6. Kompletny potok: od zgłoszenia do Pull Requesta
  7. Integracja z CI/CD
  8. Typowe warianty produkcyjne
  9. Kluczowe wnioski

Lekcja zaktualizowana 2 listopada 2026 r. Etap recenzji opierał się wcześniej na modelu Devstral, który został usunięty z API 31 lipca 2026 r. Obecnie wykorzystuje on Mistral Small 4 (mistral-small-2603). Źródło: Modele.

Automatyzacja rozwoju oprogramowania dzięki Codestral i modelowi ogólnego przeznaczenia

Do tej pory przedstawialiśmy każde narzędzie Mistral AI osobno, działające przed ludzkim użytkownikiem. Ich prawdziwa wartość ujawnia się, gdy połączysz je w łańcuch. Codestral Embed, Codestral oraz model ogólnego przeznaczenia, taki jak Mistral Small 4, tworzą zautomatyzowany potok deweloperski zdolny do wyszukiwania, generowania i recenzowania kodu bez konieczności ręcznej interwencji na każdym etapie.

Architektura potoku kodu

Kompletny potok dzieli się na trzy etapy, z których każdy przypisany jest do modelu najlepiej radzącego sobie z danym zadaniem.

  1. Wyszukiwanie kodu — znajdowanie odpowiedniego kodu w bazie kodu (Codestral Embed)
  2. Generowanie kodu — tworzenie lub modyfikowanie kodu (Codestral)
  3. Recenzja kodu — weryfikacja i zatwierdzanie zmian (Mistral Small 4)

Czytaj przepływ danych od góry do dołu; każdy blok wykorzystuje wynik działania poprzedniego.

Zgłoszenie użytkownika
    |
[Codestral Embed] -> Odpowiednie pliki
    |
[Codestral] -> Wygenerowany/Zmodyfikowany kod
    |
[Mistral Small 4] -> Zautomatyzowana recenzja
    |
Pull Request / Commit

Krok 1: Wyszukiwanie kodu za pomocą Codestral Embed

Generowanie kodu bez znajomości istniejącej bazy kodu daje wyniki, które nie mają nic wspólnego z resztą projektu. Pierwszym krokiem jest zatem zlokalizowanie odpowiednich plików przy użyciu indeksu osadzeń (embeddingów) zbudowanego w poprzedniej lekcji. Poniższa funkcja konwertuje opis zadania na wektor, porównuje go z każdym zaindeksowanym plikiem i zwraca pięć najbliższych dopasowań.

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: Generowanie kodu za pomocą Codestral

Gdy już masz kontekst, Codestral może wygenerować kod. Jakość wyniku zależy od tego, jak przedstawisz ten kontekst: połącz pobrane pliki w wiadomości systemowej, dodając wyraźną instrukcję przestrzegania istniejących konwencji. Ustawienie temperature=0.1 utrzymuje wynik blisko deterministycznego, co jest pożądane, gdy generowany kod musi płynnie integrować się z projektem, a nie zaskakiwać jego autora.

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: Recenzja kodu za pomocą Mistral Small 4

Kontrola przychodzi na końcu. Mistral Small 4 otrzymuje stan przed, stan po oraz opis zadania, a następnie wydaje swój werdykt w ścisłym formacie JSON. Ten wybór jest kluczowy: recenzje w formie swobodnego tekstu są nieużyteczne dla kolejnych etapów kodu, podczas gdy pole boolean approved pozwala zautomatyzować następne kroki. Żądane kategorie celowo oddzielają błędy blokujące, sugestie ulepszeń i problemy bezpieczeństwa, ponieważ wymagają one innego处理方式.

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

Kompletny potok: od zgłoszenia do Pull Requesta

Możesz teraz połączyć te trzy funkcje w jeden łańcuch, który zaczyna się od zgłoszenia (ticketu), a kończy na zrecenzowanym kodzie. Zachowaj przeplatane instrukcje print: w zautomatyzowanym potoku logowanie tego, co znaleziono, wygenerowano i zrecenzowano, to jedyny sposób, by później zrozumieć, dlaczego wynik Cię rozczarował.

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

    # 1. Wyszukiwanie kontekstowe
    relevant_files = search_context(ticket, codebase_index)
    print(f"Files found: {[f['path'] for f in relevant_files]}")

    # 2. Generowanie kodu
    generated_code = generate_code(ticket, relevant_files)
    print(f"Generated code: {len(generated_code)} characters")

    # 3. Zautomatyzowana recenzja
    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,
    }

Integracja z CI/CD

Mechanizm ten osiąga pełen potencjał, gdy zostanie podłączony do Twojego środowiska CI. Przepływ pracy GitHub Actions wyzwalany przy każdym otwarciu i aktualizacji pull requesta wystarczy, aby uruchomić recenzję dla każdej proponowanej zmiany, bez konieczności angażowania ludzkiego myślenia.

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

Wywoływany skrypt pobiera diff, przekazuje każdy zmodyfikowany plik do funkcji review_code i dodaje komentarz do PR tylko wtedy, gdy recenzja nie zostanie zatwierdzona. Ten warunek jest istotny: bot komentujący wszystko staje się szumem, który zespół nauczy się ignorować w ciągu kilku dni.

# scripts/ai_review.py
def review_pull_request(pr_number: int):
    """Automated PR review with Mistral Small 4."""
    # 1. Pobranie diffa z PR
    diff = get_pr_diff(pr_number)

    # 2. Analiza każdego zmodyfikowanego pliku
    for file in diff.files:
        review = review_code(
            original_code=file.before,
            modified_code=file.after,
            description=diff.title,
        )

        # 3. Dodanie komentarza do PR
        if not review["approved"]:
            post_pr_comment(pr_number, file.path, review)

Typowe warianty produkcyjne

Zespoły wdrażające ten wzorzec adaptują go do kilku powtarzających się przypadków użycia. Po pierwsze, automatyczne generowanie testów: dla każdego nowego pliku potok tworzy odpowiednie testy, przenosząc obowiązek, ale nie eliminując recenzji. Następnie, ciągła dokumentacja, gdzie docstringi są generowane i aktualizowane przy każdym commicie, a nie podczas audytu. Potem, wykrywanie regresji, gdzie model recenzujący analizuje diffy pod kątem prawdopodobnych skutków ubocznych. Wreszcie, migracja kodu, która automatyzuje konwersję między frameworkami lub wersjami – to tutaj oszczędność czasu jest największa, ponieważ transformacja jest powtarzalna, a wynik weryfikowalny przez istniejące testy.

Jedno zastrzeżenie dotyczy wszystkich czterech przypadków: zautomatyzowana recenzja nie zastępuje recenzji ludzkiej. Wyłapuje mechaniczne przeoczenia, a ocenę tego, co naprawdę ważne, pozostawia Twoim programistom.

Kluczowe wnioski

  • Potok kodu AI łączy wyszukiwanie (Embed), generowanie (Codestral) i recenzję (Mistral Small 4)
  • Codestral Embed znajduje kontekst, Codestral generuje, a model ogólnego przeznaczenia weryfikuje
  • Integracja z CI/CD umożliwia zautomatyzowane recenzje i generowanie testów
  • Wzorzec wyszukiwanie -> generowanie -> recenzja sprawdza się w wielu przepływach pracy
  • Zautomatyzowana recenzja nie zastępuje recenzji ludzkiej; ją uzupełnia