Points clés
- Le meilleur modèle local est le plus grand qui s'adapte à votre VRAM à une vitesse utilisable, et non celui qui a la meilleure réputation.
- Ollama expose un endpoint compatible OpenAI sur votre propre machine, donc le même code client fonctionne en local et hébergé.
- Le local offre la confidentialité et l'utilisation hors ligne ; l'hébergé offre un modèle plus grand, sans matériel ni configuration.
- Nous proposons uniquement un endpoint hébergé : il n'y a pas de téléchargement de modèle depuis ce service.
Réponse courte : choisissez par mémoire, puis testez deux ou trois
Il n'y a pas de meilleur modèle unique pour cela, car la limite est votre matériel. Un modèle doit tenir dans la mémoire GPU (ou dans la RAM système, beaucoup plus lentement) avec son cache de travail. La règle pratique est simple : trouvez le plus grand modèle qui tient confortablement dans votre mémoire et répond encore à une vitesse supportable, puis comparez deux ou trois candidats sur vos propres prompts.
Les noms de modèles et les classements évoluent toutes les quelques semaines, donc toute liste rédigée aujourd’hui vieillit vite. Évitez les classements et utilisez une méthode courte : parcourez la bibliothèque Ollama et les dépôts communautaires, filtrez les modèles décrits comme sans censure, ablitérés ou peaufinés pour le jeu de rôle, téléchargez-en un petit et un de taille moyenne, et exécutez les mêmes dix prompts sur chacun. Vos propres prompts vous en apprennent plus qu’un score sur le benchmark d’un autre.
Si après cela vous constatez que les modèles compatibles avec votre machine sont trop petits pour la qualité souhaitée, un endpoint hébergé est l'alternative. Le reste de cette page expose le compromis pour que vous puissiez décider avec des chiffres.
Comment dimensionner un modèle pour votre machine
Trois nombres déterminent ce qui fonctionne bien : le nombre de paramètres, la quantification et la longueur du contexte.
Paramètres et quantification
Un modèle avec plus de paramètres écrit généralement mieux, suit les instructions plus fiablement et maintient un personnage plus longtemps. Mais les paramètres prennent de la mémoire. À une précision complète de 16 bits, un modèle nécessite environ deux octets par paramètre, donc un modèle de 7B nécessite environ 14 Go avant tout cache. La quantification réduit cela. Une version 4 bits nécessite environ un demi-octet par paramètre, donc le même modèle de 7B tient dans environ 4 à 5 Go. La qualité baisse un peu à chaque étape, et la perte est généralement faible à 4 ou 5 bits et notable en dessous.
Longueur du contexte
La fenêtre de contexte coûte aussi de la mémoire, car le modèle stocke un cache de tout ce qui est dans la conversation. Une longue session de jeu de rôle ou une histoire avec beaucoup de texte antérieur nécessite un cache plus grand. Ollama vous permet de définir la taille du contexte par modèle, et une valeur plus grande utilise plus de mémoire et ralentit la génération. De nombreuses configurations locales fonctionnent avec une fenêtre de quelques milliers de tokens pour rester rapides, ce qui signifie que le modèle oublie le début des longues conversations.
Vitesse
Si un modèle déborde de la mémoire GPU vers la RAM système, la génération peut passer d'une vitesse de lecture agréable à un mot à la fois. Un modèle plus petit qui tient entièrement sur le GPU semble souvent meilleur qu'un plus grand qui ne le fait pas, même si le plus grand écrit légèrement mieux.
Exécuter un modèle dans Ollama et l'appeler depuis du code
Une fois Ollama installé, le téléchargement et le chat prennent deux commandes, et le nom exact du modèle provient de la page de bibliothèque que vous avez choisie :
ollama pull MODEL_NAME
ollama run MODEL_NAMEOllama sert également une API compatible OpenAI sur votre propre machine, par défaut à http://localhost:11434/v1. Cela signifie que le même code client peut parler à un modèle local ou hébergé, et vous changez en modifiant l'URL de base et le nom du modèle :
from openai import OpenAI
# Local Ollama (the key is ignored but must be non-empty)
local = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
# Hosted endpoint
hosted = OpenAI(base_url="https://api.ornith.top/v1", api_key="YOUR_API_KEY")
def ask(client, model, text):
r = client.chat.completions.create(
model=model,
messages=[{"role": "user", "content": text}],
)
return r.choices[0].message.content
prompt = "Write a tense two-paragraph scene set in an abandoned lighthouse."
print(ask(local, "MODEL_NAME", prompt))
print(ask(hosted, "uncensored", prompt))Exécuter les deux sur les mêmes prompts est le moyen le plus rapide de répondre à la question pour votre propre cas. Si la sortie locale est suffisamment bonne, vous avez terminé et cela vous coûte de l'électricité. Sinon, vous avez une base de référence pour ce que vous gagneriez.
Ollama local versus une API hébergée
Aucun n'est meilleur dans tous les cas. Ce tableau s'en tient à ce qui est structurellement vrai de chaque approche.
| Point | Local avec Ollama | API hébergée |
|---|---|---|
| Coût initial | Votre propre GPU ou une machine avec suffisamment de RAM | Aucun ; crédit prépayé à partir de 20 $ |
| Coût d'exécution | Électricité et votre temps | 0,15 $ par 1M de tokens d'entrée, 0,50 $ par 1M de tokens de sortie |
| Taille du modèle | Limité par votre mémoire | Un modèle choisi par le fournisseur |
| Fonctionne hors ligne | Oui | Non, nécessite internet |
| Les données quittent votre machine | Non | Oui, les prompts vont au fournisseur ; les nôtres ne sont pas utilisés pour l'entraînement |
| Choix du modèle | Tout ce que vous pouvez télécharger | Uniquement celui proposé |
| Utilisateurs simultanés | Limité par votre matériel | Jusqu'à 8 requêtes simultanées avec une clé complète |
| Configuration | Installer, télécharger, ajuster les paramètres | Changer une URL de base et une clé |
Le local gagne en confidentialité, en utilisation hors ligne et en liberté de choix. Si votre texte ne doit jamais quitter votre machine, ou si vous voulez échanger des modèles chaque semaine, exécutez en local. Une API hébergée gagne en temps de configuration, en ne pas occuper votre GPU pendant que vous travaillez, et en servant une application avec plusieurs utilisateurs à la fois.
Il est aussi juste de dire ce que nous n'offrons pas. Ce service est un endpoint hébergé uniquement. Il n'y a pas de fichier de modèle à télécharger, pas d'ajustement fin et aucun moyen d'apporter vos propres poids. Si vous voulez posséder le modèle, Ollama est le bon outil, et notre guide de l'API LLM open source passe en revue l'ensemble plus large des options.
Ce que coûte l'hébergement, détaillé
Les gens supposent souvent qu'un modèle hébergé est cher par rapport à l'exécution locale gratuite. Le local n'est pas gratuit une fois que vous comptez le matériel, mais la comparaison est plus facile avec une utilisation concrète. Les prix ici sont de 0,15 $ par 1M de tokens d'entrée et de 0,50 $ par 1M de tokens de sortie.
- Jeu de rôle décontracté, 100 messages par jour. Disons que chaque tour envoie 3 000 tokens d'historique et reçoit 300 tokens. Entrée par tour : 3 000 à 0,15 $ par 1M font 0,00045 $. Sortie : 300 à 0,50 $ par 1M font 0,00015 $. Cela fait 0,0006 $ par tour, 0,06 $ pour 100 tours, environ 1,80 $ sur 30 jours.
- Un projet d'écriture. 5M de tokens d'entrée et 1M de tokens de sortie en un mois font 0,75 $ plus 0,50 $, soit 1,25 $.
- Une petite application. 200M d'entrée et 40M de tokens de sortie par mois font 30 $ plus 20 $, soit 50 $.
Vous seul pouvez évaluer votre propre GPU, mais une utilisation légère et moyenne coûte très peu en hébergé. Le rechargement minimum de 20 $ couvre une longue période aux deux premiers niveaux, et le crédit n'expire jamais, donc il ne disparaîtra pas si vous prenez un mois de congé. Les rechargements plus importants comportent un bonus : 5 % à partir de 50 $, 10 % à partir de 100 $, 15 % à partir de 200 $. Les détails complets sont sur la page de tarification.
Une façon sensée de combiner les deux
Vous n'avez pas à choisir une fois pour toutes. Beaucoup de gens exécutent un petit modèle local pour des brouillons rapides et des notes privées, et envoient les tâches plus longues ou plus exigeantes à un endpoint hébergé. Comme les deux parlent le format OpenAI, votre application peut conserver deux objets client et router par tâche, comme dans le code ci-dessus.
Lorsque vous testez le côté hébergé, les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai en un clic sur la page clé API, sans carte, une par personne, valable 7 jours. Aux chiffres par tour ci-dessus, cela représente des centaines de tours de jeu de rôle, suffisants pour comparer avec votre meilleur modèle local sur des prompts identiques. Vous pouvez créer une clé API après vous être connecté avec Google ou avec email et mot de passe. La documentation API liste des paramètres tels que temperature, top_p, stop et seed, qui sont transmis, donc vos paramètres d'échantillonnage locaux sont conservés.
Quelques limites à prévoir. Une clé d'essai permet 2 requêtes simultanées et 60 requêtes par minute ; une clé complète permet 8 et 300. La fenêtre de contexte est de 100 000 tokens, bien plus grand que ce que la plupart des configurations locales exécutent confortablement. Et la règle qui ne change pas avec les paramètres : le modèle est pour une utilisation adulte légale et ne produira pas de contenu sexuel impliquant des mineurs.
