Saída multimodal

A API MKA1 pode retornar texto, áudio e imagens. Texto é a modalidade de saída padrão. Use modalities e audio para habilitar a saída de fala ou adicione a ferramenta image_generation para produzir imagens.

Tipos de saída compatíveis

Modalidade	Como habilitar	Formato de saída
Texto	Padrão — sem configuração adicional	`output_text` na resposta
Áudio (fala)	Defina `modalities: ["text", "audio"]`	Áudio em Base64 + transcrição
Imagem	Adicione a ferramenta `image_generation`	URL da imagem ou base64

Gerar áudio (texto para fala)

Solicite saída de áudio definindo modalities como {"text", "audio"} e especificando uma voz e um formato no parâmetro audio. A resposta inclui tanto a transcrição de texto quanto os dados de áudio codificados em base64.

Configuração de áudio

Parâmetro	Opções	Padrão
`voice`	`alloy` e outros perfis de voz	`alloy`
`format`	`wav`, `mp3`, `flac`, `opus`, `pcm16`	`wav`

O áudio é sintetizado em 24 kHz, mono de 16 bits.

mka1 llm responses create \
  -H 'X-On-Behalf-Of: <end-user-id>' \
  --body '{
    "model": "meetkai:functionary-pt",
    "input": "Diga olá de forma amigável. Mantenha bem curto.",
    "modalities": ["text", "audio"],
    "audio": { "voice": "alloy", "format": "wav" }
  }'

import { SDK } from '@meetkai/mka1';

const mka1 = new SDK({
  bearerAuth: `Bearer ${YOUR_API_KEY}`,
});

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>', // optional — attribute the request to one of your end users
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Diga olá de forma amigável. Mantenha bem curto.',
    modalities: ['text', 'audio'],
    audio: { voice: 'alloy', format: 'wav' },
  },
});

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

import OpenAI from 'openai';

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.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Diga olá de forma amigável. Mantenha bem curto.',
  modalities: ['text', 'audio'],
  audio: { voice: 'alloy', format: 'wav' },
  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

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

var sdk = new SDK(
    bearerAuth: $"Bearer {YOUR_API_KEY}",
    serverUrl: "https://apigw.mka1.com"
);

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr("Diga olá de forma amigável. Mantenha bem curto."),
    Modalities = new List<ResponsesCreateRequestModality>
    {
        ResponsesCreateRequestModality.Text,
        ResponsesCreateRequestModality.Audio,
    },
    Audio = new Audio()
    {
        Voice = "alloy",
        Format = ResponsesCreateRequestFormat.Wav,
    },
});

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

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Diga olá de forma amigável. Mantenha bem curto.",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
)

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

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-pt",
    "input": "Diga olá de forma amigável. Mantenha bem curto.",
    "modalities": ["text", "audio"],
    "audio": { "voice": "alloy", "format": "wav" }
  }'

A resposta contém um item output_audio com o áudio codificado em base64 e uma transcrição do que foi falado:

{
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        { "type": "output_text", "text": "Olá!" }
      ]
    },
    {
      "type": "output_audio",
      "id": "audio_460caf1079b34fa0b4aa74448dff4ea7",
      "data": "<Dados de áudio WAV codificados em Base64>",
      "transcript": "Olá!",
      "status": "completed"
    }
  ]
}

O campo data contém o arquivo de áudio completo (268 KB neste exemplo). O campo transcript contém o texto que o modelo escolheu falar — que pode diferir ligeiramente da saída de texto.

Salvar áudio em um arquivo

# Gere áudio e extraia os dados base64, depois decodifique para um arquivo
mka1 llm responses create \
  --body '{
    "model": "meetkai:functionary-pt",
    "input": "Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.",
    "modalities": ["text", "audio"],
    "audio": { "voice": "alloy", "format": "mp3" }
  }' \
  --output-format json \
  --jq '.output[] | select(.type == "output_audio") | .data' | base64 -d > output.mp3

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

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.',
    modalities: ['text', 'audio'],
    audio: { voice: 'alloy', format: 'mp3' },
  },
}) 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.mp3', audioBuffer);
}

