Guía completa para desarrolladores sobre cómo usar la API MiMo-V2.5

TL;DR

API MiMo-V2.5 en CometAPI proporciona acceso al modelo de mezcla dispersa de expertos de Xiaomi para programación, comprensión multimodal y cargas de trabajo con agentes. La API MiMo-V2.5 es la opción práctica por defecto cuando un proyecto necesita una ventana de contexto de 1 millón de tokens, entrada multimodal nativa y bajo costo por token; MiMo-V2.5 Pro es más adecuada cuando la programación difícil, el razonamiento o el uso de herramientas de largo horizonte importan más que el precio. Esta guía muestra cómo llamar a la API a través de CometAPI, transmitir respuestas, estructurar solicitudes multimodales, estimar costos y reforzar una integración de producción.

Puntos clave

• El modelo MiMo-V2.5 usa 310B parámetros totales con 15B parámetros activos por token y admite una ventana de contexto de 1M de tokens.
• Usa la ruta MiMo-V2.5 para trabajo multimodal, análisis de gran contexto y agentes sensibles al costo; elige MiMo-V2.5 Pro para las tareas más difíciles de programación y razonamiento.
• El endpoint compatible con OpenAI facilita la migración, pero los sistemas de producción aún necesitan tiempos de espera, lógica de reintentos, presupuestos de tokens y comprobaciones de capacidades del proveedor.
• A las tarifas indicadas de CometAPI, una solicitud con 10,000 tokens de entrada y 2,000 de salida cuesta aproximadamente $0.001568 en la ruta MiMo-V2.5.

Panorama del modelo MiMo-V2.5

Xiaomi presentó el modelo el 22 de abril de 2026. API MiMo-V2.5 en CometAPI lo expone mediante una interfaz de chat-completions compatible con OpenAI, por lo que los clientes existentes normalmente pueden migrar cambiando la URL base, la clave de API y el identificador del modelo.

Según la tarjeta de modelo oficial, el modelo combina una columna vertebral lingüística MoE dispersa con codificadores dedicados de visión y audio. Acepta entradas de texto, imagen, video y audio mientras produce salida de texto. Su amplia ventana de contexto es útil para revisión de código a escala de repositorios, conjuntos de documentos, transcripciones largas y agentes multi-paso.

La imagen oficial de benchmark multimodal a continuación reporta resultados en tareas de comprensión de imágenes, agentes multimodales y comprensión de video.

Comparación oficial de benchmark multimodal de Xiaomi MiMo-V2.5

Las rutas del proveedor pueden exponer un conjunto más estrecho de formatos de medios que los que admite el modelo subyacente. Valida el formato exacto de la carga útil de imagen, audio y video contra el endpoint activo antes de lanzar una función multimodal.

Rendimiento de MiMo-V2.5 en benchmarks

Xiaomi reporta resultados sólidos en programación, uso de terminal y evaluación de agentes multimodales. Estas cifras son útiles para posicionar el modelo, pero no sustituyen las pruebas con tus propios prompts, herramientas, objetivos de latencia y condiciones de fallo.

La comparación oficial de programación muestra 65.8 en Terminal-Bench 2.0 y 56.1 en SWE-Bench Pro, ubicando además el modelo en una comparación más amplia de agentes de programación.

Comparación oficial de benchmark de programación de Xiaomi MiMo-V2.5

Qué sugieren los resultados: el modelo es especialmente atractivo para aplicaciones que combinan código, herramientas y medios mixtos. Para decisiones de producción deterministas, ejecuta una evaluación interna que mida el éxito de las tareas, el uso de tokens, la latencia de extremo a extremo, la frecuencia de reintentos y la tasa de corrección humana.

MiMo-V2.5 vs MiMo-V2.5 Pro: una comparación multidimensional

Resultado de la comparación: comienza con la ruta MiMo-V2.5 cuando el costo, el rendimiento o la cobertura multimodal guían la decisión. Mueve solicitudes seleccionadas a MiMo-V2.5 Pro cuando las evaluaciones internas muestren una ganancia significativa en precisión en casos difíciles de programación, razonamiento o uso de herramientas. Un enrutador por niveles suele ofrecer un mejor equilibrio costo-calidad que enviar todas las solicitudes a MiMo-V2.5 Pro.

Cómo llamar a la API de MiMo-V2.5

La API sigue el conocido esquema de chat-completions. Mantén la clave en tu servidor, cárgala desde una variable de entorno y nunca la incluyas en código de navegador o móvil.

Configurar la clave de API

export COMETAPI_KEY="your_api_key_here"

$env:COMETAPI_KEY = "your_api_key_here"

