que fait ce code XenovaLLM.js // XenovaLLM.js import { BaseLLM } from…
- User
que fait ce code XenovaLLM.js // XenovaLLM.js import { BaseLLM } from "langchain/llms/base.js"; import { pipeline } from "@xenova/transformers"; import { XenovaLLM } from "./XenovaLLM.js"; // Chemin vers le fichier que tu as créé const llm = new XenovaLLM("Xenova/gpt2", { temperature: 0.7, maxNewTokens: 100 });
export class XenovaLLM extends BaseLLM { /**
- @param {string} modelName Nom du modèle à charger (ex: "Xenova/gpt2")
- @param {object} options Options de génération (temperature, maxNewTokens, topK, etc.) */ constructor(modelName = "Xenova/gpt2", options = {}) { super(options); this.modelName = modelName; this.generator = null; this.options = options; }
/**
- Initialise le pipeline de génération si ce n'est pas déjà fait */ async _initialize() { if (!this.generator) { this.generator = await pipeline("text-generation", this.modelName); } }
/**
- Méthode appelée par Langchain pour générer du texte à partir du prompt
- @param {string} prompt Texte d'entrée
- @param {object} llmOptions Options spécifiques à l'appel (overrides)
- @returns {Promise} Texte généré (uniquement la génération, sans le prompt) */ 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, }; // Appel du pipeline de génération const result = await this.generator(prompt, opts); const fullText = result[0].generated_text; // Supprime le prompt initial pour ne garder que la génération if (fullText.startsWith(prompt)) { return fullText.slice(prompt.length).trim(); } else { return fullText.trim(); }}
/**
- Retourne le type de LLM (permet à Langchain de l’identifier) */ _llmType() { return "xenova"; } } server.js // server.js import express from "express"; import cors from "cors"; import { XenovaLLM } from "./XenovaLLM.js"; import { RetrievalQAChain } from "langchain/chains"; import { BaseRetriever } from "langchain/schema";
// --- Un retriever en mémoire basique pour démo --- class SimpleRetriever extends BaseRetriever { /**
- @param {Array<{pageContent: string, metadata?: object}>} docs */ constructor(docs) { super(); this.docs = docs; }
async getRelevantDocuments(query) { // Recherche ultra basique : renvoie tous les docs contenant un mot du query const loweredQuery = query.toLowerCase().split(" "); const results = this.docs.filter(doc => loweredQuery.some(word => doc.pageContent.toLowerCase().includes(word)) ); // Pour simplifier renvoyer max 3 documents return results.slice(0, 3); } }
const app = express(); app.use(cors()); app.use(express.json()); app.use(express.static("public"));
// Instanciation du LLM Xenova (wrapper) const llm = new XenovaLLM("Xenova/gpt2", { maxNewTokens: 100, temperature: 0.7, topK: 10, });
// Exemple de documents très simples (à remplacer par ta base/doc) const documents = [ { pageContent: "La Tour Eiffel est à Paris, c’est un monument célèbre." }, { pageContent: "Le Louvre est un musée très connu en France." }, { pageContent: "La gastronomie française est réputée mondialement." }, { pageContent: "GPT-2 est un modèle de génération de texte développé par OpenAI.", }, ];
// Création du retriever avec ces docs const retriever = new SimpleRetriever(documents);
// Création de la chaîne RAG : retriever + LLM const ragChain = RetrievalQAChain.fromLLM(llm, retriever);
// Endpoint RAG app.post("/rag", async (req, res) => { try { const { question } = req.body; if (!question) { return res.status(400).json({ error: "Question requise" }); }
// Appel de la chaîne retrieval + génération const response = await ragChain.call({ query: question }); // result.text contient la réponse générée res.json({ answer: response.text });} catch (e) { console.error(e); res.status(500).json({ error: e.message }); } });
const port = 3000; app.listen(port, () => { console.log(
Serveur lancé sur http://localhost:${port}); }); public/index.htmlSaisissez votre texte :
Nombre maximal de tokens : 50
Température (créativité) : 0.7
Top-K (restriction vocabulaire) : 10
Top-p (nucleus sampling, 0.0 - 1.0) : 1.0
- Assistant
Voici une explication détaillée de ce que fait ce code (la combinaison des fichiers
XenovaLLM.js,server.jsetpublic/index.html) :
1.
XenovaLLM.jsCe fichier définit une classe XenovaLLM qui :
- Étend la classe
BaseLLMde la bibliothèque Langchain. - Utilise la librairie
@xenova/transformerspour charger un modèle de génération de texte (comme GPT-2, ici). - Implémente un wrapper personnalisé (
XenovaLLM) pour appeler un modèle de génération de texte localement (en Node.js). - Méthodes principales :
constructor(modelName, options): initialise le modèle et ses options (température, nombre max de tokens, etc.)._initialize(): charge le modèle via un pipeline "text-generation" de@xenova/transformers(s'il n'est pas déjà chargé)._call(prompt, llmOptions): génère un texte à partir du prompt donné, en appliquant les options fournies._llmType(): retourne le type de LLM (utilisé par Langchain pour identifier le modèle).
En résumé: Ce fichier permet d'utiliser localement un modèle de génération de texte GPT-2 via l’API de Xenova (une librairie pour les transformers en JavaScript/Node.js), en le rendant compatible avec Langchain.
2.
server.jsCe fichier crée un serveur web backend avec Express.js pour exposer une API et retourner du texte généré.
-
Configure un serveur HTTP avec Express avec CORS et JSON middleware.
-
Définit une classe
SimpleRetrieverbasée surBaseRetriever(Langchain) qui simule une recherche simple dans une liste en mémoire de documents, en renvoyant jusqu’à 3 documents qui contiennent au moins un mot de la requête. -
Initialise une instance
XenovaLLMavec GPT-2 (le même que dansXenovaLLM.js). -
Crée un ensemble de "documents" statiques en mémoire (exemple avec des phrases en français sur des monuments et la gastronomie).
-
Assemble une chaîne RAG (Retrieval-Augmented Generation) avec
RetrievalQAChain.fromLLM(llm, retriever). Cela signifie que pour une question, le modèle cherche d’abord dans les documents pertinents, puis génère une réponse via le LLM. -
Expose un endpoint
POST /rag:- Attend dans le corps JSON un champ
question. - Si la question est absente, répond avec une erreur 400.
- Sinon, appelle la chaîne RAG pour récupérer une réponse générée.
- Renvoie la réponse générée en JSON.
- Attend dans le corps JSON un champ
-
Écoute sur le port 3000.
En résumé: Ce serveur fournit un service capable de répondre à des questions simples en combinant recherche basique dans des documents et génération de texte avec GPT-2 local.
3.
public/index.htmlC’est une interface web simple pour :
- Saisir un prompt (texte de départ) dans une zone de texte.
- Configurer les paramètres du modèle de génération : nombre max de tokens, température (créativité), top-k et top-p (paramètres pour la génération).
- Boutons
Générer/Réinitialiser. - Affichage du résultat généré ou d’erreurs.
- Quand on clique sur "Générer", le client JS envoie une requête POST vers
/generateavec le prompt et les paramètres.
Cependant, il y a une incohérence à noter ici :
- Le serveur définit uniquement un endpoint
/rag(POST) qui reçoit unequestion. - Le client HTML POST vers
/generate(qui n’existe pas dansserver.js).
Cela implique que ce code nécessite un petit ajustement, soit:
- Ajouter dans le serveur un endpoint
/generatequi invoque directementllm._call()sans passer par le RAG. - Ou modifier le client pour poster les requêtes vers
/ragavec un champquestion.
Ce que fait globalement cette application
-
Backend
- Charge localement un modèle GPT-2 grâce à
@xenova/transformers. - Permet de faire du text-generation via le modèle.
- Combine un simple système de recherche dans un petit jeu de documents pour répondre à une question donnée (RAG).
- Expose une API REST
/ragpour faire des questions/réponses.
- Charge localement un modèle GPT-2 grâce à
-
Frontend
- Offre une interface web UX qui permet à l'utilisateur de saisir du texte et de paramétrer la génération.
- Envoie une requête AJAX POST vers un endpoint (devrait être
/generateou/rag) pour obtenir un texte généré. - Affiche le texte généré ou les erreurs.
Que manque-t-il ou que pourrait-on améliorer ?
- L’endpoint
/generatecôté serveur pour correspondre au frontend. - Le frontend pourrait être adapté pour envoyer
questionà/ragou bien l’API server.js étendue pour/generate. - Le retriever est très basique et en mémoire seule, on pourrait utiliser un système plus avancé (vectoriel, base de données, etc.).
- Le modèle GPT-2 est relativement petit/simple — on peut le remplacer par d’autres plus complexes si besoin.
En conclusion
Ce code permet :
- De créer localement un modèle de génération de texte (GPT-2) en Node.js via Xenova Transformers.
- De combiner ce modèle avec une quête simple par mots-clés dans une petite base de connaissances.
- De fournir un service web REST permettant de poser des questions et obtenir des réponses écrites générées.
- De fournir une interface web simple pour saisir un prompt et générer un texte.
Si tu veux que je t’aide à corriger l’interface front qui appelle
/generateou pour créer cet endpoint dansserver.js, n’hésite pas à me le dire ! - Étend la classe
- User
ok aide à corriger l’interface front qui appelle /generate
- Assistant
D’accord ! Pour corriger l’interface front afin qu’elle fonctionne correctement avec le serveur que tu as fourni (qui expose uniquement un endpoint
/ragacceptant unequestion), il faut :- Modifier l’appel fetch dans le JavaScript de
index.htmlpour envoyer la requête vers/rag. - Envoyer dans le corps JSON le champ
questionqui contiendra le prompt. - Ajuster éventuellement l’affichage du résultat attendu.
Voici les modifications concrètes à faire dans le
<script>deindex.html:Trouve cette partie dans le script :
const response = await fetch('/generate', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ prompt, maxTokens: parseInt(maxTokensInput.value), temperature: parseFloat(temperatureInput.value), topK: parseInt(topKInput.value), topP: parseFloat(topPInput.value) }) });
Remplace-la par :
const response = await fetch('/rag', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ question: prompt }) });
Et ensuite, dans la récupération du résultat :
Le serveur renvoie un JSON avec la clé
answer, il faut donc mettre à jour cette partie aussi :const data = await response.json(); if (data.answer) { resultDiv.textContent = data.answer; } else { errorMsg.textContent = 'Erreur : réponse invalide.'; }
Résumé complet de la partie modifiée pour la génération :
btn.addEventListener('click', async () => { const prompt = promptInput.value.trim(); errorMsg.textContent = ''; resultDiv.textContent = ''; if (!prompt) { errorMsg.textContent = 'Veuillez saisir un texte dans la zone de saisie.'; return; } setLoading(true); resultDiv.textContent = 'Génération en cours...'; try { const response = await fetch('/rag', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ question: prompt }) }); if (!response.ok) { const errorData = await response.json(); throw new Error(errorData.error || 'Erreur lors de la génération.'); } const data = await response.json(); if (data.answer) { resultDiv.textContent = data.answer; } else { errorMsg.textContent = 'Erreur : réponse invalide.'; } } catch (err) { errorMsg.textContent = 'Erreur réseau ou serveur : ' + err.message; console.error(err); } finally { setLoading(false); } });
Résultat
- Le frontend envoie la saisie utilisateur dans le champ
questionvers l’endpoint/rag. - Le backend répond par
answer(le texte généré). - Le frontend affiche cette réponse à l’utilisateur.
Si tu souhaites gérer les paramètres de génération (
maxTokens,temperature,topK,topP), il faudrait les transmettre aussi au serveur puis adapter le backend pour en tenir compte. Sinon, tu peux les laisser uniquement pour l’interface utilisateur sans effet.Veux-tu que je t’aide aussi à modifier le backend pour prendre en compte ces paramètres ?
- Modifier l’appel fetch dans le JavaScript de
- User
ok aide aussi à modifier le backend pour prendre en compte ces paramètres
- Assistant
Parfait ! Pour que le backend prenne en compte les paramètres de génération envoyés depuis le frontend (comme
maxTokens,temperature,topKettopP), il faut :-
Modifier l’endpoint
/ragdansserver.jspour récupérer ces options dans le corps de la requête. -
Les transmettre à
ragChain.callou directement au LLM de la manière appropriée.
1. Adapter le frontend (optionnel)
Pour que cela fonctionne, le frontend doit envoyer ces paramètres dans l’appel POST à
/rag.Dans le front (dans
index.html), modifie le fetch comme ça :const response = await fetch('/rag', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ question: prompt, maxNewTokens: parseInt(maxTokensInput.value), temperature: parseFloat(temperatureInput.value), topK: parseInt(topKInput.value), topP: parseFloat(topPInput.value), }) });
2. Modifier
server.jsOuvre
server.js, dans la route POST/ragmodifie la gestion comme suit :app.post("/rag", async (req, res) => { try { const { question, maxNewTokens, temperature, topK, topP } = req.body; if (!question) { return res.status(400).json({ error: "Question requise" }); } // Préparer options de génération dynamiques selon ce qui est reçu const llmOptions = { max_new_tokens: maxNewTokens, temperature, top_k: topK, top_p: topP, }; // Appel de la chaîne retrieval + génération // Ici on passe llmOptions à ragChain.call via query et config // Langchain ne supporte pas directement les options LLM dans RetrievalQAChain, // donc on contourne en injectant dans query un objet contenant ces options et on modifie le LLM. // Solution simple : modifier la méthode _call du LLM pour récupérer les options depuis l'objet query // Par exemple, créer une propriété 'llmOptions' dans query pour la passer au LLM // On modifie la requête pour y mettre les options associées (exemple simple) const response = await ragChain.call({ query: question, llmOptions // injecter options ici }); res.json({ answer: response.text }); } catch (e) { console.error(e); res.status(500).json({ error: e.message }); } });
3. Modifier
XenovaLLM.jspour prendre en compte ces options dynamiquesLe problème est que
RetrievalQAChainne transmet pas les options personnalisées du frontend à l’instance LLM sans adaptation.Pour résoudre cela, on va modifier la méthode
_calldansXenovaLLMpour qu’elle acceptera une forme d’llmOptionssupplémentaire qu’on peut passer via les appels Langchain.La méthode
_calldansXenovaLLM.jsn’a besoin que de vérifier si les options dynamiques ont été passées dansllmOptionsou dans l’objetinputs(dans ce cas,querycontient le prompt).La solution recommandée :
Modifier
_calldansXenovaLLMcomme suit (extrait pertinent) :async _call(prompt, llmOptions = {}) { await this._initialize(); // llmOptions peut venir soit directement, soit via une clé llmOptions dans llmOptions (exemple : ragChain.call( { query: ..., llmOptions: {...}} )) // Préférer fusionner les options pour permettre l’override dynamique // Si l’appel vient via RetrievalQAChain avec { query, llmOptions }, la vraie options sont dans llmOptions.llmOptions, donc : let optionsOverrides = {}; if (llmOptions.llmOptions) { optionsOverrides = llmOptions.llmOptions; } else { optionsOverrides = llmOptions; } 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, ...optionsOverrides, }; const result = await this.generator(prompt, opts); const fullText = result[0].generated_text; if (fullText.startsWith(prompt)) { return fullText.slice(prompt.length).trim(); } else { return fullText.trim(); } }
Résumé des étapes
- Frontend : envoie
{ question, maxNewTokens, temperature, topK, topP }à/rag. - Backend (/rag) : récupère ces params, les place dans
llmOptionset les passe àragChain.callvia{ query: question, llmOptions }. - XenovaLLM récupère ces options dynamiques dans
_call()et les fusionne avec les options par défaut puis les transmet au pipeline de génération.
Note importante
Cette approche fonctionne avec ta version simple et la manière dont tu utilises Langchain ici.
Si jamais le comportement de
RetrievalQAChainbloque cette transmission d’options, il faudra envisager de personnaliser plus profondément la chaîne ou d’appeler le LLM manuellement avant/après la récupération.
Si tu veux, je peux aussi te préparer une version complète corrigée de tous les fichiers. Veux-tu ?
-
- User
préparer une version complète corrigée de tous les fichiers
- Assistant
Bien sûr ! Voici la version complète corrigée de chaque fichier pour que :
- Le frontend poste vers
/ragavec tous les paramètres de génération, - Le backend les récupère, les transmet à la chaîne RAG,
- La classe
XenovaLLMutilise correctement ces options dynamiques.
1.
XenovaLLM.jsimport { BaseLLM } from "langchain/llms/base.js"; import { pipeline } from "@xenova/transformers"; export class XenovaLLM extends BaseLLM { /** * @param {string} modelName Nom du modèle à charger (ex: "Xenova/gpt2") * @param {object} options Options de génération (temperature, maxNewTokens, topK, etc.) */ constructor(modelName = "Xenova/gpt2", options = {}) { super(options); this.modelName = modelName; this.generator = null; this.options = options; } /** * Initialise le pipeline de génération si ce n'est pas déjà fait */ async _initialize() { if (!this.generator) { this.generator = await pipeline("text-generation", this.modelName); } } /** * Méthode appelée par Langchain pour générer du texte à partir du prompt * @param {string} prompt Texte d'entrée * @param {object} llmOptions Options spécifiques à l'appel (overrides) * @returns {Promise<string>} Texte généré (uniquement la génération, sans le prompt) */ async _call(prompt, llmOptions = {}) { await this._initialize(); // Gestion des options dynamiques transmises via "llmOptions.llmOptions" ou directement let optionsOverrides = {}; if (llmOptions.llmOptions) { optionsOverrides = llmOptions.llmOptions; } else { optionsOverrides = llmOptions; } 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, ...optionsOverrides, }; const result = await this.generator(prompt, opts); const fullText = result[0].generated_text; if (fullText.startsWith(prompt)) { return fullText.slice(prompt.length).trim(); } else { return fullText.trim(); } } /** * Retourne le type de LLM (permet à Langchain de l’identifier) */ _llmType() { return "xenova"; } }
2.
server.jsimport express from "express"; import cors from "cors"; import { XenovaLLM } from "./XenovaLLM.js"; import { RetrievalQAChain } from "langchain/chains"; import { BaseRetriever } from "langchain/schema"; // --- Un retriever en mémoire basique pour démo --- class SimpleRetriever extends BaseRetriever { /** * @param {Array<{pageContent: string, metadata?: object}>} docs */ constructor(docs) { super(); this.docs = docs; } async getRelevantDocuments(query) { const loweredQuery = query.toLowerCase().split(" "); const results = this.docs.filter(doc => loweredQuery.some(word => doc.pageContent.toLowerCase().includes(word)) ); return results.slice(0, 3); } } const app = express(); app.use(cors()); app.use(express.json()); app.use(express.static("public")); // Instanciation du LLM Xenova (wrapper) const llm = new XenovaLLM("Xenova/gpt2", { maxNewTokens: 100, temperature: 0.7, topK: 10, topP: 1.0, }); // Exemple de documents simples const documents = [ { pageContent: "La Tour Eiffel est à Paris, c’est un monument célèbre." }, { pageContent: "Le Louvre est un musée très connu en France." }, { pageContent: "La gastronomie française est réputée mondialement." }, { pageContent: "GPT-2 est un modèle de génération de texte développé par OpenAI." }, ]; // Création du retriever avec ces docs const retriever = new SimpleRetriever(documents); // Création de la chaîne RAG : retriever + LLM const ragChain = RetrievalQAChain.fromLLM(llm, retriever); app.post("/rag", async (req, res) => { try { const { question, maxNewTokens, temperature, topK, topP } = req.body; if (!question) { return res.status(400).json({ error: "Question requise" }); } // Options dynamiques envoyées à XenovaLLM via llmOptions const llmOptions = { max_new_tokens: maxNewTokens, temperature, top_k: topK, top_p: topP, }; // Appel à la chaîne avec passage de llmOptions dans l’objet d’appel const response = await ragChain.call({ query: question, llmOptions, }); res.json({ answer: response.text }); } catch (e) { console.error(e); res.status(500).json({ error: e.message }); } }); const port = 3000; app.listen(port, () => { console.log(`Serveur lancé sur http://localhost:${port}`); });
3.
public/index.html<!DOCTYPE html> <html lang="fr"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1" /> <title>Générateur de texte GPT-2</title> <style> body { font-family: Arial, sans-serif; padding: 2rem; background: #f0f0f0; max-width: 600px; margin: auto; } textarea { width: 100%; height: 100px; font-size: 1rem; padding: 0.5rem; } button { margin-top: 1rem; padding: 0.5rem 1rem; font-size: 1rem; cursor: pointer; } #result { margin-top: 1rem; white-space: pre-wrap; background: white; padding: 1rem; border-radius: 5px; min-height: 100px; } label { display: block; margin-top: 1rem; } input[type="range"] { width: 100%; } #errorMsg { color: red; margin-top: 1rem; } #spinner { display: none; margin-left: 10px; vertical-align: middle; border: 4px solid #ccc; border-top: 4px solid #333; border-radius: 50%; width: 18px; height: 18px; animation: spin 1s linear infinite; } @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } } .btn-row { margin-top: 1rem; display: flex; gap: 1rem; } </style> </head> <body> <h1>Générateur de texte GPT-2</h1> <label for="prompt">Saisissez votre texte :</label> <textarea id="prompt" placeholder="Commencez à écrire...">Once upon a time,</textarea> <!-- Paramètres de génération --> <label for="maxTokens">Nombre maximal de tokens : <span id="maxTokensVal">50</span></label> <input type="range" id="maxTokens" min="10" max="200" step="10" value="50" /> <label for="temperature">Température (créativité) : <span id="temperatureVal">0.7</span></label> <input type="range" id="temperature" min="0.1" max="1" step="0.1" value="0.7" /> <label for="topK">Top-K (restriction vocabulaire) : <span id="topKVal">10</span></label> <input type="range" id="topK" min="0" max="50" step="1" value="10" /> <label for="topP">Top-p (nucleus sampling, 0.0 - 1.0) : <span id="topPVal">1.0</span></label> <input type="range" id="topP" min="0" max="1" step="0.05" value="1" /> <div class="btn-row"> <button id="generateBtn">Générer</button> <button id="resetBtn" type="button">Réinitialiser</button> <div id="spinner" title="Chargement..."></div> </div> <div id="result"></div> <div id="errorMsg" role="alert" aria-live="assertive"></div> <script> const btn = document.getElementById('generateBtn'); const resetBtn = document.getElementById('resetBtn'); const promptInput = document.getElementById('prompt'); const resultDiv = document.getElementById('result'); const errorMsg = document.getElementById('errorMsg'); const spinner = document.getElementById('spinner'); const maxTokensInput = document.getElementById('maxTokens'); const maxTokensVal = document.getElementById('maxTokensVal'); const temperatureInput = document.getElementById('temperature'); const temperatureVal = document.getElementById('temperatureVal'); const topKInput = document.getElementById('topK'); const topKVal = document.getElementById('topKVal'); const topPInput = document.getElementById('topP'); const topPVal = document.getElementById('topPVal'); maxTokensInput.oninput = () => maxTokensVal.textContent = maxTokensInput.value; temperatureInput.oninput = () => temperatureVal.textContent = temperatureInput.value; topKInput.oninput = () => topKVal.textContent = topKInput.value; topPInput.oninput = () => topPVal.textContent = topPInput.value; function setLoading(isLoading) { if (isLoading) { spinner.style.display = 'inline-block'; btn.disabled = true; resetBtn.disabled = true; } else { spinner.style.display = 'none'; btn.disabled = false; resetBtn.disabled = false; } } btn.addEventListener('click', async () => { const prompt = promptInput.value.trim(); errorMsg.textContent = ''; resultDiv.textContent = ''; if (!prompt) { errorMsg.textContent = 'Veuillez saisir un texte dans la zone de saisie.'; return; } setLoading(true); resultDiv.textContent = 'Génération en cours...'; try { const response = await fetch('/rag', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ question: prompt, maxNewTokens: parseInt(maxTokensInput.value), temperature: parseFloat(temperatureInput.value), topK: parseInt(topKInput.value), topP: parseFloat(topPInput.value), }) }); if (!response.ok) { const errorData = await response.json(); throw new Error(errorData.error || 'Erreur lors de la génération.'); } const data = await response.json(); if (data.answer) { resultDiv.textContent = data.answer; } else { errorMsg.textContent = 'Erreur : réponse invalide.'; } } catch (err) { errorMsg.textContent = 'Erreur réseau ou serveur : ' + err.message; console.error(err); } finally { setLoading(false); } }); resetBtn.addEventListener('click', () => { promptInput.value = ''; resultDiv.textContent = ''; errorMsg.textContent = ''; }); </script> </body> </html>
Instructions pour tester
-
Place tous les fichiers dans ton projet (
XenovaLLM.js,server.js, dossierpublicavecindex.html). -
Installe les dépendances nécessaires (
express,cors,langchain,@xenova/transformers, etc.). -
Lance le serveur avec node :
node server.js. -
Ouvre http://localhost:3000 dans un navigateur.
-
Saisis un texte, ajuste les paramètres, clique sur Générer.
Tu devrais voir une réponse générée tenant compte des documents et des options.
Si tu rencontres des soucis ou veux optimiser d’autres aspects, je suis là pour t’aider !
- Le frontend poste vers
- User
node server.js node:internal/errors:496 ErrorCaptureStackTrace(err); ^
Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './schema' is not defined by "exports" in /home/pascal/gpt-2 (copie)/node_modules/langchain/package.json imported from /home/pascal/gpt-2 (copie)/server.js at new NodeError (node:internal/errors:405:5) at exportsNotFound (node:internal/modules/esm/resolve:366:10) at packageExportsResolve (node:internal/modules/esm/resolve:713:9) at packageResolve (node:internal/modules/esm/resolve:899:14) at moduleResolve (node:internal/modules/esm/resolve:973:20) at defaultResolve (node:internal/modules/esm/resolve:1206:11) at ModuleLoader.defaultResolve (node:internal/modules/esm/loader:404:12) at ModuleLoader.resolve (node:internal/modules/esm/loader:373:25) at ModuleLoader.getModuleJob (node:internal/modules/esm/loader:250:38) at ModuleWrap. (node:internal/modules/esm/module_job:76:39) { code: 'ERR_PACKAGE_PATH_NOT_EXPORTED' }
Node.js v18.20.8
- Assistant
L’erreur suivante :
Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './schema' is not defined by "exports" in [...]indique que tu importes un sous-module
langchain/schemaqui n’est plus exporté ni accessible directement dans la version de Langchain que tu utilises.
Pourquoi ce problème ?
Depuis quelques versions, la structure d’export des packages Langchain a changé, certains sous-modules ne sont plus accessibles par des imports
"langchain/schema".Tu dois donc :
- Modifier tes imports pour utiliser uniquement les chemins officiellement exportés,
- Ou importer ce dont tu as besoin depuis un package ou module accessible.
Solution pour ton cas avec
BaseRetrieverAu lieu de faire :
import { BaseRetriever } from "langchain/schema";fait plutôt :
import { BaseRetriever } from "langchain/retriever";ou, si ça ne fonctionne pas, tu peux créer ta propre classe simple sans importer cette classe Langchain, par exemple :
class SimpleRetriever { constructor(docs) { this.docs = docs; } async getRelevantDocuments(query) { const loweredQuery = query.toLowerCase().split(" "); const results = this.docs.filter(doc => loweredQuery.some(word => doc.pageContent.toLowerCase().includes(word)) ); return results.slice(0, 3); } }Et enlever complètement
import { BaseRetriever } from "langchain/schema".
Mise à jour complète pour
server.jsRemplace la déclaration
SimpleRetrieverpar :// --- Un retriever très simple sans dépendance Langchain --- class SimpleRetriever { /** * @param {Array<{pageContent: string, metadata?: object}>} docs */ constructor(docs) { this.docs = docs; } async getRelevantDocuments(query) { const loweredQuery = query.toLowerCase().split(" "); const results = this.docs.filter(doc => loweredQuery.some(word => doc.pageContent.toLowerCase().includes(word)) ); return results.slice(0, 3); } }Et supprime l’import suivant :
- import { BaseRetriever } from "langchain/schema";
Autre suggestions
- Vérifie la version de Langchain installée (
npm list langchain). - La documentation officielle pour la version précise que tu utilises pourra t’indiquer le bon chemin d’import.
- En général, importe uniquement depuis
"langchain"(exemple :import { RetrievalQAChain } from "langchain"). - Pour la classe baseRetriever, si la structure a changé, le mieux est soit de copier-minimalement la classe (ou créer ta propre classe retriever comme ci-dessus).
Résumé
Dans server.js :
// Supprime l'import de BaseRetriever // import { BaseRetriever } from "langchain/schema"; // Remplace SimpleRetriever ainsi : class SimpleRetriever { constructor(docs) { this.docs = docs; } async getRelevantDocuments(query) { const loweredQuery = query.toLowerCase().split(" "); const results = this.docs.filter(doc => loweredQuery.some(word => doc.pageContent.toLowerCase().includes(word)) ); return results.slice(0, 3); } }Cela devrait résoudre ton erreur
ERR_PACKAGE_PATH_NOT_EXPORTEDliée àlangchain/schema.
Si tu veux je peux t’aider à vérifier les versions précises des packages et leurs imports corrects !