bisheng-langchain 0.3.0rc0__py3-none-any.whl → 0.3.1__py3-none-any.whl

bisheng_langchain/chat_models/host_llm.py

@@ -163,7 +163,7 @@ class BaseHostChatLLM(BaseChatModel):
                     values[
                         'host_base_url'] = f"{values['host_base_url']}/{values['model_name']}/infer"
         except Exception:
-            raise Exception(f'Update Decoupled status faild for model {model}')
+            raise Exception(f'Update Decoupled status failed for model {model}')
 
         try:
             if values['headers']:

bisheng_langchain/document_loaders/elem_unstrcutured_loader.py

@@ -85,16 +85,18 @@ class ElemUnstructuredLoader(BasePDFLoader):
                        mode='partition',
                        parameters=parameters)
 
-        resp = requests.post(self.unstructured_api_url, headers=self.headers, json=payload).json()
+        resp = requests.post(self.unstructured_api_url, headers=self.headers, json=payload)
+        if resp.status_code != 200:
+            raise Exception(f'file partition {os.path.basename(self.file_name)} failed resp={resp.text}')
 
+        resp = resp.json()
         if 200 != resp.get('status_code'):
-            logger.info(f'not return resp={resp}')
+            logger.info(f'file partition {os.path.basename(self.file_name)} error resp={resp}')
         partitions = resp['partitions']
         if not partitions:
             logger.info(f'partition_error resp={resp}')
         logger.info(f'unstruct_return code={resp.get("status_code")}')
 
-        partitions = resp['partitions']
         content, metadata = merge_partitions(partitions)
         metadata['source'] = self.file_name
 

bisheng_langchain/gpts/agent_types/llm_functions_agent.py

@@ -1,5 +1,5 @@
 import json
-
+import re
 from bisheng_langchain.gpts.message_types import LiberalFunctionMessage, LiberalToolMessage
 from langchain.tools import BaseTool
 from langchain.tools.render import format_tool_to_openai_tool
@@ -39,6 +39,12 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
         last_message = messages[-1]
         # If there is no function call, then we finish
         if 'tool_calls' not in last_message.additional_kwargs:
+            if '|<instruct>|' in system_message:
+                # cohere model
+                pattern = r"Answer:(.+)\nGrounded answer"
+                match = re.search(pattern, last_message.content)
+                if match:
+                    last_message.content = match.group(1)
             return 'end'
         # Otherwise if there is, we continue
         else:

bisheng_langchain/gpts/assistant.py

@@ -126,11 +126,14 @@ class BishengAssistant:
 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")
+    # set_debug(True)
+    chat_history = []
+    query = "请简要分析中科创达软件股份有限公司2019年聘任、解聘会计师事务的情况。"
+    # chat_history = ['你好', '你好，有什么可以帮助你吗？', '福蓉科技股价多少?', '福蓉科技（股票代码：300049）的当前股价为48.67元。']
+    # query = '去年这个时候的股价是多少？'
+    # bisheng_assistant = BishengAssistant("config/base_scene.yaml")
+    # bisheng_assistant = BishengAssistant("config/knowledge_scene.yaml")
+    bisheng_assistant = BishengAssistant("config/rag_scene.yaml")
     result = bisheng_assistant.run(query, chat_history=chat_history)
     for r in result:
         print(f'------------------')

bisheng_langchain/gpts/auto_optimization.py

@@ -3,7 +3,11 @@ import os
 import re
 
 import httpx
-from bisheng_langchain.gpts.prompts import ASSISTANT_PROMPT_OPT, BREIF_DES_PROMPT, OPENDIALOG_PROMPT
+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
@@ -48,16 +52,13 @@ def optimize_assistant_prompt(
     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,
-    })
+    chain = 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
@@ -67,17 +68,15 @@ def generate_opening_dialog(
     llm: LanguageModelLike,
     description: str,
 ) -> str:
-    chain = ({
-        'description': lambda x: x['description'],
-    }
-             | OPENDIALOG_PROMPT
-             | llm)
+    chain = OPENDIALOG_PROMPT | llm
     time = 0
     while time <= 3:
         try:
-            chain_output = chain.invoke({
-                'description': description,
-            })
+            chain_output = chain.invoke(
+                {
+                    'description': description,
+                }
+            )
             output = parse_json(chain_output.content)
             output = json.loads(output)
             opening_lines = output[0]['开场白']