### Enviar una solicitud cURL

curl https://api.cometapi.com/v1/chat/completions
-H "Authorization: Bearer $COMETAPI_KEY"
-H "Content-Type: application/json"
-d '{
"model": "mimo-v2.5",
"messages": [
{"role": "system", "content": "You are a careful coding assistant."},
{"role": "user", "content": "Explain the bug and propose a minimal patch."}
],
"temperature": 0.2
}'

### Usar Python con el SDK de OpenAI

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
model="mimo-v2.5",
messages=[
{"role": "system", "content": "You are a precise engineering assistant."},
{"role": "user", "content": "Review this migration plan for hidden risks."},
],
temperature=0.2,
)

print(response.choices[0].message.content)

> No registres claves de API, encabezados de autorización completos ni contenido sensible del prompt. Usa un gestor de secretos en producción y rota credenciales en un calendario definido.

## Cómo transmitir en streaming las respuestas de la API MiMo-V2.5

El streaming reduce la latencia percibida en respuestas largas. El servicio devuelve eventos incrementales, que el SDK expone como fragmentos.

stream = client.chat.completions.create(
model="mimo-v2.5",
messages=[{"role": "user", "content": "Draft a safe database migration checklist."}],
stream=True,
)

for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="", flush=True)

En un servicio web, reenvía los deltas con Server-Sent Events o mensajes WebSocket, maneja las desconexiones del cliente y detén la generación ascendente cuando el usuario cancele.

## Flujos de trabajo multimodales y estructurados con la API MiMo-V2.5

Para tareas con comprensión de imágenes, envía una instrucción de texto más un objeto de imagen en el mismo mensaje del usuario. La representación exacta de medios aceptada puede variar según la ruta del proveedor, así que trata esto como un patrón de carga útil y confirma el soporte de la ruta actual.

{
"model": "mimo-v2.5",
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": "Extract the visible error and suggest the next diagnostic step."},
{"type": "image_url", "image_url": {"url": "https://example.com/error.png"}}
]
}
]
}

Para una salida legible por máquina, solicita un objeto JSON compacto y valídalo contra tu propio esquema. Nunca supongas que un JSON generado es seguro solo porque se pueda analizar.

import json

raw = response.choices[0].message.content
result = json.loads(raw)

required = {"summary", "risks", "next_action"}
missing = required - result.keys()
if missing:
raise ValueError(f"Missing fields: {sorted(missing)}")

## Precios de la API MiMo-V2.5 en CometAPI y control de costos

| Ruta                           | Entrada por 1M tokens | Salida por 1M tokens | Ejemplo de 100 solicitudes |
| ------------------------------ | --------------------- | -------------------- | -------------------------- |
| MiMo-V2.5                      | $0.112                | $0.224               | $0.1568                    |
| MiMo-V2.5 Pro                  | $0.348                | $0.696               | $0.4872                    |
| Referencia pago por uso de Xiaomi | $0.14              | $0.28                | $0.1960                    |

