Exécuter DeepSeek en local ou utiliser une API ? Matériel, vitesse, coût

Probablement pas, sauf si vous disposez de 128 Go de RAM ou d'une machine de la classe Mac Studio, ou si vous avez une raison de garder chaque token sur votre propre disque. Rien que le fichier DeepSeek V4-Flash fait environ 100 Go, et un guide communautaire rapporte environ 6 à 10 tokens par seconde même sur du matériel coûteux. Pour la plupart des applications et des boucles d'agents, la voie la plus courte consiste à pointer le client OpenAI vers une API hébergée : vous changez base_url et la clé, et rien d'autre dans votre code.

Ci-dessous : comment vérifier votre propre machine en cinq minutes, à quelle vitesse vous attendre, et ce que coûte une charge de travail réelle via une API.

DeepSeek tiendra-t-il dans votre mémoire ?#

Les tailles indiquées ici proviennent d'un guide communautaire sur l'exécution locale de DeepSeek (deepseek-local-guide-ru sur GitHub, 18 parties, CC BY 4.0, consulté le 22 octobre 2026). Il est non officiel et n'est pas affilié à DeepSeek. Les pages du guide ne concordent pas entièrement entre elles sur les tailles, alors vérifiez la taille du fichier sur la fiche du modèle Hugging Face avant de lancer un téléchargement de 100 Go.

Selon le guide, DeepSeek V4-Flash-0731 compte 284B paramètres, dont 13B actifs par token. Les fichiers :

Le modèle n'a pas besoin de tenir entièrement en mémoire vidéo. llama.cpp peut garder les couches d'experts en RAM système, mais la règle empirique du guide est sans détour : un GPU de 24 Go a besoin de 128 Go de RAM à côté.

Supposons que vous ayez un bon PC de jeu avec un GPU de 24 Go et 64 Go de RAM. Additionnez les deux et comparez avec le plus petit fichier :

24 + 64 = 88 Go, et le fichier Q3 fait 103 Go.

Ça ne tient pas, et le système d'exploitation a encore besoin de sa propre mémoire. Avec 24 Go de VRAM et 128 Go de RAM, vous avez 152 Go, et le fichier de 103 Go tient avec de la marge.

Le plus récent DeepSeek-V4.1-Flash-1017 est plus gros : environ 552B paramètres plus 196B d'Engram, environ 510 Go en FP8 et environ 167 Go en 2 bits, selon le même guide. Le support est l'autre problème. À la date du guide (vérifié le 22 octobre 2026), il ne fonctionne pas dans Ollama, car l'architecture deepseek_v41 n'est pas prise en charge, et le support dans llama.cpp et LM Studio n'est pas dans leurs branches principales. Cela évolue vite, alors consultez les notes de version de votre moteur avant de planifier autour de cela.

Quelle est sa vitesse ?#

Le guide donne deux mesures, toutes deux à forte quantification et toutes deux issues de la communauté, alors lisez-les comme des ordres de grandeur et non comme un benchmark :

• DGX Spark avec 128 Go, V4-Flash en IQ2 : environ 6 à 7 tokens par seconde.
• Mac Studio M3 Ultra avec 256 Go, V4.1-Flash en MLX 2 bits : environ 9,5 tokens par seconde.

Le guide ne donne aucun chiffre pour une RTX 4090 ou 5090.

Qu'est-ce que cela représente ? Une réponse de 1 000 tokens correspond à environ une page et demie de texte :

1 000 ÷ 9,5 = 105,3 secondes

1 000 ÷ 6 = 166,7 secondes

Pour un chat que vous lisez au fil du flux, c'est lent mais utilisable. Pour un agent qui effectue des dizaines d'appels par tâche, cela s'accumule vite. Supposons que votre boucle produise 2 000 000 de tokens de sortie par jour et que la machine génère réellement 9,5 tokens par seconde sans interruption :

2 000 000 ÷ 9,5 = 210 526 secondes

210 526 ÷ 3 600 = 58,5 heures

C'est plus d'une journée de génération pour une journée de travail. Les vrais serveurs traitent plusieurs requêtes en lot, donc le tableau n'est pas aussi sombre pour une équipe, mais vous passeriez votre temps à régler le moteur au lieu de construire votre produit.

Ce que coûte la même charge de travail via une API#

Rendons l'exemple concret. Supposons une boucle d'agent qui envoie 10 millions de tokens d'entrée et reçoit 2 millions de tokens de sortie par jour. Ce sont des chiffres supposés, remplacez-les par les vôtres tirés du journal d'utilisation.

