add LLM Studio-based local translation script as default option with improved speed and quality

[XM-8JD2]

This is my local LLM translation script, which uses a 7B-Q4 model running on LLM Studio for translation. I have been using it for over two months, and it performs well — providing faster response speed and higher translation quality than Google Translate, while eliminating some translation errors that used to occur due to network issues.

I wrote this code with GPT, and I believe this project should include a default local LLM translation script. Perhaps my script could be added as one of the “Local LLM Translation Scripts” and made available by default in the plugin UI, with comments guiding users to power it using LLM Studio?

// Copy the entire class below to Linguist -> Settings -> Custom translators -> Add
// Local LLM service, no API key required
class OpenAITranslator {
    #endpoint = 'http://127.0.0.1:1234/v1/completions';
    #model = 'gpt-3.5-turbo'; // You can change this to the model name of your local LLM

    #defaultPrompt = 'You are a professional foreign language translator. Translate the text from ${from} to ${to}, preserving the original meaning, style, and tone. Adapt idioms or cultural references to be understandable for native speakers of the target language. Translate accurately and naturally.';

    // Translate a single text
    async translate(text, from, to) {
        if (!text) throw new Error('No text provided for translation');
        const result = await this.#fetchTranslation(text, from, to);
        if (!result) throw new Error(`Translation failed for text: "${text}" from ${from} to ${to}`);
        return result;
    }

    // Batch translation (parallel, the entire batch fails if any one fails)
    async translateBatch(texts, from, to) {
        if (!texts?.length) throw new Error('No texts provided for batch translation');
        return Promise.all(texts.map(text => this.translate(text, from, to)));
    }

    // Model length limit (conservative value)
    getLengthLimit() {
        return 500;
    }

    // Request timeout (milliseconds)
    getRequestsTimeout() {
        return 10000;
    }

    // Check if the length limit is exceeded (returns the exceeded length; 0 means not exceeded)
    checkLimitExceeding(text) {
        const limit = this.getLengthLimit();
        if (Array.isArray(text)) {
            const totalLength = text.reduce((sum, t) => sum + (t?.length || 0), 0);
            return totalLength > limit ? totalLength - limit : 0;
        }
        return text?.length > limit ? text.length - limit : 0;
    }

    // Whether to support automatic source language detection
    static isSupportedAutoFrom() {
        return true;
    }

    // List of supported language codes
    static getSupportedLanguages() {
        return [
            'en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'zh', 'ja', 'ko',
            'ar', 'nl', 'sv', 'tr', 'pl', 'hi', 'vi', 'th', 'el', 'he'
        ];
    }

    // Internal: Call the local LLM service for translation
    async #fetchTranslation(text, from, to) {
        try {
            const systemPrompt = this.#defaultPrompt
                .replace('${from}', from || 'auto')
                .replace('${to}', to || 'auto');

            const body = {
                model: this.#model,
                prompt: `${systemPrompt}\n\nTranslate from ${from || 'auto'} to ${to || 'auto'}:\n${text}`,
                max_tokens: 1000,
                temperature: 0.3
            };

            const response = await fetch(this.#endpoint, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(body)
            });

            if (!response.ok) {
                const errorData = await response.json().catch(() => ({}));
                throw new Error(`HTTP ${response.status}: ${errorData.error?.message || response.statusText}`);
            }

            const data = await response.json();
            // The return of the completions interface is generally choices[0].text
            if (!data.choices?.[0]?.text) {
                throw new Error('Invalid response from local LLM: No translation content');
            }
            return data.choices[0].text.trim();
        } catch (error) {
            console.error('Translation error:', error);
            throw error;
        }
    }
}

// Export the class (the class name must be the last line)
OpenAITranslator;

[vitonsky]

@XM-8JD2 we have repo https://github.com/translate-tools/linguist-translators for custom translators. Feel free to make PR there.

It would be perfect if you add information about config you use (model name and details) and optionally attach a screenshot of any page translated to any language, to show example of translation quality. You may use wikipedia or any other site.

It would be useful, since I don't see a model "gpt-3.5-turbo" at https://lmstudio.ai/models

In future we will implement a new feature in Linguist UI to fetch custom translators from this repo, configure (if needed) and add as custom translator.

User will click something like "Add custom translator", then select one of translators in list, then click and input any options like API key or URL, then click "Add" and translator will be in list of translators.