El ejemplo supone 100 solicitudes, cada una con 10,000 tokens de entrada y 2,000 tokens de salida. Bajo esas suposiciones, la ruta MiMo-V2.5 es aproximadamente 68% más barata que MiMo-V2.5 Pro. Las [tarifas publicadas de pago por uso de Xiaomi](https://platform.xiaomimimo.com/docs/zh-CN/integration/roocode) proporcionan un punto de referencia útil, mientras que las facturas reales deben verificarse contra el precio del proveedor activo antes del despliegue.

MiMo-V2.5 input: 100 × 10,000 / 1,000,000 × $0.112 = $0.1120
MiMo-V2.5 output: 100 × 2,000 / 1,000,000 × $0.224 = $0.0448
MiMo-V2.5 total: $0.1568

Pro input: 100 × 10,000 / 1,000,000 × $0.348 = $0.3480
Pro output: 100 × 2,000 / 1,000,000 × $0.696 = $0.1392
Pro total: $0.4872

Controla los costos con límites de salida máxima, compresión de prompts, contexto en caché, clasificación de solicitudes y un enrutador que solo escale tareas difíciles. Rastrea el costo por tarea exitosa en lugar del costo por solicitud; una solicitud más barata que falla repetidamente puede ser más costosa en general.

## Cómo diseñar solicitudes de la API MiMo-V2.5 con contexto largo

Una ventana de 1M tokens hace posibles entradas más grandes, pero no elimina las compensaciones de recuperación y atención. Construye el prompt para que el modelo pueda localizar la evidencia relevante rápidamente.

* Coloca la tarea, el contrato de salida y los criterios de decisión cerca del inicio.
* Separa documentos con identificadores estables y delimitadores claros.
* Incluye solo evidencia que pueda afectar la respuesta.
* Pide al modelo que cite identificadores de documentos o referencias de línea en su resultado.
* Mide la precisión a medida que crece el contexto; no trates el contexto máximo como el contexto ideal.

> Un contexto largo incrementa tanto el costo de tokens como la probabilidad de que material irrelevante distraiga al modelo. La recuperación, el resumen y el prompting jerárquico siguen siendo importantes incluso cuando todo el corpus cabe.

## Confiabilidad en producción

### Reintenta solo fallos transitorios

Reintenta límites de tasa y fallos temporales del servidor con backoff exponencial y jitter. No reintentes automáticamente autenticación inválida, cargas malformadas o errores de política.

import random
import time

def delay_for(attempt: int) -> float:
return min(30.0, (2 ** attempt) + random.random())

for attempt in range(5):
try:
result = call_model()
break
except TransientAPIError:
if attempt == 4:
raise
time.sleep(delay_for(attempt))

### Establece barreras operativas

* Usa tiempos de espera de conexión y de solicitud general.
* Adjunta una clave de idempotencia a flujos con efectos externos.
* Registra el ID del modelo, latencia, tokens de entrada y salida, recuento de reintentos y estado final.
* Redacta secretos y datos personales antes de registrar.
* Exige listas permitidas de herramientas y confirmación para acciones destructivas.
* Mantén un modelo de respaldo o cola para interrupciones del proveedor.

## Errores comunes de la API MiMo-V2.5 y soluciones

| Síntoma      | Causa probable                                 | Acción recomendada                                               |
| ------------ | ---------------------------------------------- | ---------------------------------------------------------------- |
| 401 o 403    | Clave de API ausente, inválida o no autorizada | Verifica el secreto del lado del servidor y los permisos del proyecto. |
| 400          | Mensajes malformados u objeto de medios no soportado | Valida el JSON y confirma el soporte de carga específico de la ruta. |
| 413          | Cuerpo de solicitud demasiado grande           | Reduce el tamaño de los medios o divide la entrada.              |
| 429          | Límite de tasa o cuota                         | Retrocede con jitter y aplica límites de concurrencia del cliente. |
| 5xx          | Falla temporal del proveedor                   | Reintenta dentro de un presupuesto acotado o realiza failover.   |
| Respuesta lenta | Gran contexto, salida larga o latencia de herramientas | Transmite la salida, limita tokens y perfila cada etapa.         |
| JSON inválido | Deriva en la generación                       | Valida, repara una vez si es seguro y rechaza fallos persistentes. |

## Conclusión

El modelo MiMo-V2.5 es el punto de partida más sólido para equipos que necesitan entrada multimodal, gran contexto y control agresivo de costos. Pro debe ser una escalada deliberada para tareas donde las ganancias de calidad medidas justifiquen el mayor precio. Comienza con un pequeño conjunto de evaluación, instrumenta cada solicitud y promueve la integración solo después de probar cargas reales, comportamiento con contexto largo, manejo de reintentos y recuperación ante fallos.

## Preguntas frecuentes

### ¿Qué endpoint debo usar?

Usa `/api.cometapi.com/v1/chat/completions`, o establece `/api.cometapi.com/v1` como URL base en un SDK compatible con OpenAI.

### ¿Qué identificador de modelo debo enviar?

Usa `mimo-v2.5` para la ruta MiMo-V2.5. Confirma el identificador actual antes del lanzamiento si tu cuenta usa un alias específico del proveedor.

### ¿Cuándo debería elegir MiMo-V2.5 Pro?

Elige MiMo-V2.5 Pro cuando tu evaluación muestre una ventaja material en tareas difíciles de programación, razonamiento o uso prolongado de herramientas. Mantén el tráfico rutinario o multimodal en la ruta MiMo-V2.5 cuando su calidad sea suficiente.

### ¿Un contexto de 1M tokens significa que debo enviar todo?

No. Un gran contexto es un límite de capacidad, no un objetivo de diseño de prompts. Recupera y organiza la evidencia que puede afectar la respuesta, luego mide la calidad y el costo a medida que crece la entrada.

### ¿Puedo llamar a la API directamente desde un navegador?

No expongas una clave de API secreta en el frontend. Llama al proveedor desde tu backend y aplica autenticación, límites de tasa, registro y controles de datos allí.

### ¿Cómo verifico el soporte multimodal?

Prueba la carga de medios exacta contra la ruta activa del proveedor. Las modalidades nativas del modelo subyacente no garantizan que cada ruta exponga cada formato de la misma manera.