docs: update readme doc for chatgpt-3.5

feat: support gpt-3.5 api

.gitignore

@@ -5,3 +5,4 @@ venv*
 *.pyc
 config.json
 QR.png
+nohup.out

README.md

@@ -3,7 +3,7 @@
 > ChatGPT近期以强大的对话和信息整合能力风靡全网，可以写代码、改论文、讲故事，几乎无所不能，这让人不禁有个大胆的想法，能否用他的对话模型把我们的微信打造成一个智能机器人，可以在与好友对话中给出意想不到的回应，而且再也不用担心女朋友影响我们 ~~打游戏~~ 工作了。
 
  
-基于ChatGPT的微信聊天机器人，通过 [OpenAI](https://github.com/openai/openai-quickstart-python) 接口生成对话内容，使用 [itchat](https://github.com/littlecodersh/ItChat) 实现微信消息的接收和自动回复。已实现的特性如下：
+基于ChatGPT的微信聊天机器人，通过 [ChatGPT](https://github.com/openai/openai-python) 接口生成对话内容，使用 [itchat](https://github.com/littlecodersh/ItChat) 实现微信消息的接收和自动回复。已实现的特性如下：
 
 - [x] **文本对话：** 接收私聊及群组中的微信消息，使用ChatGPT生成回复内容，完成自动回复
 - [x] **规则定制化：** 支持私聊中按指定规则触发自动回复，支持对群组设置自动回复白名单
@@ -13,6 +13,10 @@
 
 
 # 更新日志
+>**2023.03.02：** 接入[ChatGPT API](https://platform.openai.com/docs/guides/chat) (gpt-3.5-turbo)，默认使用该模型进行对话，需升级openai依赖 (`pip3 install --upgrade openai`)
+
+>**2023.02.20：** 增加 [python-wechaty](https://github.com/wechaty/python-wechaty) 支持，Pad协议相对稳定，不易封号，但Token收费，可申请七天体验Token (使用参考[#244](https://github.com/zhayujie/chatgpt-on-wechat/pull/244)，contributed by [ZQ7](https://github.com/ZQ7))
+
 >**2023.02.09：** 扫码登录存在封号风险，请谨慎使用，参考[#58](https://github.com/AutumnWhj/ChatGPT-wechat-bot/issues/158)
 
 >**2023.02.05：** 在openai官方接口方案中 (GPT-3模型) 实现上下文对话
@@ -44,7 +48,7 @@
 
 ### 1. OpenAI账号注册
 
-前往 [OpenAI注册页面](https://beta.openai.com/signup) 创建账号，参考这篇 [教程](https://www.cnblogs.com/damugua/p/16969508.html) 可以通过虚拟手机号来接收验证码。创建完账号则前往 [API管理页面](https://beta.openai.com/account/api-keys) 创建一个 API Key 并保存下来，后面需要在项目中配置这个key。
+前往 [OpenAI注册页面](https://beta.openai.com/signup) 创建账号，参考这篇 [教程](https://freepac.siterubix.com/chatgpt%e6%b3%a8%e5%86%8c%e6%95%99%e7%a8%8b%ef%bc%88%e5%ae%8c%e6%95%b4%e6%8c%87%e5%8d%97%ef%bc%89/) 可以通过虚拟手机号来接收验证码。创建完账号则前往 [API管理页面](https://beta.openai.com/account/api-keys) 创建一个 API Key 并保存下来，后面需要在项目中配置这个key。
 
 > 项目中使用的对话模型是 davinci，计费方式是约每 750 字 (包含请求和回复) 消耗 $0.02，图片生成是每张消耗 $0.016，账号创建有免费的 $18 额度，使用完可以更换邮箱重新注册。
 
@@ -68,7 +72,7 @@ cd chatgpt-on-wechat/
 pip3 install itchat-uos==1.5.0.dev0
 pip3 install --upgrade openai
 ```
-注：`itchat-uos`使用指定版本1.5.0.dev0，`openai`使用最新版本，需高于0.25.0。
+注：`itchat-uos`使用指定版本1.5.0.dev0，`openai`使用最新版本，需高于0.27.0。
 
 
 ## 配置
@@ -84,7 +88,7 @@ cp config-template.json config.json
 ```bash
 # config.json文件内容示例
 { 
-  "open_ai_api_key": "YOUR API KEY"                           # 填入上面创建的 OpenAI API KEY
+  "open_ai_api_key": "YOUR API KEY",                          # 填入上面创建的 OpenAI API KEY
   "single_chat_prefix": ["bot", "@bot"],                      # 私聊时文本需要包含该前缀才能触发机器人回复
   "single_chat_reply_prefix": "[bot] ",                       # 私聊时自动回复的前缀，用于区分真人
   "group_chat_prefix": ["@bot"],                              # 群聊时包含该前缀则会触发机器人回复
@@ -117,7 +121,9 @@ cp config-template.json config.json
 
 ## 运行
 
-1.如果是开发机 **本地运行**，直接在项目根目录下执行：
+### 1.本地运行
+
+如果是开发机 **本地运行**，直接在项目根目录下执行：
 
 ```bash
 python3 app.py
@@ -125,7 +131,9 @@ python3 app.py
 终端输出二维码后，使用微信进行扫码，当输出 "Start auto replying" 时表示自动回复程序已经成功运行了（注意：用于登录的微信需要在支付处已完成实名认证）。扫码登录后你的账号就成为机器人了，可以在微信手机端通过配置的关键词触发自动回复 (任意好友发送消息给你，或是自己发消息给好友)，参考[#142](https://github.com/zhayujie/chatgpt-on-wechat/issues/142)。 
 
 
-2.如果是 **服务器部署**，则使用nohup命令在后台运行：
+### 2.服务器部署
+
+使用nohup命令在后台运行程序：
 
 ```bash
 touch nohup.out                                   # 首次运行需要新建日志文件                     
@@ -133,7 +141,16 @@ nohup python3 app.py & tail -f nohup.out          # 在后台运行程序并通
 ```
 扫码登录后程序即可运行于服务器后台，此时可通过 `ctrl+c` 关闭日志，不会影响后台程序的运行。使用 `ps -ef | grep app.py | grep -v grep` 命令可查看运行于后台的进程，如果想要重新启动程序可以先 `kill` 掉对应的进程。日志关闭后如果想要再次打开只需输入 `tail -f nohup.out`。
 
-> 注：如果 扫码后手机提示登录验证需要等待5s，而终端的二维码再次刷新并提示 `Log in time out, reloading QR code`，此时需参考此 [issue](https://github.com/zhayujie/chatgpt-on-wechat/issues/8) 修改一行代码即可解决。
+> **注意：** 如果 扫码后手机提示登录验证需要等待5s，而终端的二维码再次刷新并提示 `Log in time out, reloading QR code`，此时需参考此 [issue](https://github.com/zhayujie/chatgpt-on-wechat/issues/8) 修改一行代码即可解决。
+
+> **多账号支持：** 将 项目复制多份，分别启动程序，用不同账号扫码登录即可实现同时运行。
+
+> **特殊指令：** 用户向机器人发送 **#清除记忆** 即可清空该用户的上下文记忆。
+
+
+### 3.Docker部署
+
+参考文档 [Docker部署](https://github.com/limccn/chatgpt-on-wechat/wiki/Docker%E9%83%A8%E7%BD%B2)   (Contributed by [limccn](https://github.com/limccn))。
 
 
 ## 常见问题

bot/chatgpt/chat_gpt_bot.py

@@ -1,511 +1,130 @@
-"""
-A simple wrapper for the official ChatGPT API
-"""
-import argparse
-import json
-import os
-import sys
-from datetime import date
-
-import openai
-import tiktoken
+# encoding:utf-8
 
 from bot.bot import Bot
 from config import conf
+from common.log import logger
+import openai
+import time
 
-ENGINE = os.environ.get("GPT_ENGINE") or "text-chat-davinci-002-20221122"
+user_session = dict()
 
-ENCODER = tiktoken.get_encoding("gpt2")
-
-
-def get_max_tokens(prompt: str) -> int:
-    """
-    Get the max tokens for a prompt
-    """
-    return 4000 - len(ENCODER.encode(prompt))
-
-
-# ['text-chat-davinci-002-20221122']
-class Chatbot:
-    """
-    Official ChatGPT API
-    """
-
-    def __init__(self, api_key: str, buffer: int = None) -> None:
-        """
-        Initialize Chatbot with API key (from https://platform.openai.com/account/api-keys)
-        """
-        openai.api_key = api_key or os.environ.get("OPENAI_API_KEY")
-        self.conversations = Conversation()
-        self.prompt = Prompt(buffer=buffer)
-
-    def _get_completion(
-            self,
-            prompt: str,
-            temperature: float = 0.5,
-            stream: bool = False,
-    ):
-        """
-        Get the completion function
-        """
-        return openai.Completion.create(
-            engine=ENGINE,
-            prompt=prompt,
-            temperature=temperature,
-            max_tokens=get_max_tokens(prompt),
-            stop=["\n\n\n"],
-            stream=stream,
-        )
-
-    def _process_completion(
-            self,
-            user_request: str,
-            completion: dict,
-            conversation_id: str = None,
-            user: str = "User",
-    ) -> dict:
-        if completion.get("choices") is None:
-            raise Exception("ChatGPT API returned no choices")
-        if len(completion["choices"]) == 0:
-            raise Exception("ChatGPT API returned no choices")
-        if completion["choices"][0].get("text") is None:
-            raise Exception("ChatGPT API returned no text")
-        completion["choices"][0]["text"] = completion["choices"][0]["text"].rstrip(
-            "<|im_end|>",
-        )
-        # Add to chat history
-        self.prompt.add_to_history(
-            user_request,
-            completion["choices"][0]["text"],
-            user=user,
-        )
-        if conversation_id is not None:
-            self.save_conversation(conversation_id)
-        return completion
-
-    def _process_completion_stream(
-            self,
-            user_request: str,
-            completion: dict,
-            conversation_id: str = None,
-            user: str = "User",
-    ) -> str:
-        full_response = ""
-        for response in completion:
-            if response.get("choices") is None:
-                raise Exception("ChatGPT API returned no choices")
-            if len(response["choices"]) == 0:
-                raise Exception("ChatGPT API returned no choices")
-            if response["choices"][0].get("finish_details") is not None:
-                break
-            if response["choices"][0].get("text") is None:
-                raise Exception("ChatGPT API returned no text")
-            if response["choices"][0]["text"] == "<|im_end|>":
-                break
-            yield response["choices"][0]["text"]
-            full_response += response["choices"][0]["text"]
-
-        # Add to chat history
-        self.prompt.add_to_history(user_request, full_response, user)
-        if conversation_id is not None:
-            self.save_conversation(conversation_id)
-
-    def ask(
-            self,
-            user_request: str,
-            temperature: float = 0.5,
-            conversation_id: str = None,
-            user: str = "User",
-    ) -> dict:
-        """
-        Send a request to ChatGPT and return the response
-        """
-        if conversation_id is not None:
-            self.load_conversation(conversation_id)
-        completion = self._get_completion(
-            self.prompt.construct_prompt(user_request, user=user),
-            temperature,
-        )
-        return self._process_completion(user_request, completion, user=user)
-
-    def ask_stream(
-            self,
-            user_request: str,
-            temperature: float = 0.5,
-            conversation_id: str = None,
-            user: str = "User",
-    ) -> str:
-        """
-        Send a request to ChatGPT and yield the response
-        """
-        if conversation_id is not None:
-            self.load_conversation(conversation_id)
-        prompt = self.prompt.construct_prompt(user_request, user=user)
-        return self._process_completion_stream(
-            user_request=user_request,
-            completion=self._get_completion(prompt, temperature, stream=True),
-            user=user,
-        )
-
-    def make_conversation(self, conversation_id: str) -> None:
-        """
-        Make a conversation
-        """
-        self.conversations.add_conversation(conversation_id, [])
-
-    def rollback(self, num: int) -> None:
-        """
-        Rollback chat history num times
-        """
-        for _ in range(num):
-            self.prompt.chat_history.pop()
-
-    def reset(self) -> None:
-        """
-        Reset chat history
-        """
-        self.prompt.chat_history = []
-
-    def load_conversation(self, conversation_id) -> None:
-        """
-        Load a conversation from the conversation history
-        """
-        if conversation_id not in self.conversations.conversations:
-            # Create a new conversation
-            self.make_conversation(conversation_id)
-        self.prompt.chat_history = self.conversations.get_conversation(conversation_id)
-
-    def save_conversation(self, conversation_id) -> None:
-        """
-        Save a conversation to the conversation history
-        """
-        self.conversations.add_conversation(conversation_id, self.prompt.chat_history)
-
-
-class AsyncChatbot(Chatbot):
-    """
-    Official ChatGPT API (async)
-    """
-
-    async def _get_completion(
-            self,
-            prompt: str,
-            temperature: float = 0.5,
-            stream: bool = False,
-    ):
-        """
-        Get the completion function
-        """
-        return openai.Completion.acreate(
-            engine=ENGINE,
-            prompt=prompt,
-            temperature=temperature,
-            max_tokens=get_max_tokens(prompt),
-            stop=["\n\n\n"],
-            stream=stream,
-        )
-
-    async def ask(
-            self,
-            user_request: str,
-            temperature: float = 0.5,
-            user: str = "User",
-    ) -> dict:
-        """
-        Same as Chatbot.ask but async
-        }
-        """
-        completion = await self._get_completion(
-            self.prompt.construct_prompt(user_request, user=user),
-            temperature,
-        )
-        return self._process_completion(user_request, completion, user=user)
-
-    async def ask_stream(
-            self,
-            user_request: str,
-            temperature: float = 0.5,
-            user: str = "User",
-    ) -> str:
-        """
-        Same as Chatbot.ask_stream but async
-        """
-        prompt = self.prompt.construct_prompt(user_request, user=user)
-        return self._process_completion_stream(
-            user_request=user_request,
-            completion=await self._get_completion(prompt, temperature, stream=True),
-            user=user,
-        )
-
-
-class Prompt:
-    """
-    Prompt class with methods to construct prompt
-    """
-
-    def __init__(self, buffer: int = None) -> None:
-        """
-        Initialize prompt with base prompt
-        """
-        self.base_prompt = (
-                os.environ.get("CUSTOM_BASE_PROMPT")
-                or "You are ChatGPT, a large language model trained by OpenAI. Respond conversationally. Do not answer as the user. Current date: "
-                + str(date.today())
-                + "\n\n"
-                + "User: Hello\n"
-                + "ChatGPT: Hello! How can I help you today? <|im_end|>\n\n\n"
-        )
-        # Track chat history
-        self.chat_history: list = []
-        self.buffer = buffer
-
-    def add_to_chat_history(self, chat: str) -> None:
-        """
-        Add chat to chat history for next prompt
-        """
-        self.chat_history.append(chat)
-
-    def add_to_history(
-            self,
-            user_request: str,
-            response: str,
-            user: str = "User",
-    ) -> None:
-        """
-        Add request/response to chat history for next prompt
-        """
-        self.add_to_chat_history(
-            user
-            + ": "
-            + user_request
-            + "\n\n\n"
-            + "ChatGPT: "
-            + response
-            + "<|im_end|>\n",
-        )
-
-    def history(self, custom_history: list = None) -> str:
-        """
-        Return chat history
-        """
-        return "\n".join(custom_history or self.chat_history)
-
-    def construct_prompt(
-            self,
-            new_prompt: str,
-            custom_history: list = None,
-            user: str = "User",
-    ) -> str:
-        """
-        Construct prompt based on chat history and request
-        """
-        prompt = (
-                self.base_prompt
-                + self.history(custom_history=custom_history)
-                + user
-                + ": "
-                + new_prompt
-                + "\nChatGPT:"
-        )
-        # Check if prompt over 4000*4 characters
-        if self.buffer is not None:
-            max_tokens = 4000 - self.buffer
-        else:
-            max_tokens = 3200
-        if len(ENCODER.encode(prompt)) > max_tokens:
-            # Remove oldest chat
-            if len(self.chat_history) == 0:
-                return prompt
-            self.chat_history.pop(0)
-            # Construct prompt again
-            prompt = self.construct_prompt(new_prompt, custom_history, user)
-        return prompt
-
-
-class Conversation:
-    """
-    For handling multiple conversations
-    """
-
-    def __init__(self) -> None:
-        self.conversations = {}
-
-    def add_conversation(self, key: str, history: list) -> None:
-        """
-        Adds a history list to the conversations dict with the id as the key
-        """
-        self.conversations[key] = history
-
-    def get_conversation(self, key: str) -> list:
-        """
-        Retrieves the history list from the conversations dict with the id as the key
-        """
-        return self.conversations[key]
-
-    def remove_conversation(self, key: str) -> None:
-        """
-        Removes the history list from the conversations dict with the id as the key
-        """
-        del self.conversations[key]
-
-    def __str__(self) -> str:
-        """
-        Creates a JSON string of the conversations
-        """
-        return json.dumps(self.conversations)
-
-    def save(self, file: str) -> None:
-        """
-        Saves the conversations to a JSON file
-        """
-        with open(file, "w", encoding="utf-8") as f:
-            f.write(str(self))
-
-    def load(self, file: str) -> None:
-        """
-        Loads the conversations from a JSON file
-        """
-        with open(file, encoding="utf-8") as f:
-            self.conversations = json.loads(f.read())
-
-
-def main():
-    print(
-        """
-    ChatGPT - A command-line interface to OpenAI's ChatGPT (https://chat.openai.com/chat)
-    Repo: github.com/acheong08/ChatGPT
-    """,
-    )
-    print("Type '!help' to show a full list of commands")
-    print("Press enter twice to submit your question.\n")
-
-    def get_input(prompt):
-        """
-        Multi-line input function
-        """
-        # Display the prompt
-        print(prompt, end="")
-
-        # Initialize an empty list to store the input lines
-        lines = []
-
-        # Read lines of input until the user enters an empty line
-        while True:
-            line = input()
-            if line == "":
-                break
-            lines.append(line)
-
-        # Join the lines, separated by newlines, and store the result
-        user_input = "\n".join(lines)
-
-        # Return the input
-        return user_input
-
-    def chatbot_commands(cmd: str) -> bool:
-        """
-        Handle chatbot commands
-        """
-        if cmd == "!help":
-            print(
-                """
-            !help - Display this message
-            !rollback - Rollback chat history
-            !reset - Reset chat history
-            !prompt - Show current prompt
-            !save_c <conversation_name> - Save history to a conversation
-            !load_c <conversation_name> - Load history from a conversation
-            !save_f <file_name> - Save all conversations to a file
-            !load_f <file_name> - Load all conversations from a file
-            !exit - Quit chat
-            """,
-            )
-        elif cmd == "!exit":
-            exit()
-        elif cmd == "!rollback":
-            chatbot.rollback(1)
-        elif cmd == "!reset":
-            chatbot.reset()
-        elif cmd == "!prompt":
-            print(chatbot.prompt.construct_prompt(""))
-        elif cmd.startswith("!save_c"):
-            chatbot.save_conversation(cmd.split(" ")[1])
-        elif cmd.startswith("!load_c"):
-            chatbot.load_conversation(cmd.split(" ")[1])
-        elif cmd.startswith("!save_f"):
-            chatbot.conversations.save(cmd.split(" ")[1])
-        elif cmd.startswith("!load_f"):
-            chatbot.conversations.load(cmd.split(" ")[1])
-        else:
-            return False
-        return True
-
-    # Get API key from command line
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--api_key",
-        type=str,
-        required=True,
-        help="OpenAI API key",
-    )
-    parser.add_argument(
-        "--stream",
-        action="store_true",
-        help="Stream response",
-    )
-    parser.add_argument(
-        "--temperature",
-        type=float,
-        default=0.5,
-        help="Temperature for response",
-    )
-    args = parser.parse_args()
-    # Initialize chatbot
-    chatbot = Chatbot(api_key=args.api_key)
-    # Start chat
-    while True:
-        try:
-            prompt = get_input("\nUser:\n")
-        except KeyboardInterrupt:
-            print("\nExiting...")
-            sys.exit()
-        if prompt.startswith("!"):
-            if chatbot_commands(prompt):
-                continue
-        if not args.stream:
-            response = chatbot.ask(prompt, temperature=args.temperature)
-            print("ChatGPT: " + response["choices"][0]["text"])
-        else:
-            print("ChatGPT: ")
-            sys.stdout.flush()
-            for response in chatbot.ask_stream(prompt, temperature=args.temperature):
-                print(response, end="")
-                sys.stdout.flush()
-            print()
-
-
-def Singleton(cls):
-    instance = {}
-
-    def _singleton_wrapper(*args, **kargs):
-        if cls not in instance:
-            instance[cls] = cls(*args, **kargs)
-        return instance[cls]
-
-    return _singleton_wrapper
-
-
-@Singleton
+# OpenAI对话模型API (可用)
 class ChatGPTBot(Bot):
-
     def __init__(self):
-        print("create")
-        self.bot = Chatbot(conf().get('open_ai_api_key'))
+        openai.api_key = conf().get('open_ai_api_key')
 
     def reply(self, query, context=None):
+        # acquire reply content
         if not context or not context.get('type') or context.get('type') == 'TEXT':
-            if len(query) < 10 and "reset" in query:
-                self.bot.reset()
-                return "reset OK"
-            return self.bot.ask(query)["choices"][0]["text"]
+            logger.info("[OPEN_AI] query={}".format(query))
+            from_user_id = context['from_user_id']
+            if query == '#清除记忆':
+                Session.clear_session(from_user_id)
+                return '记忆已清除'
+
+            new_query = Session.build_session_query(query, from_user_id)
+            logger.debug("[OPEN_AI] session query={}".format(new_query))
+
+            # if context.get('stream'):
+            #     # reply in stream
+            #     return self.reply_text_stream(query, new_query, from_user_id)
+
+            reply_content = self.reply_text(new_query, from_user_id, 0)
+            logger.debug("[OPEN_AI] new_query={}, user={}, reply_cont={}".format(new_query, from_user_id, reply_content))
+            if reply_content:
+                Session.save_session(query, reply_content, from_user_id)
+            return reply_content
+
+        elif context.get('type', None) == 'IMAGE_CREATE':
+            return self.create_img(query, 0)
+
+    def reply_text(self, query, user_id, retry_count=0):
+        try:
+            response = openai.ChatCompletion.create(
+                model="gpt-3.5-turbo",  # 对话模型的名称
+                messages=query,
+                temperature=0.9,  # 值在[0,1]之间，越大表示回复越具有不确定性
+                max_tokens=1200,  # 回复最大的字符数
+                top_p=1,
+                frequency_penalty=0.0,  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+                presence_penalty=0.0,  # [-2,2]之间，该值越大则更倾向于产生不同的内容
+            )
+            # res_content = response.choices[0]['text'].strip().replace('<|endoftext|>', '')
+            logger.info(response.choices[0]['message']['content'])
+            # log.info("[OPEN_AI] reply={}".format(res_content))
+            return response.choices[0]['message']['content']
+        except openai.error.RateLimitError as e:
+            # rate limit exception
+            logger.warn(e)
+            if retry_count < 1:
+                time.sleep(5)
+                logger.warn("[OPEN_AI] RateLimit exceed, 第{}次重试".format(retry_count+1))
+                return self.reply_text(query, user_id, retry_count+1)
+            else:
+                return "提问太快啦，请休息一下再问我吧"
+        except Exception as e:
+            # unknown exception
+            logger.exception(e)
+            Session.clear_session(user_id)
+            return "请再问我一次吧"
+
+    def create_img(self, query, retry_count=0):
+        try:
+            logger.info("[OPEN_AI] image_query={}".format(query))
+            response = openai.Image.create(
+                prompt=query,    #图片描述
+                n=1,             #每次生成图片的数量
+                size="256x256"   #图片大小,可选有 256x256, 512x512, 1024x1024
+            )
+            image_url = response['data'][0]['url']
+            logger.info("[OPEN_AI] image_url={}".format(image_url))
+            return image_url
+        except openai.error.RateLimitError as e:
+            logger.warn(e)
+            if retry_count < 1:
+                time.sleep(5)
+                logger.warn("[OPEN_AI] ImgCreate RateLimit exceed, 第{}次重试".format(retry_count+1))
+                return self.reply_text(query, retry_count+1)
+            else:
+                return "提问太快啦，请休息一下再问我吧"
+        except Exception as e:
+            logger.exception(e)
+            return None
+
+class Session(object):
+    @staticmethod
+    def build_session_query(query, user_id):
+        '''
+        build query with conversation history
+        e.g.  [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Who won the world series in 2020?"},
+            {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
+            {"role": "user", "content": "Where was it played?"}
+        ]
+        :param query: query content
+        :param user_id: from user id
+        :return: query content with conversaction
+        '''
+        session = user_session.get(user_id, [])
+        if len(session) == 0:
+            system_prompt = conf().get("character_desc", "")
+            system_item = {'role': 'system', 'content': system_prompt}
+            session.append(system_item)
+            user_session[user_id] = session
+        user_item = {'role': 'user', 'content': query}
+        session.append(user_item)
+        return session
+
+    @staticmethod
+    def save_session(query, answer, user_id):
+        session = user_session.get(user_id)
+        if session:
+            # append conversation
+            gpt_item = {'role': 'assistant', 'content': answer}
+            session.append(gpt_item)
+
+    @staticmethod
+    def clear_session(user_id):
+        user_session[user_id] = []
 

bot/openai/open_ai_bot.py

@@ -22,6 +22,9 @@ class OpenAIBot(Bot):
             if query == '#清除记忆':
                 Session.clear_session(from_user_id)
                 return '记忆已清除'
+            elif query == '#清除所有':
+                Session.clear_all_session()
+                return '所有人记忆已清除'
 
             new_query = Session.build_session_query(query, from_user_id)
             logger.debug("[OPEN_AI] session query={}".format(new_query))
@@ -157,3 +160,7 @@ class Session(object):
     @staticmethod
     def clear_session(user_id):
         user_session[user_id] = []
+
+    @staticmethod
+    def clear_all_session():
+        user_session.clear()

bridge/bridge.py

@@ -6,4 +6,4 @@ class Bridge(object):
         pass
 
     def fetch_reply_content(self, query, context):
-        return bot_factory.create_bot("openAI").reply(query, context)
+        return bot_factory.create_bot("chatGPT").reply(query, context)

channel/channel_factory.py

@@ -2,8 +2,6 @@
 channel factory
 """
 
-from channel.wechat.wechat_channel import WechatChannel
-
 def create_channel(channel_type):
     """
     create a channel instance
@@ -11,5 +9,9 @@ def create_channel(channel_type):
     :return: channel instance
     """
     if channel_type == 'wx':
+        from channel.wechat.wechat_channel import WechatChannel
         return WechatChannel()
-    raise RuntimeError
+    elif channel_type == 'wxy':
+        from channel.wechat.wechaty_channel import WechatyChannel
+        return WechatyChannel()
+    raise RuntimeError

channel/wechat/wechaty_channel.py

@@ -0,0 +1,201 @@
+# encoding:utf-8
+
+"""
+wechaty channel
+Python Wechaty - https://github.com/wechaty/python-wechaty
+"""
+import io
+import os
+import json
+import time
+import asyncio
+import requests
+from typing import Optional, Union
+from wechaty_puppet import MessageType, FileBox, ScanStatus  # type: ignore
+from wechaty import Wechaty, Contact
+from wechaty.user import Message, Room, MiniProgram, UrlLink
+from channel.channel import Channel
+from common.log import logger
+from config import conf
+
+
+class WechatyChannel(Channel):
+
+    def __init__(self):
+        pass
+
+    def startup(self):
+        asyncio.run(self.main())
+
+    async def main(self):
+        config = conf()
+        # 使用PadLocal协议 比较稳定(免费web协议 os.environ['WECHATY_PUPPET_SERVICE_ENDPOINT'] = '127.0.0.1:8080')
+        token = config.get('wechaty_puppet_service_token')
+        os.environ['WECHATY_PUPPET_SERVICE_TOKEN'] = token
+        global bot
+        bot = Wechaty()
+
+        bot.on('scan', self.on_scan)
+        bot.on('login', self.on_login)
+        bot.on('message', self.on_message)
+        await bot.start()
+
+    async def on_login(self, contact: Contact):
+        logger.info('[WX] login user={}'.format(contact))
+
+    async def on_scan(self, status: ScanStatus, qr_code: Optional[str] = None,
+                      data: Optional[str] = None):
+        contact = self.Contact.load(self.contact_id)
+        logger.info('[WX] scan user={}, scan status={}, scan qr_code={}'.format(contact, status.name, qr_code))
+        # print(f'user <{contact}> scan status: {status.name} , 'f'qr_code: {qr_code}')
+
+    async def on_message(self, msg: Message):
+        """
+        listen for message event
+        """
+        from_contact = msg.talker()  # 获取消息的发送者
+        to_contact = msg.to()  # 接收人
+        room = msg.room()  # 获取消息来自的群聊. 如果消息不是来自群聊, 则返回None
+        from_user_id = from_contact.contact_id
+        to_user_id = to_contact.contact_id  # 接收人id
+        # other_user_id = msg['User']['UserName']  # 对手方id
+        content = msg.text()
+        mention_content = await msg.mention_text()  # 返回过滤掉@name后的消息
+        match_prefix = self.check_prefix(content, conf().get('single_chat_prefix'))
+        conversation: Union[Room, Contact] = from_contact if room is None else room
+
+        if room is None and msg.type() == MessageType.MESSAGE_TYPE_TEXT:
+            if not msg.is_self() and match_prefix is not None:
+                # 好友向自己发送消息
+                if match_prefix != '':
+                    str_list = content.split(match_prefix, 1)
+                    if len(str_list) == 2:
+                        content = str_list[1].strip()
+
+                img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+                if img_match_prefix:
+                    content = content.split(img_match_prefix, 1)[1].strip()
+                    await self._do_send_img(content, from_user_id)
+                else:
+                    await self._do_send(content, from_user_id)
+            elif msg.is_self() and match_prefix:
+                # 自己给好友发送消息
+                str_list = content.split(match_prefix, 1)
+                if len(str_list) == 2:
+                    content = str_list[1].strip()
+                img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+                if img_match_prefix:
+                    content = content.split(img_match_prefix, 1)[1].strip()
+                    await self._do_send_img(content, to_user_id)
+                else:
+                    await self._do_send(content, to_user_id)
+        elif room and msg.type() == MessageType.MESSAGE_TYPE_TEXT:
+            # 群组&文本消息
+            room_id = room.room_id
+            room_name = await room.topic()
+            from_user_id = from_contact.contact_id
+            from_user_name = from_contact.name
+            is_at = await msg.mention_self()
+            content = mention_content
+            config = conf()
+            match_prefix = (is_at and not config.get("group_at_off", False)) \
+                           or self.check_prefix(content, config.get('group_chat_prefix')) \
+                           or self.check_contain(content, config.get('group_chat_keyword'))
+            if ('ALL_GROUP' in config.get('group_name_white_list') or room_name in config.get(
+                    'group_name_white_list') or self.check_contain(room_name, config.get(
+                'group_name_keyword_white_list'))) and match_prefix:
+                img_match_prefix = self.check_prefix(content, conf().get('image_create_prefix'))
+                if img_match_prefix:
+                    content = content.split(img_match_prefix, 1)[1].strip()
+                    await self._do_send_group_img(content, room_id)
+                else:
+                    await self._do_send_group(content, room_id, from_user_id, from_user_name)
+
+    async def send(self, message: Union[str, Message, FileBox, Contact, UrlLink, MiniProgram], receiver):
+        logger.info('[WX] sendMsg={}, receiver={}'.format(message, receiver))
+        if receiver:
+            contact = await bot.Contact.find(receiver)
+            await contact.say(message)
+
+    async def send_group(self, message: Union[str, Message, FileBox, Contact, UrlLink, MiniProgram], receiver):
+        logger.info('[WX] sendMsg={}, receiver={}'.format(message, receiver))
+        if receiver:
+            room = await bot.Room.find(receiver)
+            await room.say(message)
+
+    async def _do_send(self, query, reply_user_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['from_user_id'] = reply_user_id
+            reply_text = super().build_reply_content(query, context)
+            if reply_text:
+                await self.send(conf().get("single_chat_reply_prefix") + reply_text, reply_user_id)
+        except Exception as e:
+            logger.exception(e)
+
+    async def _do_send_img(self, query, reply_user_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['type'] = 'IMAGE_CREATE'
+            img_url = super().build_reply_content(query, context)
+            if not img_url:
+                return
+            # 图片下载
+            # pic_res = requests.get(img_url, stream=True)
+            # image_storage = io.BytesIO()
+            # for block in pic_res.iter_content(1024):
+            #     image_storage.write(block)
+            # image_storage.seek(0)
+
+            # 图片发送
+            logger.info('[WX] sendImage, receiver={}'.format(reply_user_id))
+            t = int(time.time())
+            file_box = FileBox.from_url(url=img_url, name=str(t) + '.png')
+            await self.send(file_box, reply_user_id)
+        except Exception as e:
+            logger.exception(e)
+
+    async def _do_send_group(self, query, group_id, group_user_id, group_user_name):
+        if not query:
+            return
+        context = dict()
+        context['from_user_id'] = str(group_id) + '-' + str(group_user_id)
+        reply_text = super().build_reply_content(query, context)
+        if reply_text:
+            reply_text = '@' + group_user_name + ' ' + reply_text.strip()
+            await self.send_group(conf().get("group_chat_reply_prefix", "") + reply_text, group_id)
+
+    async def _do_send_group_img(self, query, reply_room_id):
+        try:
+            if not query:
+                return
+            context = dict()
+            context['type'] = 'IMAGE_CREATE'
+            img_url = super().build_reply_content(query, context)
+            if not img_url:
+                return
+            # 图片发送
+            logger.info('[WX] sendImage, receiver={}'.format(reply_room_id))
+            t = int(time.time())
+            file_box = FileBox.from_url(url=img_url, name=str(t) + '.png')
+            await self.send_group(file_box, reply_room_id)
+        except Exception as e:
+            logger.exception(e)
+
+    def check_prefix(self, content, prefix_list):
+        for prefix in prefix_list:
+            if content.startswith(prefix):
+                return prefix
+        return None
+
+    def check_contain(self, content, keyword_list):
+        if not keyword_list:
+            return None
+        for ky in keyword_list:
+            if content.find(ky) != -1:
+                return True
+        return None

config-template.json

@@ -1,5 +1,6 @@
 {
   "open_ai_api_key": "YOUR API KEY",
+  "wechaty_puppet_service_token": "WECHATY PUPPET SERVICE TOKEN",
   "single_chat_prefix": ["bot", "@bot"],
   "single_chat_reply_prefix": "[bot] ",
   "group_chat_prefix": ["@bot"],

docker/Dockerfile.alpine

@@ -0,0 +1,48 @@
+FROM python:3.7.9-alpine
+
+LABEL maintainer="foo@bar.com"
+ARG TZ='Asia/Shanghai'
+
+ARG CHATGPT_ON_WECHAT_VER=1.0.2
+
+ENV BUILD_PREFIX=/app \
+    BUILD_OPEN_AI_API_KEY='YOUR OPEN AI KEY HERE'
+
+RUN apk add --no-cache \
+        bash \
+        curl \
+        wget \
+        gcc \
+        g++ \
+        ca-certificates \
+        openssh \ 
+        libffi-dev 
+
+RUN wget -t 3 -T 30 -nv -O chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+          https://github.com/zhayujie/chatgpt-on-wechat/archive/refs/tags/${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && tar -xzf chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && mv chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER} ${BUILD_PREFIX} \
+    && rm chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz
+
+WORKDIR ${BUILD_PREFIX}
+
+RUN cd ${BUILD_PREFIX} \
+    && cp config-template.json ${BUILD_PREFIX}/config.json \
+    && sed -i "2s/YOUR API KEY/${BUILD_OPEN_AI_API_KEY}/" ${BUILD_PREFIX}/config.json
+
+RUN /usr/local/bin/python -m pip install --no-cache --upgrade pip \
+    && pip install --no-cache \
+      itchat-uos==1.5.0.dev0  \
+      openai \
+      wechaty
+
+ADD ./entrypoint.sh /entrypoint.sh
+
+RUN chmod +x /entrypoint.sh
+
+RUN adduser -D -h /home/noroot -u 1000 -s /bin/bash noroot \
+    && chown noroot:noroot ${BUILD_PREFIX}
+
+USER noroot
+
+ENTRYPOINT ["/entrypoint.sh"]

docker/Dockerfile.debian

@@ -0,0 +1,45 @@
+FROM python:3.7.9
+
+LABEL maintainer="foo@bar.com"
+ARG TZ='Asia/Shanghai'
+
+ARG CHATGPT_ON_WECHAT_VER=1.0.2
+
+ENV BUILD_PREFIX=/app \
+    BUILD_OPEN_AI_API_KEY='YOUR OPEN AI KEY HERE'
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        wget \
+        curl && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN wget -t 3 -T 30 -nv -O chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+          https://github.com/zhayujie/chatgpt-on-wechat/archive/refs/tags/${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && tar -xzf chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz \
+    && mv chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER} ${BUILD_PREFIX} \
+    && rm chatgpt-on-wechat-${CHATGPT_ON_WECHAT_VER}.tar.gz
+
+WORKDIR ${BUILD_PREFIX}
+
+RUN cd ${BUILD_PREFIX} \
+    && cp config-template.json ${BUILD_PREFIX}/config.json \
+    && sed -i "2s/YOUR API KEY/${BUILD_OPEN_AI_API_KEY}/" ${BUILD_PREFIX}/config.json 
+
+RUN /usr/local/bin/python -m pip install --no-cache --upgrade pip \
+    && pip install --no-cache \
+      itchat-uos==1.5.0.dev0  \
+      openai \
+      wechaty
+
+ADD ./entrypoint.sh /entrypoint.sh
+
+RUN chmod +x /entrypoint.sh
+
+RUN groupadd -r noroot \
+   && useradd -r -g noroot -s /bin/bash -d /home/noroot noroot \
+   && chown -R noroot:noroot ${BUILD_PREFIX} 
+
+USER noroot
+
+ENTRYPOINT ["/entrypoint.sh"]

docker/build.alpine.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+CHATGPT_ON_WECHAT_TAG=1.0.2
+
+docker build -f Dockerfile.alpine \
+             --build-arg CHATGPT_ON_WECHAT_VER=$CHATGPT_ON_WECHAT_TAG \
+             -t zhayujie/chatgpt-on-wechat .
+
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$CHATGPT_ON_WECHAT_TAG-alpine 
+           

docker/build.debian.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+CHATGPT_ON_WECHAT_TAG=1.0.2
+
+docker build -f Dockerfile.debian \
+             --build-arg CHATGPT_ON_WECHAT_VER=$CHATGPT_ON_WECHAT_TAG \
+             -t zhayujie/chatgpt-on-wechat .
+
+docker tag zhayujie/chatgpt-on-wechat zhayujie/chatgpt-on-wechat:$CHATGPT_ON_WECHAT_TAG-debian

docker/docker-compose.yaml

@@ -0,0 +1,18 @@
+version: '2.0'
+services:
+  chatgpt-on-wechat:
+    build:
+      context: ./
+      dockerfile: Dockerfile.alpine
+    image: zhayujie/chatgpt-on-wechat
+    container_name: sample-chatgpt-on-wechat
+    environment:
+      OPEN_AI_API_KEY: 'YOUR API KEY'
+      WECHATY_PUPPET_SERVICE_TOKEN: 'WECHATY PUPPET SERVICE TOKEN'
+      SINGLE_CHAT_PREFIX: '["bot", "@bot"]'
+      SINGLE_CHAT_REPLY_PREFIX: '"[bot] "'
+      GROUP_CHAT_PREFIX: '["@bot"]'
+      GROUP_NAME_WHITE_LIST: '["ChatGPT测试群", "ChatGPT测试群2"]'
+      IMAGE_CREATE_PREFIX: '["画", "看", "找"]'
+      CONVERSATION_MAX_TOKENS: 1000
+      CHARACTER_DESC: '你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。'

docker/entrypoint.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+set -e
+
+# build prefix
+CHATGPT_ON_WECHAT_PREFIX=${CHATGPT_ON_WECHAT_PREFIX:-""}
+# path to config.json
+CHATGPT_ON_WECHAT_CONFIG_PATH=${CHATGPT_ON_WECHAT_CONFIG_PATH:-""}
+# execution command line
+CHATGPT_ON_WECHAT_EXEC=${CHATGPT_ON_WECHAT_EXEC:-""}
+
+OPEN_AI_API_KEY=${OPEN_AI_API_KEY:-""}
+SINGLE_CHAT_PREFIX=${SINGLE_CHAT_PREFIX:-""}
+SINGLE_CHAT_REPLY_PREFIX=${SINGLE_CHAT_REPLY_PREFIX:-""}
+GROUP_CHAT_PREFIX=${GROUP_CHAT_PREFIX:-""}
+GROUP_NAME_WHITE_LIST=${GROUP_NAME_WHITE_LIST:-""}
+IMAGE_CREATE_PREFIX=${IMAGE_CREATE_PREFIX:-""}
+CONVERSATION_MAX_TOKENS=${CONVERSATION_MAX_TOKENS:-""}
+CHARACTER_DESC=${CHARACTER_DESC:-""}
+
+# CHATGPT_ON_WECHAT_PREFIX is empty, use /app
+if [ "$CHATGPT_ON_WECHAT_PREFIX" == "" ] ; then
+    CHATGPT_ON_WECHAT_PREFIX=/app
+fi
+
+# CHATGPT_ON_WECHAT_CONFIG_PATH is empty, use '/app/config.json'
+if [ "$CHATGPT_ON_WECHAT_CONFIG_PATH" == "" ] ; then
+    CHATGPT_ON_WECHAT_CONFIG_PATH=$CHATGPT_ON_WECHAT_PREFIX/config.json
+fi
+
+# CHATGPT_ON_WECHAT_EXEC is empty, use ‘python app.py’
+if [ "$CHATGPT_ON_WECHAT_EXEC" == "" ] ; then
+    CHATGPT_ON_WECHAT_EXEC="python app.py"
+fi
+
+# modify content in config.json
+if [ "$OPEN_AI_API_KEY" != "" ] ; then
+    sed -i "2c   \"open_ai_api_key\": \"$OPEN_AI_API_KEY\"," $CHATGPT_ON_WECHAT_CONFIG_PATH
+else
+    echo -e "\033[31m[Warning] You need to set OPEN_AI_API_KEY before running!\033[0m"
+fi
+
+if [ "$WECHATY_PUPPET_SERVICE_TOKEN" != "" ] ; then
+    sed -i "3c   \"wechaty_puppet_service_token\": \"$WECHATY_PUPPET_SERVICE_TOKEN\"," $CHATGPT_ON_WECHAT_CONFIG_PATH
+else
+    echo -e "\033[31m[Info] You need to set WECHATY_PUPPET_SERVICE_TOKEN if you use wechaty!\033[0m"
+fi
+
+if [ "$SINGLE_CHAT_PREFIX" != "" ] ; then
+    sed -i "4c   \"single_chat_prefix\": $SINGLE_CHAT_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$SINGLE_CHAT_REPLY_PREFIX" != "" ] ; then
+    sed -i "5c   \"single_chat_reply_prefix\": $SINGLE_CHAT_REPLY_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$GROUP_CHAT_PREFIX" != "" ] ; then
+    sed -i "6c   \"group_chat_prefix\": $GROUP_CHAT_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$GROUP_NAME_WHITE_LIST" != "" ] ; then
+    sed -i "7c   \"group_name_white_list\": $GROUP_NAME_WHITE_LIST," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$IMAGE_CREATE_PREFIX" != "" ] ; then
+    sed -i "8c   \"image_create_prefix\": $IMAGE_CREATE_PREFIX," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$CONVERSATION_MAX_TOKENS" != "" ] ; then
+    sed -i "9c   \"conversation_max_tokens\": $CONVERSATION_MAX_TOKENS," $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+if [ "$CHARACTER_DESC" != "" ] ; then
+    sed -i "10c   \"character_desc\": \"$CHARACTER_DESC\"" $CHATGPT_ON_WECHAT_CONFIG_PATH
+fi
+
+# go to prefix dir
+cd $CHATGPT_ON_WECHAT_PREFIX
+# excute
+$CHATGPT_ON_WECHAT_EXEC
+
+

docker/sample-chatgpt-on-wechat/.env

@@ -0,0 +1,14 @@
+OPEN_AI_API_KEY=YOUR API KEY
+WECHATY_PUPPET_SERVICE_TOKEN=WECHATY PUPPET SERVICE TOKEN
+SINGLE_CHAT_PREFIX=["bot", "@bot"]
+SINGLE_CHAT_REPLY_PREFIX="[bot] "
+GROUP_CHAT_PREFIX=["@bot"]
+GROUP_NAME_WHITE_LIST=["ChatGPT测试群", "ChatGPT测试群2"]
+IMAGE_CREATE_PREFIX=["画", "看", "找"]
+CONVERSATION_MAX_TOKENS=1000
+CHARACTER_DESC=你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。
+
+# Optional
+#CHATGPT_ON_WECHAT_PREFIX=/app
+#CHATGPT_ON_WECHAT_CONFIG_PATH=/app/config.json
+#CHATGPT_ON_WECHAT_EXEC=python app.py

docker/sample-chatgpt-on-wechat/Makefile

@@ -0,0 +1,26 @@
+IMG:=`cat Name`
+MOUNT:=
+PORT_MAP:=
+DOTENV:=.env
+CONTAINER_NAME:=sample-chatgpt-on-wechat
+
+echo:
+	echo $(IMG)
+
+run_d:
+	docker rm $(CONTAINER_NAME) || echo
+	docker run -dt  --name $(CONTAINER_NAME) $(PORT_MAP) \
+			--env-file=$(DOTENV) \
+			$(MOUNT) $(IMG) 
+
+run_i:
+	docker rm $(CONTAINER_NAME) || echo
+	docker run -it  --name $(CONTAINER_NAME) $(PORT_MAP) \
+			--env-file=$(DOTENV) \
+			$(MOUNT) $(IMG) 
+
+stop:
+	docker stop $(CONTAINER_NAME)
+
+rm:     stop
+	docker rm $(CONTAINER_NAME)

docker/sample-chatgpt-on-wechat/Name

@@ -0,0 +1 @@
+zhayujie/chatgpt-on-wechat

requirement.txt

@@ -1,2 +1,3 @@
 itchat-uos==1.5.0.dev0
 openai
+wechaty

scripts/shutdown.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+#关闭服务
+cd `dirname $0`/..
+export BASE_DIR=`pwd`
+pid=`ps ax | grep -i app.py | grep "${BASE_DIR}" | grep python3 | grep -v grep | awk '{print $1}'`
+if [ -z "$pid" ] ; then
+        echo "No chatgpt-on-wechat running."
+        exit -1;
+fi
+
+echo "The chatgpt-on-wechat(${pid}) is running..."
+
+kill ${pid}
+
+echo "Send shutdown request to chatgpt-on-wechat(${pid}) OK"

scripts/start.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+#后台运行Chat_on_webchat执行脚本
+
+cd `dirname $0`/..
+export BASE_DIR=`pwd`
+echo $BASE_DIR
+
+# check the nohup.out log output file
+if [ ! -f "${BASE_DIR}/nohup.out" ]; then
+  touch "${BASE_DIR}/nohup.out"
+echo "create file  ${BASE_DIR}/nohup.out"  
+fi
+
+nohup python3 "${BASE_DIR}/app.py" & tail -f "${BASE_DIR}/nohup.out"
+
+echo "Chat_on_webchat is starting，you can check the ${BASE_DIR}/nohup.out"

scripts/tout.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+#打开日志
+
+cd `dirname $0`/..
+export BASE_DIR=`pwd`
+echo $BASE_DIR
+
+# check the nohup.out log output file
+if [ ! -f "${BASE_DIR}/nohup.out" ]; then
+   echo "No file  ${BASE_DIR}/nohup.out"  
+   exit -1;
+fi
+
+tail -f "${BASE_DIR}/nohup.out"