que fait ce code polyfill-canvas.js // polyfill-canvas.js import { createCanvas,…
- User
que fait ce code polyfill-canvas.js // polyfill-canvas.js import { createCanvas, ImageData as NodeImageData } from "canvas";
global.OffscreenCanvas = class OffscreenCanvas { constructor(width, height) { return createCanvas(width, height); } };
// polyfill ImageData global.ImageData = global.ImageData || NodeImageData; XenovaLLM.js // XenovaLLM.js import "./polyfill-canvas.js"; // <-- Import impératif en premier
import pkg from "@xenova/transformers"; const { pipeline } = pkg;
export class XenovaLLM { constructor(modelName = "Xenova/gpt2", options = {}) { this.modelName = modelName; this.generator = null; this.options = options; }
async _initialize() { if (!this.generator) { this.generator = await pipeline("text-generation", this.modelName); console.log(
Modèle ${this.modelName} chargé); } }async call(prompt, llmOptions = {}) { await this._initialize();
const opts = { max_new_tokens: this.options.maxNewTokens || 50, temperature: this.options.temperature || 0.7, top_k: this.options.topK || 10, top_p: this.options.topP ?? 1.0, ...llmOptions, }; const result = await this.generator(prompt, opts); const fullText = result[0].generated_text; if (fullText.startsWith(prompt)) { return fullText.slice(prompt.length).trim(); } return fullText.trim();} } server.js // server.js import "./polyfill-canvas.js"; // <-- Import impératif en premier
import express from "express"; import cors from "cors"; import { XenovaLLM } from "./XenovaLLM.js";
const app = express(); app.use(cors()); app.use(express.json());
const llm = new XenovaLLM("Xenova/gpt2", { maxNewTokens: 150, temperature: 0.7, topK: 10, });
app.post("/v1/chat/completions", async (req, res) => { try { const { model, messages, max_tokens, temperature } = req.body;
if (!messages || !Array.isArray(messages)) { return res.status(400).json({ error: { message: "'messages' est requis et doit être un tableau." } }); } // Construction du prompt simple const prompt = messages.map(m => { const role = m.role === "user" ? "Utilisateur" : m.role === "assistant" ? "Assistant" : "Système"; return `${role}: ${m.content}`; }).join("\n") + "\nAssistant:"; // Génération const generatedText = await llm.call(prompt, { temperature, max_new_tokens: max_tokens }); // Réponse compatible OpenAI const response = { id: `chatcmpl-${Math.random().toString(36).substring(2, 10)}`, object: "chat.completion", created: Math.floor(Date.now() / 1000), model: model || "xenova-gpt2", choices: [{ index: 0, message: { role: "assistant", content: generatedText }, finish_reason: "stop" }], usage: { prompt_tokens: prompt.length, completion_tokens: generatedText.length, total_tokens: prompt.length + generatedText.length } }; res.json(response);} catch (error) { console.error(error); res.status(500).json({ error: { message: error.message || "Erreur serveur" } }); } });
const port = 3001; app.listen(port, () => { console.log(
API LLM compatible OpenAI lancée sur http://localhost:${port}); }); package.json { "name": "mon-llm-api", "version": "1.0.0", "type": "module", "main": "server.js", "scripts": { "start": "node server.js" }, "dependencies": { "@xenova/transformers": "^1.0.3", "canvas": "^3.1.2", "cors": "^2.8.5", "express": "^4.18.2", "onnxruntime-node": "^1.22.0" } } - Assistant
Voici une explication détaillée de ce que fait ce code, réparti fichier par fichier et dans son ensemble :
1. polyfill-canvas.js
import { createCanvas, ImageData as NodeImageData } from "canvas"; global.OffscreenCanvas = class OffscreenCanvas { constructor(width, height) { return createCanvas(width, height); } }; global.ImageData = global.ImageData || NodeImageData;Rôle :
- Polyfill (compensation) pour l'environnement Node.js qui ne supporte pas nativement la classe
OffscreenCanvas, utilisée souvent dans les librairies de machine learning, graphisme ou manipulations d'images. - Remplace
OffscreenCanvaspar une classe qui utilise la fonctioncreateCanvasdu modulecanvas. - Fournit aussi une définition globale pour
ImageDatasi elle n’est pas définie, en utilisantImageDatadu modulecanvas.
Contexte : certains modèles de machine learning (ici via
@xenova/transformers) peuvent nécessiter un environnement graphique (canvas) même en Node.js, ce code évite des erreurs liées à l’absence native d’API graphique dans Node.
2. XenovaLLM.js
import "./polyfill-canvas.js"; // impératif en premier import pkg from "@xenova/transformers"; const { pipeline } = pkg; export class XenovaLLM { constructor(modelName = "Xenova/gpt2", options = {}) { ... } async _initialize() { if (!this.generator) { this.generator = await pipeline("text-generation", this.modelName); console.log(`Modèle ${this.modelName} chargé`); } } async call(prompt, llmOptions = {}) { await this._initialize(); const opts = { max_new_tokens: this.options.maxNewTokens || 50, temperature: this.options.temperature || 0.7, top_k: this.options.topK || 10, top_p: this.options.topP ?? 1.0, ...llmOptions, }; const result = await this.generator(prompt, opts); const fullText = result[0].generated_text; if (fullText.startsWith(prompt)) { return fullText.slice(prompt.length).trim(); } return fullText.trim(); } }Rôle :
- Classe qui enveloppe un modèle de génération de texte (
gpt2par défaut) via la librairie@xenova/transformers. - Initialisation lazy : charge le modèle uniquement à la première requête.
- Méthode
call:- Reçoit un prompt (texte d’entrée).
- Passe des paramètres de génération (comme
temperature,max_new_tokens, etc). - Récupère le texte généré par le modèle.
- Nettoie la réponse en retirant le prompt initial si nécessaire avant de renvoyer la nouvelle partie générée.
3. server.js
import "./polyfill-canvas.js"; // impératif en premier import express from "express"; import cors from "cors"; import { XenovaLLM } from "./XenovaLLM.js"; const app = express(); app.use(cors()); app.use(express.json()); const llm = new XenovaLLM("Xenova/gpt2", { maxNewTokens: 150, temperature: 0.7, topK: 10, }); app.post("/v1/chat/completions", async (req, res) => { try { const { model, messages, max_tokens, temperature } = req.body; if (!messages || !Array.isArray(messages)) { return res.status(400).json({ error: { message: "'messages' est requis et doit être un tableau." } }); } // Construction d'un prompt simple const prompt = messages.map(m => { const role = m.role === "user" ? "Utilisateur" : m.role === "assistant" ? "Assistant" : "Système"; return `${role}: ${m.content}`; }).join("\n") + "\nAssistant:"; // Génération const generatedText = await llm.call(prompt, { temperature, max_new_tokens: max_tokens }); // Construction de la réponse compatible OpenAI Chat Completion const response = { id: `chatcmpl-${Math.random().toString(36).substring(2, 10)}`, object: "chat.completion", created: Math.floor(Date.now() / 1000), model: model || "xenova-gpt2", choices: [{ index: 0, message: { role: "assistant", content: generatedText }, finish_reason: "stop" }], usage: { prompt_tokens: prompt.length, completion_tokens: generatedText.length, total_tokens: prompt.length + generatedText.length } }; res.json(response); } catch (error) { console.error(error); res.status(500).json({ error: { message: error.message || "Erreur serveur" } }); } }); const port = 3001; app.listen(port, () => { console.log(`API LLM compatible OpenAI lancée sur http://localhost:${port}`); });Rôle :
- Serveur HTTP Node.js utilisant Express.
- Définit une route POST
/v1/chat/completionsqui implémente une interface d’API compatible OpenAI Chat Completion (à un niveau simplifié). - Attends un corps JSON avec un tableau
messages(conversations entre utilisateur, assistant, système). - Construit un prompt textuel simple à partir des messages (
"Utilisateur: ...","Assistant: ...", ...). - Appelle le modèle via la classe
XenovaLLMpour générer la réponse. - Renvoie une réponse formatée dans la même structure qu’une réponse OpenAI (pour faciliter intégration par des clients existants).
4. package.json
- Liste les dépendances nécessaires, notamment :
@xenova/transformers: bibliothèque JS pour utiliser les modèles transformer dans Node.js.canvas: bibliothèque pour fournir des API graphiques canvas côté serveur.expressetcors: serveurs HTTP et gestion du cross-origin.onnxruntime-node: runtime ONNX pour exécuter les modèles ML.
En résumé, que fait ce code ?
Ce code met en place un serveur Node.js qui offre une API REST compatible avec les endpoints OpenAI Chat Completions, mais en utilisant un modèle de génération de texte local (ici GPT-2) via la librairie @xenova/transformers.
- Il réalise les polyfills nécessaires à l’exécution des modèles qui utilisent des API graphiques côté serveur (canvas).
- Il charge et appelle un modèle GPT-2 localement pour générer une réponse textuelle.
- L’API accepte les messages d’une conversation, construit un prompt, génère une réponse textuelle intelligente (LLM), puis renvoie une réponse formattée compatible avec les clients utilisant l’API OpenAI.
Cas d’usage :
- Vous voulez exécuter un modèle de langage localement.
- Vous souhaitez exposer un endpoint Web compatible avec les outils utilisant l’API OpenAI.
- Vous ne passez plus par OpenAI cloud mais utilisez vos propres ressources.
Si vous avez besoin de détails sur une partie spécifique, n’hésitez pas à demander !
- Polyfill (compensation) pour l'environnement Node.js qui ne supporte pas nativement la classe
- User
cree page ui tres esthetique pour utiliser le llm
- Assistant
Bien sûr ! Je vais te fournir un exemple simple mais esthétique de page web React pour interagir avec ton API LLM.
Cette UI inclut :- Une zone de chat avec bulles différenciées pour l'utilisateur et l'assistant
- Un champ d'entrée pour taper le message
- Un bouton d'envoi
- Design moderne avec Tailwind CSS (si tu veux utiliser Tailwind) ou CSS pur
Option 1 : UI en React avec Tailwind CSS (recommandé pour productivité rapide)
Prérequis :
- Installer Tailwind CSS dans ton projet React (par exemple avec create-react-app)
- Ou utiliser un CDN Tailwind (moins recommandé car pas pratique pour React)
Code complet du composant
ChatUI.jsximport React, { useState, useEffect, useRef } from "react"; export default function ChatUI() { const [messages, setMessages] = useState([]); const [input, setInput] = useState(""); const [loading, setLoading] = useState(false); const bottomRef = useRef(null); // Scroll automatique en bas à chaque nouveau message useEffect(() => { if (bottomRef.current) { bottomRef.current.scrollIntoView({ behavior: "smooth" }); } }, [messages]); async function sendMessage() { if (!input.trim()) return; const userMessage = { role: "user", content: input.trim() }; const updatedMessages = [...messages, userMessage]; setMessages(updatedMessages); setInput(""); setLoading(true); try { const response = await fetch("http://localhost:3001/v1/chat/completions", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model: "xenova-gpt2", messages: updatedMessages, max_tokens: 150, temperature: 0.7, }), }); const data = await response.json(); if (data.error) { alert(`Erreur: ${data.error.message}`); } else { const assistantMessage = { role: "assistant", content: data.choices[0].message.content, }; setMessages([...updatedMessages, assistantMessage]); } } catch (e) { alert("Erreur réseau ou serveur"); } setLoading(false); } function handleKeyPress(e) { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); sendMessage(); } } return ( <div className="max-w-xl mx-auto flex flex-col h-screen p-4 bg-gradient-to-br from-gray-900 to-indigo-900 text-gray-100"> <header className="text-3xl font-bold mb-4 text-center">Mon LLM Chat</header> <main className="flex-1 overflow-y-auto mb-4 px-2"> {messages.length === 0 && ( <p className="text-center text-gray-400 mt-10"> Démarre la conversation en posant une question ! </p> )} {messages.map((msg, i) => ( <div key={i} className={`max-w-[80%] mb-3 p-3 rounded-lg whitespace-pre-line ${ msg.role === "user" ? "bg-indigo-700 self-end rounded-br-none" : "bg-gray-800 self-start rounded-bl-none" }`} > <span className="font-semibold mb-1 block"> {msg.role === "user" ? "Utilisateur" : "Assistant"} </span> {msg.content} </div> ))} <div ref={bottomRef} /> </main> <footer className="flex space-x-2"> <textarea rows={1} value={input} onChange={(e) => setInput(e.target.value)} onKeyDown={handleKeyPress} placeholder="Écris ton message..." className="flex-1 px-3 py-2 rounded-md bg-gray-700 text-gray-100 resize-none focus:outline-none focus:ring-2 focus:ring-indigo-500" disabled={loading} /> <button onClick={sendMessage} disabled={loading || !input.trim()} className="px-5 py-2 rounded-md bg-indigo-600 hover:bg-indigo-700 text-white font-semibold disabled:opacity-50 disabled:cursor-not-allowed transition" > {loading ? "..." : "Envoyer"} </button> </footer> </div> ); }
Instructions :
- Ajoute ce composant React dans ton app.
- N’oublie pas d’installer Tailwind CSS (voir https://tailwindcss.com/docs/guides/create-react-app).
- Change l’URL fetch si ton serveur n’est pas sur localhost:3001.
Option 2 : UI simple en HTML + CSS pur (sans React)
Si tu préfères une page simple à ouvrir dans un navigateur seul, voici un exemple minimaliste. Tu devras adapter légèrement pour faire des appels fetch à l’API.
Exemple HTML + CSS pur (sans build)
<!DOCTYPE html> <html lang="fr"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1" /> <title>Chat avec LLM</title> <style> body { margin: 0; padding: 0; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: linear-gradient(135deg, #1a202c, #4c51bf); color: white; display: flex; flex-direction: column; height: 100vh; } header { text-align: center; font-size: 2rem; padding: 1rem; font-weight: bold; } #chat { flex: 1; padding: 1rem; overflow-y: auto; display: flex; flex-direction: column; gap: 1rem; } .message { max-width: 70%; padding: 1rem; border-radius: 12px; white-space: pre-wrap; } .user { align-self: flex-end; background-color: #5a67d8; border-bottom-right-radius: 0; } .assistant { align-self: flex-start; background-color: #2d3748; border-bottom-left-radius: 0; } footer { padding: 1rem; display: flex; gap: 0.5rem; background: #2d3748; } textarea { flex: 1; resize: none; font-size: 1rem; padding: 0.75rem; border-radius: 8px; border: none; outline: none; } button { background-color: #5a67d8; border: none; color: white; font-weight: bold; padding: 0 1.5rem; border-radius: 8px; cursor: pointer; transition: background-color 0.3s ease; } button:hover { background-color: #434190; } button:disabled { opacity: 0.5; cursor: default; } </style> </head> <body> <header>Mon LLM Chat</header> <div id="chat"></div> <footer> <textarea id="input" rows="2" placeholder="Écris ton message..."></textarea> <button id="send">Envoyer</button> </footer> <script> const chat = document.getElementById("chat"); const input = document.getElementById("input"); const sendButton = document.getElementById("send"); let messages = []; function appendMessage(role, content) { const div = document.createElement("div"); div.className = `message ${role}`; div.textContent = content; chat.appendChild(div); chat.scrollTop = chat.scrollHeight; } async function sendMessage() { const text = input.value.trim(); if (!text) return; appendMessage("user", text); messages.push({ role: "user", content: text }); input.value = ""; sendButton.disabled = true; try { const res = await fetch("http://localhost:3001/v1/chat/completions", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model: "xenova-gpt2", messages: messages, max_tokens: 150, temperature: 0.7, }), }); const data = await res.json(); if (data.error) { alert("Erreur : " + data.error.message); sendButton.disabled = false; return; } const assistantAnswer = data.choices[0].message.content; appendMessage("assistant", assistantAnswer); messages.push({ role: "assistant", content: assistantAnswer }); } catch (e) { alert("Erreur réseau ou serveur"); } sendButton.disabled = false; } sendButton.addEventListener("click", sendMessage); input.addEventListener("keydown", (e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); sendMessage(); } }); </script> </body> </html>
Points importants à adapter selon ta config :
- L'URL
http://localhost:3001/v1/chat/completionsdoit correspondre à ton serveur Node en local ou distant. - Si ton API a besoin d’un token d’authentification, ajoute-le dans le fetch (header).
- Pour une UI plus avancée, tu peux gérer l’état "Chargement", erreurs plus fines, etc.
N’hésite pas à me demander si tu veux :
- un composant React complet avec gestion d’état plus avancée
- intégration avec Next.js
- design complètement personnalisé
- export Tailwind config, etc.
Veux-tu que je t’aide à intégrer cette UI dans un projet React existant ?
- User
node server.js Node.js environment detected, but
onnxruntime-nodewas not found. Usingonnxruntime-webas a fallback. We recommend installingonnxruntime-nodeas it generally improves performance (up to 5X). API LLM compatible OpenAI lancée sur http://localhost:3001 - Assistant
Le message affiché au démarrage :
Node.js environment detected, but `onnxruntime-node` was not found. Using `onnxruntime-web` as a fallback. We recommend installing `onnxruntime-node` as it generally improves performance (up to 5X). API LLM compatible OpenAI lancée sur http://localhost:3001est un avertissement (warning), pas une erreur bloquante.
Explication
- Ton projet utilise la librairie
@xenova/transformersqui repose suronnxruntimepour exécuter les modèles ML. - Il existe deux implémentations :
onnxruntime-node: version native optimisée pour Node.js (beaucoup plus rapide).onnxruntime-web: version JavaScript/web utilisée quand on est dans un navigateur ou quand la version native ne peut pas être trouvée.
- Ici, il détecte que tu es sous Node.js mais que
onnxruntime-noden’est pas installé dansnode_modules. - Il te prévient donc qu’il utilise la version web (moins performante) en fallback.
Que faire ?
- Installer
onnxruntime-nodepour améliorer les performances
Comme tu l’as dans ton
package.json, il faut juste :npm install onnxruntime-nodeou
yarn add onnxruntime-nodeEnsuite relance ton serveur : le warning ne devrait plus apparaître.
- Si tu ne souhaites pas l’installer, ce n’est pas grave, ton serveur fonctionnera bien, juste moins rapidement.
Bonus : vérification en local
Tu peux vérifier la présence dans
node_modules:ls node_modules/onnxruntime-nodeEt aussi dans
package-lock.jsonouyarn.lock, queonnxruntime-nodeest bien référencé.
Résumé
- Warning informatif sur la présence d’une dépendance optionnelle.
onnxruntime-nodepermet de booster les performances de l’exécution du modèle sur Node.js.- Pour l’avoir, exécute
npm install onnxruntime-node. - Ton serveur Node fonctionne bien malgré ce warning.
Si tu veux, je peux t’aider à résoudre d’éventuels problèmes d’installation de
onnxruntime-node(qui parfois peut nécessiter des outils de compilation C++ sur ta machine). - Ton projet utilise la librairie
- User
ca affiche Cannot GET /
- Assistant
Le message "Cannot GET /" signifie que tu as accédé (par exemple via ton navigateur) à la racine de ton serveur (
http://localhost:3001/) et que celui-ci ne sert aucune page ou route à cet emplacement.
Pourquoi ?
Dans ton fichier
server.js, tu as défini uniquement une route POST sur/v1/chat/completions:app.post("/v1/chat/completions", async (req, res) => { ... });Mais tu n’as pas défini de route GET sur
/ou ailleurs pour servir une page web ou un message.
Comment régler ça ?
Option 1 - Ajouter une route GET
/simple pour testerTu peux ajouter dans
server.jsjuste avantapp.listen:app.get("/", (req, res) => { res.send("Serveur LLM fonctionne. Utilise la route POST /v1/chat/completions pour interagir."); });Cela affichera un simple message si tu vas sur
http://localhost:3001dans ton navigateur.
Option 2 - Servir une UI statique (exemple)
// Par exemple si tu souhaites servir une page statique HTML dans un dossier
public:-
Crée un dossier
publicdans ton projet, et mets-y un fichierindex.html(ex: une page de chat UI). -
Dans
server.js, ajoute :
import path from "path"; import { fileURLToPath } from 'url'; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); app.use(express.static(path.join(__dirname, "public")));Cela servira la page sur
/.
Option 3 - Utiliser un front-end séparé (React ou autre)
- Tu seras obligé de lancer un serveur web statique séparé pour ta UI (par exemple avec React).
- Ton front-end fera des requêtes POST sur
http://localhost:3001/v1/chat/completions. - Dans ce cas la racine du backend n’a pas besoin de servir des pages html.
Résumé rapide
- "Cannot GET /" = aucune route GET définie sur
/. - Ajoute une route GET
/dansserver.jspour avoir un contenu au moins simple. - Ou sers un front-end statique ou une UI web depuis un autre serveur.
Si tu veux, je peux modifier et te fournir un exemple de ce que tu peux mettre pour la route GET
/ou comment servir une page d’UI.
Veux-tu ? -
- User
regenere le code server.js avec ses nouveaute
- Assistant
Voici un exemple de
server.jsmis à jour avec :- Une route GET
/qui affiche un message simple indiquant que le serveur fonctionne. - La possibilité de servir une UI statique depuis un dossier
public(si tu souhaites ajouter ta page HTML/React compilée dans ce dossier). - Le reste du code existant pour l’API
/v1/chat/completionsinchangé.
// server.js import "./polyfill-canvas.js"; // <-- Import impératif en premier import express from "express"; import cors from "cors"; import path from "path"; import { fileURLToPath } from "url"; import { XenovaLLM } from "./XenovaLLM.js"; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); const app = express(); app.use(cors()); app.use(express.json()); // Servir les fichiers statiques dans ./public (optionnel) app.use(express.static(path.join(__dirname, "public"))); // Route GET basique sur la racine app.get("/", (req, res) => { res.send( `<h1>API LLM compatible OpenAI</h1> <p>Utilisez la route POST <code>/v1/chat/completions</code> pour interagir avec le modèle.</p>` ); }); const llm = new XenovaLLM("Xenova/gpt2", { maxNewTokens: 150, temperature: 0.7, topK: 10, }); app.post("/v1/chat/completions", async (req, res) => { try { const { model, messages, max_tokens, temperature } = req.body; if (!messages || !Array.isArray(messages)) { return res.status(400).json({ error: { message: "'messages' est requis et doit être un tableau." } }); } // Construction du prompt const prompt = messages .map((m) => { const role = m.role === "user" ? "Utilisateur" : m.role === "assistant" ? "Assistant" : "Système"; return `${role}: ${m.content}`; }) .join("\n") + "\nAssistant:"; // Appel au modèle const generatedText = await llm.call(prompt, { temperature, max_new_tokens: max_tokens }); // Formattage réponse OpenAI-compatible const response = { id: `chatcmpl-${Math.random().toString(36).substring(2, 10)}`, object: "chat.completion", created: Math.floor(Date.now() / 1000), model: model || "xenova-gpt2", choices: [ { index: 0, message: { role: "assistant", content: generatedText, }, finish_reason: "stop", }, ], usage: { prompt_tokens: prompt.length, completion_tokens: generatedText.length, total_tokens: prompt.length + generatedText.length, }, }; res.json(response); } catch (error) { console.error(error); res.status(500).json({ error: { message: error.message || "Erreur serveur" } }); } }); const port = 3001; app.listen(port, () => { console.log(`API LLM compatible OpenAI lancée sur http://localhost:${port}`); });
Notes :
- Si tu crées un dossier
publicà la racine du projet avec une page statiqueindex.html, elle sera servie surhttp://localhost:3001/. - Sinon la route GET
/renvoie un petit message HTML. - Tu peux aussi supprimer la ligne
app.use(express.static(...))si tu n’as pas de page à servir côté serveur. - Cette version conserve ta logique d’API LLM telle quelle.
Veux-tu que je te fasse un exemple de page HTML à mettre dans
public/index.htmlpour tester ? - Une route GET
- User
comment tester chat
- Assistant
Pour tester ton endpoint de chat à partir de ton serveur LLM, voici plusieurs méthodes simples selon ton environnement :
1. Test rapide via curl (ligne de commande)
Envoie une requête POST avec un JSON conforme à la structure attendue (similaire à OpenAI Chat completions) :
curl -X POST http://localhost:3001/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "xenova-gpt2", "messages": [ { "role": "user", "content": "Bonjour, comment ça va ?" } ], "max_tokens": 100, "temperature": 0.7 }'
2. Test via Postman ou un autre client HTTP
- Ouvre Postman.
- Fais un POST vers
http://localhost:3001/v1/chat/completions. - Dans l’onglet Body → raw → JSON, mets :
{ "model": "xenova-gpt2", "messages": [ { "role": "user", "content": "Bonjour, comment ça va ?" } ], "max_tokens": 100, "temperature": 0.7 }- Envoie la requête.
- Tu dois recevoir une réponse JSON avec la complétion générée.
3. Avec la page Web / UI (si tu as implémenté la partie UI)
- Lance ton serveur :
node server.js. - Ouvre la page web (exemple si tu as créé
public/index.html) àhttp://localhost:3001/. - Écris un message et teste ta conversation (selon le code UI que tu as).
4. Exemple de script Node.js pour test automatisé
Si tu veux tester via un script JS (node), voici un exemple minimal :
import fetch from "node-fetch"; async function testChat() { const response = await fetch("http://localhost:3001/v1/chat/completions", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model: "xenova-gpt2", messages: [ { role: "user", content: "Quelle est la capitale de la France ?" } ], max_tokens: 100, temperature: 0.7 }), }); const data = await response.json(); console.log("Réponse de l'assistant :", data.choices[0].message.content); } testChat();
Remarques importantes
- Assure-toi que ton serveur Node est bien lancé (
node server.js). - Vérifie que le port est correct (
3001par défaut). - La structure du body doit contenir un tableau
messagesavec des objets{ role, content }. - Tu peux modifier les paramètres comme
max_tokens,temperature,top_kdans la requête.
N’hésite pas si tu veux un script complet d’exemple ou une interface web pour tester plus facilement !
- User
quand jecrit il a un message Erreur : File not found. Could not locate "https://huggingface.co/Xenova/transformers.js/resolve/main/quantized/Xenova/gpt2/causal-lm-with-past/tokenizer_config.json".
- Assistant
Le message d’erreur :
Erreur : File not found. Could not locate "https://huggingface.co/Xenova/transformers.js/resolve/main/quantized/Xenova/gpt2/causal-lm-with-past/tokenizer_config.json".indique que lors du chargement du modèle GPT-2 via la librairie
@xenova/transformers, la ressource (fichiertokenizer_config.json) est recherchée à une URL incorrecte ou inexistante sur HuggingFace.
Pourquoi ce problème ?
- La classe
XenovaLLMutilise danspipeline("text-generation", this.modelName)le nom"Xenova/gpt2". @xenova/transformerstente de récupérer les fichiers du modèle depuis un dépôt HuggingFace, mais l’URL générée est mal formée ou le fichier n’existe pas dans le repo ciblé.- Le chemin
"https://huggingface.co/Xenova/transformers.js/resolve/main/quantized/Xenova/gpt2/causal-lm-with-past/tokenizer_config.json"semble erroné, notamment parce que"Xenova/transformers.js"ne correspond pas au bon repo modèle, niquantized/Xenova/gpt2.
Comment résoudre ce problème ?
1. Vérifier le nom exact du modèle à charger
Va sur HuggingFace Hub et cherche un modèle compatible avec
@xenova/transformers, par exemple :- https://huggingface.co/Xenova/gpt2
- https://huggingface.co/xenova/gpt2 — vérifie la casse, différents noms…
Les noms sont sensibles à la casse. Essaie par exemple de remplacer
"Xenova/gpt2"par"xenova/gpt2"(tout en minuscules) dansXenovaLLM.js:this.modelName = modelName.toLowerCase();Ou juste launcher avec le nom exact :
this.modelName = "xenova/gpt2";
2. Spécifie explicitement le repo/chemin sans
quantizedni autres sous-dossiersPar exemple dans
XenovaLLM.js, modifie l'initialisation ainsi :this.generator = await pipeline("text-generation", "xenova/gpt2");Si cette erreur persiste, le problème vient peut-être du modèle quantifié qui n’existe pas dans ce repo sous cette structure.
3. Vérifier ta version de
@xenova/transformersMet à jour la dépendance avec :
npm update @xenova/transformersou réinstalle proprement :
npm install @xenova/transformers@latestUne version ancienne pourrait mal gérer la résolution des fichiers.
4. Télécharger localement ou utiliser un autre modèle
Si le problème vient du chargement à distance, une solution possible est :
- Télécharger manuellement le modèle et ses fichiers
tokenizer_config.jsondans un dossier local - Passer le chemin local (
file://...) au pipeline
Exemple :
this.generator = await pipeline("text-generation", "./mon-modele-local");Mais c’est plus avancé car il faut configurer le
transformers.jspour charger localement des fichiers.
5. Contacter ou vérifier la doc officielle
Consulte la doc officielle de
@xenova/transformers:
https://xenova.github.io/transformers.js/Pour voir le(s) modèle(s) recommandés et leur format.
En résumé rapide
- Le nom du modèle
"Xenova/gpt2"est probablement incorrect ou mal capitalisé. - Essaie
"xenova/gpt2"en minuscules. - Mets à jour la bibliothèque.
- Vérifie sur HuggingFace Hub la présence du modèle et ses fichiers.
- Si besoin, utilise un autre modèle de test recommandé dans la doc.
Si tu veux, je peux te faire une version corrigée de
XenovaLLM.jsavec la bonne référence ou d’autres suggestions.
Veux-tu ? - La classe