Entrada multimodal

A API Responses aceita texto, imagens, áudio e arquivos em uma única solicitação. Use input estruturado com arrays de conteúdo para combinar modalidades.

Tipos de entrada compatíveis

Tipo	Tipo de conteúdo	Formatos	Entrega
Texto	`input_text`	Texto simples	Embutido
Imagem	`input_image`	JPEG, PNG, WebP, GIF, TIFF	URL, URI de dados base64 ou `file_id`
Áudio	`input_audio`	WAV, MP3	Base64
Documento	`input_file`	PDF, DOCX, XLSX, PPTX, RTF, TXT, CSV	URL, URI de dados base64 ou `file_id`
Vídeo	`input_file`	MP4	URI de dados base64 ou `file_id`

Entrada de imagem

Envie uma imagem para o modelo descrever, analisar ou responder a perguntas sobre ela. Forneça a imagem como uma URL, uma URI de dados base64 ou um file_id enviado anteriormente.

Imagem por URL

mka1 llm responses create \
  -H 'X-On-Behalf-Of: <end-user-id>' \
  --body '{
    "model": "meetkai:functionary-pt",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Descreva o que você vê nesta imagem." },
          {
            "type": "input_image",
            "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
          }
        ]
      }
    ]
  }'

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>', // opcional — atribua a solicitação a um dos seus usuários finais
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Descreva o que você vê nesta imagem.' },
          {
            type: 'input_image',
            imageUrl: 'https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg',
          },
        ],
      },
    ],
  },
});

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: [
    {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: 'Descreva o que você vê nesta imagem.' },
        {
          type: 'input_image',
          image_url: 'https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg',
        },
      ],
    },
  ],
  stream: false,
});

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

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

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputText(new InputText()
                    {
                        Text = "Descreva o que você vê nesta imagem.",
                    }),
                    InputMessageContent.CreateInputImage(new InputImage()
                    {
                        ImageUrl = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
                    }),
                }),
        }),
    }),
});

from meetkai_mka1 import SDK

sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Descreva o que você vê nesta imagem."},
            {
                "type": "input_image",
                "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
            },
        ],
    }],
)

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": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Descreva o que você vê nesta imagem." },
          {
            "type": "input_image",
            "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
          }
        ]
      }
    ]
  }'

Imagem por base64

Codifique a imagem como uma URI de dados com o tipo MIME apropriado.

IMAGE_B64=$(base64 -i photo.jpg)

mka1 llm responses create \
  --body "{
    \"model\": \"meetkai:functionary-pt\",
    \"input\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          { \"type\": \"input_text\", \"text\": \"O que há nesta foto?\" },
          {
            \"type\": \"input_image\",
            \"image_url\": \"data:image/jpeg;base64,${IMAGE_B64}\"
          }
        ]
      }
    ]
  }"

import { readFileSync } from 'fs';

const imageBase64 = readFileSync('photo.jpg').toString('base64');

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'O que há nesta foto?' },
          {
            type: 'input_image',
            imageUrl: `data:image/jpeg;base64,${imageBase64}`,
          },
        ],
      },
    ],
  },
});

import { readFileSync } from 'fs';

const imageBase64 = readFileSync('photo.jpg').toString('base64');

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: 'O que há nesta foto?' },
        {
          type: 'input_image',
          image_url: `data:image/jpeg;base64,${imageBase64}`,
        },
      ],
    },
  ],
  stream: false,
});

var imageBytes = System.IO.File.ReadAllBytes("photo.jpg");
var imageBase64 = Convert.ToBase64String(imageBytes);

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputText(new InputText()
                    {
                        Text = "O que há nesta foto?",
                    }),
                    InputMessageContent.CreateInputImage(new InputImage()
                    {
                        ImageUrl = $"data:image/jpeg;base64,{imageBase64}",
                    }),
                }),
        }),
    }),
});

import base64

with open("photo.jpg", "rb") as f:
    image_base64 = base64.b64encode(f.read()).decode()

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {"type": "input_text", "text": "O que há nesta foto?"},
            {
                "type": "input_image",
                "image_url": f"data:image/jpeg;base64,{image_base64}",
            },
        ],
    }],
)