import { writeFileSync } from 'fs';

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.',
  modalities: ['text', 'audio'],
  audio: { voice: 'alloy', format: 'mp3' },
  stream: false,
});

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

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso."),
    Modalities = new List<ResponsesCreateRequestModality>
    {
        ResponsesCreateRequestModality.Text,
        ResponsesCreateRequestModality.Audio,
    },
    Audio = new Audio()
    {
        Voice = "alloy",
        Format = ResponsesCreateRequestFormat.Mp3,
    },
});

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

import base64

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "mp3"},
)

# 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.mp3", "wb") as f:
            f.write(audio_bytes)

# Gere áudio e extraia os dados base64, depois decodifique para um arquivo
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-pt",
    "input": "Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.",
    "modalities": ["text", "audio"],
    "audio": { "voice": "alloy", "format": "mp3" }
  }' | jq -r '.output[] | select(.type == "output_audio") | .data' | base64 -d > output.mp3

Idiomas compatíveis

A saída de áudio oferece suporte à detecção automática de idioma e a mais de 20 idiomas, incluindo inglês, chinês, hindi, espanhol, árabe, bengali, português, russo, japonês, punjabi, alemão, coreano, francês, turco, italiano, tailandês, polonês, holandês, indonésio, vietnamita e urdu.

Gerar imagens

Use a ferramenta image_generation para criar imagens a partir de prompts de texto. O modelo interpreta sua mensagem, gera um prompt para o modelo de imagem e retorna o resultado.

Modelos de geração de imagens

Modelo	Ideal para
`meetkai:flux-2-klein`	Geração rápida, uso geral (padrão)
`meetkai:z-image-turbo`	Imagens detalhadas e de alta qualidade

Opções de geração de imagens

Parâmetro	Opções	Padrão
`size`	`1024x1024`, `1024x1536`, `1536x1024`, `auto`	`auto`
`quality`	`standard`, `hd`	`standard`
`response_format`	`url`, `b64_json`	`url`
`background`	`transparent`, `opaque`, `auto`	`auto`

mka1 llm responses create --body '{
  "model": "meetkai:functionary-pt",
  "input": "Gere uma imagem de um pôr do sol sobre um lago nas montanhas.",
  "tools": [
    {
      "type": "image_generation",
      "model": "meetkai:functionary-pt",
      "quality": "hd",
      "size": "1024x1024",
      "response_format": "url"
    }
  ]
}'

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

const mka1 = new SDK({
  bearerAuth: `Bearer ${YOUR_API_KEY}`,
});

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Gere uma imagem de um pôr do sol sobre um lago nas montanhas.',
    tools: [
      {
        type: 'image_generation',
        model: 'meetkai:functionary-pt',
        quality: 'hd',
        size: '1024x1024',
        responseFormat: 'url',
      },
    ],
  },
}) 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('URL da imagem:', imageCall?.result);

import OpenAI from 'openai';

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.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Gere uma imagem de um pôr do sol sobre um lago nas montanhas.',
  tools: [{ type: 'image_generation' }],
  stream: false,
});

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

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr(
        "Gere uma imagem de um pôr do sol sobre um lago nas montanhas."),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateImageGenerationToolDefinition(
            new ImageGenerationToolDefinition()
            {
                Model = "meetkai:flux-2-klein",
                Quality = ImageGenerationToolDefinitionQuality.Hd,
                Size = ImageGenerationToolDefinitionSize.OneThousandAndTwentyFourx1024,
                ResponseFormat = ResponseFormat.Url,
            }
        ),
    },
});

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

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Gere uma imagem de um pôr do sol sobre um lago nas montanhas.",
    tools=[
        {
            "type": "image_generation",
            "model": "meetkai:functionary-pt",
            "quality": "hd",
            "size": "1024x1024",
            "response_format": "url",
        },
    ],
)

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

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-pt",
    "input": "Gere uma imagem de um pôr do sol sobre um lago nas montanhas.",
    "tools": [
      {
        "type": "image_generation",
        "model": "meetkai:functionary-pt",
        "quality": "hd",
        "size": "1024x1024",
        "response_format": "url"
      }
    ]
  }'

