Comment utiliser l'API Xiaomi MiMo-V2.5-Pro sur Novita AI

Xiaomi MiMo-V2.5-Pro est disponible sur Novita AI via l’API Serverless, ce qui permet aux développeurs d’appeler l’ID de modèle vérifié xiaomimimo/mimo-v2.5-pro avec le point de terminaison de chat completions compatible OpenAI de Novita pour les workflows texte long-contexte, les tâches de codage nécessitant du raisonnement, les appels de fonction et les expériences de sortie structurée.

Configuration rapide

Utilisez ce point de départ lorsque vous possédez déjà une clé API Novita AI et que vous souhaitez le chemin vérifié le plus court pour une première requête.

pip install openai
export NOVITA_API_KEY="VOTRE_CLE_API_NOVITA"

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)

La page actuelle du modèle Xiaomi MiMo-V2.5-Pro liste le modèle comme une option API Serverless Novita AI et indique l’URL de base compatible OpenAI https://api.novita.ai/openai. La référence actuelle de l’API chat completions de Novita AI documente le chemin REST comme /openai/v1/chat/completions.

Qu’est-ce que Xiaomi MiMo-V2.5-Pro ?

Xiaomi MiMo-V2.5-Pro est un modèle de langage de grande taille (LLM) texte-entrée, texte-sortie conçu pour les workflows agentiques et de génie logiciel complexes. Sur Novita AI, l’ID du modèle API est :

xiaomimimo/mimo-v2.5-pro

La liste des modèles Novita AI vérifie actuellement ces détails d’implémentation :

Champ	Valeur actuelle
Chemin d’accès	API Serverless
Famille de point de terminaison	Chat completions compatible OpenAI
URL de base	https://api.novita.ai/openai
ID du modèle	xiaomimimo/mimo-v2.5-pro
Longueur du contexte	1 048 576 jetons
Sortie maximale	131 072 jetons
Capacité d’entrée	Texte
Capacité de sortie	Texte
Appel de fonction	Pris en charge
Sortie structurée	Pris en charge
Raisonnement	Pris en charge
API Anthropic	Pris en charge

En amont, la fiche du modèle Xiaomi MiMo-V2.5-Pro sur Hugging Face décrit MiMo-V2.5-Pro comme un modèle de langage Mixture-of-Experts open source avec 1,02 billion de paramètres totaux, 42 milliards de paramètres actifs et une fenêtre de contexte allant jusqu’à 1 million de jetons. Considérez la fiche amont comme une information de contexte utile pour la famille de modèles, et utilisez la page du modèle Novita AI pour les détails spécifiques à Novita (ID du modèle, tarification, disponibilité et point de terminaison).

Quand utiliser MiMo-V2.5-Pro

MiMo-V2.5-Pro est le plus utile lorsque votre application a besoin d’un modèle texte hébergé pour un travail long et riche en instructions, plutôt que pour une réponse courte et à un seul tour. De bons cas d’évaluation incluent l’analyse de dépôts, les plans de refactorisation multi-fichiers, la synthèse de documents long-contexte, la planification agentique, les prototypes de routage d’outils et les tâches d’extraction structurée.

Utilisez-le lorsque vous avez besoin de :

• Une fenêtre de contexte vérifiée de 1 048 576 jetons sur Novita AI.
• Un paramètre de sortie maximale élevé pour des plans détaillés, des revues de code, des schémas de migration ou des traces de raisonnement multi-étapes.
• La prise en charge des appels de fonction pour orienter les décisions du modèle vers des outils applicatifs.
• La prise en charge des sorties structurées pour des réponses de type JSON que les services aval peuvent analyser.
• Des chat completions compatibles OpenAI afin de réutiliser les schémas SDK existants.

Ne présumez pas qu’il s’agit du choix le moins coûteux ou le plus rapide pour chaque tâche. Pour les prompts courts, la classification à haut volume ou les conversations simples, comparez les options actuelles dans la bibliothèque de modèles Novita AI et la page de tarification Novita AI avant de router tout le trafic vers un modèle long-contexte.

Prérequis

Avant d’effectuer la première requête, préparez quatre choses :

