O servidor MCP: `stalwart mcp`

O stalwart mcp é o servidor MCP do guardrail. Ele roda na sua máquina, por stdio, e responde às perguntas do seu assistente de IA sobre o guardrail, constrói um com você e o mede nas suas próprias chamadas. Ele lê e grava arquivos na pasta em que foi iniciado (STALWART_MCP_HOME muda a pasta). Ele chama o serviço só onde um passo já chama (compilar uma planilha de regras, uma caça hospedada, um red team), e nunca chama um modelo: onde um passo precisa de um, o seu próprio assistente o faz, por um prompt, e o servidor confere o que ele fez.

Adicionando ao seu cliente

$ stalwart mcp --config claude      # imprime: claude mcp add stalwart -- <python> -m stalwart_agents.guardrails.server
$ stalwart mcp --config cursor      # a entrada mcpServers para o Cursor
$ stalwart mcp --config vscode      # a entrada servers para o VS Code

Perguntando o que ele faz

Ferramenta	Responde
`capabilities(language)`	todas as verificações, da própria lista do guardrail: o que barram e o que não conseguem, o que leem e as opções on-fail; onde ele pode rodar; versões; o que é garantido e o que não é
`explain_check(name, language)`	uma verificação inteira, com um exemplo permitido e um barrado e a sua seção do manual
`search_manual(question, language)`	as seções do manual que mais combinam, pelas palavras, em inglês ou português; sem modelo
`how_to(goal, language)`	receitas fixas: "proteger meu servidor MCP", "adicionar ao meu guard do Guardrails AI", "escrever uma regra para reembolsos acima de 100", "avaliar nos meus traces", ...
`explain_decision(decision_id)`	por que uma chamada registrada foi barrada: a verificação, a sua regra e o que ela leu

As páginas do manual são recursos: stalwart://manual/{page} (acrescente /pt para português), uma de building, checks, tool-kinds, rule-sheet, wording-search, evaluating, connecting, mcp.

Montando

Ferramenta	Faz
`catalogue_from_server(server, out)`	lê as ferramentas de um servidor MCP (o endereço, ou uma resposta `tools/list` salva) para `tools.json`
`writes_file(tools, out)`	rascunha `tool_kinds.yaml`: o tipo, o motivo e a origem de cada ferramenta, as incertas primeiro
`set_tool_kinds(changes, reasons)`	define tipos como o seu assistente propõe, registrados como `source: assistant`
`compile_rules(sheet, out_dir)`	compila `rules.yaml` com o serviço para `compiled/`
`lint_rules(sheet, tools)`	uma regra para uma ferramenta que você não tem; uma escrita que nenhuma regra nomeia
`check_call(call, context)`	uma resposta de ensaio; nada roda
`search_wordings(tools, language, checks, seconds)`	a busca de formulações das três verificações que leem o turno
`snippet(where, upstream)`	o código para `python`, `guardrails-ai` ou `nemo`, ou o `catalogue.json` e o `gateway.yaml` do `gateway`

Medindo

Ferramenta	Faz
`replay(trace, format)`	a resposta de cada chamada; contagens por regra; as chamadas barradas; confirmações por 100 chamadas; tempo p50/p95; determinismo
`evaluate(labelled, format)`	alarmes falsos e falhas contra os seus rótulos, por regra
`counterfactual(trace, outcome_checker)`	a sua própria verificação de resultado, como rodou e sem as chamadas barradas
`hunt(sheet)`	o caçador de falhas nas suas regras (o serviço, com a sua chave)
`redteam(server)`	as ferramentas de um servidor MCP atrás do gateway, provadas para qualquer chamada (o serviço, com a sua chave)
`compare_with_gai(trace, guard)`	o seu guard do Guardrails AI sozinho, e com o nosso validador
`benchmark(name)`	busca os dados de companhia aérea ou varejo do tau2-bench nos seus commits fixados

Prompts

build-guardrail: a construção inteira, em ordem: ferramentas, tipos, uma planilha de regras rascunhada a partir da sua política em palavras simples, compilar e verificar, ensaios, busca e caça, o trecho de código. O seu assistente rascunha a planilha; você a lê antes de ela ser usada.
classify-tools: o seu assistente propõe tipos para as ferramentas de que a dedução não tem certeza.
set-up-guardrail: uma receita do how_to, seguida passo a passo.
evaluate-guardrail: replay e evaluate nas suas chamadas, sem citar nada delas.

Uma sessão de exemplo

Você: O que este guardrail consegue verificar?

(o assistente chama capabilities) Vinte e uma verificações, em quatro etapas: tipos de ferramenta; a cadeia de admissão (uma ferramenta retirada, um endereço não permitido, um passo fora de um plano aprovado); as dez regras da verificação de ferramentas (ferramentas permitidas, o registro da sessão, argumentos, destinos, ordem, desfazer, as suas regras, conteúdo de fora, confirmação, qualquer outra escrita); e as verificações do que foi dito (rastreabilidade, S1, S2, a leitura de confirmação). Ele julga ferramentas, argumentos, rótulos, histórico e regras, não o que uma resposta quer dizer.

Você: Como adiciono ao meu guard do Guardrails AI?

(o assistente chama how_to) Instale stalwart-agents[guardrails], acrescente gai.ToolCall(...) ao seu guard e valide cada chamada de ferramenta com guard.validate(gai.as_json(call), metadata={"stalwart": {...}}) antes de executá-la.

O que um relatório traz

Nomes de ferramentas, nomes de regras, contagens, ids de decisão e digests. Nunca o valor de um argumento, e nunca uma palavra que uma pessoa disse; todo texto passa pelo mascaramento de segredos e dados pessoais do pacote.

O servidor MCP: stalwart mcp