> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mka1.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Enviar corpos de requisição

> Construa requisições CLI do mka1 com flags individuais, o atalho JSON --body, ou redirecionamento via stdin — e entenda como as três entradas se combinam.

Todo comando que aceita um corpo de requisição suporta três formas de fornecê-lo:

1. Flags individuais (maior prioridade)
2. A flag `--body` com uma string JSON
3. Redirecionamento via stdin

Elas podem ser combinadas — a CLI faz a mesclagem e fontes de maior prioridade sobrescrevem as de menor prioridade no nível de campo.

## Flags individuais

Use uma flag dedicada para cada campo. Esta é a opção mais fácil de descobrir e a mais simples de usar com autocompletar do shell:

```bash theme={null}
mka1 llm responses create \
  --model meetkai:functionary-pt \
  --input '"Resuma a fila de suporte de ontem."'
```

`--help` mostra todas as flags aceitas pelo comando, junto com as obrigatórias e opções de enum.

## A flag `--body`

Envie o corpo completo da requisição como uma única string JSON. Útil quando você já tem o corpo formado — por exemplo, de outra ferramenta ou de um teste:

```bash theme={null}
mka1 llm responses create --body '{
  "model": "meetkai:functionary-pt",
  "input": "Resuma a fila de suporte de ontem."
}'
```

Flags individuais ainda sobrescrevem o corpo no nível de campo:

```bash theme={null}
# Corpo final: {"model":"meetkai:functionary-pt","input":"Um prompt diferente"}
mka1 llm responses create \
  --body '{"model":"meetkai:functionary-pt","input":"Prompt original"}' \
  --input '"Um prompt diferente"'
```

## Redirecionamento via stdin

Redirecione JSON para qualquer comando que aceite um corpo. Esta é a escolha certa para scripts, encadeamento de comandos, ou leitura de corpos a partir de arquivos:

```bash theme={null}
# De um arquivo JSON
mka1 llm responses create < request.json

# De outro comando
curl -s https://example.com/prompt.json | mka1 llm responses create

# Gerado inline
echo '{"model":"meetkai:functionary-pt","input":"Olá"}' | mka1 llm responses create
```

Flags individuais também sobrescrevem valores vindos do stdin:

```bash theme={null}
# Corpo final: {"model":"meetkai:functionary-pt","input":"Sobrescrito"}
echo '{"model":"meetkai:functionary-pt","input":"Do stdin"}' \
  | mka1 llm responses create --input '"Sobrescrito"'
```

## Cadeia de prioridade

Quando mais de uma fonte fornece o mesmo campo, a de maior prioridade vence:

| Prioridade | Fonte             | Uso típico                              |
| ---------- | ----------------- | --------------------------------------- |
| 1 (maior)  | Flags individuais | Ajustes pontuais, parâmetros em scripts |
| 2          | Flag `--body`     | Corpo JSON formado inline               |
| 3 (menor)  | Stdin             | JSON redirecionado ou vindo de arquivo  |

A CLI mescla as chaves dos objetos, então você pode misturar: redirecione a maior parte do corpo via stdin e sobrescreva um campo específico com uma flag.

## Encadeie comandos

Como cada comando imprime JSON no stdout (quando você passa `--output-format json`), é possível alimentar uma chamada na próxima:

```bash theme={null}
mka1 llm files upload \
  --file ./support-manual.pdf \
  --purpose assistants \
  --output-format json \
  --jq '{file_id: .id, purpose: .purpose}' \
  | mka1 llm vector-stores create-file --vector-store-id vs_123
```

Veja [formatar e filtrar saída](/pt/docs/cli/output-formats) para saber mais sobre `--output-format` e `--jq`.

## Entradas de arquivo

Comandos de upload de arquivos (`llm files upload`, `llm speech transcribe`, `llm extract extract` e similares) recebem um caminho com `--file`.
A CLI lê o arquivo e o envia como multipart form data:

```bash theme={null}
mka1 llm files upload --file ./dataset.jsonl --purpose fine-tune
```

Respostas binárias (por exemplo, `llm speech speak`) suportam `--output-file` para gravar o payload em um caminho em vez de imprimir:

```bash theme={null}
mka1 llm speech speak \
  --text 'Olá, bem-vindo ao nosso serviço.' \
  --output-file ./welcome.wav
```

Use `--output-b64` quando quiser o binário codificado em base64 no stdout.