DEV-AI
LM Studio LLM Local Modèles locaux Python GPU · Apple Silicon

Publié le · Lecture : 14 min

LM Studio 2026 : faire tourner un LLM en local — guide complet

Vous voulez utiliser Llama, Mistral ou DeepSeek en local sans toucher au terminal ? LM Studio est l'application qui rend le LLM local accessible à tous — des non-développeurs aux data scientists — avec une interface graphique, une API Python et un serveur compatible OpenAI.
Ce que vous allez apprendre : installer LM Studio sur macOS, Windows et Linux, télécharger et gérer des modèles depuis l'interface, démarrer le serveur local, utiliser le SDK Python natif et l'API compatible OpenAI, piloter LM Studio depuis la CLI, et comprendre quand choisir LM Studio plutôt qu'Ollama.

TL;DR — Choisir LM Studio si :

  • Vous voulez une interface graphique
  • Vous êtes sur Apple Silicon (MLX natif)
  • Vous gérez des modèles sans terminal
  • Vous voulez chatter directement dans l'app
  • Vous prototypez rapidement
  • Vous intégrez via l'API Python
  • Données sensibles / RGPD
  • Zéro cloud, zéro abonnement

1. Pourquoi faire tourner un LLM en local avec LM Studio ?

Les API cloud (OpenAI, Anthropic, Google) sont puissantes — mais elles envoient vos données vers des serveurs externes, coûtent par token, et nécessitent une connexion internet. LM Studio résout les trois problèmes à la fois.

Confidentialité totale

Vos données ne quittent jamais votre machine — plus simple à maîtriser côté RGPD, car aucun transfert vers des serveurs tiers n'a lieu.

Zéro coût variable

Pas de facturation au token. Un million de tokens = le même coût électrique qu'un million ou dix.

Interface graphique

Contrairement à Ollama, LM Studio propose un chat intégré, un gestionnaire de modèles visuel et des réglages en temps réel.

Apple Silicon MLX

Sur Mac M1/M2/M3, LM Studio exploite le moteur MLX d'Apple qui tire parti du GPU et de la mémoire unifiée — généralement plus rapide que llama.cpp sur la même machine.

2. Comment fonctionne LM Studio

LM Studio est une application Electron qui encapsule deux moteurs d'inférence selon votre matériel :

llama.cpp (GGUF)

  • Windows, Linux, macOS Intel
  • GPU NVIDIA (CUDA) et AMD (ROCm)
  • Format .gguf depuis HuggingFace
  • Quantisations Q2 à Q8

MLX (Apple Silicon)

  • M1, M2, M3, M4 uniquement
  • Mémoire unifiée CPU/GPU
  • Format mlx ou .gguf
  • Souvent plus rapide que GGUF/llama.cpp, selon le modèle et la quantisation

LM Studio choisit automatiquement le moteur optimal pour votre matériel. Vous n'avez rien à configurer. En arrière-plan, il gère le chargement du modèle en VRAM/RAM, le KV Cache, et la tokenisation.

Le serveur interne écoute sur http://localhost:1234 et expose :

3. Installation

LM Studio ne nécessite aucune dépendance préalable — Python, Docker ou CUDA ne sont pas requis pour démarrer. L'installeur embarque tout.

3.1 macOS

  1. Rendez-vous sur lmstudio.ai et téléchargez le .dmg
  2. Glissez LM Studio dans votre dossier Applications
  3. Au premier lancement, macOS demandera d'autoriser l'app (Réglages Système → Confidentialité → Ouvrir quand même)
  4. Sur Apple Silicon (M1/M2/M3/M4), LM Studio activera automatiquement le moteur MLX
# Vérifier la version installée via CLI
lms --version

3.2 Windows

  1. Téléchargez le .exe depuis lmstudio.ai (version x64 ou ARM64)
  2. Lancez l'installeur — il ne nécessite pas de droits administrateur
  3. LM Studio détecte automatiquement votre GPU NVIDIA (CUDA) ou AMD (ROCm)
  4. Sur Windows ARM (Copilot+), utilisez la version ARM64 pour les meilleures performances
Windows + NVIDIA : assurez-vous que vos drivers NVIDIA sont à jour (≥ 527.x pour CUDA 12). LM Studio gère CUDA automatiquement — vous n'avez pas à installer le toolkit CUDA séparément.

3.3 Linux

LM Studio est disponible en AppImage (portable, sans installation système) :

# Télécharger l'AppImage
wget https://releases.lmstudio.ai/linux/x64/latest/LM_Studio-linux-x64.AppImage

