> ## 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
> Envía imágenes, audio, documentos y contenido mixto a la API MKA1 para visión, transcripción, OCR y razonamiento multimodal.
La API de Respuestas acepta texto, imágenes, audio y archivos en una sola solicitud.
Utiliza `input` estructurado con arreglos de contenido para combinar modalidades.
## Tipos de entrada soportados
| Tipo | Tipo de contenido | Formatos | Entrega |
| --------- | ----------------- | ------------------------------------ | ------------------------------------ |
| Texto | `input_text` | Texto plano | En línea |
| Imagen | `input_image` | JPEG, PNG, WebP, GIF, TIFF | URL, URI de datos base64 o `file_id` |
| Audio | `input_audio` | WAV, MP3 | Base64 |
| Documento | `input_file` | PDF, DOCX, XLSX, PPTX, RTF, TXT, CSV | URL, URI de datos base64 o `file_id` |
| Video | `input_file` | MP4 | URI de datos base64 o `file_id` |
## Entrada de imagen
Envía una imagen para que el modelo la describa, analice o responda preguntas sobre ella.
Proporciona la imagen como una URL, una URI de datos base64 o un `file_id` previamente subido.
### Imagen vía URL
```bash CLI theme={null}
mka1 llm responses create \
-H 'X-On-Behalf-Of: ' \
--body '{
"model": "meetkai:functionary-es-mini",
"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-es-mini',
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-es-mini',
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-es-mini",
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-es-mini",
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-es-mini",
"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",
}
]
}
]
}'
```
### Imagen vía base64
Codifica la imagen como una URI de datos con el tipo MIME apropiado.
```bash CLI theme={null}
IMAGE_B64=$(base64 -i photo.jpg)
mka1 llm responses create \
--body "{
\"model\": \"meetkai:functionary-es-mini\",
\"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-es-mini',
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-es-mini',
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-es-mini",
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-es-mini",
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}
# Codifica una imagen local y envíala en línea
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-es-mini\",
\"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}\",
}
]
}
]
}"
```
### Imagen vía file\_id
Sube una imagen primero con la API de Archivos y luego haz referencia a ella por su ID.
```bash CLI theme={null}
# Sube la imagen
FILE_ID=$(mka1 llm files upload \
--file @photo.jpg \
--purpose assistants | jq -r '.id')
# Usa el file_id
mka1 llm responses create \
--body "{
\"model\": \"meetkai:functionary-es-mini\",
\"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}
// Sube la imagen
const uploadResult = await mka1.llm.files.create({
file: { fileName: 'photo.jpg', content: imageBuffer },
purpose: 'assistants',
});
// Usa el file_id en una respuesta
const result = await mka1.llm.responses.create({
model: 'meetkai:functionary-es-mini',
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}
// Sube la imagen
const file = await openai.files.create({
file: new File([imageBuffer], 'photo.jpg', { type: 'image/jpeg' }),
purpose: 'assistants',
});
// Usa el file_id en una respuesta
const response = await openai.responses.create({
model: 'meetkai:functionary-es-mini',
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;
// Sube la imagen
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,
});
// Usa el file_id en una respuesta
var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
{
Model = "meetkai:functionary-es-mini",
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}
# Sube la imagen
upload_result = sdk.llm.files.upload(
file={"file_name": "photo.jpg", "content": open("photo.jpg", "rb")},
purpose="assistants",
)
# Usa el file_id en una respuesta
result = sdk.llm.responses.create(
model="meetkai:functionary-es-mini",
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}
# Sube la imagen
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')
# Usa el 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-es-mini\",
\"input\": [
{
\"type\": \"message\",
\"role\": \"user\",
\"content\": [
{ \"type\": \"input_text\", \"text\": \"Describe this image.\" },
{ \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
]
}
]
}"
```
## Entrada de audio
Envía audio para que el modelo lo procese. El audio se transcribe automáticamente y el modelo responde al contenido hablado.
Formatos soportados: **WAV** y **MP3** (máx 25 MB).
```bash CLI theme={null}
AUDIO_B64=$(base64 -i recording.wav)
mka1 llm responses create \
--body "{
\"model\": \"meetkai:functionary-es-mini\",
\"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-es-mini',
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-es-mini',
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-es-mini",
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-es-mini",
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-es-mini\",
\"input\": [
{
\"type\": \"message\",
\"role\": \"user\",
\"content\": [
{
\"type\": \"input_audio\",
\"input_audio\": {
\"data\": \"${AUDIO_B64}\",
\"format\": \"wav\"
}
}
]
}
]
}"
```
El modelo transcribe automáticamente el audio y responde al contenido hablado. Por ejemplo, enviar un archivo WAV que contiene "Hello, how are you today?" devuelve:
```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
Envía documentos para que el modelo los lea y razone sobre ellos.
Los documentos PDF y escaneados se procesan automáticamente con OCR — no se necesita configuración adicional.
### Documento vía URL
```bash CLI theme={null}
mka1 llm responses create \
--body '{
"model": "meetkai:functionary-es-mini",
"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-es-mini',
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-es-mini',
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-es-mini",
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-es-mini",
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-es-mini",
"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 vía base64
Codifica el archivo como una URI de datos. Incluye el tipo MIME para que la API pueda enviarlo al procesador correcto.
```bash CLI theme={null}
PDF_B64=$(base64 -i contract.pdf)
mka1 llm responses create \
--body "{
\"model\": \"meetkai:functionary-es-mini\",
\"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-es-mini',
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-es-mini',
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-es-mini",
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-es-mini",
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-es-mini\",
\"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 escaneados y OCR
Los PDFs escaneados y las imágenes de documentos se procesan automáticamente. La API utiliza OCR para extraer texto de:
* Páginas PDF escaneadas (convertidas a imágenes a 150 DPI, luego OCR)
* Fotos de documentos (JPEG, PNG, TIFF)
* Archivos de Office (DOCX, XLSX, PPTX — convertidos a PDF primero, luego OCR)
Los documentos de varias páginas se procesan en paralelo. El texto extraído se devuelve como Markdown y se pasa al modelo para razonamiento.
No se necesitan parámetros especiales — solo envía el archivo como `input_file` y la canalización se encarga de la detección, conversión y OCR.
### Formatos de documento soportados
| Formato | Tipo MIME | Procesamiento |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------ | -------------------------- |
| PDF | `application/pdf` | OCR por página a 150 DPI |
| JPEG / PNG / TIFF / WebP / GIF | `image/*` | OCR directo |
| Word (.doc, .docx) | `application/msword`, `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | Convertir a PDF, luego OCR |
| Excel (.xls, .xlsx) | `application/vnd.ms-excel`, `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` | Convertir a PDF, luego OCR |
| PowerPoint (.ppt, .pptx) | `application/vnd.ms-powerpoint`, `application/vnd.openxmlformats-officedocument.presentationml.presentation` | Convertir a PDF, luego OCR |
| RTF | `application/rtf` | Convertir a PDF, luego OCR |
| Texto plano / CSV | `text/plain`, `text/csv` | Leer directamente |
**Límite de tamaño:** 30 MB por archivo.
## Entrada mixta
Combina múltiples tipos de contenido en un solo mensaje. El modelo ve todas las entradas juntas y puede razonar entre ellas.
```bash CLI theme={null}
mka1 llm responses create \
--body '{
"model": "meetkai:functionary-es-mini",
"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-es-mini',
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-es-mini',
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-es-mini",
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-es-mini",
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-es-mini",
"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 pasos
* [Salida multimodal](/es/docs/multimodal-output) — genera audio e imágenes en las respuestas
* [Archivos y almacenes vectoriales](/es/docs/files-and-vector-stores) — sube y gestiona archivos para reutilización
* [Generar una respuesta](/es/docs/generate-a-response) — solicitudes solo de texto e intercambios multi-turno
* [Modo de voz avanzado](/es/docs/advanced-voice-mode) — conversaciones de voz en tiempo real con LiveKit