bisheng-langchain 0.2.3.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

bisheng_langchain/gpts/assistant.py

@@ -0,0 +1,137 @@
+import asyncio
+import logging
+from enum import Enum
+from functools import lru_cache
+from typing import Any, Mapping, Optional, Sequence
+from urllib.parse import urlparse
+
+import httpx
+import yaml
+from bisheng_langchain.gpts.load_tools import get_all_tool_names, load_tools
+from bisheng_langchain.gpts.utils import import_by_type, import_class
+from langchain.tools import BaseTool
+from langchain_core.language_models.base import LanguageModelLike
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.runnables import RunnableBinding
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigurableAssistant(RunnableBinding):
+    agent_executor_type: str
+    tools: Sequence[BaseTool]
+    llm: LanguageModelLike
+    assistant_message: str
+    interrupt_before_action: bool = False
+    recursion_limit: int = 50
+
+    def __init__(
+        self,
+        *,
+        agent_executor_type: str,
+        tools: Sequence[BaseTool],
+        llm: LanguageModelLike,
+        assistant_message: str,
+        interrupt_before_action: bool = False,
+        recursion_limit: int = 50,
+        kwargs: Optional[Mapping[str, Any]] = None,
+        config: Optional[Mapping[str, Any]] = None,
+        **others: Any,
+    ) -> None:
+        others.pop("bound", None)
+        agent_executor_object = import_class(f'bisheng_langchain.gpts.agent_types.{agent_executor_type}')
+
+        _agent_executor = agent_executor_object(tools, llm, assistant_message, interrupt_before_action)
+        agent_executor = _agent_executor.with_config({"recursion_limit": recursion_limit})
+        super().__init__(
+            agent_executor_type=agent_executor_type,
+            tools=tools,
+            llm=llm,
+            assistant_message=assistant_message,
+            bound=agent_executor,
+            kwargs=kwargs or {},
+            config=config or {},
+        )
+
+
+class BishengAssistant:
+
+    def __init__(self, yaml_path) -> None:
+        self.yaml_path = yaml_path
+        with open(self.yaml_path, 'r') as f:
+            self.params = yaml.safe_load(f)
+
+        self.assistant_params = self.params['assistant']
+
+        # init assistant prompt
+        prompt_type = self.assistant_params['prompt_type']
+        assistant_message = import_class(f'bisheng_langchain.gpts.prompts.{prompt_type}')
+
+        # init llm or agent
+        llm_params = self.assistant_params['llm']
+        llm_object = import_by_type(_type='llms', name=llm_params['type'])
+        if llm_params['type'] == 'ChatOpenAI' and llm_params['openai_proxy']:
+            llm_params.pop('type')
+            llm = llm_object(
+                http_client=httpx.Client(proxies=llm_params['openai_proxy']),
+                http_async_client=httpx.AsyncClient(proxies=llm_params['openai_proxy']),
+                **llm_params,
+            )
+        else:
+            llm_params.pop('type')
+            llm = llm_object(**llm_params)
+
+        # init tools
+        available_tools = get_all_tool_names()
+        tools = []
+        for tool in self.assistant_params['tools']:
+            tool_type = tool.pop('type')
+            tool_config = tool if tool else {}
+            if tool_type not in available_tools:
+                raise ValueError(f"Tool type {tool_type} not found in TOOLS")
+            _returned_tools = load_tools({tool_type: tool_config})
+            if isinstance(_returned_tools, list):
+                tools.extend(_returned_tools)
+            else:
+                tools.append(_returned_tools)
+
+        # init agent executor
+        agent_executor_params = self.assistant_params['agent_executor']
+        agent_executor_type = agent_executor_params.pop('type')
+        self.assistant = ConfigurableAssistant(
+            agent_executor_type=agent_executor_type, 
+            tools=tools, 
+            llm=llm, 
+            assistant_message=assistant_message, 
+            **agent_executor_params
+        )
+
+    def run(self, query, chat_history=[], chat_round=5):
+        if len(chat_history) % 2 != 0:
+            raise ValueError("chat history should be even")
+        
+        # 限制chat_history轮数
+        if len(chat_history) > chat_round * 2:
+            chat_history = chat_history[-chat_round*2:]
+
+        inputs = []
+        for i in range(0, len(chat_history), 2):
+            inputs.append(HumanMessage(content=chat_history[i]))
+            inputs.append(AIMessage(content=chat_history[i+1]))
+        inputs.append(HumanMessage(content=query))
+        result = asyncio.run(self.assistant.ainvoke(inputs))
+        return result
+
+
+if __name__ == "__main__":
+    from langchain.globals import set_debug
+
+    set_debug(True)
+    # chat_history = []
+    chat_history = ['你好', '你好，有什么可以帮助你吗？', '福蓉科技股价多少?', '福蓉科技（股票代码：300049）的当前股价为48.67元。']
+    query = "去年这个时候的股价是多少？"
+    bisheng_assistant = BishengAssistant("config/base_scene.yaml")
+    result = bisheng_assistant.run(query, chat_history=chat_history)
+    for r in result:
+        print(f'------------------')
+        print(type(r), r)

