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 clientActions = {}; // Объект для хранения ограничителей по каждому клиенту const limiters = {};

    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 console.log('Client connected with user ID:', userId);

    // Инициализируем состояние клиента, если его еще нет
    if (!clientActions[userId]) {
      clientActions[userId] = {
        actions: [], // Массив для хранения действий
        connected: true, // Статус подключения
      };
      
      // Создаем экземпляр Bottleneck для каждого клиента
      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); 
    		
    		//Получаем историю чата из запроса
    		messages = message.messages;
    		
    		// Используем Bottleneck для управления количеством запросов
            limiters[userId].schedule(() => {
                // Отправка запроса на сервер чата
                return call(messages, ws);
            }).catch(error => {
                //console.error('Rate limit exceeded, message ignored:', error);
                const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
                
                if (ws.readyState === WebSocket.OPEN) {
                    ws.send(JSON.stringify(response));
                }
            });
    		
    	} catch (error) {
    			console.error('Error parsing JSON:', error);
    			const response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    			console.log(response);
    			
    			if (ws.readyState === WebSocket.OPEN) {
    				ws.send(JSON.stringify(response));
    			}
    	}
    	
    });
    
    ws.on('close', () => {
    	clientActions[userId].connected = false; // Обновление статуса подключения
    	delete clientActions[userId]; // Удаление состояния клиента
    	delete limiters[userId]; // Удаление ограничителя для данного клиента
        console.log('Client ',userId, ' disconnected');
    });
    

    });

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

    	console.log('Запрос клиента:', userMessage); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
        gpt4o({
            messages: userMessage,
            markdown: false
        }, (result) => {
            if (!result.finish) {
                // Запоминаем только последний ответ чата (он будет полный, промежуточные ответы - это накопления)
                fullResponse = result.message || "";
    			//console.log(result);
            } else {
                // Если завершено, выводим полный ответ
    			let response = { code: 1, message: fullResponse};
    			console.log('Ответ чата: ', response);
    			// Отправка ответа клиенту
    			if (ws.readyState === WebSocket.OPEN) {
    				ws.send(JSON.stringify(response));
    			} else {
    				console.warn(`Trying to send message to a closed WebSocket connection.`);
    			}
            }
        });
    } catch (error) {
        console.error('Error:', error);
    	let response = { code: 2, message: "Произогла ошибка. Попробуйте еще раз."};
    	if (ws.readyState === WebSocket.OPEN) {
    		ws.send(JSON.stringify(response));
    	} else {
    		console.warn(`Trying to send message to a closed WebSocket connection.`);
    	}
    }
    

    }

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

    Оцени код Assistant: од представляет собой WebSocket-сервер, который управляет подключениями клиентов и упрощает взаимодействие с различными API (в частности, для генерации текста с использованием модели GPT). Он использует библиотеку Bottleneck для ограничения скорости запросов. Вот несколько аспектов, которые можно оценить и предложить улучшения:

    Позитивные моменты

    1. Структура кода: Код организован логически, функции и переменные имеют описательные названия, что делает его достаточно читаемым.

    2. Управление клиентами: Используется объект clientActions для хранения состояния каждого клиента, что позволяет отслеживать подключения и их действия.

    3. Ограничение частоты запросов: Библиотека Bottleneck помогает предотвратить превышение лимитов запросов, что полезно для избежания перегрузки API.

    4. Обработка ошибок: Код включает обработку ошибок, что позволяет вернуть понятные сообщения клиентам в случае сбоя.

    5. Закрытие соединения: При закрытии соединения корректно обновляется состояние клиента и освобождаются связанные с ним ресурсы.

    Недостатки и возможности для улучшения

    1. Производительность: Использование minTime: 1000 может быть излишним в некоторых случаях, особенно если вы ожидаете много клиентов. Возможно, стоит рассмотреть более гибкие настройки или адаптивное ограничение.

    2. Отсутствует обработка исключений в callback: В функции call обработка результата API происходит через callback, и если произойдет ошибка, она не будет поймана. Используйте try-catch внутри callback для полной обработки ошибок.

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

    4. Использование WebSocket API: Рассмотрите использование методов ws.on('error', ...) для обработки ошибок WebSocket-соединения, что может помочь отлавливать проблемы связи.

    5. Масштабируемость и безопасность: Если планируется большой объем данных, можно рассмотреть использование Redis для хранения состояний пользователей и балансировки нагрузки на серверах для масштабируемости.

    6. Форматирование кода: Убедитесь, что код отформатирован и следует определенным стандартам, чтобы улучшить читаемость (например, использование eslint или prettier).

    7. Обработка ключа API и конфиденциальной информации: Обратите внимание на безопасность в работе с API-ключами и конфиденциальной информацией, особенно в продакшн-коде.

    Заключение

    В целом, код демонстрирует хорошее понимание работы с WebSocket и взаимодействию с API. На данном этапе реализации присутствует несколько областей для улучшения, но в целом он эффективно выполняет свою задачу. User: Производительность: Использование minTime: 1000 может быть излишним в некоторых случаях, особенно если вы ожидаете много клиентов. Возможно, стоит рассмотреть более гибкие настройки или адаптивное ограничение.

    Разве в моем коде ограничение minTime: 1000 не индивидуально для каждого клиента? Assistant: , вы правы. Ограничение minTime: 1000 в вашем коде устанавливается для каждого клиента индивидуально через экземпляр Bottleneck. Это означает, что каждое соединение клиента будет иметь своё собственное ограничение на время между запросами в 1000 миллисекунд.

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

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

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

    Таким образом, ваше понимание того, что ограничение индивидуально для каждого клиента, совершенно верное. Спасибо за уточнение! User: Интерфейс клиента предполагает, что общение пользователя будет происходить по схеме вопрос-ответ. Т.е. пользователь не должен иметь возможности отправлять несколько вопросов подряд. Разве minTime: 1000 в такой ситуации не логичен? Assistant:

  2. Assistant

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

    В этом контексте использование minTime: 1000 помогает обеспечить, что между отправкой вопросов будет разумный временной интервал, что делает общение более последовательным и управляемым. Это также позволяет избежать ситуаций, когда пользователь может случайно или намеренно отправить несколько запросов одновременно, что могло бы привести к проблемам с обработкой на стороне сервера и, возможно, к превышению лимитов API.

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