@@ -101,20 +100,22 @@ 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,
-    })
+    chain = 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__':
+    from dotenv import load_dotenv
+
+    load_dotenv('/app/.env', override=True)
+
     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'))

bisheng_langchain/gpts/auto_tool_selected.py

@@ -1,6 +1,9 @@
 from bisheng_langchain.gpts.prompts.select_tools_prompt import HUMAN_MSG, SYS_MSG
-from langchain.prompts import (ChatPromptTemplate, HumanMessagePromptTemplate,
-                               SystemMessagePromptTemplate)
+from langchain.prompts import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    SystemMessagePromptTemplate,
+)
 from langchain_core.language_models.base import LanguageModelLike
 from pydantic import BaseModel
 
@@ -31,19 +34,15 @@ class ToolSelector:
             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,
-        })
+        chain = 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])

bisheng_langchain/gpts/load_tools.py

@@ -1,7 +1,11 @@
+import json
+import os
 import warnings
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 import httpx
+import pandas as pd
+import pymysql
 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
@@ -13,6 +17,7 @@ from bisheng_langchain.gpts.tools.dalle_image_generator.tool import (
     DallEImageGenerator,
 )
 from bisheng_langchain.gpts.tools.get_current_time.tool import get_current_time
+from dotenv import load_dotenv
 from langchain_community.tools.arxiv.tool import ArxivQueryRun
 from langchain_community.tools.bearly.tool import BearlyInterpreterTool
 from langchain_community.utilities.arxiv import ArxivAPIWrapper
@@ -21,6 +26,7 @@ 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
+from bisheng_langchain.rag import BishengRAGTool
 
 
 def _get_current_time() -> BaseTool:
@@ -54,12 +60,14 @@ def _get_bing_search(**kwargs: Any) -> BaseTool:
 
 def _get_dalle_image_generator(**kwargs: Any) -> Tool:
     openai_api_key = kwargs.get('openai_api_key')
+    openai_api_base = kwargs.get('openai_api_base')
     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,
+            base_url=openai_api_base,
             http_client=httpc_client,
             http_async_client=http_async_client,
         )
@@ -78,7 +86,8 @@ def _get_native_code_interpreter(**kwargs: Any) -> Tool:
 _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']),
+    'bisheng_code_interpreter': (_get_native_code_interpreter, ["minio"], ['files']),
+    'bisheng_rag': (BishengRAGTool.get_rag_tool, ['name', 'description'], ['vector_store', 'keyword_store', 'llm', 'collection_name', 'max_content', 'sort_by_source_and_index']),
 }
 
 _API_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = {**ALL_API_TOOLS}  # type: ignore