bisheng_langchain/gpts/auto_optimization.py

@@ -0,0 +1,130 @@
+import json
+import os
+import re
+
+import httpx
+from bisheng_langchain.gpts.prompts import ASSISTANT_PROMPT_OPT, BREIF_DES_PROMPT, OPENDIALOG_PROMPT
+from langchain_core.language_models.base import LanguageModelLike
+from langchain_openai.chat_models import ChatOpenAI
+from loguru import logger
+
+
+def parse_markdown(input_str: str) -> str:
+    match = re.search(r'```(markdown)?(.*)```', input_str, re.DOTALL)
+    if match is None:
+        out_str = input_str
+    else:
+        out_str = match.group(2)
+
+    out_str = out_str.strip()
+    out_str = out_str.replace('```', '')
+    return out_str
+
+
+def parse_json(input_str: str) -> str:
+    match = re.search(r'```(json)?(.*)```', input_str, re.DOTALL)
+    if match is None:
+        out_str = input_str
+    else:
+        out_str = match.group(2)
+
+    out_str = out_str.strip()
+    out_str = out_str.replace('```', '')
+    return out_str
+
+
+def optimize_assistant_prompt(
+    llm: LanguageModelLike,
+    assistant_name: str,
+    assistant_description: str,
+) -> str:
+    """optimize assistant prompt
+
+    Args:
+        llm (LanguageModelLike):
+        assistant_name (str):
+        assistant_description (str):
+
+    Returns:
+        assistant_prompt(str):
+    """
+    chain = ({
+        'assistant_name': lambda x: x['assistant_name'],
+        'assistant_description': lambda x: x['assistant_description'],
+    }
+             | ASSISTANT_PROMPT_OPT
+             | llm)
+    chain_output = chain.invoke({
+        'assistant_name': assistant_name,
+        'assistant_description': assistant_description,
+    })
+    response = chain_output.content
+    assistant_prompt = parse_markdown(response)
+    return assistant_prompt
+
+
+def generate_opening_dialog(
+    llm: LanguageModelLike,
+    description: str,
+) -> str:
+    chain = ({
+        'description': lambda x: x['description'],
+    }
+             | OPENDIALOG_PROMPT
+             | llm)
+    time = 0
+    while time <= 3:
+        try:
+            chain_output = chain.invoke({
+                'description': description,
+            })
+            output = parse_json(chain_output.content)
+            output = json.loads(output)
+            opening_lines = output[0]['开场白']
+            questions = output[0]['问题']
+            break
+        except Exception as e:
+            logger.info(f'第{time}次解析失败, 错误信息: {e}')
+            logger.info(f'模型输出结果为{chain_output.content}。')
+            time += 1
+            opening_lines = ''
+            questions = []
+
+    res = {}
+    res['opening_lines'] = opening_lines
+    res['questions'] = questions
+
+    return res
+
+
+def generate_breif_description(
+    llm: LanguageModelLike,
+    description: str,
+) -> str:
+    chain = ({
+        'description': lambda x: x['description'],
+    }
+             | BREIF_DES_PROMPT
+             | llm)
+    chain_output = chain.invoke({
+        'description': description,
+    })
+    breif_description = chain_output.content
+    breif_description = breif_description.strip()
+    return breif_description
+
+
+if __name__ == '__main__':
+    httpx_client = httpx.Client(proxies=os.getenv('OPENAI_PROXY'))
+    llm = ChatOpenAI(model='gpt-4-0125-preview', temperature=0.01, http_client=httpx_client)
+    # llm = ChatQWen(model="qwen1.5-72b-chat", temperature=0.01, api_key=os.getenv('QWEN_API_KEY'))
+    assistant_name = '金融分析助手'
+    assistant_description = '1. 分析上市公司最新的年报财报；2. 获取上市公司的最新新闻；'
+    assistant_prompt = optimize_assistant_prompt(llm, assistant_name, assistant_description)
+    # print(assistant_prompt)
+
+    opening_dialog = generate_opening_dialog(llm, assistant_prompt)
+    print(opening_dialog)
+
+    # breif_description = generate_breif_description(llm, assistant_prompt)
+    # print(breif_description)

