J1147
/
ai-on-wechat
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
994 Revīzijas
2 Atzari
152MB
Koks: 8093fcc64c
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '8093fcc64c'
${ noResults }
ai-on-wechat/bot/linkai/link_ai_bot.py

468 rindas
21KB
Neapstrādāts Vainot Vēsture 

  1. # access LinkAI knowledge base platform

  2. # docs: https://link-ai.tech/platform/link-app/wechat

  3. 

  4. import re

  5. import time

  6. import requests

  7. import config

  8. from bot.bot import Bot

  9. from bot.chatgpt.chat_gpt_session import ChatGPTSession

  10. from bot.session_manager import SessionManager

  11. from bridge.context import Context, ContextType

  12. from bridge.reply import Reply, ReplyType

  13. from common.log import logger

  14. from config import conf, pconf

  15. import threading

  16. from common import memory, utils

  17. import base64

  18. import os

  19. 

  20. class LinkAIBot(Bot):

  21.     # authentication failed

  22.     AUTH_FAILED_CODE = 401

  23.     NO_QUOTA_CODE = 406

  24. 

  25.     def __init__(self):

  26.         super().__init__()

  27.         self.sessions = LinkAISessionManager(LinkAISession, model=conf().get("model") or "gpt-3.5-turbo")

  28.         self.args = {}

  29. 

  30.     def reply(self, query, context: Context = None) -> Reply:

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

  32.             return self._chat(query, context)

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

  34.             if not conf().get("text_to_image"):

  35.                 logger.warn("[LinkAI] text_to_image is not enabled, ignore the IMAGE_CREATE request")

  36.                 return Reply(ReplyType.TEXT, "")

  37.             ok, res = self.create_img(query, 0)

  38.             if ok:

  39.                 reply = Reply(ReplyType.IMAGE_URL, res)

  40.             else:

  41.                 reply = Reply(ReplyType.ERROR, res)

  42.             return reply

  43.         else:

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

  45.             return reply

  46. 

  47.     def _chat(self, query, context, retry_count=0) -> Reply:

  48.         """

  49.         发起对话请求

  50.         :param query: 请求提示词

  51.         :param context: 对话上下文

  52.         :param retry_count: 当前递归重试次数

  53.         :return: 回复

  54.         """

  55.         if retry_count > 2:

  56.             # exit from retry 2 times

  57.             logger.warn("[LINKAI] failed after maximum number of retry times")

  58.             return Reply(ReplyType.TEXT, "请再问我一次吧")

  59. 

  60.         try:

  61.             # load config

  62.             if context.get("generate_breaked_by"):

  63.                 logger.info(f"[LINKAI] won't set appcode because a plugin ({context['generate_breaked_by']}) affected the context")

  64.                 app_code = None

  65.             else:

  66.                 plugin_app_code = self._find_group_mapping_code(context)

  67.                 app_code = context.kwargs.get("app_code") or plugin_app_code or conf().get("linkai_app_code")

  68.             linkai_api_key = conf().get("linkai_api_key")

  69. 

  70.             session_id = context["session_id"]

  71.             session_message = self.sessions.session_msg_query(query, session_id)

  72.             logger.debug(f"[LinkAI] session={session_message}, session_id={session_id}")

  73. 

  74.             # image process

  75.             img_cache = memory.USER_IMAGE_CACHE.get(session_id)

  76.             if img_cache:

  77.                 messages = self._process_image_msg(app_code=app_code, session_id=session_id, query=query, img_cache=img_cache)

  78.                 if messages:

  79.                     session_message = messages

  80. 

  81.             model = conf().get("model")

  82.             # remove system message

  83.             if session_message[0].get("role") == "system":

  84.                 if app_code or model == "wenxin":

  85.                     session_message.pop(0)

  86.             body = {

  87.                 "app_code": app_code,

  88.                 "messages": session_message,

  89.                 "model": model,     # 对话模型的名称, 支持 gpt-3.5-turbo, gpt-3.5-turbo-16k, gpt-4, wenxin, xunfei

  90.                 "temperature": conf().get("temperature"),

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

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

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

  94.                 "session_id": session_id,

  95.                 "channel_type": conf().get("channel_type", "wx")

  96.             }

  97.             try:

  98.                 from linkai import LinkAIClient

  99.                 client_id = LinkAIClient.fetch_client_id()

  100.                 if client_id:

  101.                     body["client_id"] = client_id

  102.                     # start: client info deliver

  103.                     if context.kwargs.get("msg"):

  104.                         body["session_id"] = context.kwargs.get("msg").from_user_id

  105.                         if context.kwargs.get("msg").is_group:

  106.                             body["is_group"] = True

  107.                             body["group_name"] = context.kwargs.get("msg").from_user_nickname

  108.                             body["sender_name"] = context.kwargs.get("msg").actual_user_nickname

  109.                         else:

  110.                             if body.get("channel_type") in ["wechatcom_app"]:

  111.                                 body["sender_name"] = context.kwargs.get("msg").from_user_id

  112.                             else:

  113.                                 body["sender_name"] = context.kwargs.get("msg").from_user_nickname

  114. 

  115.             except Exception as e:

  116.                 pass

  117.             file_id = context.kwargs.get("file_id")

  118.             if file_id:

  119.                 body["file_id"] = file_id

  120.             logger.info(f"[LINKAI] query={query}, app_code={app_code}, model={body.get('model')}, file_id={file_id}")

  121.             headers = {"Authorization": "Bearer " + linkai_api_key}

  122. 

  123.             # do http request

  124.             base_url = conf().get("linkai_api_base", "https://api.link-ai.chat")

  125.             res = requests.post(url=base_url + "/v1/chat/completions", json=body, headers=headers,

  126.                                 timeout=conf().get("request_timeout", 180))

  127.             if res.status_code == 200:

  128.                 # execute success

  129.                 response = res.json()

  130.                 reply_content = response["choices"][0]["message"]["content"]

  131.                 total_tokens = response["usage"]["total_tokens"]

  132.                 logger.info(f"[LINKAI] reply={reply_content}, total_tokens={total_tokens}")

  133.                 self.sessions.session_reply(reply_content, session_id, total_tokens, query=query)

  134.     

  135.                 agent_suffix = self._fetch_agent_suffix(response)

  136.                 if agent_suffix:

  137.                     reply_content += agent_suffix

  138.                 if not agent_suffix:

  139.                     knowledge_suffix = self._fetch_knowledge_search_suffix(response)

  140.                     if knowledge_suffix:

  141.                         reply_content += knowledge_suffix

  142.                 # image process

  143.                 if response["choices"][0].get("img_urls"):

  144.                     thread = threading.Thread(target=self._send_image, args=(context.get("channel"), context, response["choices"][0].get("img_urls")))

  145.                     thread.start()

  146.                     if response["choices"][0].get("text_content"):

  147.                         reply_content = response["choices"][0].get("text_content")

  148.                 reply_content = self._process_url(reply_content)

  149.                 return Reply(ReplyType.TEXT, reply_content)

  150. 

  151.             else:

  152.                 response = res.json()

  153.                 error = response.get("error")

  154.                 logger.error(f"[LINKAI] chat failed, status_code={res.status_code}, "

  155.                              f"msg={error.get('message')}, type={error.get('type')}")

  156. 

  157.                 if res.status_code >= 500:

  158.                     # server error, need retry

  159.                     time.sleep(2)

  160.                     logger.warn(f"[LINKAI] do retry, times={retry_count}")

  161.                     return self._chat(query, context, retry_count + 1)

  162. 

  163.                 return Reply(ReplyType.TEXT, "提问太快啦，请休息一下再问我吧")

  164. 

  165.         except Exception as e:

  166.             logger.exception(e)

  167.             # retry

  168.             time.sleep(2)

  169.             logger.warn(f"[LINKAI] do retry, times={retry_count}")

  170.             return self._chat(query, context, retry_count + 1)

  171. 

  172.     def _process_image_msg(self, app_code: str, session_id: str, query:str, img_cache: dict):

  173.         try:

  174.             enable_image_input = False

  175.             app_info = self._fetch_app_info(app_code)

  176.             if not app_info:

  177.                 logger.debug(f"[LinkAI] not found app, can't process images, app_code={app_code}")

  178.                 return None

  179.             plugins = app_info.get("data").get("plugins")

  180.             for plugin in plugins:

  181.                 if plugin.get("input_type") and "IMAGE" in plugin.get("input_type"):

  182.                     enable_image_input = True

  183.             if not enable_image_input:

  184.                 return

  185.             msg = img_cache.get("msg")

  186.             path = img_cache.get("path")

  187.             msg.prepare()

  188.             logger.info(f"[LinkAI] query with images, path={path}")

  189.             messages = self._build_vision_msg(query, path)

  190.             memory.USER_IMAGE_CACHE[session_id] = None

  191.             return messages

  192.         except Exception as e:

  193.             logger.exception(e)

  194. 

  195.     def _find_group_mapping_code(self, context):

  196.         try:

  197.             if context.kwargs.get("isgroup"):

  198.                 group_name = context.kwargs.get("msg").from_user_nickname

  199.                 if config.plugin_config and config.plugin_config.get("linkai"):

  200.                     linkai_config = config.plugin_config.get("linkai")

  201.                     group_mapping = linkai_config.get("group_app_map")

  202.                     if group_mapping and group_name:

  203.                         return group_mapping.get(group_name)

  204.         except Exception as e:

  205.             logger.exception(e)

  206.             return None

  207. 

  208.     def _build_vision_msg(self, query: str, path: str):

  209.         try:

  210.             suffix = utils.get_path_suffix(path)

  211.             with open(path, "rb") as file:

  212.                 base64_str = base64.b64encode(file.read()).decode('utf-8')

  213.                 messages = [{

  214.                     "role": "user",

  215.                     "content": [

  216.                         {

  217.                             "type": "text",

  218.                             "text": query

  219.                         },

  220.                         {

  221.                             "type": "image_url",

  222.                             "image_url": {

  223.                                 "url": f"data:image/{suffix};base64,{base64_str}"

  224.                             }

  225.                         }

  226.                     ]

  227.                 }]

  228.                 return messages

  229.         except Exception as e:

  230.             logger.exception(e)

  231. 

  232.     def reply_text(self, session: ChatGPTSession, app_code="", retry_count=0) -> dict:

  233.         if retry_count >= 2:

  234.             # exit from retry 2 times

  235.             logger.warn("[LINKAI] failed after maximum number of retry times")

  236.             return {

  237.                 "total_tokens": 0,

  238.                 "completion_tokens": 0,

  239.                 "content": "请再问我一次吧"

  240.             }

  241. 

  242.         try:

  243.             body = {

  244.                 "app_code": app_code,

  245.                 "messages": session.messages,

  246.                 "model": conf().get("model") or "gpt-3.5-turbo",  # 对话模型的名称, 支持 gpt-3.5-turbo, gpt-3.5-turbo-16k, gpt-4, wenxin, xunfei

  247.                 "temperature": conf().get("temperature"),

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

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

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

  251.             }

  252.             if self.args.get("max_tokens"):

  253.                 body["max_tokens"] = self.args.get("max_tokens")

  254.             headers = {"Authorization": "Bearer " + conf().get("linkai_api_key")}

  255. 

  256.             # do http request

  257.             base_url = conf().get("linkai_api_base", "https://api.link-ai.chat")

  258.             res = requests.post(url=base_url + "/v1/chat/completions", json=body, headers=headers,

  259.                                 timeout=conf().get("request_timeout", 180))

  260.             if res.status_code == 200:

  261.                 # execute success

  262.                 response = res.json()

  263.                 reply_content = response["choices"][0]["message"]["content"]

  264.                 total_tokens = response["usage"]["total_tokens"]

  265.                 logger.info(f"[LINKAI] reply={reply_content}, total_tokens={total_tokens}")

  266.                 return {

  267.                     "total_tokens": total_tokens,

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

  269.                     "content": reply_content,

  270.                 }

  271. 

  272.             else:

  273.                 response = res.json()

  274.                 error = response.get("error")

  275.                 logger.error(f"[LINKAI] chat failed, status_code={res.status_code}, "

  276.                              f"msg={error.get('message')}, type={error.get('type')}")

  277. 

  278.                 if res.status_code >= 500:

  279.                     # server error, need retry

  280.                     time.sleep(2)

  281.                     logger.warn(f"[LINKAI] do retry, times={retry_count}")

  282.                     return self.reply_text(session, app_code, retry_count + 1)

  283. 

  284.                 return {

  285.                     "total_tokens": 0,

  286.                     "completion_tokens": 0,

  287.                     "content": "提问太快啦，请休息一下再问我吧"

  288.                 }

  289. 

  290.         except Exception as e:

  291.             logger.exception(e)

  292.             # retry

  293.             time.sleep(2)

  294.             logger.warn(f"[LINKAI] do retry, times={retry_count}")

  295.             return self.reply_text(session, app_code, retry_count + 1)

  296. 

  297.     def _fetch_app_info(self, app_code: str):

  298.         headers = {"Authorization": "Bearer " + conf().get("linkai_api_key")}

  299.         # do http request

  300.         base_url = conf().get("linkai_api_base", "https://api.link-ai.chat")

  301.         params = {"app_code": app_code}

  302.         res = requests.get(url=base_url + "/v1/app/info", params=params, headers=headers, timeout=(5, 10))

  303.         if res.status_code == 200:

  304.             return res.json()

  305.         else:

  306.             logger.warning(f"[LinkAI] find app info exception, res={res}")

  307. 

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

  309.         try:

  310.             logger.info("[LinkImage] image_query={}".format(query))

  311.             headers = {

  312.                 "Content-Type": "application/json",

  313.                 "Authorization": f"Bearer {conf().get('linkai_api_key')}"

  314.             }

  315.             data = {

  316.                 "prompt": query,

  317.                 "n": 1,

  318.                 "model": conf().get("text_to_image") or "dall-e-2",

  319.                 "response_format": "url",

  320.                 "img_proxy": conf().get("image_proxy")

  321.             }

  322.             url = conf().get("linkai_api_base", "https://api.link-ai.chat") + "/v1/images/generations"

  323.             res = requests.post(url, headers=headers, json=data, timeout=(5, 90))

  324.             t2 = time.time()

  325.             image_url = res.json()["data"][0]["url"]

  326.             logger.info("[OPEN_AI] image_url={}".format(image_url))

  327.             return True, image_url

  328. 

  329.         except Exception as e:

  330.             logger.error(format(e))

  331.             return False, "画图出现问题，请休息一下再问我吧"

  332. 

  333. 

  334.     def _fetch_knowledge_search_suffix(self, response) -> str:

  335.         try:

  336.             if response.get("knowledge_base"):

  337.                 search_hit = response.get("knowledge_base").get("search_hit")

  338.                 first_similarity = response.get("knowledge_base").get("first_similarity")

  339.                 logger.info(f"[LINKAI] knowledge base, search_hit={search_hit}, first_similarity={first_similarity}")

  340.                 plugin_config = pconf("linkai")

  341.                 if plugin_config and plugin_config.get("knowledge_base") and plugin_config.get("knowledge_base").get("search_miss_text_enabled"):

  342.                     search_miss_similarity = plugin_config.get("knowledge_base").get("search_miss_similarity")

  343.                     search_miss_text = plugin_config.get("knowledge_base").get("search_miss_suffix")

  344.                     if not search_hit:

  345.                         return search_miss_text

  346.                     if search_miss_similarity and float(search_miss_similarity) > first_similarity:

  347.                         return search_miss_text

  348.         except Exception as e:

  349.             logger.exception(e)

  350. 

  351. 

  352.     def _fetch_agent_suffix(self, response):

  353.         try:

  354.             plugin_list = []

  355.             logger.debug(f"[LinkAgent] res={response}")

  356.             if response.get("agent") and response.get("agent").get("chain") and response.get("agent").get("need_show_plugin"):

  357.                 chain = response.get("agent").get("chain")

  358.                 suffix = "\n\n- - - - - - - - - - - -"

  359.                 i = 0

  360.                 for turn in chain:

  361.                     plugin_name = turn.get('plugin_name')

  362.                     suffix += "\n"

  363.                     need_show_thought = response.get("agent").get("need_show_thought")

  364.                     if turn.get("thought") and plugin_name and need_show_thought:

  365.                         suffix += f"{turn.get('thought')}\n"

  366.                     if plugin_name:

  367.                         plugin_list.append(turn.get('plugin_name'))

  368.                         if turn.get('plugin_icon'):

  369.                             suffix += f"{turn.get('plugin_icon')} "

  370.                         suffix += f"{turn.get('plugin_name')}"

  371.                         if turn.get('plugin_input'):

  372.                             suffix += f"：{turn.get('plugin_input')}"

  373.                     if i < len(chain) - 1:

  374.                         suffix += "\n"

  375.                     i += 1

  376.                 logger.info(f"[LinkAgent] use plugins: {plugin_list}")

  377.                 return suffix

  378.         except Exception as e:

  379.             logger.exception(e)

  380. 

  381.     def _process_url(self, text):

  382.         try:

  383.             url_pattern = re.compile(r'\[(.*?)\]\((http[s]?://.*?)\)')

  384.             def replace_markdown_url(match):

  385.                 return f"{match.group(2)}"

  386.             return url_pattern.sub(replace_markdown_url, text)

  387.         except Exception as e:

  388.             logger.error(e)

  389. 

  390.     def _send_image(self, channel, context, image_urls):

  391.         if not image_urls:

  392.             return

  393.         max_send_num = conf().get("max_media_send_count")

  394.         send_interval = conf().get("media_send_interval")

  395.         try:

  396.             i = 0

  397.             for url in image_urls:

  398.                 if max_send_num and i >= max_send_num:

  399.                     continue

  400.                 i += 1

  401.                 if url.endswith(".mp4"):

  402.                     reply_type = ReplyType.VIDEO_URL

  403.                 elif url.endswith(".pdf") or url.endswith(".doc") or url.endswith(".docx") or url.endswith(".csv"):

  404.                     reply_type = ReplyType.FILE

  405.                     url = _download_file(url)

  406.                     if not url:

  407.                         continue

  408.                 else:

  409.                     reply_type = ReplyType.IMAGE_URL

  410.                 reply = Reply(reply_type, url)

  411.                 channel.send(reply, context)

  412.                 if send_interval:

  413.                     time.sleep(send_interval)

  414.         except Exception as e:

  415.             logger.error(e)

  416. 

  417. 

  418. def _download_file(url: str):

  419.     try:

  420.         file_path = "tmp"

  421.         if not os.path.exists(file_path):

  422.             os.makedirs(file_path)

  423.         file_name = url.split("/")[-1]  # 获取文件名

  424.         file_path = os.path.join(file_path, file_name)

  425.         response = requests.get(url)

  426.         with open(file_path, "wb") as f:

  427.             f.write(response.content)

  428.         return file_path

  429.     except Exception as e:

  430.         logger.warn(e)

  431. 

  432. 

  433. class LinkAISessionManager(SessionManager):

  434.     def session_msg_query(self, query, session_id):

  435.         session = self.build_session(session_id)

  436.         messages = session.messages + [{"role": "user", "content": query}]

  437.         return messages

  438. 

  439.     def session_reply(self, reply, session_id, total_tokens=None, query=None):

  440.         session = self.build_session(session_id)

  441.         if query:

  442.             session.add_query(query)

  443.         session.add_reply(reply)

  444.         try:

  445.             max_tokens = conf().get("conversation_max_tokens", 2500)

  446.             tokens_cnt = session.discard_exceeding(max_tokens, total_tokens)

  447.             logger.debug(f"[LinkAI] chat history, before tokens={total_tokens}, now tokens={tokens_cnt}")

  448.         except Exception as e:

  449.             logger.warning("Exception when counting tokens precisely for session: {}".format(str(e)))

  450.         return session

  451. 

  452. 

  453. class LinkAISession(ChatGPTSession):

  454.     def calc_tokens(self):

  455.         if not self.messages:

  456.             return 0

  457.         return len(str(self.messages))

  458. 

  459.     def discard_exceeding(self, max_tokens, cur_tokens=None):

  460.         cur_tokens = self.calc_tokens()

  461.         if cur_tokens > max_tokens:

  462.             for i in range(0, len(self.messages)):

  463.                 if i > 0 and self.messages[i].get("role") == "assistant" and self.messages[i - 1].get("role") == "user":

  464.                     self.messages.pop(i)

  465.                     self.messages.pop(i - 1)

  466.                     return self.calc_tokens()

  467.         return cur_tokens