La page de tarifs de DeepSeek elle-même (22 octobre 2026, la page n'affiche aucune date) liste deepseek-flash, servi par DeepSeek-V4.1-Flash-1017, à ces prix par 1M tokens, heures creuses / heures pleines : entrée avec cache manqué 0,15 $ / 0,30 $, sortie 0,60 $ / 1,20 $. Les heures pleines sont 01:00–04:00 et 06:00–10:00 UTC, du lundi au vendredi, hors jours fériés chinois ; les heures creuses valent la moitié des heures pleines. L'entrée avec cache touché est bien moins chère (0,003 $ / 0,006 $), donc une boucle qui renvoie le même long préfixe descendra sous les chiffres indiqués ici.

Pour la charge de travail supposée, avec cache manqué :

Heures creuses : 10 × 0,15 $ + 2 × 0,60 $ = 2,70 $ par jour

Heures pleines : 10 × 0,30 $ + 2 × 1,20 $ = 5,40 $ par jour

Sur CheapTokens, pour le même type de boucle d'agent, prenez MiniMax-M2.7 (minimax-m2.7) : un prix fixe à toute heure, pas de fenêtre d'heures pleines, jusqu'à 8 192 tokens de sortie par réponse, un contexte de 180K, et un seul solde pour tous les modèles. Les mêmes 10M tokens d'entrée et 2M de sortie coûtent $0.80 par jour. Globalement, en comptant l'entrée et la sortie ensemble, c'est moins cher qu'OpenRouter ; voici le tableau en direct pour exactement cette charge de travail :

Le tableau relit la liste de prix actuelle à chaque affichage, il reste donc correct quand les prix changent. La liste complète des prix se trouve sur la page de tarifs CheapTokens, et Tarifs de l'API DeepSeek en 2026 explique comment les cache touchés et les heures pleines modifient une facture.

Quand votre propre matériel est-il rentable ?#

Les tokens locaux ne coûtent rien par requête, mais la machine, si. Une façon simple de vérifier :

payback days = hardware price ÷ (daily API bill − daily electricity)

Je ne donne pas de prix matériel ici car il varie trop ; mettez celui qu'on vous a proposé. Pour vous faire une idée, prenez la facture en heures creuses de la page de tarifs DeepSeek ci-dessus. Chaque 1 000 $ de matériel nécessite autant de jours de facture API pour être amorti, avant l'électricité et votre propre temps :

1 000 ÷ 2,70 = 370,4 jours

Et cela suppose que la machine puisse fournir ce volume, ce qui n'est pas le cas : à 9,5 tokens par seconde, elle ne le peut pas (voir la section sur la vitesse ci-dessus), donc pour une charge de travail d'agent, l'amortissement ne tient pas. Le local a plus de sens quand :

• les données ne doivent pas quitter votre réseau, et cela compte plus que la facture ;
• vous possédez déjà la machine et la charge est légère, disons quelques centaines de requêtes par jour pour un outil personnel ;
• vous voulez expérimenter avec les poids eux-mêmes : quantification, fine-tuning, un moteur de votre choix.

Une API a plus de sens quand la charge de travail est un agent ou un service, quand vous avez besoin de la réponse en quelques secondes, ou quand votre matériel est en dessous des tailles de mémoire ci-dessus. Si votre machine est trop petite même pour le fichier DeepSeek le plus léger, MiniMax-M2.7 (contexte de 180K, jusqu'à 8 192 tokens de sortie par réponse, globalement moins cher qu'OpenRouter) est un modèle à essayer via le même client.

Passer du local à une API hébergée#

Les projets de loisir commencent souvent sur Ollama puis le dépassent. La bonne nouvelle : les moteurs locaux parlent le protocole OpenAI. La page de compatibilité d'Ollama (docs.ollama.com, consultée le 22 octobre 2026) montre le point de terminaison http://localhost:11434/v1/ ; le client a besoin d'une valeur api_key, mais Ollama l'ignore. Le streaming, le mode JSON et les outils fonctionnent ; les logprobs non.

Donc le basculement tient en deux lignes plus le nom du modèle :

import os
from openai import OpenAI

# Local Ollama: the key is required by the client but ignored by the server
# client = OpenAI(base_url="http://localhost:11434/v1/", api_key="ollama")

client = OpenAI(
    base_url="https://api.cheaptokens.dev/v1",
    api_key=os.environ["CHEAPTOKENS_API_KEY"],
)

reply = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M2.7",  # take the exact id from the CheapTokens docs
    messages=[{"role": "user", "content": "Summarize this ticket in one sentence: ..."}],
    max_tokens=200,
)
print(reply.choices[0].message.content)
print(reply.usage)

Quand cela fonctionne, vous voyez un résumé d'une phrase et un objet usage avec les décomptes de tokens du prompt et de la complétion, les mêmes chiffres sur lesquels votre facture est basée. L'API CheapTokens accepte aussi le format Anthropic Messages, et la documentation montre la première requête étape par étape. Si base_url est nouveau pour vous, API compatible OpenAI : qu'est-ce que base_url prend deux minutes.

Si ça ne fonctionne pas#

• Connection refused sur localhost:11434 : Ollama ne tourne pas, ou vous pointez encore vers l'adresse locale.
• 401 : la clé est manquante ou copiée avec un espace ; lisez-la depuis une variable d'environnement, comme dans l'exemple.
• 404 ou un modèle inconnu : l'identifiant du modèle ne correspond pas. Les noms locaux et hébergés diffèrent, alors copiez l'identifiant depuis la documentation.

Lequel choisir#

Si vous possédez 128 Go ou plus et êtes curieux, exécutez les poids chez vous et profitez du contrôle. Si vous construisez un agent qui consomme des millions de tokens par jour, ou un service où les utilisateurs attendent la réponse, utilisez l'API et gardez l'installation locale pour les expérimentations. Le code reste le même dans les deux cas, vous pouvez donc commencer avec l'un et passer à l'autre plus tard. Pour en savoir plus sur l'auto-hébergement, voir ce que DeepInfer signifie pour l'auto-hébergement ; pour essayer DeepSeek via l'API, voir modèles DeepSeek de CheapTokens.