> ## 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.

# Pasar cuerpos de solicitud

> Construye solicitudes CLI de mka1 con flags individuales, el atajo JSON --body, o canalización por stdin — y entiende cómo se combinan las tres entradas.

Cada comando que acepta un cuerpo de solicitud admite tres formas de proporcionarlo:

1. Flags individuales (máxima prioridad)
2. La opción `--body` con una cadena JSON
3. Canalización por stdin

Se pueden combinar — la CLI los fusiona y las fuentes de mayor prioridad sobrescriben a las de menor prioridad a nivel de campo.

## Flags individuales

Usa un flag dedicado para cada campo. Esta es la opción más fácil de descubrir y la más sencilla de usar con el autocompletado del shell:

```bash theme={null}
mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --input '"Resume la cola de soporte de ayer."'
```

`--help` muestra todos los flags que acepta el comando, junto con los obligatorios y las opciones enumeradas.

## La opción `--body`

Envía el cuerpo completo de la solicitud como una sola cadena JSON. Útil cuando ya tienes el cuerpo formado — por ejemplo, desde otra herramienta o un fixture de prueba:

```bash theme={null}
mka1 llm responses create --body '{
  "model": "meetkai:functionary-es-mini",
  "input": "Resume la cola de soporte de ayer."
}'
```

Los flags individuales aún sobrescriben el cuerpo a nivel de campo:

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

## Canalización por stdin

Canaliza JSON a cualquier comando que acepte un cuerpo. Esta es la opción adecuada para scripts, encadenar comandos o leer cuerpos desde archivos:

```bash theme={null}
# Desde un archivo JSON
mka1 llm responses create < request.json

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

# Generado en línea
echo '{"model":"meetkai:functionary-es-mini","input":"Hola"}' | mka1 llm responses create
```

Los flags individuales también sobrescriben los valores de stdin:

```bash theme={null}
# Cuerpo final: {"model":"meetkai:functionary-es-mini","input":"Sobrescrito"}
echo '{"model":"meetkai:functionary-es-mini","input":"Desde stdin"}' \
  | mka1 llm responses create --input '"Sobrescrito"'
```

## Cadena de prioridades

Cuando más de una fuente proporciona el mismo campo, la fuente de mayor prioridad gana:

| Prioridad  | Fuente             | Uso típico                               |
| ---------- | ------------------ | ---------------------------------------- |
| 1 (máxima) | Flags individuales | Ajustes puntuales, parámetros en scripts |
| 2          | Opción `--body`    | Cuerpo JSON formado en línea             |
| 3 (mínima) | Stdin              | JSON canalizado o desde archivo          |

La CLI fusiona las claves de los objetos, así que puedes mezclar y combinar: canaliza la mayor parte del cuerpo por stdin y luego sobrescribe un solo campo con un flag.

## Encadena comandos

Como cada comando imprime JSON en stdout (cuando pasas `--output-format json`), puedes alimentar una llamada en la siguiente:

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

Consulta [formatear y filtrar la salida](/es/docs/cli/output-formats) para más información sobre `--output-format` y `--jq`.

## Entradas de archivos

Los comandos de carga de archivos (`llm files upload`, `llm speech transcribe`, `llm extract extract` y similares) aceptan una ruta con `--file`.
La CLI lee el archivo y lo envía como datos de formulario multipartes:

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

Las respuestas binarias (por ejemplo, `llm speech speak`) admiten `--output-file` para escribir el contenido en una ruta en lugar de imprimirlo:

```bash theme={null}
mka1 llm speech speak \
  --text 'Hola, bienvenido a nuestro servicio.' \
  --output-file ./welcome.wav
```

Usa `--output-b64` cuando quieras que el binario se imprima en stdout codificado en base64.