Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Pipelines de Código Automatizadas

Aula 12 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Automatização do Desenvolvimento com Codestral e um Modelo de Propósito Geral
  2. Arquitetura de uma Pipeline de Código
  3. Passo 1: Pesquisa de Código com Codestral Embed
  4. Passo 2: Geração de Código com Codestral
  5. Passo 3: Revisão de Código com Mistral Small 4
  6. Pipeline Completa: Do Ticket ao PR
  7. Integração CI/CD
  8. Variações Comuns em Produção
  9. Pontos-chave

Lição atualizada em 2 de novembro de 2026. A etapa de revisão dependia anteriormente do Devstral, que foi removido da API em 31 de julho de 2026. Agora utiliza o Mistral Small 4 (mistral-small-2603). Fonte: Models.

Automatização do Desenvolvimento com Codestral e um Modelo de Propósito Geral

Até agora, apresentámos cada ferramenta da Mistral AI individualmente, operando diante de um utilizador humano. O seu verdadeiro valor emerge quando as encadeia. O Codestral Embed, o Codestral e um modelo de propósito geral como o Mistral Small 4 formam uma pipeline de desenvolvimento automatizada capaz de pesquisar, gerar e rever código sem intervenção manual em cada passo.

Arquitetura de uma Pipeline de Código

Uma pipeline completa divide-se em três etapas, cada uma atribuída ao modelo que se destaca nessa tarefa específica.

  1. Pesquisa de Código — Encontrar código relevante na base de código (Codestral Embed)
  2. Geração de Código — Gerar ou modificar código (Codestral)
  3. Revisão de Código — Verificar e validar alterações (Mistral Small 4)

Leia o fluxo de dados de cima para baixo; cada bloco consome a saída do anterior.

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

Passo 1: Pesquisa de Código com Codestral Embed

Gerar código sem conhecimento da base de código existente produz resultados que não se assemelham em nada ao resto do projeto. O primeiro passo, portanto, é localizar os ficheiros relevantes utilizando o índice de incorporação (embedding) construído na lição anterior. A função abaixo converte a descrição da tarefa num vetor, compara-o com todos os ficheiros indexados e devolve as cinco correspondências mais próximas.

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

Passo 2: Geração de Código com Codestral

Uma vez obtido o contexto, o Codestral pode gerar código. A qualidade da saída depende de como apresenta esse contexto: concatene os ficheiros recuperados na mensagem do sistema, acompanhados de uma instrução explícita para respeitar as convenções existentes. Definir temperature=0.1 mantém a saída próxima do determinismo, o que é desejável quando o código gerado deve integrar-se perfeitamente num projeto em vez de surpreender o seu autor.

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

Passo 3: Revisão de Código com Mistral Small 4

O controlo vem por último. O Mistral Small 4 recebe o estado anterior, o estado posterior e a descrição da tarefa, emitindo depois o seu veredito num formato JSON estrito. Esta escolha é crítica: revisões em prosa livre não são utilizáveis por código subsequente, enquanto um campo booleano approved permite automatizar os próximos passos. As categorias solicitadas separam deliberadamente problemas bloqueantes, sugestões de melhoria e preocupações de segurança, pois exigem tratamentos diferentes.

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

Pipeline Completa: Do Ticket ao PR

Pode agora assembling estas três funções numa única cadeia que começa com um ticket e produz código revisto. Mantenha as instruções print intercaladas: numa pipeline automatizada, registar o que foi encontrado, gerado e revisto é a sua única forma de compreender mais tarde porque é que um resultado o dececionou.

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

Integração CI/CD

Este mecanismo atinge o seu pleno potencial quando ligado à sua Integração Contínua (CI). Um fluxo de trabalho do GitHub Actions acionado em cada abertura e atualização de pull request é suficiente para executar a revisão em cada alteração proposta, sem necessidade de intervenção humana.

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

O script chamado recupera o diff, passa cada ficheiro modificado para review_code e comenta no PR apenas quando a revisão não aprova. Esta condição é essencial: um bot que comenta tudo torna-se ruído que a equipa aprende a ignorar em poucos dias.

# 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ções Comuns em Produção

As equipas que adotam este padrão adaptam-no a vários casos de uso recorrentes. Primeiro, a geração automática de testes: para cada novo ficheiro, a pipeline produz os testes correspondentes, transferindo a tarefa sem eliminar a revisão. Em seguida, a documentação contínua, onde as docstrings são geradas e atualizadas a cada commit em vez de durante uma auditoria. Depois, a deteção de regressões, onde o modelo de revisão analisa os diffs para efeitos colaterais prováveis. Finalmente, a migração de código, que automatiza a conversão entre frameworks ou versões — é aqui que a poupança de tempo é mais significativa, pois a transformação é repetitiva e o resultado é verificável pelos testes existentes.

Uma ressalva aplica-se a todos os quatro: a revisão automatizada não substitui a revisão humana. Deteta lapsos mecânicos e deixa o julgamento sobre o que realmente importa aos seus programadores.

Pontos-chave

  • Uma pipeline de código com IA combina pesquisa (Embed), geração (Codestral) e revisão (Mistral Small 4)
  • O Codestral Embed encontra o contexto, o Codestral gera e um modelo de propósito geral verifica
  • A integração CI/CD permite revisões automatizadas e geração de testes
  • O padrão pesquisa -> gerar -> rever aplica-se a muitos fluxos de trabalho
  • A revisão automatizada não substitui a revisão humana; complementa-a