Skip to content
The Chat Archive
gpt-4o-mini-2024-07-18· OpenAI WildChat-4.8M (AI2)

const { gpt, gptweb } = require("./API/gpt"); const { dalle } =…

  1. User

    User: const { gpt, gptweb } = require("./API/gpt"); const { dalle } = require("./API/dalle"); const { gpt4o } = require("./API/gpt4o"); const { gpt3 } = require("./API/gpt3.5"); const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("./API/blackbox"); const { qwen } = require("./API/qwen"); const { gemini } = require("./API/gemini"); const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики const fs = require('fs'); const path = require('path'); const Ajv = require('ajv');

    // Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме) const ajv = new Ajv(); // Объект для хранения действий и состояния каждого клиента const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Замените на ваш домен const allowedOrigin = 'http://gpt.loc';

    // Создайте WebSocket-сервер const wss = new WebSocket.Server({ port: 3000 });

    wss.on('connection', (ws, req) => {

    const urlParams = new URLSearchParams(req.url.split('?')[1]);
    const userId = urlParams.get('token'); // Получаем UUID из URL
    const userIP = req.socket.remoteAddress;
    //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
    const userHeaders = req.headers;
    
    // Проверяем Origin
    if (!checkOrigin(userHeaders.origin, ws)) {
        return; // Если отклонено, выходим из обработчика
    }
    
    // Увеличиваем общий счетчик подключений
    stats.totalConnections++;
    
    console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin);
    
    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
    	clientActions[userId] = {
    		actions: [], // Массив для хранения действий
    		connected: true, // Статус подключения
        };
    }
    else
    	clientActions[userId].connected = true;
    
    if (!limiters[userId]) { 
      // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
    	limiters[userId] = new Bottleneck({
            maxConcurrent: 1, // Максимальное количество одновременных задач
            minTime: 1000, // Минимальное время между запросами в миллисекундах
    	    highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
        });
    }
    
    ws.on('message', (message) => {
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		//Получаем историю чата из запроса
    		let messages = message.messages;
    		let model = message.model;
    		console.log('Модель - ', model);
    		// Выполняем валидацию сообщений
    		messages = validateMessages(messages);
    		
    		// Проверяем, остались ли сообщения после валидации
    		if (messages.length === 0) {
    			const response = { code: 2, message: "Нет валидных сообщений для обработки." };
    			sendMessage(ws, response);
    			return;
    		}
    		
    		// Урезаем последнее сообщение до 2000 символов, если оно от клиента
    		if (messages[messages.length - 1].role === 'user') {
    			messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
    		}
    		
    		// Увеличиваем общий счетчик запросов
            stats.totalRequests++;
    		
    		// Используем Bottleneck для управления количеством запросов
    		limiters[userId].schedule(() => {
    			// Отправка запроса на сервер чата
    			if (model == 'gpt-4o')
    				return callGPT4o(messages, ws);
    			else if (model == 'gemini-pro')
    				return callGemini(messages, ws);
    			else if (model == 'qwen')
    				return callQwen(messages, ws);
    			else if (model == 'blackbox')
    				return callBlackbox(messages, ws);
    			else if (model == 'gpt-3.5-turbo')
    				return callGPT35Turbo(messages, ws);
    		}).catch(error => {
    			stats.totalIPBlocks++;
    			//console.error('Rate limit exceeded, message ignored:', error);
    			const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    			// Отправка ответа клиенту
    			//sendMessage(ws, response);
    		});
    		
    	} catch (error) {
    			console.error('Error parsing JSON:', error);
    			const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    			console.log(response);
    			// Отправка ответа клиенту
    			sendMessage(ws, response);
    	}
    	
    });
    
    ws.on('close', () => {
    	clientActions[userId].connected = false; // Обновление статуса подключения
    	delete clientActions[userId]; // Удаление состояния клиента
    	delete limiters[userId]; // Удаление ограничителя для данного клиента
        console.log('Client ',userId, ' disconnected');
    });
    

    });

    // Запускаем планировщик для статистики scheduleDailyReset();

    // Очистка старых соединений раз в минуту (по желанию) setInterval(() => { Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен delete limiters[userId]; } }); }, 10 * 60 * 1000); // Очистка каждые 10 минут

    function checkOrigin(origin, socket) { if (origin !== allowedOrigin) { console.log('Недопустимый домен. Соединение разорвано: ', origin); socket.close(); // Закрываем соединение, если домен не разрешен return false; // Возвращаем false для индикатора отклонения } return true; // Возвращаем true, если домен разрешен }

    // Отправляет ответ клиенту function sendMessage(ws, message) { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(message)); } else { console.warn(Trying to send message to a closed WebSocket connection.); } }

    // Удаление из массива сообщений не соответствующих схеме function validateMessages(messages) { // Определяем схему для сообщений const schema = { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'], additionalProperties: false };

    // Фильтруем массив, оставляя только корректные сообщения
    return messages.filter(message => ajv.validate(schema, message));
    

    }

    console.log('WebSocket сервер запущен через порт 3000');

    //============== ВЫЗОВ API МОДЕЛЕЙ ================================================= //================================================================================== //================================================================================== //==================================================================================

    // GPT4o async function callGPT4o(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt4o({
            messages: messages,
            markdown: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // GPT3.5-Turbo async function callGPT35Turbo(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt3({
            messages: messages,
            markdown: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // Gemini async function callGemini(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gemini({
            messages: messages
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // Qwen async function callQwen(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        qwen({
            messages: messages,
            markdown: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // Blackbox async function callBlackbox(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        blackbox({
            messages: messages,
            markdown: false,
            websearch: false,
            llama: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    //============== ВЫЗОВ API МОДЕЛЕЙ (КОНЕЦ) ======================

    На мой сайт большая нагрузка, много клиентов. Нужно добавить балансировку для распределения нагрузки между серверами. Что тут сделать? Assistant: добавления балансировки нагрузки между серверами, вы можете рассмотреть несколько подходов. Вот основные шаги и рекомендации, как это можно сделать:

    1. Использование балансировщика нагрузки:

    • Аппаратный балансировщик нагрузки: Если у вас есть ресурсы, вы можете использовать устройства типа F5 или аналогичные, которые предлагают функции балансировки нагрузки.
    • Программные решения: Рассмотрите использование программных балансировщиков нагрузки, таких как NGINX или HAProxy. Они могут распределять входящие соединения между несколькими экземплярами вашего приложения на разных серверах.

    2. Настройка NGINX как балансировщика нагрузки:

    Если вы выберете NGINX, вот пример его настройки для балансировки нагрузки:

    http {
        upstream app_servers {
            server app_server_1:3000;
            server app_server_2:3000;
            server app_server_3:3000;
        }
    
        server {
            listen 80;
    
            location / {
                proxy_pass http://app_servers;
                proxy_http_version 1.1;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection 'upgrade';
                proxy_set_header Host $host;
                proxy_cache_bypass $http_upgrade;
            }
        }
    }
    

    В этом примере app_server_1, app_server_2, и app_server_3 – это адреса ваших серверов, на которых развернуто приложение.

    3. Создание кластеров приложения:

    В случае Node.js вы можете использовать cluster или pm2 для создания кластеров вашего приложения, что позволит задействовать все ядра вашего сервера.

    4. Использование Docker и Kubernetes:

    Если вы используете контейнеризацию, Kubernetes может помочь в автоматизации развертывания и настройки балансировщика нагрузки. Использование служб типа LoadBalancer в Kubernetes может автоматически выделить внешний IP и маршрутизировать трафик.

    5. Мониторинг и управление:

    • Следите за распределением нагрузки с помощью мониторинга. Инструменты как Prometheus, Grafana могут помочь в визуализации нагрузки и производительности.
    • Имейте систему для отката, если один из серверов вызывает проблемы.

    6. Кэширование:

    Реализуйте кэширование для частых запросов. Это может помочь уменьшить нагрузку. Используйте такие решения, как Redis или Memcached.

    7. Подход с микросервисами:

    Если ваше приложение имеет множество различных функций, рассмотрите возможность его разбивки на микросервисы, которые могут быть разбросаны по различным серверам, каждый из которых хорошо подходит для его задачи.

    8. Backend API Gateway:

    Подумайте об использовании API Gateway для управления горизонтальной масштабируемостью. Это может также давать возможность маршрутизировать запросы к различным сервисам.

    9. Обработка ошибок иRetries:

    Настройте обработку ошибок и перезапросы в случае отказов. Это особенно важно, если один из серверов становится недоступен.

    10. Тестирование под нагрузкой:

    После всех изменений обязательно проведите тестирование под нагрузкой (например, с использованием JMeter или k6), чтобы убедиться, что ваше решение работает эффективно под реальной нагрузкой.

    Эти рекомендации помогут вам настроить балансировку нагрузки и обеспечить более стабильную работу вашего приложения при высокой нагрузке. User: 3. Создание кластеров приложения: В случае Node.js вы можете использовать cluster или pm2 для создания кластеров вашего приложения, что позволит задействовать все ядра вашего сервера.

    подробнее, с использованием pm2 Assistant: ование pm2 для создания кластеров приложения на Node.js — это отличный способ задействовать все доступные ядра процессора на сервере и улучшить масштабируемость вашего приложения.

    Установка PM2

    Если у вас еще не установлен pm2, вы можете установить его глобально через npm:

    npm install -g pm2
    

    Запуск приложения в режиме кластера

    С pm2 вы можете запустить ваше приложение в режиме кластера с помощью команды:

    pm2 start yourApp.js -i max
    
    • yourApp.js — файл вашего приложения, который содержит код Node.js.
    • -i max — это параметр, который запускает максимальное количество экземпляров вашего приложения в зависимости от количества доступных процессоров на сервере. Вы также можете задать конкретное количество экземпляров, указав, например, -i 4 для запуска четырех экземпляров.

    Пример настройки

    1. Создайте файл приложения (app.js):
    const express = require('express');
    const app = express();
    const port = process.env.PORT || 3000;
    
    app.get('/', (req, res) => {
        res.send('Hello World!');
    });
    
    app.listen(port, () => {
        console.log(`App running on port ${port}`);
    });
    
    1. Запустите приложение в режиме кластера:
    pm2 start app.js -i max
    
    1. Проверьте статус ваших процессов:
    pm2 list
    

    Эта команда покажет вам список всех запущенных экземпляров вашего приложения, их статус, количество перезагрузок и т. д.

    1. Обработка ошибок и перезапуск:

    pm2 также позволяет вам настроить автоматический перезапуск ваших процессов в случае сбоев. Например, вы можете установить максимальное количество перезагрузок перед тем, как процесс будет помечен как "неисправный":

    pm2 start app.js -i max --max-restarts 5
    
    1. Логи:

    Для просмотра логов вашего приложения вы можете использовать команду:

    pm2 logs
    

    Это откроет консоль с логами всех ваших экземпляров приложения. Чтобы увидеть логи только для одного экземпляра, используйте:

    pm2 logs <process_id>
    

    где <process_id> — это идентификатор вашего процесса.

    1. Экспортирование конфигурации:

    Вы можете создать файл конфигурации ecosystem.config.js, чтобы управлять приложениями pm2. Пример файла:

    module.exports = {
        apps: [{
            name: 'myApp',
            script: 'app.js',
            instances: 'max',
            exec_mode: 'cluster',
            watch: true
        }]
    }
    

    И запустить его с помощью:

    pm2 start ecosystem.config.js
    
    1. Мониторинг и управление:

    pm2 также предоставляет инструменты для мониторинга вашего приложения и управления им. Например, вы можете использовать команду:

    pm2 monit
    

    Это откроет простой интерфейс мониторинга в консоли.

    Устойчивость при перезагрузке

    Для того чтобы ваши приложения автоматически перезапускались после перезагрузки сервера, выполните следующую команду:

    pm2 startup
    

    Это сгенерирует и покажет вам команду, которую необходимо выполнить с правами администратора, чтобы включить автозапуск.

    Чтобы сохранить текущие процессы, запущенные в pm2, выполните:

    pm2 save
    

    Заключение

    Использование pm2 для создания кластеров значительно упрощает управление приложениями Node.js и улучшает их производительность. Это позволяет вам легко и быстро масштабировать ваше приложение, а также управлять им без лишних хлопот. User: Теперь на примере моего приложения. Сейчас я запускаю так pm2 start call.js --name server

    вот сам call.js

    const { gpt, gptweb } = require("./API/gpt"); const { dalle } = require("./API/dalle"); const { gpt4o } = require("./API/gpt4o"); const { gpt3 } = require("./API/gpt3.5"); const { prompts } = require("./API/gpt-prompts"); const { blackbox } = require("./API/blackbox"); const { qwen } = require("./API/qwen"); const { gemini } = require("./API/gemini"); const WebSocket = require('ws'); const Bottleneck = require('bottleneck'); const { stats, scheduleDailyReset, resetStatistics } = require('./stats'); // Импортируем модуль статистики const fs = require('fs'); const path = require('path'); const Ajv = require('ajv');

    // Создаем экземпляр Ajv (проверка входящей переписки на соответствие схеме) const ajv = new Ajv(); // Объект для хранения действий и состояния каждого клиента const clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {}; // Замените на ваш домен const allowedOrigin = 'http://gpt.loc';

    // Создайте WebSocket-сервер const wss = new WebSocket.Server({ port: 3000 });

    wss.on('connection', (ws, req) => {

    const urlParams = new URLSearchParams(req.url.split('?')[1]);
    const userId = urlParams.get('token'); // Получаем UUID из URL
    const userIP = req.socket.remoteAddress;
    //console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
    const userHeaders = req.headers;
    
    // Проверяем Origin
    if (!checkOrigin(userHeaders.origin, ws)) {
        return; // Если отклонено, выходим из обработчика
    }
    
    // Увеличиваем общий счетчик подключений
    stats.totalConnections++;
    
    console.log('Client connected with user ID:', userId, 'Домен - ', userHeaders.origin);
    
    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
    	clientActions[userId] = {
    		actions: [], // Массив для хранения действий
    		connected: true, // Статус подключения
        };
    }
    else
    	clientActions[userId].connected = true;
    
    if (!limiters[userId]) { 
      // Создаем экземпляр Bottleneck для каждого клиента (ограничение на количество запросов по Id)
    	limiters[userId] = new Bottleneck({
            maxConcurrent: 1, // Максимальное количество одновременных задач
            minTime: 1000, // Минимальное время между запросами в миллисекундах
    	    highWater: 0 // Не разрешать в очереди больше 0 запросов (игнорировать)
        });
    }
    
    ws.on('message', (message) => {
    	// Проверяем, является ли сообщение экземпляром Buffer
    	if (Buffer.isBuffer(message))
    		message = message.toString(); 
    	try {
    		// Преобразуем строку JSON обратно в объект
    		message = JSON.parse(message); 
    		//Получаем историю чата из запроса
    		let messages = message.messages;
    		let model = message.model;
    		console.log('Модель - ', model);
    		// Выполняем валидацию сообщений
    		messages = validateMessages(messages);
    		
    		// Проверяем, остались ли сообщения после валидации
    		if (messages.length === 0) {
    			const response = { code: 2, message: "Нет валидных сообщений для обработки." };
    			sendMessage(ws, response);
    			return;
    		}
    		
    		// Урезаем последнее сообщение до 2000 символов, если оно от клиента
    		if (messages[messages.length - 1].role === 'user') {
    			messages[messages.length - 1].content = messages[messages.length - 1].content.substring(0, 2000000);
    		}
    		
    		// Увеличиваем общий счетчик запросов
            stats.totalRequests++;
    		
    		// Используем Bottleneck для управления количеством запросов
    		limiters[userId].schedule(() => {
    			// Отправка запроса на сервер чата
    			if (model == 'gpt-4o')
    				return callGPT4o(messages, ws);
    			else if (model == 'gemini-pro')
    				return callGemini(messages, ws);
    			else if (model == 'qwen')
    				return callQwen(messages, ws);
    			else if (model == 'blackbox')
    				return callBlackbox(messages, ws);
    			else if (model == 'gpt-3.5-turbo')
    				return callGPT35Turbo(messages, ws);
    		}).catch(error => {
    			stats.totalIPBlocks++;
    			//console.error('Rate limit exceeded, message ignored:', error);
    			const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    			// Отправка ответа клиенту
    			//sendMessage(ws, response);
    		});
    		
    	} catch (error) {
    			console.error('Error parsing JSON:', error);
    			const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    			console.log(response);
    			// Отправка ответа клиенту
    			sendMessage(ws, response);
    	}
    	
    });
    
    ws.on('close', () => {
    	clientActions[userId].connected = false; // Обновление статуса подключения
    	delete clientActions[userId]; // Удаление состояния клиента
    	delete limiters[userId]; // Удаление ограничителя для данного клиента
        console.log('Client ',userId, ' disconnected');
    });
    

    });

    // Запускаем планировщик для статистики scheduleDailyReset();

    // Очистка старых соединений раз в минуту (по желанию) setInterval(() => { Object.keys(clientActions).forEach(userId => { if (!clientActions[userId].connected) { delete clientActions[userId]; // Удаляем пользователя из памяти, если он отключен delete limiters[userId]; } }); }, 10 * 60 * 1000); // Очистка каждые 10 минут

    function checkOrigin(origin, socket) { if (origin !== allowedOrigin) { console.log('Недопустимый домен. Соединение разорвано: ', origin); socket.close(); // Закрываем соединение, если домен не разрешен return false; // Возвращаем false для индикатора отклонения } return true; // Возвращаем true, если домен разрешен }

    // Отправляет ответ клиенту function sendMessage(ws, message) { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify(message)); } else { console.warn(Trying to send message to a closed WebSocket connection.); } }

    // Удаление из массива сообщений не соответствующих схеме function validateMessages(messages) { // Определяем схему для сообщений const schema = { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'], additionalProperties: false };

    // Фильтруем массив, оставляя только корректные сообщения
    return messages.filter(message => ajv.validate(schema, message));
    

    }

    console.log('WebSocket сервер запущен через порт 3000');

    //============== ВЫЗОВ API МОДЕЛЕЙ ================================================= //================================================================================== //================================================================================== //==================================================================================

    // GPT4o async function callGPT4o(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt4o({
            messages: messages,
            markdown: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // GPT3.5-Turbo async function callGPT35Turbo(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt3({
            messages: messages,
            markdown: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // Gemini async function callGemini(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gemini({
            messages: messages
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // Qwen async function callQwen(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        qwen({
            messages: messages,
            markdown: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    // Blackbox async function callBlackbox(messages, ws) { try { let fullResponse = ""; // Переменная для результата

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        blackbox({
            messages: messages,
            markdown: false,
            websearch: false,
            llama: false
        }, (result) => {
    		// Обработка результата внутри колбэка
            if (result.error) {
                throw new Error(result.error); // Обрабатываем ошибку, если она есть
            }
    		try {
    			if (!result.finish) {
    				// Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
    				fullResponse = result.message || "";
    				//console.log(result);
    			} else {
    				// Если завершено, выводим полный ответ
    				let response = { code: 1, message: fullResponse};
    				console.log('Ответ чата: ', response);
    				// Отправка ответа клиенту
    				sendMessage(ws, response);
    			}
    		}
    		catch (callbackError) {
                console.error('Error processing callback result:', callbackError);
                let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                // Отправка ответа клиенту
    			sendMessage(ws, response);
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

    //============== ВЫЗОВ API МОДЕЛЕЙ (КОНЕЦ) ====================== Assistant: запустить ваше Node.js приложение в режиме кластера с помощью pm2, вы можете использовать несколько простых шагов. Я покажу вам, как адаптировать ваши команды для pm2, чтобы запустить файл call.js в кластерном режиме, используя pm2.

    Шаги для запуска приложения в режиме кластера с использованием PM2

    1. Убедитесь, что PM2 установлен: Если вы еще не установили pm2, выполните следующую команду:

      npm install -g pm2
      
    2. Запустите ваше приложение в кластерном режиме: Поскольку вы сейчас запускаете ваше приложение с помощью следующей команды:

      pm2 start call.js --name server
      

      Измените команду так:

      pm2 start call.js --name server -i max
      

      Здесь -i max указывает pm2 запустить количество экземпляров, равное количеству доступных ядер вашего процессора. Это поможет использовать весь потенциал вашего серверного оборудования.

    3. Проверяйте статус вашего приложения: После запуска вы можете просмотреть статус вашего приложения и запущенных процессов с помощью:

      pm2 list
      
    4. Логи приложения: Чтобы просмотреть логи вашего приложения, используйте:

      pm2 logs server
      
    5. Автозапуск приложения: Чтобы ваше приложение автоматически перезапускалось после перезагрузки сервера, выполните команду:

      pm2 startup
      

      После этого вам будет предложено выполнить команду с правами администратора, чтобы завершить настройку.

    6. Сохранение текущих процессов: Сохраните текущее состояние ваших процессов с помощью:

      pm2 save
      

    Пример полного запуска

    Вот команда, которую вы используете для запуска call.js в кластере:

    pm2 start call.js --name server -i max
    

    Объяснение

    • -i max: Эта опция запускает ваше приложение в режиме кластера, создавая экземпляры равным количеству ядер в вашем сервере. Это помогает максимизировать использование ресурса CPU.
    • --name server: Это позволяет вам задать специфичное имя для вашего приложения в pm2, чтобы из списка процессов было легко его идентифицировать.

    Теперь ваше Node.js приложение будет запущено в кластерном режиме с помощью pm2, и оно будет автоматически масштабироваться в зависимости от доступных ядер. Это должно помочь справиться с высоким трафиком и значительно улучшить производительность вашего приложения. User: Если у меня VPS с 8 ядрами на процессоре и я запускаю сервер командой pm2 start call.js --name server, значит я всегда использую только одно ядро?, Т.е. мощность процессора всегда используется только на 12,5% ? И если это ядро будет максимально нагружено, то другие ядра не подключатся к работе? Assistant:

  2. Assistant

    Да, вы правы. Если вы запускаете ваше приложение Node.js с помощью команды:

    pm2 start call.js --name server
    

    то, по умолчанию, ваше приложение будет работать только в одном экземпляре и использовать одно ядро процессора. Поскольку ваш процессор имеет 8 ядер, это означает, что вы используете только 12,5% мощности процессора. В случае, если это одно ядро будет сильно нагружено, другие ядра не будут задействованы для выполнения задач вашего приложения.

    Как использовать все ядра?

    Чтобы задействовать все доступные ядра и улучшить производительность вашего приложения, вы должны запустить его в кластерном режиме. Это можно сделать с помощью pm2, указав количество экземпляров, равное количеству доступных ядер, или просто указав max, чтобы pm2 сам определил оптимальное количество:

    pm2 start call.js --name server -i max
    

    Преимущества использования кластера

    1. Балансировка нагрузки: Каждый экземпляр будет работать на своем отдельном ядре, что позволит вашему приложению обрабатывать больший объем одновременных подключений и улучшит общую производительность.

    2. Устойчивость: Если один экземпляр упадет, остальные продолжат обрабатывать запросы, что делает вашу систему более устойчивой.

    3. Производительность: Вы сможете использовать доступные ресурсы процессора более эффективно, что может привести к увеличению пропускной способности и уменьшению времени отклика.

    Ресурсы в случае нагрузки

    Если вы используете команду pm2 start call.js --name server -i max, это позволит процессам вашего приложения распределяться по всем доступным ядрам, что сделает использование серверных ресурсов более эффективным. Если одно ядро будет нагружено, другие экземпляры вашего приложения на других ядрах смогут продолжать обрабатывать запросы, тем самым минимизируя влияние нагрузки на общее производительность системы.

    Если бы вы запустили свое приложение только на одном экземпляре (одном ядре), то при повышенной загрузке одного ядра вы бы фактически ограничили производительность вашего приложения, так как другие ядра останутся бездействующими. Использование кластера помогает предотвратить этот сценарий.