Salida multimodal

La API de MKA1 puede devolver texto, audio e imágenes. El texto es la modalidad de salida predeterminada. Usa modalities para habilitar la salida de voz, o agrega la herramienta image_generation para producir imágenes.

Tipos de salida soportados

Modalidad	Cómo habilitar	Formato de salida
Texto	Predeterminado — sin configuración extra	`output_text` en la respuesta
Audio (voz)	Establece `modalities: ["text", "audio"]`	Audio en base64 + transcripción
Imagen	Agrega la herramienta `image_generation`	URL de imagen o base64

Generar audio (texto a voz)

Solicita salida de audio estableciendo modalities a ["text", "audio"]. La respuesta incluye el texto generado y su grabación codificada en base64.

Configuración de audio

La salida de audio siempre es un archivo WAV: 24 kHz, 16 bits, mono. La voz sigue el idioma de la respuesta, que la API detecta a partir del texto (consulta Idiomas soportados). El objeto audio de la solicitud (voice y format) se acepta pero no tiene efecto, por lo que los ejemplos lo omiten.

import { SDK } from '@meetkai/mka1';
import type { ResponseObject } from '@meetkai/mka1/models/components';
import { writeFileSync } from 'fs';

const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

const result = await sdk.llm.responses.create({
  xOnBehalfOf: '<end-user-id>', // opcional — atribuye la solicitud a uno de tus usuarios finales
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Say hello in a friendly way. Keep it very short.',
    modalities: ['text', 'audio'],
  },
}) as ResponseObject;

// The output includes an output_audio item with base64 data and a transcript

import OpenAI from 'openai';
import { writeFileSync } from 'fs';

const openai = new OpenAI({
  apiKey: '<mka1-api-key>',
  baseURL: 'https://apigw.mka1.com/api/v1/llm/',
  defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
});

const response = await openai.post<{ output: Array<{ type: string; data?: string; transcript?: string }> }>('/responses', { body: {
  model: 'meetkai:functionary-es-mini',
  input: 'Say hello in a friendly way. Keep it very short.',
  modalities: ['text', 'audio'],
  stream: false,
} });

// Find the audio output
const audioItem = response.output.find((item) => item.type === 'output_audio');
// audioItem.data contains base64-encoded WAV
// audioItem.transcript contains the spoken text

from meetkai_mka1 import SDK
import base64

sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Say hello in a friendly way. Keep it very short.",
    modalities=["text", "audio"],
)

# The output includes an output_audio item with base64 data and a transcript

using MeetKai.MKA1;
using MeetKai.MKA1.Types.Components;

var sdk = new SDK(bearerAuth: "Bearer <mka1-api-key>");

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr("Say hello in a friendly way. Keep it very short."),
    Modalities = new List<ResponsesCreateRequestModality>
    {
        ResponsesCreateRequestModality.Text,
        ResponsesCreateRequestModality.Audio,
    },
});

// The output includes an output_audio item with base64 data and a transcript

mka1 llm responses create \
  -H 'X-On-Behalf-Of: <end-user-id>' \
  --body '{
    "model": "meetkai:functionary-es-mini",
    "input": "Say hello in a friendly way. Keep it very short.",
    "modalities": ["text", "audio"]
  }'

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --data '{
    "model": "meetkai:functionary-es-mini",
    "input": "Say hello in a friendly way. Keep it very short.",
    "modalities": ["text", "audio"]
  }'

La respuesta contiene un elemento output_audio con el audio codificado en base64 y una transcripción de lo que se dijo:

{
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        { "type": "output_text", "text": "Hello!" }
      ]
    },
    {
      "type": "output_audio",
      "id": "audio_460caf1079b34fa0b4aa74448dff4ea7",
      "data": "<Base64-encoded WAV audio data>",
      "transcript": "Hello!",
      "status": "completed"
    }
  ]
}

El campo data contiene el archivo WAV completo. El campo transcript contiene el texto que se pronunció, que es el texto de salida de la respuesta. Si la síntesis de voz falla, la respuesta se completa igualmente, sin un elemento output_audio.

Guardar audio en un archivo

const result = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Read this sentence aloud: The quick brown fox jumps over the lazy dog.',
    modalities: ['text', 'audio'],
  },
}) as ResponseObject;