# Rendre exécutable
chmod +x LM_Studio-linux-x64.AppImage

# Lancer
./LM_Studio-linux-x64.AppImage

Pour une installation plus propre avec le CLI lms accessible globalement :

# Après le premier lancement, installer le CLI
lms install-cli

# Vérifier
lms --help

4. Premiers pas — télécharger et lancer un modèle

4.1 Depuis l'interface graphique

À l'ouverture de LM Studio, vous avez accès à quatre onglets principaux :

Pour télécharger votre premier modèle :

  1. Allez dans l'onglet Discover
  2. Tapez llama ou mistral dans la barre de recherche
  3. Sélectionnez Llama 3.2 3B Instruct pour commencer (léger, ~2 Go)
  4. Choisissez la quantisation Q4_K_M (recommandée : meilleur ratio qualité/taille)
  5. Cliquez Download
Où sont stockés les modèles ?
Par défaut dans ~/.lmstudio/models/ sur macOS/Linux et %USERPROFILE%\.lmstudio\models\ sur Windows. Chaque modèle est un unique fichier .gguf.

4.2 Depuis la CLI (lms get)

# Télécharger un modèle directement
lms get llama3.2

# Ou un modèle spécifique depuis HuggingFace
lms get bartowski/Llama-3.2-3B-Instruct-GGUF

# Lister les modèles disponibles sur disque
lms ls

5. Quels modèles choisir ? Comparatif et VRAM requise

LM Studio supporte tous les modèles au format GGUF (HuggingFace) et les modèles MLX pour Apple Silicon. Voici les recommandations par profil matériel.

5.1 Tableau VRAM / RAM requise par modèle (quantisation Q4_K_M)

Modèle Taille fichier VRAM / RAM min. Tokens/s (RTX 4070, indicatif) Usage idéal
Llama 3.2 3B ~2 Go 4 Go 90+ t/s Démarrage rapide, prototypage
Mistral 7B Instruct ~4.1 Go 8 Go 55 t/s Usage général, résumé, rédaction
Llama 3.1 8B Instruct ~4.7 Go 8 Go 48 t/s Meilleur équilibre qualité/vitesse
DeepSeek-R1-Distill-Qwen-7B ~4.7 Go 8 Go 40 t/s Raisonnement, maths, code
Qwen3 14B ~8.5 Go 12 Go 28 t/s Multilingue, analyse longue
Gemma 3 27B ~17 Go 20 Go 14 t/s Excellent niveau, multimodal (vision)

5.2 Apple Silicon — avantage MLX

Sur Mac M-series, LM Studio utilise le moteur MLX qui exploite le GPU Apple et la mémoire unifiée. Un M3 Pro (18 Go) peut faire tourner confortablement un modèle 13B en Q4 — souvent au-dessus de ce que permet 8 Go de VRAM dédiée sur PC.

Puce Apple Mémoire unifiée Modèles recommandés
M1 / M2 (8 Go)8 Go3B-7B (Llama 3.2, Mistral 7B)
M2 Pro / M3 (16 Go)16 Go8B-13B confortablement
M3 Pro / M4 Pro (36 Go)36 Go27B-34B avec bonnes perfs
M3 Max / M4 Max (64 Go)64 Go70B en Q4 possible

6. CLI lms — piloter LM Studio en ligne de commande

LM Studio embarque un CLI appelé lms, installable globalement après le premier lancement de l'app. Il permet de tout piloter sans interface graphique — idéal pour les scripts et l'automatisation.

# Installer le CLI globalement
lms install-cli

# Télécharger un modèle
lms get llama3.2

# Lister les modèles sur disque
lms ls

# Charger un modèle (utiliser le model_key affiché par lms ls)
lms load llama3.2 --gpu=max

# Charger avec contexte étendu
lms load llama3.2 --context-length=32768

# Lister les modèles actuellement en mémoire
lms ps

# Décharger tous les modèles
lms unload --all

# Démarrer le serveur local
lms server start

# Arrêter le serveur
lms server stop

# Chat interactif depuis le terminal
lms chat

7. Démarrer le serveur local

Pour utiliser LM Studio depuis Python ou n'importe quelle application externe, vous devez démarrer le serveur local. Il écoute sur http://localhost:1234 par défaut.

7.1 Via l'interface

  1. Ouvrez LM Studio → onglet Developer
  2. Chargez un modèle dans le menu déroulant
  3. Cliquez Start Server
  4. Le serveur est prêt quand vous voyez Server running on port 1234

