Comment exécuter le LLM Dolphin : configuration locale vs API hébergée

Décidez d'abord : quel matériel avez-vous ?

La mémoire décide de tout. Un modèle de langage est un très grand ensemble de nombres, et l'intégralité de cet ensemble doit résider en mémoire rapide pendant la génération. La quantification réduit ces nombres. Un modèle quantifié en 4 bits prend environ la moitié d'un octet par paramètre, donc un modèle de 8 milliards de paramètres pèse environ 5 Go, et un de 70 milliards environ 40 Go. Considérez ces chiffres comme approximatifs, car la taille exacte dépend du format de quantification.

En plus des poids, vous avez besoin d'espace pour la fenêtre de contexte. Elle augmente avec la longueur du prompt, donc un historique de jeu de rôle long ou un gros document coûte plus de mémoire qu'une question courte. Prévoyez quelques gigaoctets supplémentaires pour une fenêtre de contexte modeste, plus si vous visez des prompts longs.

• Ordinateur portable de 8 Go sans GPU : uniquement des petits modèles, sortie lente.
• Mac Apple Silicon de 16 à 32 Go : les modèles de taille moyenne tournent bien car le CPU et le GPU partagent la mémoire.
• GPU grand public unique avec 12 à 24 Go de VRAM : modèles de taille moyenne à bonne vitesse.
• Plus gros : plusieurs GPU ou un serveur loué.

Méthode 1 : Ollama en quelques commandes

Ollama est le chemin le plus court. Il télécharge un modèle quantifié, démarre un serveur en arrière-plan et vous donne une invite de chat. Installez-le depuis le site officiel pour votre système d'exploitation, puis vérifiez quels tags Dolphin la bibliothèque de modèles Ollama liste actuellement, car les noms et tailles changent entre les versions.

Copy# replace <tag> with a Dolphin tag from the Ollama library
ollama pull <tag>
ollama run <tag>

La première commande télécharge le fichier, ce qui peut prendre un certain temps sur une connexion lente. La seconde ouvre un chat interactif dans le terminal. Ollama sert également une API HTTP sur votre machine, y compris une route au style OpenAI sous /v1, afin que d'autres programmes puissent l'utiliser.

Si la génération est très lente, le modèle ne tient probablement pas dans la VRAM et une partie s'exécute sur le CPU. Choisissez un tag plus petit ou une quantification à bits plus faibles.

Méthode 2 : llama.cpp pour plus de contrôle

llama.cpp est le moteur C++ sur lequel sont construits de nombreux autres outils. Vous téléchargez un fichier GGUF du modèle, puis démarrez son serveur. Cela prend plus d'étapes qu'Ollama mais vous permet de définir la longueur de la fenêtre de contexte, le nombre de couches placées sur le GPU et la quantification souhaitée.

Copy# after building llama.cpp and downloading a GGUF file
llama-server -m ./model.gguf -c 8192 -ngl 99 --port 8080

Ici -c définit la longueur de la fenêtre de contexte, -ngl définit combien de couches vont au GPU, et --port choisit le port. Consultez le README du projet pour les drapeaux de votre version, car ils évoluent. Une plus grande -c utilise plus de mémoire, augmentez-la seulement si vous en avez besoin.

Pour une utilisation graphique, des interfaces frontales comme Open WebUI peuvent parler à l'un ou l'autre serveur. Notre note sur les endpoints API Open WebUI montre comment ajouter un endpoint personnalisé.

Appeler votre serveur local depuis du code

Les deux outils peuvent parler le format de chat OpenAI, donc vous écrivez le client une fois et changez la cible avec deux paramètres. Ce script conserve les deux cibles côte à côte. Le local utilise le port qu'Ollama utilise par défaut ; changez-le si vous avez démarré llama.cpp sur le 8080.

Copyfrom openai import OpenAI

TARGETS = {
    "local": {"base_url": "http://localhost:11434/v1", "key": "not-needed", "model": "your-local-tag"},
    "hosted": {"base_url": "https://api.dolphinllm.com/v1", "key": "YOUR_KEY", "model": "uncensored"},
}

