> ## 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.
# Entrada multimodal
> Envie imagens, áudios, documentos e conteúdo misto para a API MKA1 para visão, transcrição, OCR e raciocínio multimodal.
A API de Respostas aceita texto, imagens, áudio e arquivos em uma única solicitação.
Use o campo estruturado `input` com arrays de conteúdo para combinar modalidades.
## Tipos de entrada suportados
| Tipo | Tipo de conteúdo | Formatos | Entrega |
| --------- | ---------------- | ------------------------------------ | --------------------------------- |
| Texto | `input_text` | Texto simples | Inline |
| Imagem | `input_image` | JPEG, PNG, WebP, GIF, TIFF | URL, data URI base64 ou `file_id` |
| Áudio | `input_audio` | WAV, MP3 | Base64 |
| Documento | `input_file` | PDF, DOCX, XLSX, PPTX, RTF, TXT, CSV | URL, data URI base64 ou `file_id` |
| Vídeo | `input_file` | MP4 | Data URI base64 ou `file_id` |
## Entrada de imagem
Envie uma imagem para o modelo descrever, analisar ou responder perguntas sobre ela.
Forneça a imagem como uma URL, um data URI base64 ou um `file_id` previamente enviado.
### Imagem via URL
```bash CLI theme={null}
mka1 llm responses create \
-H 'X-On-Behalf-Of: ' \
--body '{
"model": "meetkai:functionary-pt",
"input": [
{
"type": "message",
"role": "user",
"content": [
{ "type": "input_text", "text": "Describe what you see in this image." },
{
"type": "input_image",
"image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
}
]
}
]
}'
```
```ts MKA1 SDK theme={null}
import { SDK } from '@meetkai/mka1';
const mka1 = new SDK({
bearerAuth: `Bearer ${YOUR_API_KEY}`,
});
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Describe what you see in this image.' },
{
type: 'input_image',
image_url: 'https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg',
},
],
},
],
}, { headers: { 'X-On-Behalf-Of': '' } });
```
```ts OpenAI SDK theme={null}
import OpenAI from 'openai';
const openai = new OpenAI({
apiKey: '',
baseURL: 'https://apigw.mka1.com/api/v1/llm/',
defaultHeaders: { 'X-On-Behalf-Of': '' },
});
const response = await openai.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Describe what you see in this image.' },
{
type: 'input_image',
image_url: 'https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg',
},
],
},
],
stream: false,
});
```
```csharp C# SDK theme={null}
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.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputText(new InputText()
{
Text = "Describe what you see in this image.",
}),
InputMessageContent.CreateInputImage(new InputImage()
{
ImageUrl = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
from 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": "Describe what you see in this image."},
{
"type": "input_image",
"image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
},
],
}],
)
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses \
--request POST \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: ' \
--data '{
"model": "meetkai:functionary-pt",
"input": [
{
"type": "message",
"role": "user",
"content": [
{ "type": "input_text", "text": "Describe what you see in this image." },
{
"type": "input_image",
"image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
}
]
}
]
}'
```
### Imagem via base64
Codifique a imagem como um data URI com o tipo MIME apropriado.
```bash CLI theme={null}
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\": \"What is in this photo?\" },
{
\"type\": \"input_image\",
\"image_url\": \"data:image/jpeg;base64,${IMAGE_B64}\"
}
]
}
]
}"
```
```ts MKA1 SDK theme={null}
import { readFileSync } from 'fs';
const imageBase64 = readFileSync('photo.jpg').toString('base64');
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'What is in this photo?' },
{
type: 'input_image',
image_url: `data:image/jpeg;base64,${imageBase64}`,
},
],
},
],
});
```
```ts OpenAI SDK theme={null}
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: 'What is in this photo?' },
{
type: 'input_image',
image_url: `data:image/jpeg;base64,${imageBase64}`,
},
],
},
],
stream: false,
});
```
```csharp C# SDK theme={null}
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.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputText(new InputText()
{
Text = "What is in this photo?",
}),
InputMessageContent.CreateInputImage(new InputImage()
{
ImageUrl = $"data:image/jpeg;base64,{imageBase64}",
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
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": "What is in this photo?"},
{
"type": "input_image",
"image_url": f"data:image/jpeg;base64,{image_base64}",
},
],
}],
)
```
```bash bash theme={null}
# Codifique uma imagem local e envie inline
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 ' \
--data "{
\"model\": \"meetkai:functionary-pt\",
\"input\": [
{
\"type\": \"message\",
\"role\": \"user\",
\"content\": [
{ \"type\": \"input_text\", \"text\": \"What is in this photo?\" },
{
\"type\": \"input_image\",
\"image_url\": \"data:image/jpeg;base64,${IMAGE_B64}\",
}
]
}
]
}"
```
### Imagem via file\_id
Envie uma imagem primeiro com a API de Arquivos e depois referencie pelo ID.
```bash CLI theme={null}
# 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\": \"Describe this image.\" },
{ \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
]
}
]
}"
```
```ts MKA1 SDK theme={null}
// Envie a imagem
const uploadResult = await mka1.llm.files.create({
file: { fileName: 'photo.jpg', content: imageBuffer },
purpose: 'assistants',
});
// Use o file_id em uma resposta
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Describe this image.' },
{ type: 'input_image', file_id: uploadResult.id },
],
},
],
});
```
```ts OpenAI SDK theme={null}
// 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: 'Describe this image.' },
{ type: 'input_image', file_id: file.id },
],
},
],
stream: false,
});
```
```csharp C# SDK theme={null}
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.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputText(new InputText()
{
Text = "Describe this image.",
}),
InputMessageContent.CreateInputImage(new InputImage()
{
FileId = uploadResult.File!.Id,
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
# 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": "Describe this image."},
{"type": "input_image", "file_id": upload_result.id},
],
}],
)
```
```bash bash theme={null}
# Envie a imagem
FILE_ID=$(curl -s https://apigw.mka1.com/api/v1/llm/files \
--header 'Authorization: Bearer ' \
--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 ' \
--data "{
\"model\": \"meetkai:functionary-pt\",
\"input\": [
{
\"type\": \"message\",
\"role\": \"user\",
\"content\": [
{ \"type\": \"input_text\", \"text\": \"Describe this image.\" },
{ \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
]
}
]
}"
```
## Entrada de áudio
Envie áudio para o modelo processar. O áudio é automaticamente transcrito e o modelo responde ao conteúdo falado.
Formatos suportados: **WAV** e **MP3** (máx. 25 MB).
```bash CLI theme={null}
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\"
}
}
]
}
]
}"
```
```ts MKA1 SDK theme={null}
import { readFileSync } from 'fs';
const audioBase64 = readFileSync('recording.wav').toString('base64');
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{
type: 'input_audio',
input_audio: {
data: audioBase64,
format: 'wav',
},
},
],
},
],
}, { headers: { 'X-On-Behalf-Of': '' } });
```
```ts OpenAI SDK theme={null}
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,
});
```
```csharp C# SDK theme={null}
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.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputAudio(new InputAudio()
{
InputAudioValue = new InputAudioInputAudio()
{
Data = audioBase64,
Format = InputAudioFormat.Wav,
},
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
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",
},
},
],
}],
)
```
```bash bash theme={null}
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 ' \
--header 'X-On-Behalf-Of: ' \
--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, ao enviar um arquivo WAV contendo "Hello, how are you today?" retorna:
```json theme={null}
{
"status": "completed",
"output": [
{
"type": "message",
"role": "assistant",
"content": [
{
"type": "output_text",
"text": "Hello! I'm doing well, thank you for asking. I'm here and ready to help you with any questions or tasks you might have. How can I assist you today?"
}
]
}
]
}
```
## Entrada de documento
Envie documentos para o modelo ler e raciocinar sobre eles.
PDFs e documentos digitalizados são processados automaticamente com OCR — não é necessária configuração extra.
### Documento via URL
```bash CLI theme={null}
mka1 llm responses create \
--body '{
"model": "meetkai:functionary-pt",
"input": [
{
"type": "message",
"role": "user",
"content": [
{ "type": "input_text", "text": "Summarize this document in three bullet points." },
{
"type": "input_file",
"file_url": "https://example.com/report.pdf",
"filename": "report.pdf"
}
]
}
]
}'
```
```ts MKA1 SDK theme={null}
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Summarize this document in three bullet points.' },
{
type: 'input_file',
file_url: 'https://example.com/report.pdf',
filename: 'report.pdf',
},
],
},
],
});
```
```ts OpenAI SDK theme={null}
const response = await openai.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Summarize this document in three bullet points.' },
{
type: 'input_file',
file_url: 'https://example.com/report.pdf',
filename: 'report.pdf',
},
],
},
],
stream: false,
});
```
```csharp C# SDK theme={null}
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
Model = "meetkai:functionary-pt",
Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List-
{
Item.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputText(new InputText()
{
Text = "Summarize this document in three bullet points.",
}),
InputMessageContent.CreateInputFile(new InputFile()
{
FileUrl = "https://example.com/report.pdf",
Filename = "report.pdf",
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
result = sdk.llm.responses.create(
model="meetkai:functionary-pt",
input=[{
"type": "message",
"role": "user",
"content": [
{"type": "input_text", "text": "Summarize this document in three bullet points."},
{
"type": "input_file",
"file_url": "https://example.com/report.pdf",
"filename": "report.pdf",
},
],
}],
)
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses \
--request POST \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: ' \
--data '{
"model": "meetkai:functionary-pt",
"input": [
{
"type": "message",
"role": "user",
"content": [
{ "type": "input_text", "text": "Summarize this document in three bullet points." },
{
"type": "input_file",
"file_url": "https://example.com/report.pdf",
"filename": "report.pdf"
}
]
}
]
}'
```
### Documento via base64
Codifique o arquivo como um data URI. Inclua o tipo MIME para que a API possa encaminhar para o processador correto.
```bash CLI theme={null}
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\": \"What are the key terms in this contract?\" },
{
\"type\": \"input_file\",
\"file_data\": \"data:application/pdf;base64,${PDF_B64}\",
\"filename\": \"contract.pdf\"
}
]
}
]
}"
```
```ts MKA1 SDK theme={null}
import { readFileSync } from 'fs';
const pdfBase64 = readFileSync('contract.pdf').toString('base64');
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'What are the key terms in this contract?' },
{
type: 'input_file',
file_data: `data:application/pdf;base64,${pdfBase64}`,
filename: 'contract.pdf',
},
],
},
],
});
```
```ts OpenAI SDK theme={null}
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: 'What are the key terms in this contract?' },
{
type: 'input_file',
file_data: `data:application/pdf;base64,${pdfBase64}`,
filename: 'contract.pdf',
},
],
},
],
stream: false,
});
```
```csharp C# SDK theme={null}
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.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputText(new InputText()
{
Text = "What are the key terms in this contract?",
}),
InputMessageContent.CreateInputFile(new InputFile()
{
FileData = $"data:application/pdf;base64,{pdfBase64}",
Filename = "contract.pdf",
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
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": "What are the key terms in this contract?"},
{
"type": "input_file",
"file_data": f"data:application/pdf;base64,{pdf_base64}",
"filename": "contract.pdf",
},
],
}],
)
```
```bash bash theme={null}
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 ' \
--data "{
\"model\": \"meetkai:functionary-pt\",
\"input\": [
{
\"type\": \"message\",
\"role\": \"user\",
\"content\": [
{ \"type\": \"input_text\", \"text\": \"What are the key terms in this contract?\" },
{
\"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 utiliza OCR para extrair texto de:
* Páginas PDF digitalizadas (convertidas em imagens a 150 DPI, depois OCR)
* Fotos de documentos (JPEG, PNG, TIFF)
* Arquivos Office (DOCX, XLSX, PPTX — convertidos para PDF primeiro, depois OCR)
Documentos com várias páginas são processados em paralelo. O texto extraído é retornado como Markdown e enviado ao modelo para raciocínio.
Nenhum parâmetro especial é necessário — basta enviar o arquivo como `input_file` e o pipeline cuida da detecção, conversão e OCR.
### Formatos de documento suportados
| 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, depois OCR |
| Excel (.xls, .xlsx) | `application/vnd.ms-excel`, `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` | Converter para PDF, depois OCR |
| PowerPoint (.ppt, .pptx) | `application/vnd.ms-powerpoint`, `application/vnd.openxmlformats-officedocument.presentationml.presentation` | Converter para PDF, depois OCR |
| RTF | `application/rtf` | Converter para PDF, depois OCR |
| Texto simples / CSV | `text/plain`, `text/csv` | Lido diretamente |
**Limite de tamanho:** 30 MB por arquivo.
## Entrada mista
Combine múltiplos tipos de conteúdo em uma única mensagem. O modelo vê todas as entradas juntas e pode raciocinar sobre elas.
```bash CLI theme={null}
mka1 llm responses create \
--body '{
"model": "meetkai:functionary-pt",
"input": [
{
"type": "message",
"role": "user",
"content": [
{ "type": "input_text", "text": "Compare the chart in the image with the data in the spreadsheet. Are the numbers consistent?" },
{
"type": "input_image",
"image_url": "https://example.com/chart.png"
},
{
"type": "input_file",
"file_url": "https://example.com/data.xlsx",
"filename": "data.xlsx"
}
]
}
]
}'
```
```ts MKA1 SDK theme={null}
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Compare the chart in the image with the data in the spreadsheet. Are the numbers consistent?' },
{
type: 'input_image',
image_url: 'https://example.com/chart.png',
},
{
type: 'input_file',
file_url: 'https://example.com/data.xlsx',
filename: 'data.xlsx',
},
],
},
],
});
```
```ts OpenAI SDK theme={null}
const response = await openai.responses.create({
model: 'meetkai:functionary-pt',
input: [
{
type: 'message',
role: 'user',
content: [
{ type: 'input_text', text: 'Compare the chart in the image with the data in the spreadsheet. Are the numbers consistent?' },
{
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,
});
```
```csharp C# SDK theme={null}
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
Model = "meetkai:functionary-pt",
Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List-
{
Item.CreateInputMessage(new InputMessage()
{
Role = InputMessageRole.User,
Content = InputMessageContent1.CreateArrayOfInputMessageContent(
new List
{
InputMessageContent.CreateInputText(new InputText()
{
Text = "Compare the chart in the image with the data in the spreadsheet. Are the numbers consistent?",
}),
InputMessageContent.CreateInputImage(new InputImage()
{
ImageUrl = "https://example.com/chart.png",
}),
InputMessageContent.CreateInputFile(new InputFile()
{
FileUrl = "https://example.com/data.xlsx",
Filename = "data.xlsx",
}),
}),
}),
}),
});
```
```python Python SDK theme={null}
result = sdk.llm.responses.create(
model="meetkai:functionary-pt",
input=[{
"type": "message",
"role": "user",
"content": [
{"type": "input_text", "text": "Compare the chart in the image with the data in the spreadsheet. Are the numbers consistent?"},
{
"type": "input_image",
"image_url": "https://example.com/chart.png",
},
{
"type": "input_file",
"file_url": "https://example.com/data.xlsx",
"filename": "data.xlsx",
},
],
}],
)
```
```bash bash theme={null}
curl https://apigw.mka1.com/api/v1/llm/responses \
--request POST \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ' \
--header 'X-On-Behalf-Of: ' \
--data '{
"model": "meetkai:functionary-pt",
"input": [
{
"type": "message",
"role": "user",
"content": [
{ "type": "input_text", "text": "Compare the chart in the image with the data in the spreadsheet. Are the numbers consistent?" },
{
"type": "input_image",
"image_url": "https://example.com/chart.png"
},
{
"type": "input_file",
"file_url": "https://example.com/data.xlsx",
"filename": "data.xlsx"
}
]
}
]
}'
```
## Próximos passos
* [Saída multimodal](/pt/docs/multimodal-output) — gere áudio e imagens nas respostas
* [Arquivos e vetores](/pt/docs/files-and-vector-stores) — envie e gerencie arquivos para reutilização
* [Gerar uma resposta](/pt/docs/generate-a-response) — solicitações apenas de texto e trocas multi-turno
* [Modo de voz avançado](/pt/docs/advanced-voice-mode) — conversas de voz em tempo real com LiveKit