LongCat-2.5 dans Claude Code : configuration, prix et benchmarks

Pour configurer LongCat-2.5 dans Claude Code, utilisez l’endpoint de LongCat compatible avec Anthropic et l’identifiant exact LongCat-2.5. Commencez par une petite tâche sur un dépôt avant d’y transférer de longues sessions de programmation. Si vous utilisez Codex, suivez la configuration de l’API Responses présentée plus bas.

Qu’apporte LongCat-2.5 ?

LongCat-2.5 est le modèle multimodal natif de Meituan. Il vise les tâches qui enchaînent de nombreuses étapes de raisonnement et d’utilisation d’outils. Son annonce de lancement décrit une meilleure compréhension visuelle et de meilleures capacités de programmation que LongCat-2.0.

L’annonce indique 1.6 billion de paramètres au total, dont environ 48 milliards activés par token. Le billet est daté du 2026-11-01. Le journal des modifications de l’API annonce la disponibilité du modèle le 2026-11-02.

Au 2026-11-06, la référence actuelle du modèle donne les limites suivantes :

Limite	LongCat-2.5
Fenêtre de contexte	1,048,576 tokens, soit 1M
Sortie maximale de l’API	262,144 tokens, soit 256K

Un client peut imposer un plafond de sortie inférieur ou compacter plus tôt l’historique de la conversation. Ni Claude Code ni Codex ne reprennent automatiquement toutes les limites annoncées par le service.

Essayez LongCat sur des modifications de plusieurs fichiers ou sur des tâches de développement visuel dont vous pouvez vérifier le résultat. Les scores publiés justifient un essai, mais ne prouvent pas qu’il surpassera votre modèle actuel.

Comment configurer Claude Code ?

Utilisez l’API de LongCat compatible avec Anthropic et fournissez la clé depuis votre shell. Il vous faut le CLI Claude Code installé, un compte LongCat et une clé créée sur la page API Keys de la plateforme. Pour le paiement à l’usage, conservez un solde prépayé suffisant et rechargez-le si nécessaire.

Dans Bash, saisissez la clé sans l’afficher :

read -rs LONGCAT_API_KEY && export LONGCAT_API_KEY
unset ANTHROPIC_API_KEY
export ANTHROPIC_AUTH_TOKEN="$LONGCAT_API_KEY"

Intégrez cette configuration à ~/.claude/settings.json. Conservez vos permissions existantes et les paramètres sans rapport avec cette connexion.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.longcat.chat/anthropic",
    "ANTHROPIC_MODEL": "LongCat-2.5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "LongCat-2.5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "LongCat-2.5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "LongCat-2.5",
    "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "32000",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  }
}

Cet exemple adapte la configuration LongCat pour Claude Code à un premier test limité. La clé reste hors du JSON et l’affectation de Haiku utilise la variable actuelle.

Champ ou variable	Rôle
env	Fournit les variables d’environnement à Claude Code.
ANTHROPIC_AUTH_TOKEN	Envoie votre clé LongCat avec une authentification Bearer. Définissez-la dans Bash, comme ci-dessus.
ANTHROPIC_BASE_URL	Sélectionne l’endpoint LongCat compatible avec Anthropic. N’ajoutez pas /v1 : le client ajoute le chemin Messages.
ANTHROPIC_MODEL	Sélectionne LongCat-2.5 pour la session principale.
ANTHROPIC_DEFAULT_SONNET_MODEL	Associe l’alias sonnet à LongCat.
ANTHROPIC_DEFAULT_OPUS_MODEL	Associe l’alias opus à LongCat.
ANTHROPIC_DEFAULT_HAIKU_MODEL	Associe haiku et les fonctions en arrière-plan à LongCat.
CLAUDE_CODE_MAX_OUTPUT_TOKENS	Fixe le plafond initial de sortie de cet exemple à 32000. Ne définit pas la fenêtre de contexte.
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC	Désactive le trafic non essentiel du client et les mises à jour automatiques. Prévoyez une autre méthode de mise à jour.