@@ -159,3 +168,46 @@ def load_tools(
 def get_all_tool_names() -> List[str]:
     """Get a list of all possible tool names."""
     return list(_ALL_TOOLS.keys())
+
+
+def get_tool_table():
+
+    load_dotenv('.sql_env', override=True)
+    db = pymysql.connect(
+        host=os.getenv('MYSQL_HOST'),
+        user=os.getenv('MYSQL_USER'),
+        password=os.getenv('MYSQL_PASSWORD'),
+        database=os.getenv('MYSQL_DATABASE'),
+        port=int(os.getenv('MYSQL_PORT')),
+    )
+    cursor = db.cursor()
+    cursor.execute("SELECT name, t.desc, tool_key, extra FROM t_gpts_tools as t;")
+    results = cursor.fetchall()
+    db.close()
+    
+    df = pd.DataFrame(
+        columns=[
+            '前端工具名',
+            '前端工具描述',
+            'tool_key',
+            'tool参数配置',
+            'function_name',
+            'function_description',
+            'function_args',
+        ]
+    )
+    for i, result in enumerate(results):
+        name, desc, tool_key, extra = result
+        if not extra:
+            extra = '{}'
+        tool_func = load_tools({tool_key: json.loads(extra)})[0]
+
+        df.loc[i, '前端工具名'] = name
+        df.loc[i, '前端工具描述'] = desc
+        df.loc[i, 'tool_key'] = tool_key
+        df.loc[i, 'tool参数配置'] = extra
+        df.loc[i, 'function_name'] = tool_func.name
+        df.loc[i, 'function_description'] = tool_func.description
+        df.loc[i, 'function_args'] = f"{tool_func.args_schema.schema()['properties']}"
+
+    return df

bisheng_langchain/gpts/prompts/__init__.py

@@ -1,12 +1,14 @@
 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.assistant_prompt_base import ASSISTANT_PROMPT_DEFAULT
+from bisheng_langchain.gpts.prompts.assistant_prompt_cohere import ASSISTANT_PROMPT_COHERE
 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_DEFAULT",
+    "ASSISTANT_PROMPT_COHERE",
     "ASSISTANT_PROMPT_OPT",
     "OPENDIALOG_PROMPT",
     "BREIF_DES_PROMPT",

bisheng_langchain/gpts/prompts/assistant_prompt_base.py

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

bisheng_langchain/gpts/prompts/assistant_prompt_cohere.py

@@ -0,0 +1,19 @@
+preamble="""You are a helpful assistant.
+"""
+
+ASSISTANT_PROMPT_COHERE="""{preamble}|<instruct>|Carefully perform the following instructions, in order, starting each with a new line.
+Firstly, You may need to use complex and advanced reasoning to complete your task and answer the question. Think about how you can use the provided tools to answer the question and come up with a high level plan you will execute.
+Write 'Plan:' followed by an initial high level plan of how you will solve the problem including the tools and steps required.
+Secondly, Carry out your plan by repeatedly using actions, reasoning over the results, and re-evaluating your plan. Perform Action, Observation, Reflection steps with the following format. Write 'Action:' followed by a json formatted action containing the "tool_name" and "parameters"
+ Next you will analyze the 'Observation:', this is the result of the action.
+After that you should always think about what to do next. Write 'Reflection:' followed by what you've figured out so far, any changes you need to make to your plan, and what you will do next including if you know the answer to the question.
+... (this Action/Observation/Reflection can repeat N times)
+Thirdly, Decide which of the retrieved documents are relevant to the user's last input by writing 'Relevant Documents:' followed by comma-separated list of document numbers. If none are relevant, you should instead write 'None'.
+Fourthly, Decide which of the retrieved documents contain facts that should be cited in a good answer to the user's last input by writing 'Cited Documents:' followed a comma-separated list of document numbers. If you dont want to cite any of them, you should instead write 'None'.
+Fifthly, Write 'Answer:' followed by a response to the user's last input. Use the retrieved documents to help you. Do not insert any citations or grounding markup.
+Finally, Write 'Grounded answer:' followed by a response to the user's last input in high quality natural english. Use the symbols <co: doc> and </co: doc> to indicate when a fact comes from a document in the search result, e.g <co: 4>my fact</co: 4> for a fact from document 4.
+
+Additional instructions to note:
+- If the user's question is in Chinese, please answer it in Chinese. 
+- 当问题中有涉及到时间信息时，比如最近6个月、昨天、去年等，你需要用时间工具查询时间信息。
+""".format(preamble=preamble)

bisheng_langchain/gpts/prompts/opening_dialog_prompt.py

@@ -6,7 +6,7 @@ from langchain_core.prompts.chat import (
 )
 
 system_template = """
-你是一个生成开场白和预置问题的助手。接下来，你会收到一段关于任务助手的描述，你需要带入描述中的角色，以描述中的角色身份生成一段开场白，同时你还需要以描述中的角色身份生成几个预置问题。输出格式如下：
+你是一个生成开场白和预置问题的助手。接下来，你会收到一段关于任务助手的描述，你需要带入描述中的角色，以描述中的角色身份生成一段开场白，同时你还需要站在用户的角度生成几个用户可能的提问。输出格式如下：
 [
     {{
         "开场白": "开场白内容",

bisheng_langchain/gpts/tools/api_tools/__init__.py

@@ -40,7 +40,7 @@ _MACRO_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = {
 
 _tmp_flow = ['knowledge_retrieve']
 _TMP_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = {
-    f'flow_{name}': (FlowTools.get_api_tool, ['collection_id'])
+    f'flow_{name}': (FlowTools.get_api_tool, ['collection_id', 'description'])
     for name in _tmp_flow
 }
 ALL_API_TOOLS = {}

bisheng_langchain/gpts/tools/api_tools/base.py

@@ -64,7 +64,7 @@ class APIToolBase(BaseModel):
         resp = self.client.get(url)
         if resp.status_code != 200:
             logger.info('api_call_fail res={}', resp.text)
-        return resp.text
+        return resp.text[:10000]
 
     async def arun(self, query: str, **kwargs) -> str:
         """Run query through api and parse result."""
@@ -79,8 +79,8 @@ class APIToolBase(BaseModel):
             url = self.url
         logger.info('api_call url={}', url)
         resp = await self.async_client.aget(url)
-        logger.info(resp)
-        return resp
+        logger.info(resp[:10000])
+        return resp[:10000]
 
     @classmethod
     def get_api_tool(cls, name, **kwargs: Any) -> BaseTool:

bisheng_langchain/gpts/tools/api_tools/flow.py

@@ -1,7 +1,9 @@
 from loguru import logger
-from pydantic import BaseModel, Field
-
+from langchain_core.pydantic_v1 import BaseModel, Field
+from typing import Any
 from .base import APIToolBase
+from .base import MultArgsSchemaTool
+from langchain_core.tools import BaseTool
 
 
 class FlowTools(APIToolBase):
@@ -34,10 +36,8 @@ class FlowTools(APIToolBase):
         return resp
 
     @classmethod
-    def knowledge_retrieve(cls, collection_id: int = None) -> str:
-        """
-        知识库检索工具，从内部知识库进行检索总结
-        """
+    def knowledge_retrieve(cls, collection_id: int = None) -> str:    
+
         flow_id = 'c7985115-a9d2-446a-9c55-40b5728ffb52'
         url = 'http://192.168.106.120:3002/api/v1/process/{}'.format(flow_id)
         input_key = 'inputs'
@@ -53,7 +53,19 @@ class FlowTools(APIToolBase):
         }
 
         class InputArgs(BaseModel):
-            """args_schema"""
             query: str = Field(description='questions to ask')
 
         return cls(url=url, params=params, input_key=input_key, args_schema=InputArgs)
+    
+    @classmethod
+    def get_api_tool(cls, name, **kwargs: Any) -> BaseTool:
+        attr_name = name.split('_', 1)[-1]
+        class_method = getattr(cls, attr_name)
+        function_description = kwargs.get('description','')
+        kwargs.pop('description')
+        return MultArgsSchemaTool(name=name + '_' +str(kwargs.get('collection_id')),
+                                  description=function_description,
+                                  func=class_method(**kwargs).run,
+                                  coroutine=class_method(**kwargs).arun,
+                                  args_schema=class_method(**kwargs).args_schema)
+    

bisheng_langchain/gpts/tools/api_tools/macro_data.py

@@ -81,7 +81,7 @@ class MacroData(BaseModel):
         JS_CHINA_GDP_YEARLY_URL = 'https://cdn.jin10.com/dc/reports/dc_chinese_gdp_yoy_all.js?v={}&_={}'
         t = time.time()
         r = requests.get(JS_CHINA_GDP_YEARLY_URL.format(str(int(round(t * 1000))), str(int(round(t * 1000)) + 90)))
-        json_data = json.loads(r.text[r.text.find('{') : r.text.rfind('}') + 1])
+        json_data = json.loads(r.text[r.text.find('{'): r.text.rfind('}') + 1])
         date_list = [item['date'] for item in json_data['list']]
         value_list = [item['datas']['中国GDP年率报告'] for item in json_data['list']]
         value_df = pd.DataFrame(value_list)
@@ -249,6 +249,60 @@ class MacroData(BaseModel):
             temp_df = temp_df[(temp_df['月份'] >= start) & (temp_df['月份'] <= end)]
         return temp_df.to_markdown()
 
+    @classmethod
+    def china_pmi(cls, start_date: str = '', end_date: str = '') -> str:
+        """中国 PMI （采购经理人指数）月度统计数据。
+        返回数据包括：月份制造业 PMI，制造业 PMI 同比增长，非制造业 PMI，非制造业 PMI 同比增长。
+        """
+        url = "https://datacenter-web.eastmoney.com/api/data/v1/get"
+        params = {
+            "columns": "REPORT_DATE,TIME,MAKE_INDEX,MAKE_SAME,NMAKE_INDEX,NMAKE_SAME",
+            "pageNumber": "1",
+            "pageSize": "2000",
+            "sortColumns": "REPORT_DATE",
+            "sortTypes": "-1",
+            "source": "WEB",
+            "client": "WEB",
+            "reportName": "RPT_ECONOMY_PMI",
+            "p": "1",
+            "pageNo": "1",
+            "pageNum": "1",
+            "_": "1669047266881",
+        }
+        r = requests.get(url, params=params)
+        data_json = r.json()
+        temp_df = pd.DataFrame(data_json["result"]["data"])
+        temp_df.columns = [
+            "-",
+            "月份",
+            "制造业-指数",
+            "制造业-同比增长",
+            "非制造业-指数",
+            "非制造业-同比增长",
+        ]
+        temp_df = temp_df[
+            [
+                "月份",
+                "制造业-指数",
+                "制造业-同比增长",
+                "非制造业-指数",
+                "非制造业-同比增长",
+            ]
+        ]
+        temp_df["制造业-指数"] = pd.to_numeric(temp_df["制造业-指数"], errors="coerce")
+        temp_df["制造业-同比增长"] = pd.to_numeric(
+            temp_df["制造业-同比增长"], errors="coerce"
+        )
+        temp_df["非制造业-指数"] = pd.to_numeric(temp_df["非制造业-指数"], errors="coerce")
+        temp_df["非制造业-同比增长"] = pd.to_numeric(
+            temp_df["非制造业-同比增长"], errors="coerce"
+        )
+        if start_date and end_date:
+            start = start_date.split('-')[0] + '年' + start_date.split('-')[1] + '月份'
+            end = end_date.split('-')[0] + '年' + end_date.split('-')[1] + '月份'
+            temp_df = temp_df[(temp_df['月份'] >= start) & (temp_df['月份'] <= end)]
+        return temp_df.to_markdown()
+
     @classmethod
     def china_money_supply(cls, start_date: str = '', end_date: str = '') -> pd.DataFrame:
         """中国货币供应量（M2，M1，M0）月度统计数据。\
@@ -376,6 +430,121 @@ M0数量（单位：亿元），M0 同比（单位：%），M0 环比（单位
 
         return temp_df.to_markdown()
 
+    @classmethod
+    def bond_zh_us_rate(cls, start_date: str = "", end_date: str = "") -> str:
+        """
+        本接口返回指定时间段[start_date,end_date]内交易日的中美两国的 2 年、5 年、10 年、30 年、10 年-2 年收益率数据。
+        start_date表示起始日期，end_date表示结束日期，日期格式例如 2024-04-07
+        """
+        url = "https://datacenter.eastmoney.com/api/data/get"
+        params = {
+            "type": "RPTA_WEB_TREASURYYIELD",
+            "sty": "ALL",
+            "st": "SOLAR_DATE",
+            "sr": "-1",
+            "token": "894050c76af8597a853f5b408b759f5d",
+            "p": "1",
+            "ps": "500",
+            "pageNo": "1",
+            "pageNum": "1",
+            "_": "1615791534490",
+        }
+        r = requests.get(url, params=params)
+        data_json = r.json()
+        total_page = data_json["result"]["pages"]
+        big_df = pd.DataFrame()
+        for page in range(1, total_page + 1):
+            params = {
+                "type": "RPTA_WEB_TREASURYYIELD",
+                "sty": "ALL",
+                "st": "SOLAR_DATE",
+                "sr": "-1",
+                "token": "894050c76af8597a853f5b408b759f5d",
+                "p": page,
+                "ps": "500",
+                "pageNo": page,
+                "pageNum": page,
+                "_": "1615791534490",
+            }
+            r = requests.get(url, params=params)
+            data_json = r.json()
+            # 时间过滤
+            if start_date and end_date:
+                temp_data = []
+                for item in data_json["result"]["data"]:
+                    if start_date <= item["SOLAR_DATE"].split(" ")[0] <= end_date:
+                        temp_data.append(item)
+                    elif start_date > item["SOLAR_DATE"].split(" ")[0]:
+                        break
+                    else:
+                        continue
+            else:
+                temp_data = data_json["result"]["data"]
+            temp_df = pd.DataFrame(temp_data)
+            for col in temp_df.columns:
+                if temp_df[col].isnull().all():  # 检查列是否包含 None 或 NaN
+                    temp_df[col] = pd.to_numeric(temp_df[col], errors='coerce')
+            if big_df.empty:
+                big_df = temp_df
+            else:
+                big_df = pd.concat(objs=[big_df, temp_df], ignore_index=True)
+
+        big_df.rename(
+            columns={
+                "SOLAR_DATE": "日期",
+                "EMM00166462": "中国国债收益率5年",
+                "EMM00166466": "中国国债收益率10年",
+                "EMM00166469": "中国国债收益率30年",
+                "EMM00588704": "中国国债收益率2年",
+                "EMM01276014": "中国国债收益率10年-2年",
+                "EMG00001306": "美国国债收益率2年",
+                "EMG00001308": "美国国债收益率5年",
+                "EMG00001310": "美国国债收益率10年",
+                "EMG00001312": "美国国债收益率30年",
+                "EMG01339436": "美国国债收益率10年-2年",
+                "EMM00000024": "中国GDP年增率",
+                "EMG00159635": "美国GDP年增率",
+            },
+            inplace=True,
+        )
+        big_df = big_df[
+            [
+                "日期",
+                "中国国债收益率2年",
+                "中国国债收益率5年",
+                "中国国债收益率10年",
+                "中国国债收益率30年",
+                "中国国债收益率10年-2年",
+                "中国GDP年增率",
+                "美国国债收益率2年",
+                "美国国债收益率5年",
+                "美国国债收益率10年",
+                "美国国债收益率30年",
+                "美国国债收益率10年-2年",
+                "美国GDP年增率",
+            ]
+        ]
+        big_df = big_df.drop(["中国GDP年增率", "美国GDP年增率"], axis=1)
+        big_df["日期"] = pd.to_datetime(big_df["日期"], errors="coerce")
+        big_df["中国国债收益率2年"] = pd.to_numeric(big_df["中国国债收益率2年"], errors="coerce")
+        big_df["中国国债收益率5年"] = pd.to_numeric(big_df["中国国债收益率5年"], errors="coerce")
+        big_df["中国国债收益率10年"] = pd.to_numeric(big_df["中国国债收益率10年"], errors="coerce")
+        big_df["中国国债收益率30年"] = pd.to_numeric(big_df["中国国债收益率30年"], errors="coerce")
+        big_df["中国国债收益率10年-2年"] = pd.to_numeric(big_df["中国国债收益率10年-2年"], errors="coerce")
+        # big_df["中国GDP年增率"] = pd.to_numeric(big_df["中国GDP年增率"], errors="coerce")
+        big_df["美国国债收益率2年"] = pd.to_numeric(big_df["美国国债收益率2年"], errors="coerce")
+        big_df["美国国债收益率5年"] = pd.to_numeric(big_df["美国国债收益率5年"], errors="coerce")
+        big_df["美国国债收益率10年"] = pd.to_numeric(big_df["美国国债收益率10年"], errors="coerce")
+        big_df["美国国债收益率30年"] = pd.to_numeric(big_df["美国国债收益率30年"], errors="coerce")
+        big_df["美国国债收益率10年-2年"] = pd.to_numeric(big_df["美国国债收益率10年-2年"], errors="coerce")
+        # big_df["美国GDP年增率"] = pd.to_numeric(big_df["美国GDP年增率"], errors="coerce")
+        big_df.sort_values("日期", inplace=True)
+        big_df.set_index(["日期"], inplace=True)
+        big_df = big_df[pd.to_datetime(start_date):]
+        big_df.reset_index(inplace=True)
+        big_df["日期"] = pd.to_datetime(big_df["日期"]).dt.date
+        return big_df.to_markdown()
+
     @classmethod
     def get_api_tool(cls, name: str, **kwargs: Any) -> BaseTool:
         attr_name = name.split('_', 1)[-1]
@@ -385,13 +554,15 @@ M0数量（单位：亿元），M0 同比（单位：%），M0 环比（单位
 
 
 if __name__ == '__main__':
-    start_date = '2023-01-01'
-    end_date = '2023-05-01'
+    tmp_start_date = '2024-01-01'
+    tmp_end_date = '2024-01-03'
     # start_date = ''
     # end_date = ''
     # print(MacroData.china_ppi(start_date=start_date, end_date=end_date))
     # print(MacroData.china_shrzgm(start_date=start_date, end_date=end_date))
     # print(MacroData.china_consumer_goods_retail(start_date=start_date, end_date=end_date))
     # print(MacroData.china_cpi(start_date=start_date, end_date=end_date))
+    # print(MacroData.china_pmi(start_date=start_date, end_date=end_date))
     # print(MacroData.china_money_supply(start_date=start_date, end_date=end_date))
-    print(MacroData.china_gdp_yearly(start_date=start_date, end_date=end_date))
+    # print(MacroData.china_gdp_yearly(start_date=start_date, end_date=end_date))
+    print(MacroData.bond_zh_us_rate(start_date=tmp_start_date, end_date=tmp_end_date))