bisheng_langchain/gpts/auto_tool_selected.py

@@ -0,0 +1,54 @@
+from bisheng_langchain.gpts.prompts.select_tools_prompt import HUMAN_MSG, SYS_MSG
+from langchain.prompts import (ChatPromptTemplate, HumanMessagePromptTemplate,
+                               SystemMessagePromptTemplate)
+from langchain_core.language_models.base import LanguageModelLike
+from pydantic import BaseModel
+
+
+class ToolInfo(BaseModel):
+    tool_name: str
+    tool_description: str
+
+
+class ToolSelector:
+
+    def __init__(
+        self,
+        llm: LanguageModelLike,
+        tools: list[ToolInfo],
+        system_message: str = SYS_MSG,
+        human_message: str = HUMAN_MSG,
+    ) -> None:
+        self.llm = llm
+        self.tools = tools
+        self.system_message = system_message
+        self.human_message = human_message
+
+    def select(self, task_name: str, task_description: str) -> list[str]:
+        tool_pool = [tool.dict() for tool in self.tools]
+        messages = [
+            SystemMessagePromptTemplate.from_template(self.system_message),
+            HumanMessagePromptTemplate.from_template(self.human_message),
+        ]
+
+        chain = ({
+            'tool_pool': lambda x: x['tool_pool'],
+            'task_name': lambda x: x['task_name'],
+            'task_description': lambda x: x['task_description'],
+        }
+                 | ChatPromptTemplate.from_messages(messages)
+                 | self.llm)
+
+        chain_output = chain.invoke({
+            'tool_pool': tool_pool,
+            'task_name': task_name,
+            'task_description': task_description,
+        })
+
+        try:
+            all_tool_name = set([tool.tool_name for tool in self.tools])
+            output = list(set(eval(chain_output.content)) & all_tool_name)
+            return output
+        except Exception as e:
+            print(e)
+            return []

bisheng_langchain/gpts/load_tools.py

