Fiche - Etude - LM Studio, modèles locaux & linker avec GPT publics (ExoJS / Hexo.js)

Posté le 2025-11-23 Édité le 2025-11-26 dans Intelligence Artificielle , Développement

1. Contexte de l’échange

Cet article est une synthèse détaillée d’un échange autour des sujets suivants :

Comment installer et utiliser LM Studio en local.
Ce que l’on peut faire avec ses propres IA locales.
Les types de modèles (GPT-like), tailles, stats et cas d’usage.
Les types de données d’entrée (texte, PDF, etc.) et les livrables possibles.
Les outils équivalents à LM Studio (Ollama, Hugging Face, etc.) et un rapide comparatif.
La mise en place d’un linker entre des GPT publics (API hébergées) et les modèles locaux.
Un exemple d’intégration ExoJS avec un blog statique (Hexo.js / gPage) et gTube.

L’objectif : disposer d’une documentation complète directement exploitable dans un blog Hexo.js (fichier Markdown avec front matter).

2. Présentation de LM Studio

LM Studio est une application desktop open source qui permet d’exécuter des modèles de langage (LLM) en local, sur ta machine.

2.1 Caractéristiques principales

Application desktop (Windows / macOS, et parfois Linux selon les builds).
Interface graphique conviviale :
- sélection et téléchargement de modèles,
- lancement / arrêt du modèle,
- zone de chat pour tester des prompts,
- réglage des paramètres (température, top-k, top-p, etc.).
Support des modèles au format GGUF (famille LLaMA, Mistral, Gemma, Phi, etc.).
Exécution offline : après téléchargement initial d’un modèle, tu peux travailler sans connexion internet.
Dans certaines versions/configs, LM Studio expose une API locale HTTP pour l’intégrer dans des scripts ou un backend (ExoJS, Node, etc.).

2.2 Licence

LM Studio est distribué sous une licence open source de type permissive (style MIT / Apache-like).
Toujours vérifier la licence exacte dans le dépôt officiel.

3. Historique & écosystème des outils LLM

Pour positionner LM Studio dans le paysage des LLM, voici quelques repères temporels (approximatifs) :

3.1 Hugging Face & Transformers

Hugging Face (HF) : société fondée vers 2016.
Bibliothèque Transformers (NLP / LLM) : premières versions publiques vers 2019.
Rôle :
- énorme hub de modèles (modèles open source hébergés),
- SDK Python pour charger et exécuter des modèles,
- solutions d’inférence (API, Text Generation Inference, etc.).

3.2 Ollama

Outil apparu autour de 2023.
Orienté runtime local :
- installation via CLI,
- exécution de modèles en local,
- API locale pour interagir avec les modèles.
Offre un format de modèle packagé + fichier de configuration simple.

3.3 LM Studio

Montée en puissance aussi autour de 2023, dans la vague des modèles LLaMA/Mistral open source.
Positionnement :
- Application GUI simple pour lancer un LLM local,
- Destiné à un usage de lab personnel ou de prototypage.

3.4 Relations entre ces projets

De nombreux modèles disponibles sur Hugging Face peuvent être convertis en GGUF et utilisés par LM Studio ou Ollama.
Hugging Face agit comme hub + écosystème, alors que LM Studio et Ollama fournissent un environnement d’exécution local clé en main.
Ces outils sont complémentaires : HF pour trouver/modifier des modèles, LM Studio / Ollama pour les exécuter facilement chez soi.

4. Pré-requis matériels & logiciels

4.1 Matériel

Les besoins dépendent de la taille du modèle et du niveau de performance attendu.

Catégorie de modèle	Paramètres (ordre de grandeur)	RAM/VRAM conseillée	Exemple d’usage
Petit (3B–7B)	3 à 7 milliards	8–16 Go	Chat basique, aide à la rédaction simple
Moyen (8B–13B)	8 à 13 milliards	16–32 Go	Chat avancé, résumé de documents
Grand (30B+)	30+ milliards	32+ Go	Raisonnement plus profond, meilleure cohérence

LM Studio peut fonctionner CPU-only, mais une GPU (NVIDIA, Apple Silicon, etc.) apporte un gros gain en vitesse.

4.2 Logiciel

Système d’exploitation : Windows / macOS (Linux si builds disponibles).
LM Studio : application desktop.
Pour les intégrations avancées (ExoJS / Hexo.js / pipelines) :
- Node.js (ou Deno/Bun selon ton écosystème),
- bibliothèques HTTP (fetch, axios, etc.),
- éventuellement des scripts Python pour pré/post-traitement de données.