A resposta inclui um item image_generation_call com a URL da imagem gerada e o prompt revisado usado pelo modelo de imagem:

{
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "Vou gerar para você uma imagem de um belo pôr do sol sobre um lago nas montanhas."
        }
      ]
    },
    {
      "type": "image_generation_call",
      "id": "ig_abc123",
      "status": "completed",
      "result": "<URL da imagem gerada>",
      "revised_prompt": "Um pôr do sol deslumbrante sobre um lago montanhoso intocado, com tons dourados e alaranjados refletindo na superfície calma da água. Picos de montanhas cobertos de neve ao fundo, nuvens dramáticas no céu com cores vibrantes de pôr do sol em rosa, roxo e laranja.",
      "size": "auto",
      "quality": "auto",
      "output_format": "png"
    }
  ]
}

O campo result contém uma URL para a imagem gerada. O revised_prompt mostra o prompt expandido usado pelo modelo de imagem — o LLM aprimora sua breve instrução para uma descrição detalhada da imagem.

Forçar a geração de imagens

Use tool_choice para garantir que o modelo gere uma imagem em vez de responder apenas com texto.

mka1 llm responses create --body '{
  "model": "meetkai:functionary-pt",
  "input": "Um círculo vermelho sobre um fundo branco.",
  "tools": [{ "type": "image_generation" }],
  "tool_choice": { "type": "image_generation" }
}'

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: 'Um círculo vermelho sobre um fundo branco.',
    tools: [{ type: 'image_generation' }],
    toolChoice: { type: 'image_generation' },
  },
});

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: 'Um círculo vermelho sobre um fundo branco.',
  tools: [{ type: 'image_generation' }],
  tool_choice: { type: 'image_generation' },
  stream: false,
});

var result = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateStr("Um círculo vermelho sobre um fundo branco."),
    Tools = new List<ResponsesCreateRequestTool>
    {
        ResponsesCreateRequestTool.CreateImageGenerationToolDefinition(
            new ImageGenerationToolDefinition()
        ),
    },
    ToolChoice = ToolChoice.CreateHostedToolChoice(new HostedToolChoice()
    {
        Type = HostedToolChoiceType.ImageGeneration,
    }),
});

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input="Um círculo vermelho sobre um fundo branco.",
    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-pt",
    "input": "Um círculo vermelho sobre um fundo branco.",
    "tools": [{ "type": "image_generation" }],
    "tool_choice": { "type": "image_generation" }
  }'

Estrutura da saída de imagem

A matriz output da resposta contém estes itens quando uma imagem é gerada:

function_call — a chamada do modelo para a ferramenta de geração de imagens com o prompt refinado
image_generation_call — o resultado da geração com status: "completed" e result (URL da imagem)
function_call_output — a saída bruta da ferramenta contendo a URL
message — a resposta de texto do modelo descrevendo ou fazendo referência à imagem

As URLs das imagens expiram após 1 hora. Baixe-as ou armazene-as em cache se precisar de acesso de longo prazo.

APIs independentes

Para acesso direto sem passar pela API Responses, a MKA1 também fornece endpoints independentes:

API de texto para fala

O endpoint de texto para fala retorna áudio binário (audio/wav) e um cabeçalho de resposta X-Language-Code. Se você definir store: true, a resposta também incluirá um cabeçalho X-Tts-Id contendo o ID do registro de histórico armazenado.