@@ -0,0 +1,161 @@
+import warnings
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import httpx
+from bisheng_langchain.gpts.tools.api_tools import ALL_API_TOOLS
+from bisheng_langchain.gpts.tools.bing_search.tool import BingSearchRun
+from bisheng_langchain.gpts.tools.calculator.tool import calculator
+from bisheng_langchain.gpts.tools.code_interpreter.tool import CodeInterpreterTool
+
+# from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
+from bisheng_langchain.gpts.tools.dalle_image_generator.tool import (
+    DallEAPIWrapper,
+    DallEImageGenerator,
+)
+from bisheng_langchain.gpts.tools.get_current_time.tool import get_current_time
+from langchain_community.tools.arxiv.tool import ArxivQueryRun
+from langchain_community.tools.bearly.tool import BearlyInterpreterTool
+from langchain_community.utilities.arxiv import ArxivAPIWrapper
+from langchain_community.utilities.bing_search import BingSearchAPIWrapper
+from langchain_core.callbacks import BaseCallbackManager, Callbacks
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.tools import BaseTool, Tool
+from mypy_extensions import Arg, KwArg
+
+
+def _get_current_time() -> BaseTool:
+    return get_current_time
+
+
+def _get_calculator() -> BaseTool:
+    return calculator
+
+
+def _get_arxiv() -> BaseTool:
+    return ArxivQueryRun(api_wrapper=ArxivAPIWrapper())
+
+
+_BASE_TOOLS: Dict[str, Callable[[], BaseTool]] = {
+    'get_current_time': _get_current_time,
+    'calculator': _get_calculator,
+    'arxiv': _get_arxiv,
+}
+
+_LLM_TOOLS: Dict[str, Callable[[BaseLanguageModel], BaseTool]] = {}
+
+_EXTRA_LLM_TOOLS: Dict[
+    str, Tuple[Callable[[Arg(BaseLanguageModel, 'llm'), KwArg(Any)], BaseTool], List[str]]  # noqa  # noqa #type: ignore
+] = {}
+
+
+def _get_bing_search(**kwargs: Any) -> BaseTool:
+    return BingSearchRun(api_wrapper=BingSearchAPIWrapper(**kwargs))
+
+
+def _get_dalle_image_generator(**kwargs: Any) -> Tool:
+    openai_api_key = kwargs.get('openai_api_key')
+    http_async_client = httpx.AsyncClient(proxies=kwargs.get('openai_proxy'))
+    httpc_client = httpx.Client(proxies=kwargs.get('openai_proxy'))
+    return DallEImageGenerator(
+        api_wrapper=DallEAPIWrapper(
+            model='dall-e-3',
+            api_key=openai_api_key,
+            http_client=httpc_client,
+            http_async_client=http_async_client,
+        )
+    )
+
+
+def _get_bearly_code_interpreter(**kwargs: Any) -> Tool:
+    return BearlyInterpreterTool(**kwargs).as_tool()
+
+
+def _get_native_code_interpreter(**kwargs: Any) -> Tool:
+    return CodeInterpreterTool(**kwargs).as_tool()
+
+
+# 第二个list内填必填参数，第三个list内填可选参数
+_EXTRA_PARAM_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[Optional[str]], List[Optional[str]]]] = {  # type: ignore
+    'dalle_image_generator': (_get_dalle_image_generator, ['openai_api_key', 'openai_proxy'], []),
+    'bing_search': (_get_bing_search, ['bing_subscription_key', 'bing_search_url'], []),
+    'code_interpreter': (_get_native_code_interpreter, ["minio"], ['files']),
+}
+
+_API_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = {**ALL_API_TOOLS}  # type: ignore
+
+_ALL_TOOLS = {
+    **_BASE_TOOLS,
+    **_LLM_TOOLS,
+    **_EXTRA_LLM_TOOLS,
+    **_EXTRA_PARAM_TOOLS,
+    **_API_TOOLS,
+}
+
+
+def _handle_callbacks(callback_manager: Optional[BaseCallbackManager], callbacks: Callbacks) -> Callbacks:
+    if callback_manager is not None:
+        warnings.warn(
+            'callback_manager is deprecated. Please use callbacks instead.',
+            DeprecationWarning,
+        )
+        if callbacks is not None:
+            raise ValueError('Cannot specify both callback_manager and callbacks arguments.')
+        return callback_manager
+    return callbacks
+
+
+def load_tools(
+    tool_params: Dict[str, Dict[str, Any]],
+    llm: Optional[BaseLanguageModel] = None,
+    callbacks: Callbacks = None,
+    **kwargs: Any,
+) -> List[BaseTool]:
+    tools = []
+    callbacks = _handle_callbacks(callback_manager=kwargs.get('callback_manager'), callbacks=callbacks)
+    for name, params in tool_params.items():
+        if name in _BASE_TOOLS:
+            tools.append(_BASE_TOOLS[name]())
+        elif name in _LLM_TOOLS:
+            if llm is None:
+                raise ValueError(f'Tool {name} requires an LLM to be provided')
+            tool = _LLM_TOOLS[name](llm)
+            tools.append(tool)
+        elif name in _EXTRA_LLM_TOOLS:
+            if llm is None:
+                raise ValueError(f'Tool {name} requires an LLM to be provided')
+            _get_llm_tool_func, extra_keys = _EXTRA_LLM_TOOLS[name]
+            missing_keys = set(extra_keys).difference(params)
+            if missing_keys:
+                raise ValueError(f'Tool {name} requires some parameters that were not ' f'provided: {missing_keys}')
+            sub_kwargs = {k: params[k] for k in extra_keys}
+            tool = _get_llm_tool_func(llm=llm, **sub_kwargs)
+            tools.append(tool)
+        elif name in _EXTRA_PARAM_TOOLS:
+            _get_tool_func, extra_keys, optional_keys = _EXTRA_PARAM_TOOLS[name]
+            missing_keys = set(extra_keys).difference(params)
+            if missing_keys:
+                raise ValueError(f'Tool {name} requires some parameters that were not ' f'provided: {missing_keys}')
+            extra_kwargs = {k: params[k] for k in extra_keys}
+            optional_kwargs = {k: params[k] for k in optional_keys if k in params}
+            all_kwargs = {**extra_kwargs, **optional_kwargs}
+            tool = _get_tool_func(**all_kwargs)
+            tools.append(tool)
+        elif name in _API_TOOLS:
+            _get_api_tool_func, extra_keys = _API_TOOLS[name]
+            missing_keys = set(extra_keys).difference(params)
+            if missing_keys:
+                raise ValueError(f'Tool {name} requires some parameters that were not ' f'provided: {missing_keys}')
+            mini_kwargs = {k: params[k] for k in extra_keys}
+            tool = _get_api_tool_func(name=name, **mini_kwargs)
+            tools.append(tool)
+        else:
+            raise ValueError(f'Got unknown tool {name}')
+    if callbacks is not None:
+        for tool in tools:
+            tool.callbacks = callbacks
+    return tools
+
+
+def get_all_tool_names() -> List[str]:
+    """Get a list of all possible tool names."""
+    return list(_ALL_TOOLS.keys())