# Codifique uma imagem local e envie-a embutida
IMAGE_B64=$(base64 -i photo.jpg)

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\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          { \"type\": \"input_text\", \"text\": \"O que há nesta foto?\" },
          {
            \"type\": \"input_image\",
            \"image_url\": \"data:image/jpeg;base64,${IMAGE_B64}\"
          }
        ]
      }
    ]
  }"

Imagem por file_id

Primeiro, envie uma imagem com a API Files e, em seguida, faça referência a ela pelo ID.

# Envie a imagem
FILE_ID=$(mka1 llm files upload \
  --file @photo.jpg \
  --purpose assistants | jq -r '.id')

# Use o file_id
mka1 llm responses create \
  --body "{
    \"model\": \"meetkai:functionary-pt\",
    \"input\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          { \"type\": \"input_text\", \"text\": \"Descreva esta imagem.\" },
          { \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
        ]
      }
    ]
  }"

import { readFileSync } from 'fs';

const imageBuffer = readFileSync('photo.jpg');

// Envie a imagem
const uploadResult = await mka1.llm.files.upload({
  requestBody: {
    file: { fileName: 'photo.jpg', content: imageBuffer },
    purpose: 'assistants',
  },
});

// Use o file_id em uma resposta
const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Descreva esta imagem.' },
          { type: 'input_image', fileId: uploadResult.id },
        ],
      },
    ],
  },
});

import { readFileSync } from 'fs';

const imageBuffer = readFileSync('photo.jpg');

// Envie a imagem
const file = await openai.files.create({
  file: new File([imageBuffer], 'photo.jpg', { type: 'image/jpeg' }),
  purpose: 'assistants',
});

// Use o file_id em uma resposta
const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: 'Descreva esta imagem.' },
        { type: 'input_image', file_id: file.id },
      ],
    },
  ],
  stream: false,
});

using MeetKai.MKA1.Types.Requests;

// Envie a imagem
var uploadResult = await sdk.Llm.Files.UploadAsync(new UploadFileRequestBody()
{
    File = new UploadFileFile()
    {
        FileName = "photo.png",
        Content = System.IO.File.ReadAllBytes("photo.png"),
    },
    Purpose = UploadFilePurpose.Assistants,
});

// Use o file_id em uma resposta
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputText(new InputText()
                    {
                        Text = "Descreva esta imagem.",
                    }),
                    InputMessageContent.CreateInputImage(new InputImage()
                    {
                        FileId = uploadResult.File!.Id,
                    }),
                }),
        }),
    }),
});

# Envie a imagem
upload_result = sdk.llm.files.upload(
    file={"file_name": "photo.jpg", "content": open("photo.jpg", "rb")},
    purpose="assistants",
)

# Use o file_id em uma resposta
result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Descreva esta imagem."},
            {"type": "input_image", "file_id": upload_result.id},
        ],
    }],
)

# Envie a imagem
FILE_ID=$(curl -s https://apigw.mka1.com/api/v1/llm/files \
  --header 'Authorization: Bearer <mka1-api-key>' \
  --form file=@photo.jpg \
  --form purpose=assistants | jq -r '.id')

# Use o file_id
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\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          { \"type\": \"input_text\", \"text\": \"Descreva esta imagem.\" },
          { \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
        ]
      }
    ]
  }"

Entrada de áudio

Envie áudio para o modelo processar. O áudio é transcrito automaticamente, e o modelo responde ao conteúdo falado. Formatos compatíveis: WAV e MP3 (máximo de 25 MB).

AUDIO_B64=$(base64 -i recording.wav)

mka1 llm responses create \
  --body "{
    \"model\": \"meetkai:functionary-pt\",
    \"input\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          {
            \"type\": \"input_audio\",
            \"input_audio\": {
              \"data\": \"${AUDIO_B64}\",
              \"format\": \"wav\"
            }
          }
        ]
      }
    ]
  }"

import { readFileSync } from 'fs';

const audioBase64 = readFileSync('recording.wav').toString('base64');