t = TARGETS["hosted"]
client = OpenAI(base_url=t["base_url"], api_key=t["key"])

resp = client.chat.completions.create(
    model=t["model"],
    messages=[{"role": "user", "content": "Summarize what a GGUF file is."}],
)
print(resp.choices[0].message.content)

Les serveurs locaux ignorent généralement la clé, mais le SDK exige une chaîne non vide. Le nom du modèle pour un serveur local est le tag ou l'alias que vous avez chargé, tandis que l'ID de modèle hébergé est toujours uncensored.

Méthode 3 : sautez l'installation et utilisez un endpoint hébergé

Si les calculs matériels sont défavorables, ou si vous voulez le même comportement sur chaque machine, un endpoint hébergé est plus simple. Ce service propose un seul modèle à poids ouverts, géré par un fournisseur indépendant et ajusté pour répondre sans refus de contenu pour une utilisation légale des adultes. Ce n'est pas l'API officielle d'aucun vendeur de modèle, et il ne vous permet pas de choisir d'autres modèles. Ce que vous obtenez est une URL stable, une clé et une facturation par token.

Les étapes sont courtes. Créez un compte avec Google ou par e-mail et mot de passe, ouvrez la page clé API, et obtenez le crédit d'essai de 0,50 $ en un clic. Aucune carte n'est requise, il est valable 7 jours, et il est limité à un par personne. Puis exécutez le script Python ci-dessus avec la cible hébergée. Si vous préférez curl :

Copycurl https://api.dolphinllm.com/v1/chat/completions   -H "Authorization: Bearer YOUR_KEY"   -H "Content-Type: application/json"   -d '{"model":"uncensored","messages":[{"role":"user","content":"Hello"}],"stream":false}'

La fenêtre de contexte est de 100 000 tokens, ce qui est plus que ce que la plupart des ordinateurs portables peuvent conserver confortablement en cache. Les prompts ne sont pas utilisés pour l'entraînement.

Coût et effort comparés

Le local semble gratuit, mais ce n'est pas le cas. Vous payez pour le matériel, l'électricité et votre propre temps. L'hébergé coûte de l'argent par requête, mais les chiffres sont faibles. À 0,15 $ par 1M de tokens d'entrée et 0,50 $ par 1M de tokens de sortie, un tour de chat avec 3 000 tokens d'entrée et 700 tokens de sortie coûte :

• Entrée : 3 000 x $0,15 / 1 000 000 = $0,00045
• Sortie : 700 x 0,50 $ / 1 000 000 = 0,00035 $
• Total : 0,0008 $ par tour, soit 0,80 $ pour 1 000 tours

Même un utilisateur intensif envoyant 5 000 de ces tours par mois dépenserait environ $4. Un GPU coûtant des centaines de dollars mettrait des années à rentabiliser ce volume. La comparaison s'inverse lorsque vous avez un volume élevé continu, besoin d'un fine-tune spécifique, ou ne pouvez pas envoyer de données hors de votre machine.

Les détails complets des prix, y compris les bonus de rechargement de +5 %, +10 % et +15 %, sont sur la page tarifs, et la documentation couvre les limites et les paramètres.

Une règle simple pour choisir

Exécutez-les en local si vous souhaitez expérimenter avec de nombreux modèles fine-tuned, travailler hors ligne ou conserver chaque prompt sur votre propre disque. Utilisez l'endpoint hébergé si vous construisez quelque chose que d'autres utiliseront, si votre matériel est modeste ou si vous souhaitez une fenêtre de contexte de 100 000 tokens sans gérer la mémoire. De nombreux développeurs font les deux : un modèle local pour des expérimentations privées, et un endpoint hébergé pour tout ce qui doit rester disponible. Comme le code client est identique, le changement ne coûte qu'une ligne.

Plus de guides

• Dolphin LLM API : Local, GPU loué ou Hébergé
• API LLM gratuite pour les développeurs : essai vs paiement à l’usage