bisheng_langchain/gpts/message_types.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+from langchain_core.messages import FunctionMessage, ToolMessage
+
+
+class LiberalFunctionMessage(FunctionMessage):
+    content: Any
+
+
+class LiberalToolMessage(ToolMessage):
+    content: Any

bisheng_langchain/gpts/prompts/__init__.py

@@ -0,0 +1,15 @@
+from bisheng_langchain.gpts.prompts.assistant_prompt_opt import ASSISTANT_PROMPT_OPT
+from bisheng_langchain.gpts.prompts.base_prompt import DEFAULT_SYSTEM_MESSAGE
+from bisheng_langchain.gpts.prompts.breif_description_prompt import BREIF_DES_PROMPT
+from bisheng_langchain.gpts.prompts.opening_dialog_prompt import OPENDIALOG_PROMPT
+from bisheng_langchain.gpts.prompts.select_tools_prompt import HUMAN_MSG, SYS_MSG
+
+
+__all__ = [
+    "DEFAULT_SYSTEM_MESSAGE",
+    "ASSISTANT_PROMPT_OPT",
+    "OPENDIALOG_PROMPT",
+    "BREIF_DES_PROMPT",
+    "SYS_MSG",
+    "HUMAN_MSG",
+]

bisheng_langchain/gpts/prompts/assistant_prompt_opt.py

