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

Agentes de Código na Prática: API, Vibe Code CLI e Vibe Code Web

Aula 8 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Três formas de colocar um agente a trabalhar
  2. Através da API Mistral
  3. Através do Vibe Code localmente: a CLI e a extensão VS Code
  4. Através do Vibe Code Web
  5. Comparando os três caminhos
  6. O que faz a diferença na prática
  7. Pontos-chave

Lição reescrita em 2 de novembro de 2026. Como o Devstral foi removido da API em 31 de julho de 2026, os exemplos de API aqui utilizam o Mistral Small 4. A secção Vibe reflete a documentação atual do Vibe Code: instalação, o modelo integrado (Mistral Medium 3.5) e as três interfaces — CLI, extensão VS Code e Vibe Code Web. Fontes: Instalação e configuração · Escolher sessões CLI, VS Code ou web · Configuração.

Três formas de colocar um agente a trabalhar

Um modelo agêntico só é tão bom quanto a forma como o conecta ao trabalho real. A Mistral oferece três caminhos: a API, onde constrói o seu próprio agente; o Vibe Code localmente, no seu terminal ou VS Code; e o Vibe Code Web, que executa o agente num sandbox remoto ligado a um repositório GitHub. Cada um adequa-se a uma parte diferente do dia de um programador.

Através da API Mistral

A API é a interface mais flexível: permite-lhe construir os seus próprios fluxos de trabalho agênticos com as suas próprias ferramentas e lógica de controlo. Comece pelo caso mais simples, uma chamada de chat sem ferramentas. Aqui, submetemos uma função de autenticação vulnerável ao Mistral Small 4 e pedimos um diagnóstico. Definir temperature=0 não é decorativo: para análise de segurança, quer resultados reproduzíveis, não variações de uma execução para outra.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-small-2603",
    messages=[
        {
            "role": "system",
            "content": "You are an expert development agent. Analyze the provided code and propose improvements."
        },
        {
            "role": "user",
            "content": """Here is a Python file that handles authentication.
Identify security issues and propose fixes:

def login(username, password):
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    user = db.execute(query).fetchone()
    if user:
        session['user_id'] = user['id']
        return True
    return False
"""
        }
    ],
    temperature=0,
    max_tokens=2000,
)

print(response.choices[0].message.content)

O modo agêntico altera a natureza da troca. Em vez de receber texto, declara as ferramentas que o modelo pode solicitar chamar, e o modelo devolve tool_calls — um nome de ferramenta e os seus argumentos. As três ferramentas abaixo formam a base mínima para um agente de código: ler um ficheiro, escrever num ficheiro, executar um comando. Com elas, a instrução “adicionar dicas de tipo a todos os ficheiros em src/utils/” torna-se executável, enquanto no modo de chat permaneceria apenas uma sugestão.

tools = [
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the contents of a source file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "Relative path to the file"
                    }
                },
                "required": ["path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_file",
            "description": "Write content to a file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"},
                    "content": {"type": "string"}
                },
                "required": ["path", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_command",
            "description": "Execute a shell command",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {"type": "string"}
                },
                "required": ["command"]
            }
        }
    }
]

response = client.chat.complete(
    model="mistral-small-2603",
    messages=[
        {
            "role": "user",
            "content": "Explore the project and add Python type hints to all files in the src/utils/ directory"
        }
    ],
    tools=tools,
    tool_choice="auto",
)

