J1147
/
ai-on-wechat
Следить 1
В избранное 0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
1207 коммитов
3 Ветки
10MB
Дерево: 86925ddf25
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из '86925ddf25'
${ noResults }
ai-on-wechat/bot/chatgpt/chat_gpt_bot.py

324 lines
16KB
Исходник Blame История 

  1. # encoding:utf-8

  2. 

  3. import time

  4. 

  5. import openai

  6. import openai.error

  7. import requests

  8. import json

  9. 

  10. from bot.bot import Bot

  11. from bot.chatgpt.chat_gpt_session import ChatGPTSession

  12. from bot.openai.open_ai_image import OpenAIImage

  13. from bot.session_manager import SessionManager

  14. from bridge.context import ContextType

  15. from bridge.reply import Reply, ReplyType

  16. from common.log import logger

  17. from common.token_bucket import TokenBucket

  18. from config import conf, load_config

  19. from channel.chat_message import ChatMessage

  20. 

  21. from common import memory

  22. 

  23. 

  24. # OpenAI对话模型API (可用)

  25. class ChatGPTBot(Bot, OpenAIImage):

  26.     def __init__(self):

  27.         super().__init__()

  28.         # set the default api_key

  29.         openai.api_key = conf().get("open_ai_api_key")

  30.         if conf().get("open_ai_api_base"):

  31.             openai.api_base = conf().get("open_ai_api_base")

  32.         proxy = conf().get("proxy")

  33.         if proxy:

  34.             openai.proxy = proxy

  35.         if conf().get("rate_limit_chatgpt"):

  36.             self.tb4chatgpt = TokenBucket(conf().get("rate_limit_chatgpt", 20))

  37. 

  38.         self.sessions = SessionManager(ChatGPTSession, model=conf().get("model") or "gpt-3.5-turbo")

  39.         self.args = {

  40.             "model": conf().get("model") or "gpt-3.5-turbo",  # 对话模型的名称

  41.             "temperature": conf().get("temperature", 0.9),  # 值在[0,1]之间，越大表示回复越具有不确定性

  42.             # "max_tokens":4096,  # 回复最大的字符数

  43.             "top_p": conf().get("top_p", 1),

  44.             "frequency_penalty": conf().get("frequency_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容

  45.             "presence_penalty": conf().get("presence_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容

  46.             "request_timeout": conf().get("request_timeout", None),  # 请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间

  47.             "timeout": conf().get("request_timeout", None),  # 重试超时时间，在这个时间内，将会自动重试

  48.         }

  49. 

  50.     def reply(self, query, context=None):

  51.         # acquire reply content

  52.         if context.type == ContextType.TEXT:

  53.             # print(context.__dict__)

  54.             msg: ChatMessage = context.kwargs['msg']

  55.             # print(msg.from_user_nickname)

  56.             logger.info("[CHATGPT] {} query={}".format(msg.from_user_nickname,query))

  57.             

  58.             session_id = context["session_id"]

  59.             # print(f'会话id:{session_id}')

  60.             reply = None

  61.             clear_memory_commands = conf().get("clear_memory_commands", ["#清除记忆"])

  62.             if query in clear_memory_commands:

  63.                 self.sessions.clear_session(session_id)

  64.                 reply = Reply(ReplyType.INFO, "记忆已清除")

  65.             elif query == "#清除所有":

  66.                 self.sessions.clear_all_session()

  67.                 reply = Reply(ReplyType.INFO, "所有人记忆已清除")

  68.             elif query == "#更新配置":

  69.                 load_config()

  70.                 reply = Reply(ReplyType.INFO, "配置已更新")

  71.             if reply:

  72.                 return reply

  73.             session = self.sessions.session_query(query, session_id)

  74.             logger.debug("[CHATGPT] session query={}".format(session.messages))

  75. 

  76.             api_key = context.get("openai_api_key")

  77.             model = context.get("gpt_model")

  78.             new_args = None

  79.             if model:

  80.                 new_args = self.args.copy()

  81.                 new_args["model"] = model

  82.             # if context.get('stream'):

  83.             #     # reply in stream

  84.             #     return self.reply_text_stream(query, new_query, session_id)

  85. 

  86.             reply_content = self.reply_text(session, api_key, args=new_args)

  87.             logger.debug(

  88.                 "[CHATGPT] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(

  89.                     session.messages,

  90.                     session_id,

  91.                     reply_content["content"],

  92.                     reply_content["completion_tokens"],

  93.                 )

  94.             )

  95.             if reply_content["completion_tokens"] == 0 and len(reply_content["content"]) > 0:

  96.                 reply = Reply(ReplyType.ERROR, reply_content["content"])

  97.             elif reply_content["completion_tokens"] > 0:

  98.                 self.sessions.session_reply(reply_content["content"], session_id, reply_content["total_tokens"])

  99.                 reply = Reply(ReplyType.TEXT, reply_content["content"])

  100.             else:

  101.                 reply = Reply(ReplyType.ERROR, reply_content["content"])

  102.                 logger.debug("[CHATGPT] reply {} used 0 tokens.".format(reply_content))

  103.             return reply

  104. 

  105.         elif context.type == ContextType.IMAGE_CREATE:

  106.             ok, retstring = self.create_img(query, 0)

  107.             reply = None

  108.             if ok:

  109.                 reply = Reply(ReplyType.IMAGE_URL, retstring)

  110.             else:

  111.                 reply = Reply(ReplyType.ERROR, retstring)

  112.             return reply

  113.         else:

  114.             reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))

  115.             return reply

  116. 

  117.     def reply_text(self, session: ChatGPTSession, api_key=None, args=None, retry_count=0) -> dict:

  118.         """

  119.         call openai's ChatCompletion to get the answer

  120.         :param session: a conversation session

  121.         :param session_id: session id

  122.         :param retry_count: retry count

  123.         :return: {}

  124.         """

  125.         try:

  126.             if conf().get("rate_limit_chatgpt") and not self.tb4chatgpt.get_token():

  127.                 raise openai.error.RateLimitError("RateLimitError: rate limit exceeded")

  128.             # if api_key == None, the default openai.api_key will be used

  129.             if args is None:

  130.                 args = self.args

  131. 

  132.             # Define additional parameters

  133.             additional_params = {

  134.                 "chatId": session.session_id,

  135.                 "detail": True

  136.             }

  137. 

  138.             # Combine the additional params with the existing args (if any)

  139.             args.update(additional_params)

  140.             # msgs=session.messages

  141.             

  142. 

  143.             # cache_data = memory.USER_INTERACTIVE_CACHE.get(session.session_id)

  144. 

  145.             # # Determine messages to send based on cache data

  146.             # messages_to_send = msgs[-1] if cache_data and cache_data.get('interactive') else msgs

  147.             # print(msgs[-1])

  148.             # print('----------------')

  149.             # # Send the response using OpenAI API

  150.             # response = openai.ChatCompletion.create(api_key=api_key, messages=messages_to_send, **args)

  151.             messages_to_send=session.messages

  152. 

  153.             cache_data = memory.USER_INTERACTIVE_CACHE.get(session.session_id)

  154.             if cache_data and cache_data.get('interactive'):

  155.                 messages_to_send=[session.messages[-1]]

  156.             print(messages_to_send)

  157.             response = openai.ChatCompletion.create(api_key=api_key, messages=messages_to_send, **args)

  158.             # print("{}".format(session.__dict__))

  159.             logger.info("[CHATGPT] 请求={}".format(messages_to_send))

  160.             # print(f'会话id:{session.session_id}')

  161.             # logger.info("[CHATGPT] 响应={}".format(response))

  162.             logger.info("[CHATGPT] 响应={}".format(json.dumps(response, separators=(',', ':'),ensure_ascii=False)))

  163.             # logger.info("[ChatGPT] reply={}, total_tokens={}".format(response.choices[0]['message']['content'], response["usage"]["total_tokens"]))

  164.             content=response.choices[0]["message"]["content"]

  165.             description = ''

  166.             userSelectOptions = []

  167.             if isinstance(content, list) and any(item.get("type") == "interactive" for item in content):

  168.                 # print(content)

  169.                 for item in content:

  170.                     if item["type"] == "interactive" and item["interactive"]["type"] == "userSelect":

  171.                         params = item["interactive"]["params"]

  172.                         description = params.get("description")

  173.                         userSelectOptions = params.get("userSelectOptions", [])

  174.                 values_string = "\n".join(option["value"] for option in userSelectOptions)

  175.                 if description is not None:

  176.                     memory.USER_INTERACTIVE_CACHE[session.session_id] = {

  177.                        "interactive":True

  178.                     }          

  179.                     return {

  180.                         "total_tokens": response["usage"]["total_tokens"],

  181.                         "completion_tokens": response["usage"]["completion_tokens"],

  182.                         "content": description + '------------------------------\n'+values_string,

  183.                     }

  184.                 

  185.             elif isinstance(content, list) and any(item.get("type") == "text" for item in content):

  186.                 memory.USER_INTERACTIVE_CACHE[session.session_id] = {

  187.                     "interactive":False

  188.                 }

  189.                 text=''

  190.                 for item in content:

  191.                     if item["type"] == "text":

  192.                         text=item["text"]["content"]

  193.                 

  194.                 if text=='':

  195.                     args.pop('chatId', None)  # The second argument (None) is the default return value if the key doesn't exist

  196.                     args.pop('detail', None)

  197.                     response = openai.ChatCompletion.create(api_key=api_key, messages=messages_to_send, **args)

  198.                     text=response.choices[0]["message"]["content"]

  199.                 return {

  200.                     "total_tokens": response["usage"]["total_tokens"],

  201.                     "completion_tokens": response["usage"]["completion_tokens"],

  202.                     "content": text,

  203.                 }                

  204. 

  205.             else:

  206.                 memory.USER_INTERACTIVE_CACHE[session.session_id] = {

  207.                     "interactive":False

  208.                 }                

  209.                 return {

  210.                     "total_tokens": response["usage"]["total_tokens"],

  211.                     "completion_tokens": response["usage"]["completion_tokens"],

  212.                     "content": content.lstrip("\n"),

  213.                 }

  214.         except Exception as e:

  215.             need_retry = retry_count < 2

  216.             result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}

  217.             if isinstance(e, openai.error.RateLimitError):

  218.                 logger.warn("[CHATGPT] RateLimitError: {}".format(e))

  219.                 result["content"] = "提问太快啦，请休息一下再问我吧"

  220.                 if need_retry:

  221.                     time.sleep(20)

  222.             elif isinstance(e, openai.error.Timeout):

  223.                 logger.warn("[CHATGPT] Timeout: {}".format(e))

  224.                 result["content"] = "我没有收到你的消息"

  225.                 if need_retry:

  226.                     time.sleep(5)

  227.             elif isinstance(e, openai.error.APIError):

  228.                 logger.warn("[CHATGPT] Bad Gateway: {}".format(e))

  229.                 result["content"] = "请再问我一次"

  230.                 if need_retry:

  231.                     time.sleep(10)

  232.             elif isinstance(e, openai.error.APIConnectionError):

  233.                 logger.warn("[CHATGPT] APIConnectionError: {}".format(e))

  234.                 result["content"] = "我连接不到你的网络"

  235.                 if need_retry:

  236.                     time.sleep(5)

  237.             else:

  238.                 logger.exception("[CHATGPT] Exception: {}".format(e))

  239.                 need_retry = False

  240.                 self.sessions.clear_session(session.session_id)

  241. 

  242.             if need_retry:

  243.                 logger.warn("[CHATGPT] 第{}次重试".format(retry_count + 1))

  244.                 return self.reply_text(session, api_key, args, retry_count + 1)

  245.             else:

  246.                 return result

  247. 

  248. 

  249. class AzureChatGPTBot(ChatGPTBot):

  250.     def __init__(self):

  251.         super().__init__()

  252.         openai.api_type = "azure"

  253.         openai.api_version = conf().get("azure_api_version", "2023-06-01-preview")

  254.         self.args["deployment_id"] = conf().get("azure_deployment_id")

  255. 

  256.     def create_img(self, query, retry_count=0, api_key=None):

  257.         text_to_image_model = conf().get("text_to_image")

  258.         if text_to_image_model == "dall-e-2":

  259.             api_version = "2023-06-01-preview"

  260.             endpoint = conf().get("azure_openai_dalle_api_base","open_ai_api_base")

  261.             # 检查endpoint是否以/结尾

  262.             if not endpoint.endswith("/"):

  263.                 endpoint = endpoint + "/"

  264.             url = "{}openai/images/generations:submit?api-version={}".format(endpoint, api_version)

  265.             api_key = conf().get("azure_openai_dalle_api_key","open_ai_api_key")

  266.             headers = {"api-key": api_key, "Content-Type": "application/json"}

  267.             try:

  268.                 body = {"prompt": query, "size": conf().get("image_create_size", "256x256"),"n": 1}

  269.                 submission = requests.post(url, headers=headers, json=body)

  270.                 operation_location = submission.headers['operation-location']

  271.                 status = ""

  272.                 while (status != "succeeded"):

  273.                     if retry_count > 3:

  274.                         return False, "图片生成失败"

  275.                     response = requests.get(operation_location, headers=headers)

  276.                     status = response.json()['status']

  277.                     retry_count += 1

  278.                 image_url = response.json()['result']['data'][0]['url']

  279.                 return True, image_url

  280.             except Exception as e:

  281.                 logger.error("create image error: {}".format(e))

  282.                 return False, "图片生成失败"

  283.         elif text_to_image_model == "dall-e-3":

  284.             api_version = conf().get("azure_api_version", "2024-02-15-preview")

  285.             endpoint = conf().get("azure_openai_dalle_api_base","open_ai_api_base")

  286.             # 检查endpoint是否以/结尾

  287.             if not endpoint.endswith("/"):

  288.                 endpoint = endpoint + "/"

  289.             url = "{}openai/deployments/{}/images/generations?api-version={}".format(endpoint, conf().get("azure_openai_dalle_deployment_id","text_to_image"),api_version)

  290.             api_key = conf().get("azure_openai_dalle_api_key","open_ai_api_key")

  291.             headers = {"api-key": api_key, "Content-Type": "application/json"}

  292.             try:

  293.                 body = {"prompt": query, "size": conf().get("image_create_size", "1024x1024"), "quality": conf().get("dalle3_image_quality", "standard")}

  294.                 response = requests.post(url, headers=headers, json=body)

  295.                 response.raise_for_status()  # 检查请求是否成功

  296.                 data = response.json()

  297. 

  298.                 # 检查响应中是否包含图像 URL

  299.                 if 'data' in data and len(data['data']) > 0 and 'url' in data['data'][0]:

  300.                     image_url = data['data'][0]['url']

  301.                     return True, image_url

  302.                 else:

  303.                     error_message = "响应中没有图像 URL"

  304.                     logger.error(error_message)

  305.                     return False, "图片生成失败"

  306. 

  307.             except requests.exceptions.RequestException as e:

  308.                 # 捕获所有请求相关的异常

  309.                 try:

  310.                     error_detail = response.json().get('error', {}).get('message', str(e))

  311.                 except ValueError:

  312.                     error_detail = str(e)

  313.                 error_message = f"{error_detail}"

  314.                 logger.error(error_message)

  315.                 return False, error_message

  316. 

  317.             except Exception as e:

  318.                 # 捕获所有其他异常

  319.                 error_message = f"生成图像时发生错误: {e}"

  320.                 logger.error(error_message)

  321.                 return False, "图片生成失败"

  322.         else:

  323.             return False, "图片生成失败，未配置text_to_image参数"