Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 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 { RateLimiterMemory } = require('rate-limiter-flexible'); 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';

    // Настройки для ограничений по IP const rateLimiter = new RateLimiterMemory({ points: 20, // разрешается 10 запросов duration: 1, // за 1 секунду blockDuration: 60 // время блокировки в секундах });

    // Создайте 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;
    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;
    		// Выполняем валидацию сообщений
    		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++;
    		
    		rateLimiter.consume(userIP)
                .then(() => {
    				// Используем Bottleneck для управления количеством запросов
    				limiters[userId].schedule(() => {
    					// Отправка запроса на сервер чата
    					return call(messages, ws);
    				}).catch(error => {
    					//console.error('Rate limit exceeded, message ignored:', error);
    					const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    					// Отправка ответа клиенту
    					sendMessage(ws, response);
    				});
    			})
                .catch(() => {
    				// Увеличиваем счетчик блокировок по IP
                    stats.totalIPBlocks++;
                    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');
    });
    

    });

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

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt4o({
            messages: messages,
            markdown: false
        }, (result) => {
    		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);
    }
    

    }

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

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

    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');

    rateLimiter тут это глобальная переменная. Для каждого клиента, которые подключаются c разных IP будет свое ограничение по IP? Assistant: , ваш код настроен так, чтобы для каждого клиента, который подключается с разных IP, было своё ограничение по количеству запросов. Давайте рассмотрим, как это происходит:

    1. Глобальный экземпляр rateLimiter: В вашем коде вы создаете один общий объект rateLimiter, который использует конструктор RateLimiterMemory. Это означает, что все пользователи будут использовать одно и то же хранилище для ограничений, и, следовательно, ограничения будут применяться ко всем клиентам независимо от их IP.

    2. Уникальность для каждого IP: В вашем обработчике сообщений (внутри ws.on('message', ...)) вы применяете код, который использует rateLimiter.consume(userIP). Это означает, что вы применяете ограничения на основе IP-адреса, что позволяет каждому IP иметь своё собственное ограничение по количеству запросов. Если один IP превышает лимит, пользователь с этого IP будет временно заблокирован, не влияя на других пользователей.

    Таким образом, да, ваше текущее решение позволяет каждому клиенту (или, точнее, каждому уникальному IP-адресу) получать свои индивидуальные лимиты. Однако, если несколько клиентов подключаются с одного и того же IP-адреса, они будут делить один лимит.

    Если вам необходимо, чтобы ограничения были раздельными для каждого клиента, то вы можете создать отдельные экземпляры RateLimiterMemory для каждого уникального userId, а не использовать один глобальный экземпляр для всех:

    const limiters = {}; // Объект для хранения ограничителей по каждому клиенту
    
    // Внутри ws.on('connection', ...)
    if (!limiters[userId]) { 
        limiters[userId] = new RateLimiterMemory({
            points: 20, // разрешается 20 запросов
            duration: 1, // за 1 секунду
            blockDuration: 60 // время блокировки в секундах
        });
    }
    

    Эти изменения дадут каждому уникальному клиенту свои ограничения, основанные на идентификаторе пользователя, и не будут зависеть от IP-адреса. User: console.log("IP-адрес - ", userIP, "Время подключения - ", Date()); Найди ошибку, время подключения должно быть текущее время Assistant: вашем коде вызов Date() возвращает объект Date, который нужно преобразовать в строковое представление, чтобы корректно отобразить время подключения в консоли. Чтобы это сделать, вы можете использовать метод toString() или другие методы форматирования для объектов Date.

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

    console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toString());
    

    Или, если вы хотите получить более сжатый формат времени, вы можете использовать метод toISOString():

    console.log("IP-адрес - ", userIP, "Время подключения - ", new Date().toISOString());
    

    Это создаст строку, представляющую текущее время в удобочитаемом виде или в формате ISO 8601, соответственно. В обоих случаях вы получите актуальное время подключения. User: Какой должна быть посещаемость сайта в среднем чтобы образовалась ситуация когда подключены несколько клиентов с одного IP и с этого IP превышен лимит запросов 20 в секунду, если сайт доступен по всей России Assistant: рассмотреть сценарий, в котором несколько клиентов на одном IP-адресе превышают лимит запросов, установленный на уровне 20 запросов в секунду, нужно учесть несколько факторов:

    1. Характер использования сайта:

    • Временные пики: Если ваш сайт получает значительное количество трафика в определенные моменты времени (например, акции, новостные события), это увеличивает вероятность того, что несколько пользователей подключатся с одного IP.
    • Количество пользователей на сайте: Важно понимать, сколько пользователей фактически используют ваш сайт в одно и то же время. Пользователи могут находиться в разных регионах и даже с разных устройств, но если они используют тот же маршрутизатор (например, в домашних или офисных условиях), они будут иметь один и тот же внешний IP-адрес.

    2. Средний трафик:

    • Количество активных пользователей: Если ваш сайт имеет активную пользовательскую базу, которая превышает несколько сотен человек в секунду, шансы на то, что несколько пользователей будут с одного IP, увеличиваются. Например, если ваш сайт обслуживает 1,000 активных пользователей с одним IP-адресом.
    • Средняя частота запросов: Если каждый пользователь отправляет запросы с частотой 1 раз в 2-3 секунды, 20 запросов в секунду могут быть достигнуты очень быстро, если в сети несколько пользовательских устройств.

    3. Статистика о Интернете:

    • Динамика интернет-пользователей: В России больше 100 миллионов пользователей, и многие из них находятся за NAT (например, в домашние сети, Wi-Fi кафе и офисы), которые делят один IP-адрес. При популярном контенте или при массированном тестировании нагрузки (например, разработка, мониторинг) вы можете столкнуться с ситуацией, когда несколько пользователей с одной и той же NAT используют сайт параллельно.

    Примерные расчеты:

    • Если ваш сайт в среднем привлекает 1,000 уникальных посетителей в час, это будет около 16 уникальных пользователей в минуту (1,000 / 60). Если на 10 пользователей приходится один IP (например, домашние пользователи), это значит, что 10 пользователей могут подключиться одновременно с одного IP-адреса. Если каждый из них активен и делает 1 запрос в секунду, общий лимит в 20 запросов может быть достигнут.

    • В случае, если ваш сайт получает 100,000 посещений в день (что вполне реально даже для небольших сайтов), это будет около 1,000 пользователей в день, при этом 100-500 активными моментами увеличивается вероятность одновременного превышения лимитов.

    Заключение:

    Чтобы свести к минимуму проблемы с превышением лимитов, вы могли бы рассмотреть возможность создания более гибкой системы ограничения запросов или применять разные стратегии, такие как распределенное кэширование, настройка уровня API обработки и использование механизма очередей для обработки запросов. User: Т.е. мой код неэффективен если предполагается что сайт доступен всем в России Assistant: код, в котором используется ограничение на уровне 20 запросов в секунду для каждого IP-адреса, может столкнуться с некоторыми проблемами производительности и доступности, особенно если сайт имеет высокий трафик и множество активных пользователей. Вот основные моменты, которые стоит учитывать:

    1. Ограничение по IP

    Ваше текущее ограничение по IP подразумевает, что все пользователи, подключающиеся с одного IP (например, из одного домашнего роутера, офисной сети или публичной Wi-Fi сети), будут сталкиваться с одним и тем же лимитом. Это может привести к ситуации, когда несколько пользователей, использующих один IP, не смогут сделать больше 20 запросов в секунду, даже если на сайте много свободных ресурсов для обработки запросов.

    2. Распределенные подключения

    В крупных городах и регионах России, особенно в местах с большой плотностью населения (например, офисные здания, колледжи, кафе), несколько пользователей могут подключаться через одну сеть. В таких случаях может возникнуть ситуация, когда пользователи, ожидая ответа от сервера, будут блокироваться из-за ограничения по IP.

    3. Потребительский трафик

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

    4. Альтернативные решения

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

    • Индивидуальные ограничения: Рассмотрите возможность применения индивидуального лимита для каждого уникального пользователя (например, в зависимости от userId, sessionId или токена аутентификации).

    • Групповые и временные ограничения: Настройте временные ограничения на уровне групп пользователей, чтобы обеспечить некоторую гибкость между пользователями, которые могут подключаться с одного и того же IP.

    • Кэширование запросов: Рассмотрите возможность кэширования ответов на часто задаваемые запросы, чтобы снизить нагрузку на сервер и улучшить время отклика.

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

    • Мониторинг и аналитика: Внедрите систему мониторинга и аналитики, чтобы отслеживать, как запросы обрабатываются в реальном времени и выявлять узкие места.

    Заключение

    Ваше текущее решение работает, но в условиях большой посещаемости и различных сценариев использования может быть эффективно доработано для улучшения пользовательского опыта. Рассмотрите возможность внесения изменений в архитектуру вашего приложения, чтобы более гибко управлять нагрузкой и запросами пользователей. 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 { RateLimiterMemory } = require('rate-limiter-flexible'); 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';

    // Настройки для ограничений по IP const rateLimiter = new RateLimiterMemory({ points: 20, // разрешается 10 запросов duration: 1, // за 1 секунду blockDuration: 60 // время блокировки в секундах });

    // Создайте 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;
    		// Выполняем валидацию сообщений
    		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++;
    		
    		rateLimiter.consume(userIP)
                .then(() => {
    				// Используем Bottleneck для управления количеством запросов
    				limiters[userId].schedule(() => {
    					// Отправка запроса на сервер чата
    					return call(messages, ws);
    				}).catch(error => {
    					//console.error('Rate limit exceeded, message ignored:', error);
    					const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    					// Отправка ответа клиенту
    					sendMessage(ws, response);
    				});
    			})
                .catch(() => {
    				// Увеличиваем счетчик блокировок по IP
                    stats.totalIPBlocks++;
                    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');
    });
    

    });

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

    	console.log('Запрос клиента:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt4o({
            messages: messages,
            markdown: false
        }, (result) => {
    		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);
    }
    

    }

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

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

    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');

    убери из этого кода rate-limiter-flexible и проверки связанные с ним. Оставь ограничения только с помощью Bottleneck Assistant:

  2. Assistant

    Вы можете удалить rate-limiter-flexible и связанные с ним проверки из вашего кода, оставив только ограничения, управляемые с помощью Bottleneck. Вот модифицированная версия вашего кода без использования rate-limiter-flexible:

    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;
        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;
                // Выполняем валидацию сообщений
                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(() => {
                    // Отправка запроса на сервер чата
                    return call(messages, ws);
                }).catch(error => {
                    const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
                    // Отправка ответа клиенту
                    sendMessage(ws, response);
                });
            } catch (error) {
                console.error('Error parsing JSON:', error);
                const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
                // Отправка ответа клиенту
                sendMessage(ws, response);
            }
        });
    
        ws.on('close', () => {
            clientActions[userId].connected = false; // Обновление статуса подключения
            delete clientActions[userId]; // Удаление состояния клиента
            delete limiters[userId]; // Удаление ограничителя для данного клиента
            console.log('Client ', userId, ' disconnected');
        });
    });
    
    // GPT4o
    async function call(messages, ws) {
        try {
            let fullResponse = ""; // Переменная для результата
            
            console.log('Запрос клиента:', messages[messages.length - 1]); 
            gpt4o({
                messages: messages,
                markdown: false
            }, (result) => {
                try {
                    if (!result.finish) {
                        // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
                        fullResponse = result.message || "";
                    } 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);
        }
    }
    
    // Запускаем планировщик для статистики
    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');
    

    Изменения, внесенные в код:

    1. Удален код, связанный с rate-limiter-flexible и его проверки.
    2. Оставлены только ограничения, управляемые с помощью Bottleneck.

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