L’exemple de LongCat utilise encore ANTHROPIC_SMALL_FAST_MODEL. La référence de configuration des modèles d’Anthropic déclare cette variable obsolète au profit de ANTHROPIC_DEFAULT_HAIKU_MODEL.

L’exemple actuel de LongCat fixe aussi CLAUDE_CODE_MAX_OUTPUT_TOKENS à 262144. Toutefois, la référence des variables d’environnement d’Anthropic indique un plafond de 128000 lorsque Claude Code ne reconnaît pas l’identifiant du modèle. Dans ce cas, les valeurs supérieures sont ramenées à ce plafond. La valeur plus basse de cet exemple évite de supposer que le client permet d’atteindre les 256K de l’API.

Avant d’utiliser la clé du shell, supprimez les entrées d’authentification conflictuelles dans vos réglages Claude existants. La commande unset ne supprime que la variable du shell. Les valeurs des fichiers de configuration peuvent remplacer les variables exportées.

Placez-vous dans la copie locale d’un petit dépôt contenant README.md. Démarrez ensuite le client dans la même session Bash :

claude

Exécutez /status et vérifiez le modèle, l’URL de base et l’origine de la clé. Demandez-lui de lire README.md et de résumer le projet sans modifier les fichiers. Vérifiez qu’un outil lit réellement le fichier et que la réponse est pertinente. Une simple salutation ne vérifie pas l’usage des outils.

Comment tester l’API compatible avec OpenAI ?

Envoyez une requête directe avec le SDK pour vérifier la clé et l’endpoint indépendamment des réglages de l’agent. L’URL de base du SDK est https://api.longcat.chat/openai/v1.

Cet exemple nécessite Python 3.10 ou une version ultérieure. Exécutez ces commandes dans la même session Bash, où LONGCAT_API_KEY est déjà exportée :

python3 -m venv .venv-longcat
source .venv-longcat/bin/activate
python -m pip install --upgrade openai

python - <<'PY'
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LONGCAT_API_KEY"],
    base_url="https://api.longcat.chat/openai/v1",
    max_retries=0,
)

response = client.chat.completions.create(
    model="LongCat-2.5",
    messages=[
        {"role": "user", "content": "Reply with exactly LONGCAT_OK."}
    ],
    max_tokens=1024,
    extra_body={"thinking": {"type": "disabled"}},
)

print(response.model)
print(response.choices[0].message.content)
print(response.choices[0].finish_reason)
print(response.usage)
PY

Le SDK ajoute /chat/completions pour former l’endpoint indiqué dans la référence Chat Completions de LongCat. Conservez donc /v1 dans cette URL de base.

L’instruction demande la réponse LONGCAT_OK. Vérifiez que le contenu n’est pas vide, puis contrôlez le modèle renvoyé, la fin normale de la génération et les données de consommation. Il s’agit d’un test de connexion, pas d’une évaluation de programmation. Le raisonnement est désactivé pour limiter la taille du test.

Le SDK Python d’OpenAI accepte des champs de requête supplémentaires via extra_body. Ici, max_retries=0 rend l’échec immédiatement visible. L’exemple n’applique pas automatiquement la politique de nouvelles tentatives décrite plus bas.

Peut-on utiliser LongCat-2.5 dans Codex ?

Oui. LongCat publie un guide d’intégration avec Codex et une référence distincte pour l’API Responses. Utilisez wire_api = "responses" pour cette connexion.

Une fois Codex installé, intégrez la configuration suivante à ~/.codex/config.toml. Gardez les clés racine avant la première table TOML. Modifiez les entrées existantes au lieu de les dupliquer.

model = "LongCat-2.5"
model_provider = "longcat"
web_search = "disabled"