@@ -0,0 +1,95 @@
+from langchain_core.prompts import PromptTemplate
+from langchain_core.prompts.chat import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    SystemMessagePromptTemplate,
+)
+
+# 例如助手的身份、相关完成任务的具体方法和步骤、回答问题时的语气以及应该注意什么问题等
+system_template = """你是一个prompt优化大师，你会得到一个助手的名字和简单描述，你需要根据这些信息，为助手生成一个合适的角色描述、详细的技能说明、相关约束信息，输出为markdown格式。你需要按照以下格式进行组织输出内容：
+```markdown
+## 角色
+你是一个[助手的角色]，[助手的角色描述]。
+
+## 技能
+1. [技能 1 的描述]：
+  - [技能 1 的具体内容]。
+  - [技能 1 的具体内容]。
+2. [技能 2 的描述]：
+  - [技能 2 的具体内容]。
+  - [技能 2 的具体内容]。
+
+## 限制
+- [限制 1 的描述]。
+- [限制 2 的描述]。
+```
+
+以下是一些例子：
+示例1：
+输入：
+助手名字: 金融分析助手
+助手描述: 1. 分析上市公司最新的年报财报；2. 获取上市公司的最新新闻；
+
+输出：
+```markdown
+## 角色
+你是一个金融分析师，会利用最新的信息和数据来分析公司的财务状况、市场趋势和行业动态，以帮助客户做出明智的投资决策。
+
+## 技能
+1. 分析上市公司最新的年报财报：
+  - 使用财务分析工具和技巧，对公司的财务报表进行详细的分析和解读。
+  - 评估公司的财务健康状况，包括营收、利润、资产负债表、现金流量等方面。
+  - 分析公司的财务指标，如利润率、偿债能力、周转率等，以评估其盈利能力和风险水平。
+  - 比较公司的财务表现与同行业其他公司的平均水平，以评估其相对竞争力。
+2. 获取上市公司的最新新闻：
+  - 使用新闻来源和数据库，定期获取上市公司的最新新闻和公告。
+  - 分析新闻对公司股价和投资者情绪的潜在影响。
+  - 关注公司的重大事件，如合并收购、产品发布、管理层变动等，以及这些事件对公司未来发展的影响。
+  - 结合财务分析和新闻分析，提供对公司的综合评估和投资建议。
+
+## 限制
+- 只讨论与金融分析相关的内容，拒绝回答与金融分析无关的话题。
+- 所有的输出内容必须按照给定的格式进行组织，不能偏离框架要求。
+- 分析部分不能超过 100 字。
+```
+
+示例2：
+输入：
+助手名字: 前端开发助手
+助手描述: 你的角色是前端开发，能帮助我把图片制作成html页面，css使用tailwind.css，ui库使用antd
+
+输出：
+```markdown
+# 角色
+你是一个前端开发工程师，可以使用 HTML、CSS 和 JavaScript 等技术构建网站和应用程序。
+
+## 技能
+1. 将图片制作成 HTML 页面
+  - 当用户需要将图片制作成 HTML 页面时，你可以根据用户提供的图片和要求，使用 HTML 和 CSS 等技术构建一个页面。
+  - 在构建页面时，你可以使用 Tailwind CSS 来简化 CSS 样式的编写，并使用 Antd 库来提供丰富的 UI 组件。
+  - 构建完成后，你可以将页面代码返回给用户，以便用户可以将其部署到服务器上或在本地查看。
+
+2. 提供前端开发相关的建议和帮助
+  - 当用户需要前端开发相关的建议和帮助时，你可以根据用户的问题，提供相关的建议和帮助。
+  - 你可以提供关于 HTML、CSS、JavaScript 等前端技术的建议和帮助，也可以提供关于前端开发工具和流程的建议和帮助。
+
+## 限制
+- 只讨论与前端开发相关的内容，拒绝回答与前端开发无关的话题。
+- 所输出的内容必须按照给定的格式进行组织，不能偏离框架要求。
+```
+"""
+
+human_template = """
+输入：
+助手名字: {assistant_name}
+助手描述: {assistant_description}
+
+输出：
+"""
+
+
+messages = [
+    SystemMessagePromptTemplate.from_template(system_template),
+    HumanMessagePromptTemplate.from_template(human_template),
+]
+ASSISTANT_PROMPT_OPT = ChatPromptTemplate.from_messages(messages)

bisheng_langchain/gpts/prompts/base_prompt.py

@@ -0,0 +1 @@
+DEFAULT_SYSTEM_MESSAGE = "You are a helpful assistant."