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;
    		// Выполняем валидацию сообщений
    		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);
    			else
    				return callGPT4o(messages, ws);
    		}).catch(error => {
    			stats.totalIPBlocks++;
    			//console.error('Rate limit exceeded, message ignored:', error);
    			const response = { code: 2, message: "Превышен лимит запросов. Пожалуйста, попробуйте позже." };
    			// Отправка ответа клиенту
    			//sendMessage(ws, response);
    		});
    		
    	} catch (error) {
    			stats.totalWsMessErrors++;
    			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(() => { console.log('Количество активных клиентов - ', Object.keys(clientActions).length); 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 => {
        // Проверяем, соответствует ли сообщение схеме
        if (ajv.validate(schema, message)) {
            // Обрезаем содержимое, если оно длиннее 2000 символов
            if (message.content.length > 2000000) {
                message.content = message.content.substring(0, 2000000);
            }
            return true; // Сообщение валидно, оставляем в массиве
        }
        return false; // Сообщение не валидно, исключаем из массива
    });
    

    }

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

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

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

    	console.log('Запрос клиента к GPT4o===:', messages[messages.length - 1]); 
    	//console.log('Запрос клиента к GPT4o:', messages); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
    	let messageSent = false;
        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);
    			if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ
                    stats.totalGPT4oCallbackErrors++;
                    let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                    sendMessage(ws, errorResponse);
                    messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось
                }
            }
        });
    } catch (error) {
    	stats.totalGPT4oMessErrors++;
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

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

    	console.log('Запрос клиента к Gemini:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
    	let messageSent = false;
        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);
    			if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ
                    stats.totalGeminiCallbackErrors++;
                    let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                    sendMessage(ws, errorResponse);
                    messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось
                }
            }
        });
    } catch (error) {
    	stats.totalGeminiMessErrors++;
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

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

    	console.log('Запрос клиента к Qwen:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
    	let messageSent = false;
        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);
    			if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ
                    stats.totalQwenCallbackErrors++;
                    let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                    sendMessage(ws, errorResponse);
                    messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось
                }
            }
        });
    } catch (error) {
    	stats.totalQwenMessErrors++;
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

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

    	console.log('Запрос клиента к Blackbox:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
    	let messageSent = false;
        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);
    			if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ
                    stats.totalBlackboxCallbackErrors++;
                    let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                    sendMessage(ws, errorResponse);
                    messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось
                }
            }
        });
    } catch (error) {
    	stats.totalBlackboxMessErrors++;
        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('Запрос клиента к GPT3.5-Turbo:', messages[messages.length - 1]); 
    	//throw new Error("Намеренная ошибка для тестирования catch");
    	let messageSent = false;
        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);
    			if (!messageSent) { // Отправляем сообщение об ошибке только если еще не отправили ответ
                    stats.totalGPT35CallbackErrors++;
                    let errorResponse = { code: 2, message: "Произошла ошибка. Попробуйте еще раз." };
                    sendMessage(ws, errorResponse);
                    messageSent = true; // Обновляем флаг, чтобы сообщение больше не отправлялось
                }
            }
        });
    } catch (error) {
    	stats.totalGPT35MessErrors++;
        console.error('Error:', error);
    	let response = { code: 2, message: "Произошла ошибка. Попробуйте еще раз."};
    	// Отправка ответа клиенту
    	sendMessage(ws, response);
    }
    

    }

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

    Проанализируй. Достаточен ли в этом коде контроль за утечками памяти? Assistant: оценки контроля за утечками памяти в данном коде, необходимо проанализировать, как управляются объекты и ресурсы, которые могут быть источниками утечек. Рассмотрим некоторые ключевые моменты кода:

    1. Управление подключениями:

      • После закрытия WebSocket-соединения (ws.on('close', ...)), вызывается удаление связанного состояния клиента из clientActions и limiters. Это хорошая практика, так как освобождает ресурсы, когда пользователь отключается.
    2. Очистка старых соединений:

      • Код включает установку интервала (каждые 10 минут), который проверяет состояние активных клиентов и удаляет тех, кто отключился. Это также полезно для предотвращения накопления неиспользуемых объектов в памяти.
    3. Использование Bottleneck для управления запросами:

      • Каждый клиент имеет свой экземпляр Bottleneck, что позволяет ограничивать количество запросов и предотвращать перегруженность сервера. Однако, если клиент не отключится, и вы продолжаете создавать новые экземпляры ограничителей, это может привести к утечкам памяти. Однако в данном коде существует очистка limiters при отключении клиента, что снижает риск утечек.
    4. Отправка сообщений через WebSocket:

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

      • Предусмотрена валидация входящих данных. Объекты, которые не соответствуют схеме, отбрасываются, что позволяет избежать хранения ненужных данных.
    6. Использование try...catch:

      • Обработка ошибок заключена в блоки try...catch, что позволяет предотвратить падение приложения из-за непредвиденных ошибок и дает возможность освободить ресурсы или очистить состояние.

    Потенциальные области для улучшения

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

    • Метрики и анализ: В коде не предусмотрены механизмы для отслеживания использования памяти приложения или анализа утечек. Инструменты вроде memwatch или встроенные средства диагностики в Node.js могут помочь отслеживать уровень использования памяти и выявлять потенциальные утечки.

    • Необходимость очистки других ресурсов: Если какой-либо callback (например, в gpt4o, gemini, и др.) хранит ссылки на внешние объекты или рекурсивные вызовы, это может привести к утечкам, если они не очищаются (например, при ошибках или отключениях).

    Заключение

    В целом, код в значительной степени справляется с задачами управления памятью и предотвращения утечек, но следует внимательно следить за долгоживущими объектами и их состоянием, особенно в высоконагруженных приложениях. Возможно, стоит рассмотреть добавление инструментов для мониторинга и диагностики, чтобы помочь в выявлении проблем с производительностью или утечками памяти. User: Метрики и анализ: В коде не предусмотрены механизмы для отслеживания использования памяти приложения или анализа утечек. Инструменты вроде memwatch или встроенные средства диагностики в Node.js могут помочь отслеживать уровень использования памяти и выявлять потенциальные утечки. как использовать встроенные средства диагностики в Node.jsmemwatch в этот код? Assistant: Использование встроенных средств диагностики в Node.js и memwatch

    Node.js предоставляет несколько встроенных средств диагностики, таких как process.memoryUsage(), которые позволяют отслеживать использование памяти. Установить memwatch-next также можно для более детального анализа утечек памяти.

    1. Использование встроенных средств диагностики

    Вы можете использовать process.memoryUsage() для получения текущего использования памяти в вашем приложении. Эта функция возвращает объект с использованием различных типов памяти.

    Вот как можно интегрировать это в ваш код:

    setInterval(() => {
      const memoryUsage = process.memoryUsage();
      console.log(`Текущие метрики использования памяти: 
        RSS: ${memoryUsage.rss / (1024 * 1024)} MB,
        Heap Total: ${memoryUsage.heapTotal / (1024 * 1024)} MB,
        Heap Used: ${memoryUsage.heapUsed / (1024 * 1024)} MB,
        External: ${memoryUsage.external / (1024 * 1024)} MB`);
    }, 60000); // Вывод каждый 60 секунд
    

    Этот код будет выводить текущие метрики использования памяти приложения каждую минуту.

    2. Использование memwatch-next

    memwatch-next — это пакет для Node.js, который позволяет отслеживать использование памяти и обнаруживать утечки. Чтобы использовать его, сначала вам нужно установить пакет:

    npm install memwatch-next
    

    После установки вы можете интегрировать memwatch-next в ваш код следующим образом:

    const memwatch = require('memwatch-next');
    
    // Родное событие для отслеживания утечек памяти
    memwatch.on('leak', (info) => {
      console.error('Обнаружена утечка памяти:', info);
    });
    
    // Событие для регулярной проверки памяти
    memwatch.on('stats', (stats) => {
      console.log('Текущая статистика использования памяти:', stats);
    });
    
    // Вызываем stats и leak на регулярной основе
    setInterval(() => {
      const memoryUsage = process.memoryUsage();
      console.log(`Текущие метрики использования памяти: 
        RSS: ${memoryUsage.rss / (1024 * 1024)} MB,
        Heap Total: ${memoryUsage.heapTotal / (1024 * 1024)} MB,
        Heap Used: ${memoryUsage.heapUsed / (1024 * 1024)} MB,
        External: ${memoryUsage.external / (1024 * 1024)} MB`);
    }, 60000); // Вывод каждую минуту
    

    Этот код будет вызывать события leak и stats, когда фиксируются утечки памяти и выводить текущую статистику.

    Заключение

    Добавление интеграции memwatch-next и использования process.memoryUsage() в ваше приложение поможет вам отслеживать использование памяти, идентифицировать утечки, и улучшить стабильность вашего Node.js приложения. Не забудьте запускать ваше приложение в режиме диагностики, чтобы вы могли увидеть, как память используется, и оптимизировать его по мере необходимости. User: разве VPS не предоставляет инструментов слежения за использованием ресурсов? Assistant:

  2. Assistant

    Да, большинство провайдеров VPS (Virtual Private Server) предлагают различные инструменты и средства мониторинга для отслеживания использования ресурсов вашего сервера. Это может включать использование CPU, памяти, дискового пространства, сетевого трафика и других метрик. Вот некоторые распространенные способы мониторинга ресурсов на VPS:

    1. Мониторинг через панель управления

    Многие провайдеры VPS предлагают собственные панели управления, такие как:

    • cPanel: предоставляет методы мониторинга использования ресурсов, таких как процессор и память.
    • Plesk: аналогично cPanel, также предоставляет информацию о нагрузке и использовании ресурсов.
    • Webmin/Virtualmin: позволяет управлять сервером и предоставляет информацию о производительности.

    2. Использование командной строки

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

    • top: показывает текущую загрузку процессора и использование памяти в режиме реального времени.
    • htop: аналогично top, но с более удобным интерфейсом и возможностями для сортировки и фильтрации.
    • free -m: выводит общее и доступное количество памяти.
    • vmstat: предоставляет статистику о системе в режиме реального времени.
    • iostat: для мониторинга ввода-вывода и использования дисков.

    3. Мониторинг с помощью специализированного ПО

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

    • Prometheus и Grafana: позволяют собирать и визуализировать данные мониторинга системы.
    • Netdata: предоставляет интуитивно понятные графики о ресурсах в режиме реального времени и может быть легко установлен.
    • Nagios: система мониторинга, которая может отслеживать состояние вашего сервера и отправлять уведомления в случае проблем.

    4. Использование REST API

    Некоторые провайдеры VPS также предоставляют REST API для доступа к данным мониторинга. Через API можно получить информацию о состоянии ресурсов и обрабатывать эти данные программно.

    5. Уведомления и алерты

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

    Заключение

    Таким образом, многие VPS-провайдеры действительно предоставляют мощные инструменты мониторинга, как на уровне программного обеспечения (например, cPanel или API), так и на уровне операционной системы (например, утилиты командной строки). Это помогает администраторам получать информацию о состоянии системы и эффективно управлять ресурсами.