# Process the tool calls returned by the model
for tool_call in response.choices[0].message.tool_calls:
    print(f"Tool: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

Note que nada é executado por si só: o ciclo — chamar a ferramenta, devolver a saída ao modelo, pedir o próximo passo — permanece inteiramente da sua responsabilidade. Esse é o preço da flexibilidade, e é exatamente isso que a CLI do Vibe trata por si.

Através do Vibe Code localmente: a CLI e a extensão VS Code

O Vibe Code é o modo “code” do Vibe, o agente da Mistral. Localmente, apresenta-se em duas formas que partilham o mesmo motor, configuração e histórico de sessões: a CLI, no seu terminal, e a extensão VS Code, que adiciona contexto do editor (ficheiro ativo, seleção, diffs). Instalar a CLI requer apenas uma linha no macOS e Linux:

# Official installer (installs uv if needed, then the mistral-vibe package)
curl -LsSf https://mistral.ai/vibe/install.sh | bash

# Or manual installation
uv tool install mistral-vibe

Depois, navegue até ao seu projeto e execute vibe. No primeiro arranque, um assistente pede-lhe para iniciar sessão com a sua conta Mistral (o Vibe Code está incluído nos planos, com limites de uso dependendo do plano) ou para inserir uma chave de API. Depois, conversa com o agente como se fosse um colega com as mãos no teclado:

Explain this project's architecture.
Add an API route /health that returns the server status, along with its test.
Run the test suite and fix what fails.

O Vibe fornece as próprias ferramentas (leitura/escrita de ficheiros, comandos de shell) e o ciclo agêntico que teve de escrever manualmente com a API. Vem com um modelo integrado, o Mistral Medium 3.5, e o comando /model permite-lhe escolher outro entre os configurados (Small 4, Codestral, um modelo local…). As alterações e comandos passam por um sistema de aprovação que configura por agente: reveja-o antes de confiar num repositório importante. Para automação, vibe --prompt executa uma execução não interativa, útil em integração contínua.

Através do Vibe Code Web

O Vibe Code Web é a terceira interface: um cockpit para agentes remotos. Cria um projeto a partir de um ou mais repositórios GitHub sob o mesmo proprietário, inicia uma sessão com uma instrução precisa, e o agente trabalha num sandbox gerido na nuvem: clona, planeia, modifica, executa comandos e testes, e depois prepara uma branch ou pull request para rever no GitHub. Não é necessária cópia local, e a sua máquina pode permanecer fechada enquanto o agente trabalha. A partir da CLI, o comando /teleport transfere uma sessão em curso para a web.

Escolha a CLI ou a extensão quando a tarefa depender de ficheiros, serviços ou segredos presentes apenas na sua máquina.

Comparando os três caminhos

CritérioAPI PythonVibe Code (CLI, VS Code)Vibe Code Web
Ciclo agênticoEscreve-oIntegradoIntegrado
Acesso a ficheirosAtravés das suas ferramentasCópia de trabalho localSandbox remoto, repositório GitHub
ModeloO que chamarMedium 3.5 integrado, outros opcionaisMotor Vibe Code
Modo não interativoSimSim (vibe --prompt, apenas CLI)Não
Caso de usoPipelines, produtos personalizadosDesenvolvimento diárioTarefas de longa duração num repositório remoto

Lendo da direita para a esquerda, esta tabela descreve um gradiente de controlo: quanto mais se move em direção à API, mais decide tudo, incluindo o que pode falhar.

O que faz a diferença na prática

A qualidade do resultado depende menos do modelo do que da forma como formula o seu pedido. “Adicionar validação” deixa o agente inventar a localização, o estilo e as regras; “Adicionar validação de email em src/auth/validators.py usando o padrão existente” dá-lhe o ficheiro, a convenção e o limite. No mesmo espírito, cite explicitamente ficheiros relevantes e restrições do projeto em vez de esperar que os adivinhe.

A verificação permanece não negociável: um agente competente pode ainda introduzir uma regressão, especialmente ao tocar em vários ficheiros de uma vez. Torne hábito rever o diff antes de o aceitar, tal como faria com um pull request de um novo contratado. E tenha em mente a configuração final: escolher a ferramenta certa. Use o Vibe Code localmente para desenvolvimento diário, o Vibe Code Web para tarefas de longa duração num repositório remoto, e a API para as suas próprias pipelines.

Pontos-chave

  • A API dá controlo total: escreve as ferramentas e o ciclo agêntico
  • O Vibe Code instala-se com curl -LsSf https://mistral.ai/vibe/install.sh | bash (ou uv tool install mistral-vibe) e vem com o Mistral Medium 3.5
  • A CLI e a extensão VS Code partilham configuração e sessões; vibe --prompt é para automação
  • O Vibe Code Web executa o agente num sandbox remoto e produz branches e pull requests
  • Instruções precisas e revisão de diffs permanecem essenciais