5. Installation & utilisation de LM Studio

5.1 Téléchargement

Aller sur le site officiel ou le dépôt GitHub de LM Studio.
Télécharger l’installeur correspondant à ton OS.

5.2 Installation

Lancer l’installeur.
Suivre les étapes jusqu’à la fin (classique).

5.3 Premier lancement

Ouvrir LM Studio.
Aller dans la section Models / Store pour télécharger un modèle (ex. Mistral 7B, LLaMA 2 7B, etc.).
Une fois le modèle téléchargé, cliquer sur Load / Run.
Utiliser l’onglet Chat pour entrer un prompt et tester la génération.

5.4 Interface

Zone de chat : entrée de texte et affichage de la réponse.
Liste de modèles : aperçu de la taille, quantization, etc.
Réglages : température, top-k, top-p, longueur max, etc.
Logs / paramètres : pour monitorer le comportement.

5.5 API locale (si disponible)

LM Studio peut exposer une API HTTP sur http://localhost:<port>.
Un client ExoJS / Node peut alors appeler cette API pour obtenir des complétions, comme un mini-OpenAI local.

6. Types de modèles & statistiques

LM Studio supporte en général des modèles GPT-like au format GGUF :

Familles principales :
- LLaMA (LLaMA 1, LLaMA 2, LLaMA 3, etc. selon version supportée),
- Mistral (Mistral 7B, Mixtral),
- Gemma, Phi, etc.
Tailles courantes :
- 3B / 7B / 8B / 13B / 34B / 70B…
Quantization : q2, q4, q5, q8…
Plus la quantization est forte (q2 → q4 → q5), plus la taille mémoire baisse, au prix d’une légère perte de qualité.

6.1 Exemples indicatifs

Modèle (exemple)	Params approx.	Poids GGUF (quant.)	Usage typique
LLaMA-2 7B q4	7B	~4–6 Go	Assistant général, rédaction de base
Mistral 7B Instruct q4	7B	~4–6 Go	Assistant de conversation performant
LLaMA-2 13B q4	13B	~8–10 Go	Meilleure cohérence de longue durée
Modèle 34B+ q4	34B+	20 Go+	Raisonnement avancé (machine adaptée)

Chiffres approximatifs : ils varient selon les builds.

7. Types de données source & médias

LM Studio est conçu pour le texte. Les autres médias sont gérés via des outils externes (OCR, transcription, etc.) qui produisent du texte.

7.1 Types de documents en entrée

Type de source	Contenu principal	Pré-traitement conseillé
Texte brut (.txt)	Notes, articles, prompts	Nettoyage, segmentation par paragraphe
Markdown (.md)	Documentation, billets de blog, README	Conserver titres/sous-titres pour le contexte
PDF textuels	Rapports, livres, docs techniques	Extraction du texte, suppression des artefacts
HTML / web	Blogs, documentation web	Extraction du contenu principal
Code source	JS, TS, Python, etc.	Conserver blocs de code + commentaires
JSON / CSV texte	Données structurées textuelles	Sérialiser / présenter sous forme lisible

7.2 Médias non textuels

Images : traitement via OCR → texte, puis injection dans LM Studio.
Vidéos : transcription (sous-titres) → texte.
Audio : transcription (ASR) → texte.

Une fois transformées en texte, ces données peuvent être utilisées comme contexte, corpus ou prompts.

8. Types de résultats & livrables

Avec LM Studio (et les LLM en général), tu peux générer :

Texte libre : billets de blog, pages de site, emails, descriptions produits, etc.
Résumés : synthèses de documents longs.
Réécriture / amélioration : correction, changement de ton, simplification.
Code : snippets, exemples, fonctions, pseudo-code.
Format structuré : JSON, listes, tableaux, champs précis pour être consommés dans d’autres systèmes.

Livrables classiques :

fichiers .md (parfait pour Hexo.js / gPage),
fichiers .txt,
fichiers JSON pour intégration dans une API ou une base de données,
scripts/commandes générés automatiquement (par ex. pour déploiement).

9. Comparaison : LM Studio, Ollama, Hugging Face, etc.

9.1 Tableau synthétique

Outil	Type	Interface	Installation	Usage principal
LM Studio	App desktop LLM	GUI + API locale	Installeur simple	Chat & tests de modèles locaux
Ollama	Runtime LLM local	CLI + API locale	Installation CLI	Orchestration de modèles en local
HF Transformers + TGI	Librairie + serveur	Pas de GUI natif	Python + Docker	Déploiement LLM pro / serveurs
UIs web diverses	Web UI self-hosted	Interface web	Plus technique	Interface avancée pour power users