// Find the audio output in the response
const audioItem = result.output.find((item) => item.type === 'output_audio');
if (audioItem) {
  const audioBuffer = Buffer.from(audioItem.data, 'base64');
  writeFileSync('output.wav', audioBuffer);
}

const response = await openai.post<{ output: Array<{ type: string; data?: string; transcript?: string }> }>('/responses', { body: {
  model: 'meetkai:functionary-es-mini',
  input: 'Read this sentence aloud: The quick brown fox jumps over the lazy dog.',
  modalities: ['text', 'audio'],
  stream: false,
} });

const audioItem = response.output.find((item) => item.type === 'output_audio');
if (audioItem?.data) {
  const audioBuffer = Buffer.from(audioItem.data, 'base64');
  writeFileSync('output.wav', audioBuffer);
}

result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Read this sentence aloud: The quick brown fox jumps over the lazy dog.",
    modalities=["text", "audio"],
)

# Find the audio output in the response
for item in result.output:
    if item.type == "output_audio":
        audio_bytes = base64.b64decode(item.data)
        with open("output.wav", "wb") as f:
            f.write(audio_bytes)

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Read this sentence aloud: The quick brown fox jumps over the lazy dog."),
    Modalities = new List<ResponsesCreateRequestModality>
    {
        ResponsesCreateRequestModality.Text,
        ResponsesCreateRequestModality.Audio,
    },
});

// Save the audio output to a file
// (iterate result.Output to find the output_audio item and decode its base64 data)

# Genera audio y extrae los datos base64, luego decodifica a un archivo
mka1 llm responses create \
  --body '{
    "model": "meetkai:functionary-es-mini",
    "input": "Read this sentence aloud: The quick brown fox jumps over the lazy dog.",
    "modalities": ["text", "audio"]
  }' \
  --output-format json \
  --jq '.output[] | select(.type == "output_audio") | .data' | base64 -d > output.wav

# Genera audio y extrae los datos base64, luego decodifica a un archivo
curl -s https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --data '{
    "model": "meetkai:functionary-es-mini",
    "input": "Read this sentence aloud: The quick brown fox jumps over the lazy dog.",
    "modalities": ["text", "audio"]
  }' | jq -r '.output[] | select(.type == "output_audio") | .data' | base64 -d > output.wav

Idiomas soportados

La salida de audio usa los idiomas que se enumeran en Idiomas de texto a voz. Una respuesta en cualquier otro idioma se pronuncia con la voz en inglés. Para elegir el idioma tú mismo, u obtener MP3 en lugar de WAV, envía el texto de la respuesta al endpoint de texto a voz.

Generar imágenes

Usa la herramienta image_generation para crear imágenes a partir de indicaciones de texto. El modelo interpreta tu mensaje, genera una indicación para el modelo de imágenes y devuelve el resultado.

Modelos de generación de imágenes

Modelo	Mejor para
`meetkai:flux-2-klein`	Generación rápida, propósito general (predeterminado)
`meetkai:z-image-turbo`	Imágenes de alta calidad y detalle

Opciones de generación de imágenes

Parámetro	Opciones	Predeterminado
`size`	`1024x1024`, `1024x1536`, `1536x1024`, `auto`	`auto`
`quality`	`low`, `medium`, `high`, `auto`	`auto`
`output_format`	`png`, `webp`, `jpeg`	`png`
`background`	`transparent`, `opaque`, `auto`	`auto`

const result = await sdk.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'Generate an image of a sunset over a mountain lake.',
    tools: [
      {
        type: 'image_generation',
        model: 'auto',
        quality: 'high',
        size: '1024x1024',
        outputFormat: 'png',
      },
    ],
  },
}) as ResponseObject;

// The output includes an image_generation_call item with a result URL
const imageCall = result.output.find((item) => item.type === 'image_generation_call');
console.log('Image URL:', imageCall?.result);

const response = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: 'Generate an image of a sunset over a mountain lake.',
  tools: [{ type: 'image_generation' }],
  stream: false,
});

const imageCall = response.output.find((item) => item.type === 'image_generation_call');
console.log('Image URL:', imageCall?.result);

result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="Generate an image of a sunset over a mountain lake.",
    tools=[
        {
            "type": "image_generation",
            "model": "auto",
            "quality": "high",
            "size": "1024x1024",
            "output_format": "png",
        },
    ],
)

