O Xiaomi MiMo-V2.5-Pro está disponível no Novita AI através da API Serverless, para que os desenvolvedores possam chamar o ID do modelo verificado xiaomimimo/mimo-v2.5-pro com o endpoint de conclusões de chat compatível com OpenAI do Novita para fluxos de trabalho de texto de contexto longo, tarefas de codificação pesadas em raciocínio, chamada de funções e experimentos de saída estruturada.
Configuração rápida
Use este ponto de partida quando você já tiver uma chave de API Novita AI e quiser o caminho verificado mais curto para uma primeira solicitação.
pip install openai
export NOVITA_API_KEY="YOUR_NOVITA_API_KEY"
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
response = client.chat.completions.create(
model="xiaomimimo/mimo-v2.5-pro",
messages=[
{
"role": "system",
"content": "You are a concise software architecture assistant.",
},
{
"role": "user",
"content": "Outline a migration plan for moving a Python monolith into services.",
},
],
max_tokens=2048,
temperature=0.7,
)
print(response.choices[0].message.content)
A página do modelo Xiaomi MiMo-V2.5-Pro atual lista o modelo como uma opção da API Serverless Novita AI e mostra a URL base compatível com OpenAI https://api.novita.ai/openai. A referência da API de chat completions do Novita AI atual documenta o caminho REST como /openai/v1/chat/completions.
O que é o Xiaomi MiMo-V2.5-Pro
O Xiaomi MiMo-V2.5-Pro é um modelo de linguagem grande que aceita texto e gera texto para fluxos de trabalho complexos de agente e engenharia de software. No Novita AI, o ID do modelo da API é:
xiaomimimo/mimo-v2.5-pro
A listagem atual do modelo no Novita AI verifica estes detalhes de implementação:
| Campo | Valor atual |
|---|---|
| Caminho de acesso | API Serverless |
| Família de endpoint | Conclusões de chat compatíveis com OpenAI |
| URL base | https://api.novita.ai/openai |
| ID do modelo | xiaomimimo/mimo-v2.5-pro |
| Tamanho do contexto | 1.048.576 tokens |
| Saída máxima | 131.072 tokens |
| Capacidade de entrada | Texto |
| Capacidade de saída | Texto |
| Chamada de funções | Suportado |
| Saída estruturada | Suportado |
| Raciocínio | Suportado |
| API Anthropic | Suportado |
Acima, a ficha do modelo Xiaomi MiMo-V2.5-Pro no Hugging Face descreve o MiMo-V2.5-Pro como um modelo de linguagem de código aberto baseado em Mixture-of-Experts com 1,02 trilhões de parâmetros totais, 42 bilhões de parâmetros ativos e uma janela de contexto de até 1 milhão de tokens. Trate a ficha do modelo upstream como contexto útil para a família de modelos e use a página do modelo Novita AI para obter detalhes específicos do Novita sobre ID do modelo, preços, disponibilidade e endpoint.
Quando usar o MiMo-V2.5-Pro
O MiMo-V2.5-Pro é mais útil quando sua aplicação precisa de um modelo de texto hospedado para trabalhos longos e com muitas instruções, em vez de uma resposta curta de única interação. Bons alvos de avaliação incluem análise de repositório, planos de refatoração de múltiplos arquivos, síntese de documentos de contexto longo, planejamento de agentes, protótipos de roteamento de ferramentas e tarefas de extração estruturada.
Use-o quando precisar de:
- Uma janela de contexto verificada de 1.048.576 tokens no Novita AI.
- Uma configuração de saída máxima alta para planos detalhados, revisões de código, esboços de migração ou rastros de raciocínio em várias etapas.
- Suporte a chamada de funções para rotear decisões do modelo para ferramentas da aplicação.
- Suporte a saída estruturada para respostas no formato JSON que serviços downstream possam analisar.
- Conclusões de chat compatíveis com OpenAI para reutilizar padrões de SDK existentes.
Não assuma que seja a escolha de menor custo ou menor latência para todas as tarefas. Para prompts curtos, classificação de alto volume ou chat simples, compare as opções atuais na biblioteca de modelos Novita AI e na página de preços do Novita AI antes de direcionar todo o tráfego para um modelo de contexto longo.
Pré-requisitos
Antes de fazer a primeira solicitação, prepare quatro coisas:
- Uma conta no Novita AI.
- Uma chave de API Novita AI armazenada em uma variável de ambiente como
NOVITA_API_KEY. - O SDK Python do OpenAI ou outro cliente HTTP que possa chamar endpoints compatíveis com OpenAI.
- Uma verificação atual de preços e limites para
xiaomimimo/mimo-v2.5-pro.
A página atual do modelo Novita AI lista preços serverless baseados em tokens para o MiMo-V2.5-Pro. Mostra um preço geral de exibição de $2 por milhão de tokens de entrada, $0,4 por milhão de tokens de leitura em cache e $6 por milhão de tokens de saída. Também lista preços em camadas por tamanho de entrada:
| Tamanho da entrada | Preço de entrada por milhão de tokens | Preço de saída por milhão de tokens | Preço de leitura em cache por milhão de tokens |
|---|---|---|---|
| 1 a menos de 262.144 tokens | $1 | $3 | $0,2 |
| 262.144 a menos de 1.048.576 tokens | $2 | $6 | $0,4 |
Como as páginas de modelos e tabelas de preços podem mudar, confirme as taxas atuais na página do modelo ou na página de preços antes do uso em produção, especialmente para prompts longos onde a segunda camada pode ser aplicada.
Primeira solicitação à API
A chamada inicial mais simples usa o SDK do OpenAI com a URL base do Novita AI e o ID do modelo MiMo-V2.5-Pro.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
response = client.chat.completions.create(
model="xiaomimimo/mimo-v2.5-pro",
messages=[
{"role": "system", "content": "You are a practical coding assistant."},
{
"role": "user",
"content": "Review this API design and list the main reliability risks.",
},
],
max_tokens=1024,
temperature=0.7,
)
print(response.choices[0].message.content)
Se preferir REST, chame o caminho de conclusões de chat atual diretamente:
curl --request POST \
--url https://api.novita.ai/openai/v1/chat/completions \
--header "Authorization: Bearer $NOVITA_API_KEY" \
--header "Content-Type: application/json" \
--data '{
"model": "xiaomimimo/mimo-v2.5-pro",
"messages": [
{
"role": "system",
"content": "You are a practical coding assistant."
},
{
"role": "user",
"content": "Create a checklist for validating a payment webhook integration."
}
],
"max_tokens": 1024,
"temperature": 0.7
}'
Para código de produção, mantenha as chaves de API fora do controle de versão, limite max_tokens à quantidade real que seu fluxo de trabalho precisa e registre o uso de tokens para que você possa ver quando prompts de contexto longo começam a dominar o custo.
Notas sobre streaming e uso de contexto longo
A referência de conclusões de chat do Novita AI inclui os campos stream e stream_options, e a página do modelo MiMo-V2.5-Pro verifica um comprimento de contexto de 1.048.576 tokens com uma saída máxima de 131.072 tokens. Use esses limites como tetos de engenharia, não como configurações padrão.
Para uma resposta em streaming:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
stream = client.chat.completions.create(
model="xiaomimimo/mimo-v2.5-pro",
messages=[
{"role": "system", "content": "You write concise engineering plans."},
{
"role": "user",
"content": "Draft a step-by-step rollback plan for a failed database migration.",
},
],
max_tokens=2048,
temperature=0.7,
stream=True,
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="")
Para prompts de contexto longo, mantenha estas práticas em vigor:
- Coloque a tarefa, o formato de saída e as condições de parada perto do início da conversa.
- Separe arquivos ou documentos não relacionados em seções claramente identificadas.
- Peça ao modelo para citar nomes de seções ou caminhos de arquivo do contexto fornecido, em vez de inventar locais.
- Comece com valores menores de
max_tokensdurante o desenvolvimento e aumente o limite apenas quando o fluxo de trabalho precisar de saída mais longa. - Acompanhe os tokens de prompt, conclusão e total a partir do objeto
usagequando a resposta o incluir.
Exemplo de chamada de funções
A página do modelo MiMo-V2.5-Pro verifica o suporte a chamada de funções, e a referência de conclusões de chat inclui um parâmetro tools com metadados de função. Use isso quando o modelo deve escolher uma ação da aplicação, como consultar um ticket interno, buscar um estado de conta ou criar uma tarefa de implantação.
import json
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
tools = [
{
"type": "function",
"function": {
"name": "create_deployment_ticket",
"description": "Create a deployment follow-up ticket.",
"parameters": {
"type": "object",
"properties": {
"service": {
"type": "string",
"description": "The service that needs follow-up.",
},
"priority": {
"type": "string",
"enum": ["low", "medium", "high"],
},
"summary": {
"type": "string",
"description": "A short ticket summary.",
},
},
"required": ["service", "priority", "summary"],
"additionalProperties": False,
},
"strict": True,
},
}
]
response = client.chat.completions.create(
model="xiaomimimo/mimo-v2.5-pro",
messages=[
{
"role": "system",
"content": "Decide whether the user's deployment note requires a follow-up ticket.",
},
{
"role": "user",
"content": "Checkout latency increased after the payment-service deploy. Create a high priority follow-up.",
},
],
tools=tools,
max_tokens=1024,
temperature=0.2,
)
message = response.choices[0].message
if message.tool_calls:
tool_call = message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
print(args)
else:
print(message.content)
Em uma aplicação real, valide os argumentos da ferramenta no servidor antes de executar qualquer ação. A chamada de funções fornece uma decisão estruturada do modelo para sua aplicação; ela não substitui autorização, validação de entrada, registro de auditoria ou controles de reversão.
Exemplo de saída estruturada
A página do modelo MiMo-V2.5-Pro também verifica o suporte a saída estruturada, e a referência de conclusões de chat do Novita AI inclui response_format com campos de esquema JSON. Use saída estruturada quando quiser que o modelo retorne dados analisáveis em vez de prosa livre.
import json
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["NOVITA_API_KEY"],
base_url="https://api.novita.ai/openai",
)
response_format = {
"type": "json_schema",
"json_schema": {
"name": "migration_risk_report",
"schema": {
"type": "object",
"properties": {
"risk_level": {
"type": "string",
"enum": ["low", "medium", "high"],
},
"main_risks": {
"type": "array",
"items": {"type": "string"},
},
"next_actions": {
"type": "array",
"items": {"type": "string"},
},
},
"required": ["risk_level", "main_risks", "next_actions"],
"additionalProperties": False,
},
"strict": True,
},
}
response = client.chat.completions.create(
model="xiaomimimo/mimo-v2.5-pro",
messages=[
{
"role": "system",
"content": "Return only a structured migration risk report.",
},
{
"role": "user",
"content": "We are moving billing jobs from cron to a queue and changing retry behavior.",
},
],
response_format=response_format,
max_tokens=1024,
temperature=0.2,
)
report = json.loads(response.choices[0].message.content)
print(json.dumps(report, indent=2))
Se a resposta falhar na análise JSON durante os testes, reduza a ambiguidade no prompt, diminua a temperatura, mantenha o esquema compacto e tente novamente com uma entrada mais curta. Para fluxos de trabalho de produção, valide o objeto analisado em relação ao seu próprio esquema antes de usá-lo.
Cuidados com custo, latência e limites
O MiMo-V2.5-Pro é construído para tarefas de contexto longo e agentes, portanto, o controle de custos é importante. Um prompt próximo ao nível superior de contexto pode ser materialmente mais caro do que uma solicitação curta, e saídas longas também aumentam o custo dos tokens de conclusão. A página do modelo Novita AI atualmente lista preços em camadas para entrada/saída, então estime tanto os tokens de prompt quanto os de conclusão antes de rotear trabalhos grandes automaticamente.
Use estes controles:
- Defina um limite prático de
max_tokensem vez de usar o limite máximo de saída por padrão. - Resuma ou recupere apenas o contexto necessário para a tarefa atual.
- Armazene em cache ou reutilize contexto estável onde sua arquitetura suportar.
- Monitore o uso de tokens por funcionalidade, usuário e fluxo de trabalho.
- Adicione timeouts e novas tentativas em torno das chamadas de rede.
- Mantenha um modelo de fallback menor para tarefas curtas se seu produto não precisar do MiMo-V2.5-Pro em todas as solicitações.
A latência pode variar com o comprimento do prompt, comprimento da saída, modo de streaming e condições atuais do serviço. Para aplicações voltadas ao usuário, transmita respostas mais longas quando apropriado e projete a interface em torno da saída incremental, em vez de uma única resposta bloqueante.
Solução de problemas
Se sua primeira solicitação ao MiMo-V2.5-Pro falhar, verifique estes itens primeiro.
| Sintoma | Causa provável | Correção |
|---|---|---|
| Erro de autenticação | Chave de API ausente ou mal formatada | Envie Authorization: Bearer $NOVITA_API_KEY para chamadas REST ou passe api_key para o cliente SDK. |
| Modelo não encontrado | ID do modelo incorreto | Use xiaomimimo/mimo-v2.5-pro exatamente como listado na página do modelo Novita AI. |
| Erro no caminho da solicitação | URLs base misturadas | Use https://api.novita.ai/openai com o SDK do OpenAI, ou https://api.novita.ai/openai/v1/chat/completions para REST. |
| Erro de contexto ou saída | Prompt mais saída solicitada excede os limites do modelo | Mantenha o comprimento total do prompt dentro da janela de contexto atual e limite max_tokens abaixo da saída máxima verificada. |
| Chamada de ferramenta ausente | O prompt não requer uma ferramenta, ou o esquema da ferramenta não está claro | Torne a decisão da ferramenta explícita e mantenha o esquema da função conciso. |
| Falha ao analisar saída estruturada | Esquema ou prompt muito amplo | Use response_format, defina strict quando apropriado, diminua a temperatura e valide o resultado. |
| Custo inesperado | Prompt grande, saída grande ou nível de preço superior | Verifique os preços atuais, registre o uso de tokens e reduza o contexto ou a saída máxima. |
Para detalhes do endpoint, consulte a referência da API de chat completions do Novita AI. Para limites e preços específicos do modelo, consulte a página do modelo Xiaomi MiMo-V2.5-Pro (API e playground).
Próximos passos
Comece com a página do modelo Xiaomi MiMo-V2.5-Pro, teste um prompt pequeno no playground e, em seguida, mova o mesmo prompt para seu cliente de API com o ID do modelo verificado. Quando estiver pronto para comparar alternativas, use a biblioteca de modelos Novita AI e a página de preços do Novita AI para verificar preços atuais, janelas de contexto, limites de saída e suporte a recursos.
Para aplicações no estilo agente, avalie o MiMo-V2.5-Pro em relação aos seus próprios rastros: edições de repositório, roteamento de chamadas de ferramentas, extração estruturada, sumarização de contexto longo e recuperação de instruções ambíguas. Mantenha a avaliação vinculada aos prompts reais da sua aplicação, em vez de descrições genéricas.
