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

# Formatear y filtrar la salida

> Cambia el CLI de mka1 entre salida pretty, JSON, YAML, table y TOON. Transforma resultados con jq, transmite eventos SSE y controla el color.

Cada comando soporta `--output-format` para controlar cómo se muestran los resultados en stdout:

| Formato | Flag                                   | Cuándo usarlo                                                                                                                                                                 |
| ------- | -------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Pretty  | `--output-format pretty` (por defecto) | Para leer la salida en una terminal. Pares clave-valor alineados con color e indentación anidada.                                                                             |
| JSON    | `--output-format json`                 | Scripting, canalizar en `jq`, guardar en un archivo. Mantiene el orden original de los campos y la precisión numérica cuando la respuesta ya es JSON.                         |
| YAML    | `--output-format yaml`                 | Salida tipo configuración, fácil de diferenciar visualmente.                                                                                                                  |
| Table   | `--output-format table`                | Respuestas en array donde cada elemento tiene la misma estructura — por ejemplo, `llm models list`.                                                                           |
| TOON    | `--output-format toon`                 | [Token-Oriented Object Notation](https://github.com/toon-format/spec). Compacto, orientado por líneas, 30–60% menos tokens que JSON — ideal para canalizar en prompts de LLM. |

```bash theme={null}
# Por defecto, legible para humanos
mka1 llm models list

# JSON legible por máquinas
mka1 llm models list --output-format json

# TOON compacto para pasar a otro LLM
mka1 llm responses get --response-id resp_123 --output-format toon
```

## Filtrar y transformar con jq

Utiliza `--jq` para filtrar o reestructurar respuestas en línea con una expresión [jq](https://jqlang.org). Esto siempre produce JSON y sobrescribe `--output-format`:

```bash theme={null}
# Extraer un solo campo
mka1 llm models list --jq '.data[].id'

# Filtrar un array
mka1 llm responses list --jq '.data[] | select(.status == "completed")'

# Reestructurar en un nuevo objeto
mka1 llm files list --jq '.data[] | {id, name: .filename, bytes}'
```

Como `--jq` imprime JSON plano, se compone bien con shells y otras llamadas al CLI:

```bash theme={null}
mka1 llm files upload --file ./doc.pdf --purpose assistants --jq '.id' \
  | xargs -I {} mka1 llm vector-stores create-file --vector-store-id vs_123 --file-id {}
```

## Paginación y transmisión

Algunas operaciones devuelven muchos elementos o eventos enviados por el servidor. La salida se escribe de forma incremental a medida que llega cada elemento:

| Formato                | Comportamiento en streaming                                                         |
| ---------------------- | ----------------------------------------------------------------------------------- |
| `json`                 | Un objeto JSON compacto por línea ([NDJSON](https://github.com/ndjson/ndjson-spec)) |
| `yaml`                 | Documentos YAML separados por `---`                                                 |
| `toon`                 | Un objeto codificado en TOON por bloque, separados por líneas en blanco             |
| `pretty` (por defecto) | Elementos impresos en formato pretty separados por líneas en blanco                 |

### Paginar a través de una colección

Pasa `--all` en comandos de lista para seguir automáticamente el cursor `next` y emitir cada página a medida que llega:

```bash theme={null}
mka1 llm responses list --all --output-format json > responses.ndjson
```

### Transmitir eventos enviados por el servidor

Las operaciones en streaming (por ejemplo, `llm responses create --stream`) emiten un evento por línea:

```bash theme={null}
mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --input '"Escribe tres puntos para las notas de la versión."' \
  --stream \
  --output-format json

# Solo conservar los deltas de texto
mka1 llm responses create \
  --model meetkai:functionary-es-mini \
  --input '"Escribe tres puntos para las notas de la versión."' \
  --stream \
  --jq 'select(.type == "response.output_text.delta") | .delta'
```

Presiona `Ctrl+C` para dejar de consumir un stream antes de tiempo.

## Color

`--color` controla los colores de la terminal para el formato `pretty`:

| Valor                | Comportamiento                                                  |
| -------------------- | --------------------------------------------------------------- |
| `auto` (por defecto) | Colorea cuando stdout es un TTY, texto plano en caso contrario. |
| `always`             | Siempre colorea.                                                |
| `never`              | Nunca colorea.                                                  |

El CLI también respeta las variables de entorno ampliamente usadas [`NO_COLOR`](https://no-color.org/) y `FORCE_COLOR`.

## Incluir cabeceras de respuesta

Utiliza `--include-headers` cuando necesites las cabeceras HTTP de la respuesta junto con el cuerpo — por ejemplo, para leer un ID de solicitud para soporte o inspeccionar una cabecera de límite de tasa:

```bash theme={null}
mka1 llm models list --include-headers
```

## Escribir respuestas binarias a un archivo

Los comandos que devuelven datos binarios (como `llm speech speak`) soportan `--output-file` para escribir el cuerpo a una ruta sin contaminar stdout:

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

Utiliza `--output-b64` en su lugar cuando necesites incrustar la carga binaria en un pipeline de JSON o texto.

## Códigos de salida

| Código de salida | Significado                         |
| ---------------- | ----------------------------------- |
| `0`              | Éxito. Respuesta escrita en stdout. |
| `1`              | Error. Detalles escritos en stderr. |

Esto hace que el flujo de control tipo `if` sea sencillo en scripts:

```bash theme={null}
if ! mka1 llm responses get --response-id resp_123 > out.json 2> err.log; then
  echo "La solicitud falló — ver err.log"
  exit 1
fi
```

Consulta [debug y diagnóstico](/es/docs/cli/diagnostics) para `--dry-run` y `--debug`, que te dan más visibilidad sobre por qué falló un comando.