1. Un compte Novita AI.
2. Une clé API Novita AI stockée dans une variable d’environnement telle que NOVITA_API_KEY.
3. Le SDK Python OpenAI ou un autre client HTTP capable d’appeler des points de terminaison compatibles OpenAI.
4. Une vérification actuelle des tarifs et des limites pour xiaomimimo/mimo-v2.5-pro.

La page actuelle du modèle Novita AI affiche une tarification serverless basée sur les jetons pour MiMo-V2.5-Pro. Elle indique un prix d’affichage général de 2 $ par million de jetons d’entrée, 0,4 $ par million de jetons de lecture en cache et 6 $ par million de jetons de sortie. Elle liste également une tarification par palier selon la longueur d’entrée :

Longueur d’entrée	Prix d’entrée par million de jetons	Prix de sortie par million de jetons	Prix de lecture en cache par million de jetons
1 à moins de 262 144 jetons	1 $	3 $	0,2 $
262 144 à moins de 1 048 576 jetons	2 $	6 $	0,4 $

Étant donné que les pages de modèles et les tableaux de tarification peuvent changer, confirmez les tarifs actuels sur la page du modèle ou la page de tarification avant une utilisation en production, en particulier pour les prompts longs où le second palier peut s’appliquer.

Première requête API

L’appel initial le plus simple utilise le SDK OpenAI avec l’URL de base de Novita AI et l’ID du modèle 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)

Si vous préférez REST, appelez directement le chemin actuel des chat completions :

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
  }'

Pour le code de production, conservez les clés API en dehors du contrôle de source, limitez max_tokens à la quantité réellement nécessaire pour votre workflow et journalisez l’utilisation des jetons afin de pouvoir détecter quand les prompts long-contexte commencent à dominer le coût.

Remarques sur le streaming et l’utilisation long-contexte

La référence des chat completions de Novita AI inclut les champs stream et stream_options, et la page du modèle MiMo-V2.5-Pro vérifie une longueur de contexte de 1 048 576 jetons avec une sortie maximale de 131 072 jetons. Utilisez ces limites comme plafonds techniques, pas comme paramètres par défaut.

Pour une réponse en 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="")

Pour les prompts long-contexte, respectez ces bonnes pratiques :

• Placez la tâche, le format de sortie et les conditions d’arrêt près du début de la conversation.
• Divisez les fichiers ou documents non liés en sections clairement étiquetées.
• Demandez au modèle de citer les noms de sections ou les chemins de fichiers du contexte fourni plutôt que d’inventer des emplacements.
• Commencez avec des valeurs max_tokens plus petites pendant le développement, puis augmentez la limite uniquement lorsque le workflow nécessite une sortie plus longue.
• Suivez les jetons de prompt, de completion et totaux à partir de l’objet usage lorsque la réponse l’inclut.

Exemple d’appel de fonction

La page du modèle MiMo-V2.5-Pro vérifie la prise en charge des appels de fonction, et la référence des chat completions inclut un paramètre tools avec des métadonnées de fonction. Utilisez-le lorsque le modèle doit choisir une action applicative, par exemple consulter un ticket interne, récupérer un état de compte ou créer une tâche de déploiement.

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)

Dans une application réelle, validez les arguments de l’outil côté serveur avant d’exécuter toute action. L’appel de fonction offre à votre application une décision structurée du modèle ; il ne remplace pas l’autorisation, la validation d’entrée, la journalisation d’audit ou les contrôles de restauration.

Exemple de sortie structurée

La page du modèle MiMo-V2.5-Pro vérifie également la prise en charge des sorties structurées, et la référence des chat completions de Novita AI inclut response_format avec des champs de schéma JSON. Utilisez la sortie structurée lorsque vous souhaitez que le modèle renvoie des données analysables plutôt qu’une prose libre.

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))

Si la réponse échoue à l’analyse JSON lors des tests, réduisez l’ambiguïté dans le prompt, diminuez la température, conservez un schéma compact et réessayez avec une entrée plus courte. Pour les workflows de production, validez l’objet analysé par rapport à votre propre schéma avant de l’utiliser.

