J1147
/
ai-on-wechat
Beobachten 1
Favorisieren 0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
876 Commits
3 Branches
10MB
Struktur: 86a58c3d80
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „86a58c3d80“
${ noResults }
ai-on-wechat/bot/linkai/link_ai_bot.py

278 Zeilen
12KB
Originalformat Blame Verlauf 

  1. # access LinkAI knowledge base platform

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

  3. 

  4. import time

  5. 

  6. import requests

  7. 

  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. 

  17. class LinkAIBot(Bot):

  18.     # authentication failed

  19.     AUTH_FAILED_CODE = 401

  20.     NO_QUOTA_CODE = 406

  21. 

  22.     def __init__(self):

  23.         super().__init__()

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

  25.         self.args = {}

  26. 

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

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

  29.             return self._chat(query, context)

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

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

  32.             if ok:

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

  34.             else:

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

  36.             return reply

  37.         else:

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

  39.             return reply

  40. 

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

  42.         """

  43.         发起对话请求

  44.         :param query: 请求提示词

  45.         :param context: 对话上下文

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

  47.         :return: 回复

  48.         """

  49.         if retry_count > 2:

  50.             # exit from retry 2 times

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

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

  53. 

  54.         try:

  55.             # load config

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

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

  58.                 app_code = None

  59.             else:

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

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

  62. 

  63.             session_id = context["session_id"]

  64. 

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

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

  67.             # remove system message

  68.             if session.messages[0].get("role") == "system":

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

  70.                     session.messages.pop(0)

  71. 

  72.             body = {

  73.                 "app_code": app_code,

  74.                 "messages": session.messages,

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

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

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

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

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

  80.             }

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

  82.             if file_id:

  83.                 body["file_id"] = file_id

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

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

  86. 

  87.             # do http request

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

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

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

  91.             if res.status_code == 200:

  92.                 # execute success

  93.                 response = res.json()

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

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

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

  97.                 self.sessions.session_reply(reply_content, session_id, total_tokens)

  98.     

  99.                 agent_suffix = self._fetch_agent_suffix(response)

  100.                 if agent_suffix:

  101.                     reply_content += agent_suffix

  102.                 if not agent_suffix:

  103.                     knowledge_suffix = self._fetch_knowledge_search_suffix(response)

  104.                     if knowledge_suffix:

  105.                         reply_content += knowledge_suffix

  106.                 # image process

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

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

  109.                     thread.start()

  110.                 return Reply(ReplyType.TEXT, reply_content)

  111. 

  112.             else:

  113.                 response = res.json()

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

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

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

  117. 

  118.                 if res.status_code >= 500:

  119.                     # server error, need retry

  120.                     time.sleep(2)

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

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

  123. 

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

  125. 

  126.         except Exception as e:

  127.             logger.exception(e)

  128.             # retry

  129.             time.sleep(2)

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

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

  132. 

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

  134.         if retry_count >= 2:

  135.             # exit from retry 2 times

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

  137.             return {

  138.                 "total_tokens": 0,

  139.                 "completion_tokens": 0,

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

  141.             }

  142. 

  143.         try:

  144.             body = {

  145.                 "app_code": app_code,

  146.                 "messages": session.messages,

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

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

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

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

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

  152.             }

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

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

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

  156. 

  157.             # do http request

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

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

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

  161.             if res.status_code == 200:

  162.                 # execute success

  163.                 response = res.json()

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

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

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

  167.                 return {

  168.                     "total_tokens": total_tokens,

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

  170.                     "content": reply_content,

  171.                 }

  172. 

  173.             else:

  174.                 response = res.json()

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

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

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

  178. 

  179.                 if res.status_code >= 500:

  180.                     # server error, need retry

  181.                     time.sleep(2)

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

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

  184. 

  185.                 return {

  186.                     "total_tokens": 0,

  187.                     "completion_tokens": 0,

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

  189.                 }

  190. 

  191.         except Exception as e:

  192.             logger.exception(e)

  193.             # retry

  194.             time.sleep(2)

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

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

  197. 

  198. 

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

  200.         try:

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

  202.             headers = {

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

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

  205.             }

  206.             data = {

  207.                 "prompt": query,

  208.                 "n": 1,

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

  210.                 "response_format": "url",

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

  212.             }

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

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

  215.             t2 = time.time()

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

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

  218.             return True, image_url

  219. 

  220.         except Exception as e:

  221.             logger.error(format(e))

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

  223. 

  224. 

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

  226.         try:

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

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

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

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

  231.                 plugin_config = pconf("linkai")

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

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

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

  235.                     if not search_hit:

  236.                         return search_miss_text

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

  238.                         return search_miss_text

  239.         except Exception as e:

  240.             logger.exception(e)

  241. 

  242.     def _fetch_agent_suffix(self, response):

  243.         try:

  244.             plugin_list = []

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

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

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

  248.                 suffix = "\n\n- - - - - - - - - - - -"

  249.                 i = 0

  250.                 for turn in chain:

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

  252.                     suffix += "\n"

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

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

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

  256.                     if plugin_name:

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

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

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

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

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

  262.                         suffix += "\n"

  263.                     i += 1

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

  265.                 return suffix

  266.         except Exception as e:

  267.             logger.exception(e)

  268. 

  269. 

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

  271.         if not image_urls:

  272.             return

  273.         try:

  274.             for url in image_urls:

  275.                 reply = Reply(ReplyType.IMAGE_URL, url)

  276.                 channel.send(reply, context)

  277.         except Exception as e:

  278.             logger.error(e)