9.2 Points forts de LM Studio

Approche clé en main pour lancer un modèle local.
Accessible même sans être expert en ligne de commande.
Bon compromis pour un laboratoire personnel d’expérimentation.
S’intègre ensuite dans un pipeline plus large (ExoJS, Node, Hexo.js, etc.) via une API locale.

10. Linker : connecter GPT publics & modèles locaux

L’idée discutée dans l’échange était de créer un linker entre :

des GPT publics (API hébergées, par exemple type OpenAI / autres fournisseurs),
et des modèles locaux tournant dans LM Studio.

10.1 Schéma de flux

Front (interface ExoJS / appli web / CLI) reçoit un sujet ou une consigne.
Appel à GPT public pour :
- générer un brouillon,
- faire de la recherche ou enrichir le contexte,
- proposer une première version de contenu.
Scraping / capture de la sortie GPT (texte).
Post-traitement par LM Studio :
- harmonisation du style,
- adaptation à la ligne éditoriale,
- ajout de contraintes métiers (formats, ton, structure).
Sortie finale :
- intégration dans un blog (Hexo.js / gPage),
- génération de scripts pour gTube,
- enregistrement dans des fichiers ou une base de données.

10.2 Avantages

Tirer parti de la puissance des modèles publics (gros pré-entraînement, connaissances larges).
Garder le contrôle sur le style, les formats, et une partie des données via le modèle local.
Possibilité de faire du post-filtrage local (sécurité, conformité, ton de marque, etc.).

11. Intégration ExoJS / Hexo.js / gPage / gTube

L’échange évoquait l’idée de :

utiliser ExoJS comme moteur d’orchestration (pipeline),
générer des contenus de blog pour un hébergement type gPage (blog statique, analogue à Hexo),
et produire des scripts pour gTube (contenus vidéo / audio).

11.1 Architecture logique

Module contentSource.gptPublic
- Appelle une API GPT publique pour générer un brouillon d’article.
Module contentRefine.lmStudio
- Envoie ce brouillon à l’API locale LM Studio pour affiner le texte.
Module publisher.gPage
- Génère un fichier Markdown dans le dossier du blog Hexo.js (source/_posts).
- Déclenche éventuellement un build & déploiement.
Module publisher.gTube (optionnel)
- Transforme l’article en script vidéo (plan, narration, bullet points).
- Stocke ce script pour usage ultérieur.

11.2 Pseudo-code ExoJS / Node

1) Générer un brouillon avec un GPT public