7.2 Via la CLI (headless)

# Charger un modèle puis démarrer le serveur
lms load llama3.2 --gpu=max
lms server start

# Vérifier que l'API répond
curl http://localhost:1234/v1/models

8. SDK Python natif

LM Studio propose un SDK Python officiel — plus simple que l'API OpenAI pour les cas courants, avec une gestion native du chat multi-tours et des embeddings.

8.1 Installation

pip install lmstudio

Le SDK se connecte automatiquement au serveur LM Studio sur localhost:1234. Démarrez le serveur avant d'exécuter votre code.

8.2 Réponse simple

import lmstudio as lms

# Utilise le modèle actuellement chargé dans LM Studio
model = lms.llm()

result = model.respond("Explique le RAG en une phrase.")
print(result)

8.3 Conversation multi-tours

import lmstudio as lms

model = lms.llm()
chat = lms.Chat("Tu es un assistant expert en Python.")

questions = [
  "C'est quoi un décorateur ?",
  "Donne-moi un exemple concret.",
  "Comment l'utiliser pour mesurer le temps d'exécution ?",
]

for question in questions:
  chat.add_user_message(question)
  response = model.respond(chat)
  chat.add_assistant_response(response)
  print(f"Q: {question}")
  print(f"R: {response}\n")

8.4 Completion de texte (non-chat)

import lmstudio as lms

model = lms.llm()

# Completion de texte brut (pas de format chat)
result = model.complete("Les LLMs fonctionnent en")
print(result)

8.5 Spécifier un modèle

import lmstudio as lms

# Charger un modèle spécifique (LM Studio le charge si nécessaire)
model = lms.llm("llama3.2")
result = model.respond("Bonjour !")
print(result)

8.6 API async (Python asyncio)

import asyncio
import lmstudio as lms

async def main():
  async with lms.AsyncClient() as client:
    model = await client.llm.model("llama3.2")
    result = await model.respond("Qu'est-ce que le deep learning ?")
    print(result)

asyncio.run(main())

9. API compatible OpenAI

Si vous avez déjà du code qui utilise le SDK openai, vous pouvez basculer sur LM Studio sans modifier votre code applicatif — juste en changeant l'URL et la clé API.

9.1 Chat simple

from openai import OpenAI

client = OpenAI(
  base_url="http://localhost:1234/v1",
  api_key="lm-studio", # valeur libre, non vérifiée en local
)

response = client.chat.completions.create(
  model="llama3.2", # nom du modèle chargé dans LM Studio
  messages=[{"role": "user", "content": "Explique les embeddings en 3 lignes."}],
  temperature=0.7,
)

print(response.choices[0].message.content)

9.2 Streaming

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

stream = client.chat.completions.create(
  model="llama3.2",
  messages=[{"role": "user", "content": "Écris un poème sur le Python."}],
  stream=True,
)

for chunk in stream:
  delta = chunk.choices[0].delta.content
  if delta:
    print(delta, end="", flush=True)

9.3 Embeddings

from openai import OpenAI

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

# Charger un modèle d'embedding dans LM Studio avant
# (ex: nomic-embed-text, all-MiniLM)
response = client.embeddings.create(
  model="nomic-embed-text",
  input="Les LLMs transforment le développement logiciel.",
)

vector = response.data[0].embedding
print(f"Dimension : {len(vector)}") # 768 pour nomic-embed

9.4 Structured Output (JSON Schema)

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

schema = {
  "type": "object",
  "properties": {
    "nom": {"type": "string"},
    "langage": {"type": "string"},
    "annee": {"type": "integer"},
  },
  "required": ["nom", "langage", "annee"],
}

response = client.chat.completions.create(
  model="llama3.2",
  messages=[{"role": "user", "content": "Donne-moi les infos sur TensorFlow."}],
  response_format={"type": "json_schema", "json_schema": {"name": "framework", "schema": schema}},
)

data = json.loads(response.choices[0].message.content)
print(data) # {"nom": "TensorFlow", "langage": "Python", "annee": 2015}

10. LM Studio vs Ollama — lequel choisir ?

Les deux outils font la même chose à la base — faire tourner un LLM en local — mais avec des philosophies différentes.