# The output includes an image_generation_call item with a result URL
for item in result.output:
    if item.type == "image_generation_call":
        print("Image URL:", item.result)

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Generate an image of a sunset over a mountain lake."),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateImageGenerationToolDefinition(
            new ImageGenerationToolDefinition()
            {
                Model = "meetkai:flux-2-klein",
                Quality = ImageGenerationToolDefinitionQuality.High,
                Size = ImageGenerationToolDefinitionSize.OneThousandAndTwentyFourx1024,
                OutputFormat = OutputFormat.Png,
            }
        ),
    },
});

// The output includes an image_generation_call item with a result URL

mka1 llm responses create --body '{
  "model": "meetkai:functionary-es-mini",
  "input": "Generate an image of a sunset over a mountain lake.",
  "tools": [
    {
      "type": "image_generation",
      "model": "auto",
      "quality": "high",
      "size": "1024x1024",
      "output_format": "png"
    }
  ]
}'

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --header 'X-On-Behalf-Of: <end-user-id>' \
  --data '{
    "model": "meetkai:functionary-es-mini",
    "input": "Generate an image of a sunset over a mountain lake.",
    "tools": [
      {
        "type": "image_generation",
        "model": "auto",
        "quality": "high",
        "size": "1024x1024",
        "output_format": "png"
      }
    ]
  }'

La respuesta incluye un elemento image_generation_call con la URL de la imagen generada y la indicación revisada utilizada por el modelo de imágenes:

{
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "I'll generate an image of a beautiful sunset over a mountain lake for you."
        }
      ]
    },
    {
      "type": "image_generation_call",
      "id": "ig_abc123",
      "status": "completed",
      "result": "<Generated Image URL>",
      "revised_prompt": "A breathtaking sunset over a pristine mountain lake, with golden and orange hues reflecting on the calm water surface. Snow-capped mountain peaks in the background, dramatic clouds in the sky with vibrant sunset colors of pink, purple, and orange.",
      "size": "auto",
      "quality": "auto",
      "output_format": "png"
    }
  ]
}

El campo result contiene una URL a la imagen generada. El campo revised_prompt muestra la indicación expandida que usó el modelo de imágenes — el LLM mejora tu instrucción breve en una descripción detallada de la imagen.

Forzar la generación de imágenes

Usa tool_choice para asegurar que el modelo genere una imagen en vez de responder solo con texto.

const result = await sdk.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-es-mini',
    input: 'A red circle on a white background.',
    tools: [{ type: 'image_generation' }],
    toolChoice: { type: 'image_generation' },
  },
}) as ResponseObject;

const response = await openai.responses.create({
  model: 'meetkai:functionary-es-mini',
  input: 'A red circle on a white background.',
  tools: [{ type: 'image_generation' }],
  tool_choice: { type: 'image_generation' },
  stream: false,
});

result = sdk.llm.responses.create(
    model="meetkai:functionary-es-mini",
    input="A red circle on a white background.",
    tools=[{"type": "image_generation"}],
    tool_choice={"type": "image_generation"},
)

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-es-mini",
    Input = ResponsesCreateRequestInput.CreateStr("A red circle on a white background."),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateImageGenerationToolDefinition(
            new ImageGenerationToolDefinition()
        ),
    },
    ToolChoice = ToolChoice.CreateHostedToolChoice(new HostedToolChoice()
    {
        Type = HostedToolChoiceType.ImageGeneration,
    }),
});

mka1 llm responses create --body '{
  "model": "meetkai:functionary-es-mini",
  "input": "A red circle on a white background.",
  "tools": [{ "type": "image_generation" }],
  "tool_choice": { "type": "image_generation" }
}'

curl https://apigw.mka1.com/api/v1/llm/responses \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --data '{
    "model": "meetkai:functionary-es-mini",
    "input": "A red circle on a white background.",
    "tools": [{ "type": "image_generation" }],
    "tool_choice": { "type": "image_generation" }
  }'

Estructura de la salida de imagen

El arreglo output de la respuesta contiene estos elementos cuando se genera una imagen:

function_call — la llamada del modelo a la herramienta de generación de imágenes con la indicación refinada
image_generation_call — el resultado de la generación con status: "completed" y result (URL de la imagen)
function_call_output — la salida cruda de la herramienta que contiene la URL
message — la respuesta de texto del modelo describiendo o haciendo referencia a la imagen