// contentSource.gptPublic.js
export async function generateDraft(topic) {
  const prompt = `Écris un brouillon d’article de blog sur le sujet suivant : "${topic}".
  Structure le texte en introduction, 3 parties, conclusion.`;

  const response = await fetch(PUBLIC_GPT_API_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${process.env.PUBLIC_GPT_KEY}`
    },
    body: JSON.stringify({
      prompt,
      max_tokens: 1200
    })
  });

  const data = await response.json();
  return data.choices[0].text;
}

// contentRefine.lmStudio.js
export async function refineWithLocalLLM(draft) {
  const prompt = `Tu es un éditeur de contenu. Améliore le texte suivant pour un article de blog.
  - Langue : français
  - Public : développeurs / makers
  - Format : Markdown (titre H1, sous-titres H2/H3, listes, exemples)
  
  Texte :
  ${draft}
  `;

  const response = await fetch("http://localhost:1234/v1/completions", { // URL d'API LM Studio à adapter
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      prompt,
      max_tokens: 1200,
      temperature: 0.7
    })
  });

  const data = await response.json();
  return data.choices[0].text;
}

// publisher.gPage.js
import { writeFileSync } from "node:fs";
import { join } from "node:path";

export function publishToHexo(slug, title, markdownBody) {
  const frontMatter = `---
title: "${title}"
date: ${new Date().toISOString()}
tags:
  - LM Studio
  - LLM
  - GPT
categories:
  - IA
  - Développement
---

`;

  const fullContent = frontMatter + markdownBody;

  const filePath = join(process.cwd(), "source", "_posts", `${slug}.md`);
  writeFileSync(filePath, fullContent, "utf8");

  console.log(`Article Hexo publié : ${filePath}`);
}

// pipeline.exo.js
import { generateDraft } from "./contentSource.gptPublic.js";
import { refineWithLocalLLM } from "./contentRefine.lmStudio.js";
import { publishToHexo } from "./publisher.gPage.js";

export async function runBlogPipeline(topic, slug) {
  const draft = await generateDraft(topic);
  const refined = await refineWithLocalLLM(draft);
  publishToHexo(slug, `Article sur ${topic}`, refined);
}

import streamlit as st

def main():
    st.title("Générateur de contenu LM Studio avec Streamlit")
    
    # Zone de saisie pour le prompt utilisateur
    user_prompt = st.text_area("Entrez votre prompt pour le modèle LM Studio", "Écrivez votre texte ici...")
    
    # Bouton pour générer la réponse
    if st.button("Générer"):
        # Ici, on simule la génération de texte
        # Dans un cas réel, on appellerait l'API LM Studio ou un modèle local
        generated_text = f"Réponse générée pour le prompt : {user_prompt}"
        
        # Affichage du résultat
        st.subheader("Texte généré :")
        st.write(generated_text)

if __name__ == "__main__":
    main()

11. Interface web locale : LMStudioWebUI

En plus de l’application desktop, il existe des projets communautaires fournissant une interface web locale pour LM Studio, dont le plus connu est LMStudioWebUI.

11.1 Présentation

LMStudioWebUI est une interface web légère (une simple page HTML/JS/CSS) permettant de se connecter au serveur local de LM Studio et de chatter avec un modèle depuis n’importe quel navigateur (desktop ou mobile).

Projet d’origine : YorkieDev/LMStudioWebUI (work-in-progress, Web UI simple pour LM Studio, licence MIT). :contentReference[oaicite:0]{index=0}
Plusieurs forks / variantes existent, qui gardent la même philosophie : page statique, connexion au serveur LM Studio, chat moderne avec historique. :contentReference[oaicite:1]{index=1}

11.2 Principe de fonctionnement

Côté LM Studio (desktop)
- Ouvrir LM Studio.
- Aller dans l’onglet Server (ou Developer -> Local Server selon la version).
- Activer :
  - Serve on Local Network (serveur accessible sur le LAN) ;
  - CORS (pour autoriser l’accès depuis la page web). :contentReference[oaicite:2]{index=2}
- Cliquer sur Start Server et noter l’adresse (ex. http://192.168.1.10:1234).
Côté LMStudioWebUI (page web)
- Télécharger le fichier HTML (index.html, lmstudiowebui.html ou équivalent selon le repo). :contentReference[oaicite:3]{index=3}
- Ouvrir ce fichier dans un navigateur :
  - sur desktop : double-clic sur le fichier ;
  - sur mobile : transférer le fichier (mail, cloud, AirDrop, etc.) puis l’ouvrir depuis un gestionnaire de fichiers ou l’app de cloud. :contentReference[oaicite:4]{index=4}
- Dans l’interface, saisir l’URL du serveur LM Studio (ex. http://192.168.1.10:1234) puis cliquer sur Connect.
- Une fois connecté, taper des messages dans la zone de saisie et utiliser le bouton Send pour dialoguer avec le modèle.

11.3 Fonctionnalités typiques

Selon le fork / variante utilisé (YorkieDev, aayes89, etc.), on retrouve généralement : :contentReference[oaicite:5]{index=5}

Chat multi-messages avec affichage type “assistant / utilisateur”.
Sélection du modèle exposé par LM Studio (via un menu déroulant).
Mise en forme Markdown : titres, listes, bloc de code, citations.
Mise en valeur du code (Highlight.js) pour les réponses techniques.
Thèmes visuels (sombre/clair) et interface responsive (desktop / mobile).
Possibilité de gérer plusieurs conversations ou de nettoyer / sauvegarder l’historique (selon le repo).

11.4 Cas d’usage avec ton écosystème ExoJS

LMStudioWebUI est utile si tu veux :

Proposer une UI web locale simple pour tester ton modèle sans passer par l’interface desktop de LM Studio.
Tester rapidement des prompts et récupérer les transcripts de conversation (copier/coller) pour les intégrer ensuite dans :
- des flows ExoJS,
- des scripts de génération de contenu (gPage, gTube),
- ou des prompts de “linker” (GPT public → LM Studio) déjà décrits dans cette documentation.

Pour une intégration plus profonde, tu peux :

continuer à utiliser LMStudioWebUI comme outil de test / debug humain,
et réserver l’API HTTP de LM Studio à tes pipelines ExoJS automatisés (ceux qui génèrent des fichiers Markdown pour Hexo/gPage, scripts gTube, etc.).