Critère LM Studio Ollama
Interface graphique Complète Terminal only
Apple Silicon MLX Natif Partiel
SDK Python officiel lmstudio ollama
API compatible OpenAI Port 1234 Port 11434
Compatibilité Anthropic /v1/messages
Légèreté / ressources Electron (~300 Mo) Très léger
Usage serveur / CI Headless possible Idéal
Chat RAG local intégré Dans l’app Externe
Support MCP Natif Non natif
Public cibleTous niveauxDéveloppeurs
Recommandation : utilisez LM Studio si vous voulez une interface graphique, êtes sur Mac Apple Silicon, ou prototypez rapidement. Utilisez Ollama si vous intégrez dans un pipeline Python automatisé, un serveur ou un container Docker. Les deux peuvent coexister sur la même machine.

11. Cas d'usage concrets

11.1 Analyse de documents confidentiels

from openai import OpenAI
from pathlib import Path

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

# Lire un document confidentiel (contrat, rapport interne…)
document = Path("contrat_confidentiel.txt").read_text()

response = client.chat.completions.create(
  model="llama3.2",
  messages=[
    {"role": "system", "content": "Tu es un juriste. Résume et identifie les risques."},
    {"role": "user", "content": document},
  ]
)
print(response.choices[0].message.content) # Zéro donnée envoyée en dehors de votre machine

11.2 Pipeline de classification locale

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:1234/v1", api_key="lm-studio")

tickets = [
  "Mon paiement n'a pas fonctionné",
  "Je veux changer mon mot de passe",
  "Le site est lent depuis ce matin",
]

for ticket in tickets:
  resp = client.chat.completions.create(
    model="llama3.2",
    messages=[
      {"role": "system", "content": 'Réponds uniquement en JSON: {"categorie": "paiement|compte|technique", "priorite": "haute|normale"}'},
      {"role": "user", "content": ticket},
    ],
    response_format={"type": "json_object"},
  )
  result = json.loads(resp.choices[0].message.content)
  print(f"{ticket[:40]} → {result}")

FAQ

Qu'est-ce que LM Studio ?

LM Studio est une application desktop gratuite (macOS, Windows, Linux) qui permet de télécharger et d'exécuter des LLMs en local — zéro cloud, zéro abonnement. Il propose une interface graphique pour chatter avec les modèles, un gestionnaire de modèles visuel, un serveur local compatible OpenAI et un SDK Python officiel.

Quelle est la différence entre LM Studio et Ollama ?

LM Studio propose une interface graphique complète — chat intégré, gestionnaire de modèles visuel, réglages en temps réel. Ollama est orienté terminal et développeurs : plus léger, parfait pour les pipelines Python automatisés et les serveurs. LM Studio est idéal pour les utilisateurs qui ne veulent pas toucher au terminal ; Ollama pour ceux qui automatisent et scriptent. Voir notre guide Ollama complet →

De combien de VRAM ai-je besoin pour LM Studio ?

Avec 4-6 Go de VRAM (ou RAM sur Mac), des modèles 3B tournent correctement. Avec 8 Go, les modèles 7-8B (Mistral, Llama 3.1 8B) donnent d'excellents résultats. Sur Apple Silicon, la mémoire unifiée est partagée — un M2 de 16 Go peut faire tourner des modèles 13B. Sur CPU pur (sans GPU), des modèles 3B restent utilisables mais lents.

LM Studio est-il gratuit ?

Oui, LM Studio est entièrement gratuit pour usage personnel et professionnel. L'application est disponible sur lmstudio.ai. Attention : les modèles ont chacun leur propre licence — vérifiez toujours la licence avant tout usage commercial (Llama, Mistral, Gemma ont des conditions spécifiques).

LM Studio supporte-t-il l'API OpenAI ?

Oui. Une fois le serveur local démarré, LM Studio expose une API compatible OpenAI sur http://localhost:1234/v1. Remplacez simplement base_url dans votre client Python existant. LM Studio supporte aussi une compatibilité Anthropic (/v1/messages) — unique parmi les outils LLM locaux.

LM Studio fonctionne-t-il sans GPU ?

Oui. LM Studio fonctionne en mode CPU pur. Sur Mac Apple Silicon (M1/M2/M3), c'est même recommandé — MLX exploite le GPU Apple et la mémoire unifiée pour des performances très correctes sur des modèles 8B+. Sur Windows/Linux sans GPU, préférez des modèles 3B maximum pour une expérience fluide.

Ressources complémentaires

Ollama — LLM local

L'alternative CLI, plus légère

RAG avec Ollama en Python

Connecter vos documents à un LLM local

MLflow — Tracking LLM

Évaluer et monitorer vos modèles locaux

Langfuse — Observabilité LLM

Traces et évaluation de vos pipelines IA