Las URLs de imágenes expiran después de 1 hora. Descárgalas o guárdalas en caché si necesitas acceso a largo plazo.

APIs independientes

Para acceso directo sin pasar por la API de Responses, MKA1 también ofrece endpoints independientes:

API de texto a voz

El endpoint de texto a voz devuelve audio binario (audio/wav) y un encabezado de respuesta X-Language-Code. Si estableces store: true, la respuesta también incluye un encabezado X-Tts-Id con el ID del registro de historial almacenado.

const ttsAudio = await sdk.llm.speech.speak({
  textToSpeechRequest: {
    text: 'Hello, welcome to the MKA1 platform.',
    language: 'en',
    model: 'auto',
    store: false,
  },
});

// ttsAudio.result es un ReadableStream<Uint8Array> de audio WAV

audio = sdk.llm.speech.speak(
    text="Hello, welcome to the MKA1 platform.",
    language="en",
    model="auto",
    store=False,
)

# audio es audio binario (WAV)

var audio = await sdk.Llm.Speech.SpeakAsync(new MeetKai.MKA1.Types.Components.TextToSpeechRequest()
{
    Text = "Hello, welcome to the MKA1 platform.",
    Language = TextToSpeechRequestLanguage.En,
    Model = "auto",
    Store = false,
});

// audio es audio binario (WAV)

mka1 llm speech speak \
  --text 'Hello, welcome to the MKA1 platform.' \
  --language en \
  --output-file output.wav

curl https://apigw.mka1.com/api/v1/llm/speech/tts \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --data '{
    "text": "Hello, welcome to the MKA1 platform.",
    "language": "en"
  }' \
  --output output.wav

API de imágenes

const imageResult = await sdk.llm.images.create({
  imageGenerationRequest: {
    model: 'auto',
    prompt: 'A futuristic city skyline at dusk',
    quality: 'high',
  },
});

image_result = sdk.llm.images.create(
    model="auto",
    prompt="A futuristic city skyline at dusk",
    quality="hd",
)

var imageResult = await sdk.Llm.Images.CreateAsync(new ImageGenerationRequest()
{
    Model = "meetkai:z-image-turbo",
    Prompt = "A futuristic city skyline at dusk",
    Quality = ImageGenerationRequestQuality.High,
});

mka1 llm images create \
  --model auto \
  --prompt 'A futuristic city skyline at dusk' \
  --quality hd

curl https://apigw.mka1.com/api/v1/llm/images/generations \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --data '{
    "model": "auto",
    "prompt": "A futuristic city skyline at dusk",
    "quality": "hd"
  }'

Próximos pasos

Entrada multimodal — envía imágenes, audio y documentos al modelo
Voz — transcribe audio y genera voz con los endpoints independientes de voz
Modo de voz avanzado — conversaciones de voz en tiempo real con LiveKit
Generar una respuesta — solicitudes de texto e intercambios multi-turno

Comenzar

SDKs y CLI

Respuestas

APIs independientes

Agentes

Compute

Producción

Salida multimodal

Tipos de salida soportados

Generar audio (texto a voz)

Configuración de audio

Guardar audio en un archivo

Idiomas soportados

Generar imágenes

Modelos de generación de imágenes

Opciones de generación de imágenes

Forzar la generación de imágenes

Estructura de la salida de imagen

APIs independientes

API de texto a voz

API de imágenes

Próximos pasos

​Tipos de salida soportados

​Generar audio (texto a voz)

​Configuración de audio

​Guardar audio en un archivo

​Idiomas soportados

​Generar imágenes

​Modelos de generación de imágenes

​Opciones de generación de imágenes

​Forzar la generación de imágenes

​Estructura de la salida de imagen

​APIs independientes

​API de texto a voz

​API de imágenes

​Próximos pasos

Tipos de salida soportados

Generar audio (texto a voz)

Configuración de audio

Guardar audio en un archivo

Idiomas soportados

Generar imágenes

Modelos de generación de imágenes

Opciones de generación de imágenes

Forzar la generación de imágenes

Estructura de la salida de imagen

APIs independientes

API de texto a voz

API de imágenes

Próximos pasos