Saída multimodal

A API MKA1 pode retornar texto, áudio e imagens. Texto é a modalidade de saída padrão. Use modalities 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"]. A resposta inclui o texto gerado e a gravação dele codificada em base64.

Configuração de áudio

A saída de áudio é sempre um arquivo WAV: 24 kHz, 16 bits, mono. A voz segue o idioma da resposta, que a API detecta a partir do texto (consulte Idiomas compatíveis). O objeto audio da solicitação (voice e format) é aceito, mas não tem efeito, por isso os exemplos o omitem.

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

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

const result = await sdk.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'],
  },
});

// 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-pt',
  input: 'Diga olá de forma amigável. Mantenha bem curto.',
  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-pt",
    input="Diga olá de forma amigável. Mantenha bem curto.",
    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-pt",
    Input = ResponsesCreateRequestInput.CreateStr("Diga olá de forma amigável. Mantenha bem curto."),
    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-pt",
    "input": "Diga olá de forma amigável. Mantenha bem curto.",
    "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-pt",
    "input": "Diga olá de forma amigável. Mantenha bem curto.",
    "modalities": ["text", "audio"]
  }'

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 WAV completo. O campo transcript contém o texto que foi falado, que é o texto de saída da resposta. Se a síntese de fala falhar, a resposta ainda é concluída, sem um item output_audio.

Salvar áudio em um arquivo

const result = await sdk.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'],
  },
}) 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-pt',
  input: 'Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.',
  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-pt",
    input="Leia esta frase em voz alta: A rápida raposa marrom pula sobre o cachorro preguiçoso.",
    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-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,
    },
});

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

# 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"]
  }' \
  --output-format json \
  --jq '.output[] | select(.type == "output_audio") | .data' | base64 -d > output.wav

# 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"]
  }' | jq -r '.output[] | select(.type == "output_audio") | .data' | base64 -d > output.wav

Idiomas compatíveis

A saída de áudio usa os idiomas listados em Idiomas de texto para fala. Uma resposta em qualquer outro idioma é falada com a voz em inglês. Para escolher o idioma você mesmo ou obter MP3 em vez de WAV, envie o texto da resposta para o endpoint de texto para fala.

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`

const result = await sdk.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: 'high',
        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);

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);

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)

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.High,
                Size = ImageGenerationToolDefinitionSize.OneThousandAndTwentyFourx1024,
            }
        ),
    },
});

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

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"
    }
  ]
}'

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.

const result = await sdk.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,
});

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"},
)

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,
    }),
});

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" }
}'

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.

const ttsAudio = await sdk.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

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

# audio is binary audio (WAV)

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

// audio is binary audio (WAV)

mka1 llm speech speak \
  --text 'Olá, bem-vindo à plataforma MKA1.' \
  --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": "Olá, bem-vindo à plataforma MKA1.",
    "language": "en"
  }' \
  --output output.wav

API de imagens

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

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

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

mka1 llm images create \
  --model meetkai:functionary-pt \
  --prompt 'Um horizonte de cidade futurista ao entardecer' \
  --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": "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

SDKs e CLI

Respostas

APIs independentes

Agentes

Avaliações

Computação

Produção

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