const result = await mka1.llm.responses.create({
  xOnBehalfOf: '<end-user-id>',
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          {
            type: 'input_audio',
            inputAudio: {
              data: audioBase64,
              format: 'wav',
            },
          },
        ],
      },
    ],
  },
});

import { readFileSync } from 'fs';

const audioBase64 = readFileSync('recording.wav').toString('base64');

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    {
      type: 'message',
      role: 'user',
      content: [
        {
          type: 'input_audio',
          input_audio: {
            data: audioBase64,
            format: 'wav',
          },
        },
      ],
    },
  ],
  stream: false,
});

var audioBytes = System.IO.File.ReadAllBytes("recording.wav");
var audioBase64 = Convert.ToBase64String(audioBytes);

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputAudio(new InputAudio()
                    {
                        InputAudioValue = new InputAudioInputAudio()
                        {
                            Data = audioBase64,
                            Format = InputAudioFormat.Wav,
                        },
                    }),
                }),
        }),
    }),
});

import base64

with open("recording.wav", "rb") as f:
    audio_base64 = base64.b64encode(f.read()).decode()

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {
                "type": "input_audio",
                "input_audio": {
                    "data": audio_base64,
                    "format": "wav",
                },
            },
        ],
    }],
)

AUDIO_B64=$(base64 -i recording.wav)

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\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          {
            \"type\": \"input_audio\",
            \"input_audio\": {
              \"data\": \"${AUDIO_B64}\",
              \"format\": \"wav\"
            }
          }
        ]
      }
    ]
  }"

O modelo transcreve automaticamente o áudio e responde ao conteúdo falado. Por exemplo, enviar um arquivo WAV contendo “Olá, como você está hoje?” retorna:

{
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "Olá! Estou bem, obrigado por perguntar. Estou aqui e pronto para ajudar você com quaisquer dúvidas ou tarefas que possa ter. Como posso ajudar você hoje?"
        }
      ]
    }
  ]
}

Entrada de documento

Envie documentos para o modelo ler e raciocinar sobre eles. PDFs e documentos digitalizados são processados automaticamente com OCR — nenhuma configuração extra é necessária.

Documento por URL

mka1 llm responses create \
  --body '{
    "model": "meetkai:functionary-pt",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Resuma este documento em três tópicos." },
          {
            "type": "input_file",
            "file_url": "https://example.com/report.pdf",
            "filename": "report.pdf"
          }
        ]
      }
    ]
  }'

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Resuma este documento em três tópicos.' },
          {
            type: 'input_file',
            fileUrl: 'https://example.com/report.pdf',
            filename: 'report.pdf',
          },
        ],
      },
    ],
  },
});

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: 'Resuma este documento em três tópicos.' },
        {
          type: 'input_file',
          file_url: 'https://example.com/report.pdf',
          filename: 'report.pdf',
        },
      ],
    },
  ],
  stream: false,
});

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputText(new InputText()
                    {
                        Text = "Resuma este documento em três tópicos.",
                    }),
                    InputMessageContent.CreateInputFile(new InputFile()
                    {
                        FileUrl = "https://example.com/report.pdf",
                        Filename = "report.pdf",
                    }),
                }),
        }),
    }),
});

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Resuma este documento em três tópicos."},
            {
                "type": "input_file",
                "file_url": "https://example.com/report.pdf",
                "filename": "report.pdf",
            },
        ],
    }],
)

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": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Resuma este documento em três tópicos." },
          {
            "type": "input_file",
            "file_url": "https://example.com/report.pdf",
            "filename": "report.pdf"
          }
        ]
      }
    ]
  }'

Documento por base64

Codifique o arquivo como uma URI de dados. Inclua o tipo MIME para que a API possa encaminhá-lo ao processador correto.

PDF_B64=$(base64 -i contract.pdf)

mka1 llm responses create \
  --body "{
    \"model\": \"meetkai:functionary-pt\",
    \"input\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          { \"type\": \"input_text\", \"text\": \"Quais são os principais termos deste contrato?\" },
          {
            \"type\": \"input_file\",
            \"file_data\": \"data:application/pdf;base64,${PDF_B64}\",
            \"filename\": \"contract.pdf\"
          }
        ]
      }
    ]
  }"