[model_providers.longcat]
name = "LongCat"
base_url = "https://api.longcat.chat/openai/v1"
wire_api = "responses"
env_key = "LONGCAT_API_KEY"
requires_openai_auth = false

L’identifiant longcat relie model_provider à la table du fournisseur. env_key lit la clé exportée. requires_openai_auth = false sélectionne l’authentification par clé du fournisseur dans cet exemple. Le guide d’authentification d’OpenAI précise qu’avec true, Codex ignore env_key.

Cette adaptation des instructions de LongCat évite de stocker la clé dans auth.json. La recherche web reste désactivée pour le premier test.

Depuis la même session Bash et le dépôt de test, exécutez :

codex --sandbox read-only

Consultez /status, puis demandez le même résumé de README.md. Vérifiez la lecture du fichier et la pertinence de la réponse. La requête au modèle utilise https://api.longcat.chat/openai/v1/responses. Une requête Chat Completions réussie ne vérifie pas, à elle seule, cet endpoint distinct.

Que vaut-il face à GLM-5.3, Kimi K3 et DeepSeek ?

Utilisez les scores officiels pour sélectionner les modèles à tester sur votre projet. Le tableau de lancement de LongCat rassemble ses propres résultats et des scores de concurrents publiés par d’autres sources.

Benchmark	LongCat-2.5	GLM-5.3	kimi-k3	DeepSeek-V4.1-Flash
Terminal Bench v2.1	88.4	88.2*	88.3*	90.6*
Terminal Bench v4.0	38.5	41.8*	12.6*	31.2*
Program Bench Almost Resolved	25.5	19.0*	17.5*	20.3*
DeepSWE v1.1	64.6	66.9*	67.5*	74.2*
NL2Repo	60.5	58.0*	58.0*	65.4*

L’astérisque signale qu’un score concurrent vient d’un rapport technique public, d’un blog ou d’un classement officiel. Dans le tableau complet, les autres scores de concurrents sans astérisque proviennent de tests menés par LongCat et sont présentés comme indicatifs. Tous les scores concurrents reproduits ci-dessus portent un astérisque.

Tenez compte de la méthode publiée :

• Sauf mention contraire, LongCat-2.5 utilise enable_thinking=on, temperature = 1.0 et top_p = 0.95.
• Terminal Bench v2.1/v4.0, Program Bench et NL2Repo utilisent Claude Code v2.1.280 avec max_seq_length = 512K.
• DeepSWE v1.1 utilise mini-swe-agent avec max_seq_length = 1M.
• Les résultats de Terminal Bench v2.1 et DeepSWE sont la moyenne de trois exécutions indépendantes.

Ces réglages décrivent l’évaluation de LongCat. Ils ne prouvent pas que les scores provenant d’autres sources ont été obtenus dans les mêmes conditions.

LongCat devance ces trois alternatives sur Program Bench Almost Resolved. GLM-5.3 obtient un meilleur score sur Terminal Bench v4.0, tandis que les trois alternatives dépassent LongCat sur DeepSWE. Un écart de 0.1 ou 0.2 sur Terminal Bench v2.1 ne démontre pas un avantage concret sans tests menés dans les mêmes conditions.

Pour évaluer des corrections dans un dépôt, gardez DeepSeek-V4.1-Flash parmi les candidats. Pour développer un projet, incluez LongCat. Le guide de programmation et de benchmarks DeepSeek aide à distinguer ses différentes versions.

Utilisez le même commit du dépôt, le même prompt et les mêmes permissions d’outils. Gardez aussi les mêmes tests d’acceptation et le même budget de nouvelles tentatives. Notez les résultats acceptés, le temps écoulé et le montant total facturé. Ne changez de modèle que si cet essai améliore les critères qui comptent pour votre équipe.

Combien coûte LongCat-2.5 ?

Établissez votre budget avec les tarifs publiés pour une durée limitée. Vérifiez-les de nouveau avant de prévoir un usage récurrent. Au 2026-11-06, la page des tarifs LongCat indique :