Précautions concernant les coûts, la latence et les limites

MiMo-V2.5-Pro est conçu pour les tâches long-contexte et agentiques, donc le contrôle des coûts est important. Un prompt proche du palier de contexte supérieur peut être matériellement plus coûteux qu’une requête courte, et les sorties longues augmentent également le coût des jetons de complétion. La page du modèle Novita AI liste actuellement une tarification par palier pour les entrées/sorties, alors estimez à la fois les jetons de prompt et de complétion avant de router automatiquement des tâches volumineuses.

Utilisez ces contrôles :

• Définissez une limite max_tokens pratique plutôt que d’utiliser la limite de sortie maximale par défaut.
• Résumez ou récupérez uniquement le contexte nécessaire pour la tâche en cours.
• Mettez en cache ou réutilisez un contexte stable lorsque votre architecture le permet.
• Surveillez l’utilisation des jetons par fonctionnalité, utilisateur et workflow.
• Ajoutez des timeouts et des tentatives autour des appels réseau.
• Conservez un modèle de repli plus petit pour les tâches courtes si votre produit n’a pas besoin de MiMo-V2.5-Pro pour chaque requête.

La latence peut varier en fonction de la longueur du prompt, de la longueur de la sortie, du mode de streaming et des conditions de service actuelles. Pour les applications destinées aux utilisateurs, diffusez les réponses plus longues lorsque cela est approprié et concevez l’interface utilisateur autour d’une sortie incrémentielle plutôt que d’une réponse bloquante unique.

Résolution des problèmes

Si votre première requête MiMo-V2.5-Pro échoue, vérifiez ces éléments en premier.

Symptôme	Cause probable	Correctif
Erreur d’authentification	Clé API manquante ou mal formée	Envoyez Authorization: Bearer $NOVITA_API_KEY pour les appels REST ou passez api_key au client SDK.
Modèle non trouvé	ID de modèle incorrect	Utilisez xiaomimimo/mimo-v2.5-pro exactement comme indiqué sur la page du modèle Novita AI.
Erreur de chemin de requête	URL de base mélangée	Utilisez https://api.novita.ai/openai avec le SDK OpenAI, ou https://api.novita.ai/openai/v1/chat/completions pour REST.
Erreur de contexte ou de sortie	La demande de prompt + sortie dépasse les limites du modèle	Maintenez la longueur totale du prompt dans la fenêtre de contexte actuelle et limitez max_tokens en dessous de la sortie maximale vérifiée.
Appel d’outil manquant	Le prompt ne nécessite pas d’outil, ou le schéma de l’outil n’est pas clair	Rendez la décision d’outil explicite et conservez un schéma de fonction concis.
Échec d’analyse de la sortie structurée	Schéma ou prompt trop lâche	Utilisez response_format, définissez strict lorsque approprié, réduisez la température et validez le résultat.
Coût inattendu	Prompt volumineux, sortie volumineuse ou palier de tarification supérieur	Vérifiez les tarifs actuels, journalisez l’utilisation des jetons et réduisez le contexte ou la sortie maximale.

Pour les détails du point de terminaison, reportez-vous à la référence de l’API chat completions de Novita AI. Pour les limites et tarifs spécifiques au modèle, reportez-vous à la page API et playground de Xiaomi MiMo-V2.5-Pro.

Prochaines étapes

Commencez par la page du modèle Xiaomi MiMo-V2.5-Pro, testez un petit prompt dans le playground, puis déplacez le même prompt dans votre client API avec l’ID de modèle vérifié. Lorsque vous êtes prêt à comparer des alternatives, utilisez la bibliothèque de modèles Novita AI et la page de tarification Novita AI pour vérifier les tarifs actuels, les fenêtres de contexte, les limites de sortie et le support des capacités.

Pour les applications de type agentique, évaluez MiMo-V2.5-Pro par rapport à vos propres traces : modifications de dépôt, routage d’appels d’outils, extraction structurée, résumé long-contexte et récupération après des instructions ambiguës. Maintenez l’évaluation liée aux prompts réels de votre application plutôt qu’à des benchmarks génériques.