mka1 llm speech speak \
  --text 'Olá, bem-vindo à plataforma MKA1.' \
  --language en \
  --output-file output.wav

const ttsAudio = await mka1.llm.speech.speak({
  textToSpeechRequest: {
    text: 'Olá, bem-vindo à plataforma MKA1.',
    language: 'en',
    model: 'meetkai:functionary-pt',
    store: false,
  },
});

// ttsAudio.result is a ReadableStream<Uint8Array> of WAV audio

var audio = await sdk.Llm.Speech.SpeakAsync(new TextToSpeechRequest()
{
    Text = "Olá, bem-vindo à plataforma MKA1.",
    Language = TextToSpeechRequestLanguage.En,
    Model = "meetkai:functionary-pt",
    Store = false,
});

// audio is binary audio (WAV)

audio = sdk.llm.speech.speak(
    text="Olá, bem-vindo à plataforma MKA1.",
    language="en",
    model="meetkai:functionary-pt",
    store=False,
)

# audio is binary audio (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": "Olá, bem-vindo à plataforma MKA1.",
    "language": "en"
  }' \
  --output output.wav

API de imagens

mka1 llm images create \
  --model meetkai:functionary-pt \
  --prompt 'Um horizonte de cidade futurista ao entardecer' \
  --quality hd

const imageResult = await mka1.llm.images.create({
  imageGenerationRequest: {
    model: 'meetkai:functionary-pt',
    prompt: 'Um horizonte de cidade futurista ao entardecer',
    quality: 'hd',
  },
});

// imageResult.data[0].url contains the generated image URL

var imageResult = await sdk.Llm.Images.CreateAsync(new ImageGenerationRequest()
{
    Model = "meetkai:z-image-turbo",
    Prompt = "Um horizonte de cidade futurista ao entardecer",
    Quality = ImageGenerationRequestQuality.Hd,
});

// imageResult.Data[0].Url contains the generated image URL

image_result = sdk.llm.images.create(
    model="meetkai:functionary-pt",
    prompt="Um horizonte de cidade futurista ao entardecer",
    quality="hd",
)

# image_result.data[0].url contains the generated image URL

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": "meetkai:functionary-pt",
    "prompt": "Um horizonte de cidade futurista ao entardecer",
    "quality": "hd"
  }'

Próximas etapas

Entrada multimodal — envie imagens, áudio e documentos ao modelo
Fala — transcreva áudio e gere fala com os endpoints de fala independentes
Modo de voz avançado — conversas de voz em tempo real com LiveKit
Gerar uma resposta — solicitações de texto e trocas de múltiplos turnos

Primeiros passos

Respostas

Recursos

Computação

CLI

Receitas

Benchmarks

Infraestrutura

Saída multimodal

Tipos de saída compatíveis

Gerar áudio (texto para fala)

Configuração de áudio

Salvar áudio em um arquivo

Idiomas compatíveis

Gerar imagens

Modelos de geração de imagens

Opções de geração de imagens

Forçar a geração de imagens

Estrutura da saída de imagem

APIs independentes

API de texto para fala

API de imagens

Próximas etapas

​Tipos de saída compatíveis

​Gerar áudio (texto para fala)

​Configuração de áudio

​Salvar áudio em um arquivo

​Idiomas compatíveis

​Gerar imagens

​Modelos de geração de imagens

​Opções de geração de imagens

​Forçar a geração de imagens

​Estrutura da saída de imagem

​APIs independentes

​API de texto para fala

​API de imagens

​Próximas etapas

Tipos de saída compatíveis

Gerar áudio (texto para fala)

Configuração de áudio

Salvar áudio em um arquivo

Idiomas compatíveis

Gerar imagens

Modelos de geração de imagens

Opções de geração de imagens

Forçar a geração de imagens

Estrutura da saída de imagem

APIs independentes

API de texto para fala

API de imagens

Próximas etapas