import { readFileSync } from 'fs';

const pdfBase64 = readFileSync('contract.pdf').toString('base64');

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Quais são os principais termos deste contrato?' },
          {
            type: 'input_file',
            fileData: `data:application/pdf;base64,${pdfBase64}`,
            filename: 'contract.pdf',
          },
        ],
      },
    ],
  },
});

import { readFileSync } from 'fs';

const pdfBase64 = readFileSync('contract.pdf').toString('base64');

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: 'Quais são os principais termos deste contrato?' },
        {
          type: 'input_file',
          file_data: `data:application/pdf;base64,${pdfBase64}`,
          filename: 'contract.pdf',
        },
      ],
    },
  ],
  stream: false,
});

var pdfBytes = System.IO.File.ReadAllBytes("contract.pdf");
var pdfBase64 = Convert.ToBase64String(pdfBytes);

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputText(new InputText()
                    {
                        Text = "Quais são os principais termos deste contrato?",
                    }),
                    InputMessageContent.CreateInputFile(new InputFile()
                    {
                        FileData = $"data:application/pdf;base64,{pdfBase64}",
                        Filename = "contract.pdf",
                    }),
                }),
        }),
    }),
});

import base64

with open("contract.pdf", "rb") as f:
    pdf_base64 = base64.b64encode(f.read()).decode()

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Quais são os principais termos deste contrato?"},
            {
                "type": "input_file",
                "file_data": f"data:application/pdf;base64,{pdf_base64}",
                "filename": "contract.pdf",
            },
        ],
    }],
)

PDF_B64=$(base64 -i contract.pdf)

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\": [
      {
        \"type\": \"message\",
        \"role\": \"user\",
        \"content\": [
          { \"type\": \"input_text\", \"text\": \"Quais são os principais termos deste contrato?\" },
          {
            \"type\": \"input_file\",
            \"file_data\": \"data:application/pdf;base64,${PDF_B64}\",
            \"filename\": \"contract.pdf\"
          }
        ]
      }
    ]
  }"

Documentos digitalizados e OCR

PDFs digitalizados e imagens de documentos são processados automaticamente. A API usa OCR para extrair texto de:

Páginas de PDF digitalizadas (convertidas em imagens a 150 DPI e, em seguida, processadas por OCR)
Fotos de documentos (JPEG, PNG, TIFF)
Arquivos do Office (DOCX, XLSX, PPTX — primeiro convertidos em PDF e, em seguida, processados por OCR)

Documentos com várias páginas são processados em paralelo. O texto extraído é retornado como Markdown e passado ao modelo para raciocínio. Não são necessários parâmetros especiais — basta enviar o arquivo como input_file, e o pipeline lida com a detecção, a conversão e o OCR.

Formatos de documento compatíveis

Formato	Tipo MIME	Processamento
PDF	`application/pdf`	OCR por página a 150 DPI
JPEG / PNG / TIFF / WebP / GIF	`image/*`	OCR direto
Word (.doc, .docx)	`application/msword`, `application/vnd.openxmlformats-officedocument.wordprocessingml.document`	Converter para PDF e, em seguida, OCR
Excel (.xls, .xlsx)	`application/vnd.ms-excel`, `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`	Converter para PDF e, em seguida, OCR
PowerPoint (.ppt, .pptx)	`application/vnd.ms-powerpoint`, `application/vnd.openxmlformats-officedocument.presentationml.presentation`	Converter para PDF e, em seguida, OCR
RTF	`application/rtf`	Converter para PDF e, em seguida, OCR
Texto simples / CSV	`text/plain`, `text/csv`	Ler diretamente

Limite de tamanho: 30 MB por arquivo.

Entrada mista

Combine vários tipos de conteúdo em uma única mensagem. O modelo vê todas as entradas em conjunto e pode raciocinar entre elas.

mka1 llm responses create \
  --body '{
    "model": "meetkai:functionary-pt",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Compare o gráfico na imagem com os dados na planilha. Os números são consistentes?" },
          {
            "type": "input_image",
            "image_url": "https://example.com/chart.png"
          },
          {
            "type": "input_file",
            "file_url": "https://example.com/data.xlsx",
            "filename": "data.xlsx"
          }
        ]
      }
    ]
  }'