Catégorie de tokens	USD pour 1M tokens
Entrée sans cache	$0.30
Entrée en cache	$0.006
Sortie	$1.20

Les pages des tarifs et du paiement à l’usage ne précisent pas la date de fin de la promotion. Elles n’indiquent pas non plus le prix habituel sans remise. Les tarifs de la plateforme et les relevés de facturation font foi. La mention « limited-time » ne permet pas de déduire une date d’expiration ou un pourcentage d’économie.

Pour une session regroupant plusieurs requêtes, supposons 1,000,000 tokens d’entrée sans cache et 100,000 tokens de sortie facturés. Avec les tarifs indiqués, sans aucun token servi depuis le cache ni remise négociée :

(1,000,000 / 1,000,000 × $0.30) + (100,000 / 1,000,000 × $1.20) = $0.42

Il s’agit d’une estimation des frais de tokens, pas du coût mesuré d’une tâche. Ces quantités couvrent l’ensemble de la session, pas une seule requête.

Pour les requêtes Responses, usage.output_tokens inclut les tokens de raisonnement, selon la référence de l’API Responses. Ne les ajoutez pas une deuxième fois. Les tokens d’entrée en cache font également partie du total d’entrée. N’appliquez le tarif réduit qu’à la consommation effectivement indiquée comme servie depuis le cache.

Le prix par token ne suffit pas à déterminer le modèle de programmation le moins cher. Utilisez le coût par tâche acceptée lorsque les nouvelles tentatives, les longs raisonnements ou les modifications de code infructueuses influencent la facture.

Que faire en cas d’erreur 429 rate_limit_exceeded ?

Réduisez le nombre de requêtes simultanées et limitez les nouvelles tentatives, avec une attente entre elles. La présentation de l’API LongCat indique que les limites de débit s’appliquent par clé API.

Le guide de démarrage donne cet exemple :

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Request rate limit exceeded, please try again later",
    "type": "rate_limit_error",
    "retry_after": 60
  }
}

La valeur 60 de l’exemple ne garantit aucun délai précis de réinitialisation. Suivez les indications de nouvelle tentative renvoyées par le serveur et augmentez l’attente de façon exponentielle.

Pour votre propre client, commencez par autoriser au maximum trois nouvelles tentatives. Augmentez l’attente entre elles et ajoutez une variation aléatoire, appelée jitter. C’est une recommandation d’implémentation, pas un quota LongCat. Placez dans une file d’attente les requêtes qui partagent la même clé et tenez compte des tentatives déjà effectuées par le SDK.

Après l’attente, envoyez une petite requête. Si elle réussit, augmentez progressivement le nombre de requêtes simultanées. Si la limitation persiste, demandez à LongCat quelles limites s’appliquent à votre compte. La documentation publique citée ne donne aucun plafond chiffré de requêtes ou de tokens par minute.

Si l’erreur indique plutôt insufficient_quota, vérifiez le solde et le quota applicable. Renvoyer la même requête sans rien changer ne corrige pas cette situation.

Les poids de LongCat-2.5 sont-ils disponibles ?

Prévoyez cette intégration avec le modèle hébergé par le fournisseur. Au 2026-11-06, la page de lancement marque ses liens GitHub et Hugging Face « Coming soon ». Ces liens ne donnent accès à aucun téléchargement utilisable des poids et n’annoncent aucune date ferme de publication.

Cela ne signifie pas que le modèle soit limité à l’API : Meituan annonce aussi un accès depuis son site web. Pour un déploiement local, attendez des poids LongCat-2.5 téléchargeables, une licence et des instructions d’exécution du modèle.

Commencez avec le client que vous utilisez déjà, vérifiez la lecture d’un fichier, puis testez une modification de code bien délimitée. Si vous transférez une tâche en cours, conservez ses exigences et ses résultats de test dans un point de reprise pour changer de modèle.