const result = await mka1.llm.responses.create({
  responsesCreateRequest: {
    model: 'meetkai:functionary-pt',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Compare o gráfico na imagem com os dados na planilha. Os números são consistentes?' },
          {
            type: 'input_image',
            imageUrl: 'https://example.com/chart.png',
          },
          {
            type: 'input_file',
            fileUrl: 'https://example.com/data.xlsx',
            filename: 'data.xlsx',
          },
        ],
      },
    ],
  },
});

const response = await openai.responses.create({
  model: 'meetkai:functionary-pt',
  input: [
    {
      type: 'message',
      role: 'user',
      content: [
        { type: 'input_text', text: 'Compare o gráfico na imagem com os dados na planilha. Os números são consistentes?' },
        {
          type: 'input_image',
          image_url: 'https://example.com/chart.png',
        },
        {
          type: 'input_file',
          file_url: 'https://example.com/data.xlsx',
          filename: 'data.xlsx',
        },
      ],
    },
  ],
  stream: false,
});

var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
    Model = "meetkai:functionary-pt",
    Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
    {
        Item.CreateInputMessage(new InputMessage()
        {
            Role = InputMessageRole.User,
            Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                new List<InputMessageContent>
                {
                    InputMessageContent.CreateInputText(new InputText()
                    {
                        Text = "Compare o gráfico na imagem com os dados na planilha. Os números são consistentes?",
                    }),
                    InputMessageContent.CreateInputImage(new InputImage()
                    {
                        ImageUrl = "https://example.com/chart.png",
                    }),
                    InputMessageContent.CreateInputFile(new InputFile()
                    {
                        FileUrl = "https://example.com/data.xlsx",
                        Filename = "data.xlsx",
                    }),
                }),
        }),
    }),
});

result = sdk.llm.responses.create(
    model="meetkai:functionary-pt",
    input=[{
        "type": "message",
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Compare o gráfico na imagem com os dados na planilha. Os números são consistentes?"},
            {
                "type": "input_image",
                "image_url": "https://example.com/chart.png",
            },
            {
                "type": "input_file",
                "file_url": "https://example.com/data.xlsx",
                "filename": "data.xlsx",
            },
        ],
    }],
)

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": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Compare o gráfico na imagem com os dados na planilha. Os números são consistentes?" },
          {
            "type": "input_image",
            "image_url": "https://example.com/chart.png"
          },
          {
            "type": "input_file",
            "file_url": "https://example.com/data.xlsx",
            "filename": "data.xlsx"
          }
        ]
      }
    ]
  }'

Próximas etapas

Saída multimodal — gere áudio e imagens nas respostas
Arquivos e armazenamentos vetoriais — envie e gerencie arquivos para reutilização
Gerar uma resposta — solicitações somente de texto e trocas com vários turnos
Modo de voz avançado — conversas de voz em tempo real com o LiveKit

Primeiros passos

Respostas

Recursos

Computação

CLI

Receitas

Benchmarks

Infraestrutura

Entrada multimodal

Tipos de entrada compatíveis

Entrada de imagem

Imagem por URL

Imagem por base64

Imagem por file_id

Entrada de áudio

Entrada de documento

Documento por URL

Documento por base64

Documentos digitalizados e OCR

Formatos de documento compatíveis

Entrada mista

Próximas etapas

​Tipos de entrada compatíveis

​Entrada de imagem

​Imagem por URL

​Imagem por base64

​Imagem por file_id

​Entrada de áudio

​Entrada de documento

​Documento por URL

​Documento por base64

​Documentos digitalizados e OCR

​Formatos de documento compatíveis

​Entrada mista

​Próximas etapas

Tipos de entrada compatíveis

Entrada de imagem

Imagem por URL

Imagem por base64

Imagem por file_id

Entrada de áudio

Entrada de documento

Documento por URL

Documento por base64

Documentos digitalizados e OCR

Formatos de documento compatíveis

Entrada mista

Próximas etapas