bisheng-langchain 0.3.7.dev2__py3-none-any.whl → 0.4.0.dev1__py3-none-any.whl

bisheng_langchain/document_loaders/custom_kv.py

@@ -15,8 +15,8 @@ import cv2
 import fitz
 import numpy as np
 from bisheng_langchain.utils.requests import Requests
-from langchain.docstore.document import Document
-from langchain.document_loaders.base import BaseLoader
+from langchain_community.docstore.document import Document
+from langchain_community.document_loaders.base import BaseLoader
 from PIL import Image
 
 logger = logging.getLogger(__name__)

bisheng_langchain/document_loaders/elem_pdf.py

@@ -12,9 +12,9 @@ from typing import List, Optional, Union
 import fitz
 import numpy as np
 from bisheng_langchain.document_loaders.parsers import LayoutParser
-from langchain.docstore.document import Document
-from langchain.document_loaders.blob_loaders import Blob
-from langchain.document_loaders.pdf import BasePDFLoader
+from langchain_community.docstore.document import Document
+from langchain_community.document_loaders.blob_loaders import Blob
+from langchain_community.document_loaders.pdf import BasePDFLoader
 from shapely import Polygon
 from shapely import box as Rect
 

bisheng_langchain/document_loaders/elem_unstrcutured_loader.py

@@ -6,8 +6,8 @@ import os
 from typing import List
 
 import requests
-from langchain.docstore.document import Document
-from langchain.document_loaders.pdf import BasePDFLoader
+from langchain_community.docstore.document import Document
+from langchain_community.document_loaders.pdf import BasePDFLoader
 
 logger = logging.getLogger(__name__)
 

bisheng_langchain/document_loaders/parsers/image.py

@@ -4,7 +4,7 @@ import json
 from typing import List, Optional
 
 import requests
-from langchain.document_loaders.blob_loaders import Blob
+from langchain_community.document_loaders.blob_loaders import Blob
 from langchain.schema import Document
 
 

bisheng_langchain/document_loaders/universal_kv.py

@@ -11,8 +11,8 @@ import filetype
 import fitz
 import numpy as np
 from bisheng_langchain.document_loaders.parsers import ELLMClient
-from langchain.docstore.document import Document
-from langchain.document_loaders.base import BaseLoader
+from langchain_community.docstore.document import Document
+from langchain_community.document_loaders.base import BaseLoader
 from PIL import Image
 
 

bisheng_langchain/gpts/agent_types/llm_functions_agent.py

@@ -1,5 +1,6 @@
 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
@@ -8,13 +9,14 @@ from langchain_core.messages import FunctionMessage, SystemMessage, ToolMessage
 from langgraph.graph import END
 from langgraph.graph.message import MessageGraph
 from langgraph.prebuilt import ToolExecutor, ToolInvocation
+from langgraph.utils.runnable import RunnableCallable
 
 
 def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageModelLike,
                                         system_message: str, interrupt_before_action: bool,
                                         **kwargs):
 
-    async def _get_messages(messages):
+    def _get_messages(messages):
         msgs = []
         for m in messages:
             if isinstance(m, LiberalToolMessage):
@@ -31,6 +33,7 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
         llm_with_tools = llm.bind(tools=[format_tool_to_openai_tool(t) for t in tools])
     else:
         llm_with_tools = llm
+
     agent = _get_messages | llm_with_tools
     tool_executor = ToolExecutor(tools)
 
@@ -41,7 +44,7 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
         if 'tool_calls' not in last_message.additional_kwargs:
             if '|<instruct>|' in system_message:
                 # cohere model
-                pattern = r"Answer:(.+)\nGrounded answer"
+                pattern = r'Answer:(.+)\nGrounded answer'
                 match = re.search(pattern, last_message.content)
                 if match:
                     last_message.content = match.group(1)
@@ -51,7 +54,7 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
             return 'continue'
 
     # Define the function to execute tools
-    async def call_tool(messages):
+    async def acall_tool(messages):
         actions: list[ToolInvocation] = []
         # Based on the continue condition
         # we know the last message involves a function call
@@ -78,11 +81,38 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
         ]
         return tool_messages
 
+    def call_tool(messages):
+        actions: list[ToolInvocation] = []
+        # Based on the continue condition
+        # we know the last message involves a function call
+        last_message = messages[-1]
+        for tool_call in last_message.additional_kwargs['tool_calls']:
+            function = tool_call['function']
+            function_name = function['name']
+            _tool_input = json.loads(function['arguments'] or '{}')
+            # We construct an ToolInvocation from the function_call
+            actions.append(ToolInvocation(
+                tool=function_name,
+                tool_input=_tool_input,
+            ))
+        # We call the tool_executor and get back a response
+        responses = tool_executor.batch(actions, **kwargs)
+        # We use the response to create a ToolMessage
+        tool_messages = [
+            LiberalToolMessage(
+                tool_call_id=tool_call['id'],
+                content=response,
+                additional_kwargs={'name': tool_call['function']['name']},
+            )
+            for tool_call, response in zip(last_message.additional_kwargs['tool_calls'], responses)
+        ]
+        return tool_messages
+
     workflow = MessageGraph()
 
     # Define the two nodes we will cycle between
     workflow.add_node('agent', agent)
-    workflow.add_node('action', call_tool)
+    workflow.add_node('action', RunnableCallable(call_tool, acall_tool))
 
     # Set the entrypoint as `agent`
     # This means that this node is the first one called
@@ -116,7 +146,7 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
     # Finally, we compile it!
     # This compiles it into a LangChain Runnable,
     # meaning you can use it as you would any other runnable
-    app = workflow.compile()
+    app = workflow.compile(checkpointer=False)
     if interrupt_before_action:
         app.interrupt = ['action:inbox']
     return app

bisheng_langchain/gpts/agent_types/llm_react_agent.py

@@ -1,24 +1,20 @@
 import operator
 from typing import Annotated, Sequence, TypedDict, Union
+
+from bisheng_langchain.gpts.prompts.react_agent_prompt import react_agent_prompt
+from langchain.agents import create_structured_chat_agent
 from langchain.tools import BaseTool
 from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.messages import BaseMessage
 from langchain_core.language_models import LanguageModelLike
+from langchain_core.messages import BaseMessage
 from langgraph.graph import END, StateGraph
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.prebuilt.tool_executor import ToolExecutor
-from langgraph.utils import RunnableCallable
-from langchain.agents import create_structured_chat_agent
-from bisheng_langchain.gpts.prompts.react_agent_prompt import react_agent_prompt
+from langgraph.utils.runnable import RunnableCallable
 
 
-def get_react_agent_executor(
-    tools: list[BaseTool], 
-    llm: LanguageModelLike,
-    system_message: str, 
-    interrupt_before_action: bool,
-    **kwargs
-):
+def get_react_agent_executor(tools: list[BaseTool], llm: LanguageModelLike, system_message: str,
+                             interrupt_before_action: bool, **kwargs):
     prompt = react_agent_prompt
     prompt = prompt.partial(assistant_message=system_message)
     agent = create_structured_chat_agent(llm, tools, prompt)
@@ -56,9 +52,7 @@ def _get_agent_state(input_schema=None):
     return AgentState
 
 
-def create_agent_executor(
-    agent_runnable, tools, input_schema=None
-) -> CompiledStateGraph:
+def create_agent_executor(agent_runnable, tools, input_schema=None) -> CompiledStateGraph:
     """This is a helper function for creating a graph that works with LangChain Agents.
 
     Args:
@@ -82,65 +76,59 @@ def create_agent_executor(
     def should_continue(data):
         # If the agent outcome is an AgentFinish, then we return `exit` string
         # This will be used when setting up the graph to define the flow
-        if isinstance(data["agent_outcome"], AgentFinish):
-            return "end"
+        if isinstance(data['agent_outcome'], AgentFinish):
+            return 'end'
         # Otherwise, an AgentAction is returned
         # Here we return `continue` string
         # This will be used when setting up the graph to define the flow
         else:
-            return "continue"
+            return 'continue'
 
     def run_agent(data, config):
         agent_outcome = agent_runnable.invoke(data, config)
-        return {"agent_outcome": agent_outcome}
+        return {'agent_outcome': agent_outcome}
 
     async def arun_agent(data, config):
         agent_outcome = await agent_runnable.ainvoke(data, config)
-        return {"agent_outcome": agent_outcome}
+        return {'agent_outcome': agent_outcome}
 
     # Define the function to execute tools
     def execute_tools(data, config):
         # Get the most recent agent_outcome - this is the key added in the `agent` above
-        agent_action = data["agent_outcome"]
+        agent_action = data['agent_outcome']
         if not isinstance(agent_action, list):
             agent_action = [agent_action]
         output = tool_executor.batch(agent_action, config, return_exceptions=True)
         return {
-            "intermediate_steps": [
-                (action, str(out)) for action, out in zip(agent_action, output)
-            ]
+            'intermediate_steps': [(action, str(out)) for action, out in zip(agent_action, output)]
         }
 
     async def aexecute_tools(data, config):
         # Get the most recent agent_outcome - this is the key added in the `agent` above
-        agent_action = data["agent_outcome"]
+        agent_action = data['agent_outcome']
         if not isinstance(agent_action, list):
             agent_action = [agent_action]
-        output = await tool_executor.abatch(
-            agent_action, config, return_exceptions=True
-        )
+        output = await tool_executor.abatch(agent_action, config, return_exceptions=True)
         return {
-            "intermediate_steps": [
-                (action, str(out)) for action, out in zip(agent_action, output)
-            ]
+            'intermediate_steps': [(action, str(out)) for action, out in zip(agent_action, output)]
         }
 
     # Define a new graph
     workflow = StateGraph(state)
 
     # Define the two nodes we will cycle between
-    workflow.add_node("agent", RunnableCallable(run_agent, arun_agent))
-    workflow.add_node("tools", RunnableCallable(execute_tools, aexecute_tools))
+    workflow.add_node('agent', RunnableCallable(run_agent, arun_agent))
+    workflow.add_node('tools', RunnableCallable(execute_tools, aexecute_tools))
 
     # Set the entrypoint as `agent`
     # This means that this node is the first one called
-    workflow.set_entry_point("agent")
+    workflow.set_entry_point('agent')
 
     # We now add a conditional edge
     workflow.add_conditional_edges(
         # First, we define the start node. We use `agent`.
         # This means these are the edges taken after the `agent` node is called.
-        "agent",
+        'agent',
         # Next, we pass in the function that will determine which node is called next.
         should_continue,
         # Finally we pass in a mapping.
@@ -151,21 +139,21 @@ def create_agent_executor(
         # Based on which one it matches, that node will then be called.
         {
             # If `tools`, then we call the tool node.
-            "continue": "tools",
+            'continue': 'tools',
             # Otherwise we finish.
-            "end": END,
+            'end': END,
         },
     )
 
     # We now add a normal edge from `tools` to `agent`.
     # This means that after `tools` is called, `agent` node is called next.
-    workflow.add_edge("tools", "agent")
+    workflow.add_edge('tools', 'agent')
 
     # Finally, we compile it!
     # This compiles it into a LangChain Runnable,
     # meaning you can use it as you would any other runnable
-    return workflow.compile()
+    return workflow.compile(checkpointer=False)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     pass

bisheng_langchain/gpts/assistant.py

@@ -1,9 +1,6 @@
 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
@@ -11,7 +8,7 @@ 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.messages import AIMessage, HumanMessage
 from langchain_core.runnables import RunnableBinding
 
 logger = logging.getLogger(__name__)
@@ -38,11 +35,13 @@ class ConfigurableAssistant(RunnableBinding):
         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}')
+        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})
+        _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,
@@ -88,7 +87,7 @@ class BishengAssistant:
             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")
+                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)
@@ -98,43 +97,44 @@ class BishengAssistant:
         # init agent executor
         agent_executor_params = self.assistant_params['agent_executor']
         self.agent_executor_type = agent_executor_params.pop('type')
-        self.assistant = ConfigurableAssistant(
-            agent_executor_type=self.agent_executor_type, 
-            tools=tools, 
-            llm=llm, 
-            assistant_message=assistant_message, 
-            **agent_executor_params
-        )
+        self.assistant = ConfigurableAssistant(agent_executor_type=self.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")
-        
+            raise ValueError('chat history should be even')
+
         # 限制chat_history轮数
         if len(chat_history) > chat_round * 2:
-            chat_history = 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(AIMessage(content=chat_history[i + 1]))
         inputs.append(HumanMessage(content=query))
         if self.agent_executor_type == 'get_react_agent_executor':
-            result = asyncio.run(self.assistant.ainvoke({"input": inputs[-1].content, "chat_history": inputs[:-1]}))
+            result = asyncio.run(
+                self.assistant.ainvoke({
+                    'input': inputs[-1].content,
+                    'chat_history': inputs[:-1]
+                }))
         else:
             result = asyncio.run(self.assistant.ainvoke(inputs))
         return result
 
 
-if __name__ == "__main__":
-    from langchain.globals import set_debug
+if __name__ == '__main__':
 
     # set_debug(True)
     # chat_history = []
     # query = "分析当日市场行情"
     chat_history = ['你好', '你好，有什么可以帮助你吗？', '福蓉科技股价多少?', '福蓉科技（股票代码：300049）的当前股价为48.67元。']
     query = '今天是什么时候？去年这个时候的股价是多少？'
-    bisheng_assistant = BishengAssistant("config/base_scene.yaml")
+    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)

bisheng_langchain/gpts/tools/api_tools/base.py

@@ -29,7 +29,7 @@ class APIToolBase(BaseModel):
     headers: Dict[str, Any] = {}
     request_timeout: int = 30
     url: str = None
-    params: Dict[str, Any] = Field(default_factory=dict)
+    params: Dict[str, Any] = {}
     input_key: str = 'keyword'
     args_schema: Type[BaseModel] = ApiArg
 

bisheng_langchain/gpts/tools/api_tools/openapi.py

@@ -4,27 +4,27 @@ from langchain_core.tools import BaseTool
 from loguru import logger
 from pydantic import BaseModel, create_model
 
-from .base import APIToolBase, MultArgsSchemaTool, Field
+from .base import APIToolBase, Field, MultArgsSchemaTool
 
 
 class OpenApiTools(APIToolBase):
 
     def get_real_path(self):
-        return self.url + self.params["path"]
+        return self.url + self.params['path']
 
     def get_request_method(self):
-        return self.params["method"].lower()
+        return self.params['method'].lower()
 
     def get_params_json(self, **kwargs):
         params_define = {}
-        for one in self.params["parameters"]:
-            params_define[one["name"]] = one
+        for one in self.params['parameters']:
+            params_define[one['name']] = one
 
         params = {}
         json_data = {}
         for k, v in kwargs.items():
             if params_define.get(k):
-                if params_define[k]["in"] == "query":
+                if params_define[k]['in'] == 'query':
                     params[k] = v
                 else:
                     json_data[k] = v
@@ -33,66 +33,93 @@ class OpenApiTools(APIToolBase):
         return params, json_data
 
     def parse_args_schema(self):
-        params = self.params["parameters"]
+        params = self.params['parameters']
         model_params = {}
         for one in params:
-            field_type = one["schema"]["type"]
-            if field_type == "number":
-                field_type = "float"
-            elif field_type == "integer":
-                field_type = "int"
-            elif field_type == "string":
-                field_type = "str"
+            field_type = one['schema']['type']
+            if field_type == 'number':
+                field_type = float
+            elif field_type == 'integer':
+                field_type = int
+            elif field_type == 'string':
+                field_type = str
+            elif field_type in {'object', 'dict'}:
+                param_object_param = {}
+                for param in one['schema']['properties'].keys():
+                    field_type = one['schema']['properties'][param]['type']
+                    if field_type == 'number':
+                        field_type = float
+                    elif field_type == 'integer':
+                        field_type = int
+                    elif field_type == 'string':
+                        field_type = str
+                    param_object_param[param] = (
+                        field_type,
+                        Field(description=one['schema']['properties'][param]['description']))
+                param_model = create_model(
+                    param,
+                    __module__='bisheng_langchain.gpts.tools.api_tools.openapi',
+                    **param_object_param)
+                field_type = param_model
             else:
-                raise Exception(f"schema type is not support: {field_type}")
-            model_params[one["name"]] = (eval(field_type), Field(description=one["description"]))
-        return create_model("InputArgs", __module__='bisheng_langchain.gpts.tools.api_tools.openapi',
-                            __base__=BaseModel, **model_params)
+                raise Exception(f'schema type is not support: {field_type}')
+            model_params[one['name']] = (field_type, Field(description=one['description']))
+        return create_model('InputArgs',
+                            __module__='bisheng_langchain.gpts.tools.api_tools.openapi',
+                            __base__=BaseModel,
+                            **model_params)
 
     def run(self, **kwargs) -> str:
         """Run query through api and parse result."""
+        extra = {}
+        if 'proxy' in kwargs:
+            extra['proxy'] = kwargs.pop('proxy')
         path = self.get_real_path()
         logger.info('api_call url={}', path)
         method = self.get_request_method()
         params, json_data = self.get_params_json(**kwargs)
 
-        if method == "get":
-            resp = self.client.get(path, params=params)
+        if method == 'get':
+            resp = self.client.get(path, params=params, **extra)
         elif method == 'post':
-            resp = self.client.post(path, params=params, json=json_data)
+            resp = self.client.post(path, params=params, json=json_data, **extra)
         elif method == 'put':
-            resp = self.client.put(path, params=params, json=json_data)
+            resp = self.client.put(path, params=params, json=json_data, **extra)
         elif method == 'delete':
-            resp = self.client.delete(path, params=params, json=json_data)
+            resp = self.client.delete(path, params=params, json=json_data, **extra)
         else:
-            raise Exception(f"http method is not support: {method}")
+            raise Exception(f'http method is not support: {method}')
         if resp.status_code != 200:
             logger.info(f'api_call_fail code={resp.status_code} res={resp.text}')
-            raise Exception(f"api_call_fail: {resp.status_code} {resp.text}")
+            raise Exception(f'api_call_fail: {resp.status_code} {resp.text}')
         return resp.text
 
     async def arun(self, **kwargs) -> str:
         """Run query through api and parse result."""
+        extra = {}
+        if 'proxy' in kwargs:
+            extra['proxy'] = kwargs.pop('proxy')
+
         path = self.get_real_path()
         logger.info('api_call url={}', path)
         method = self.get_request_method()
         params, json_data = self.get_params_json(**kwargs)
 
-        if method == "get":
-            resp = await self.async_client.aget(path, params=params)
+        if method == 'get':
+            resp = await self.async_client.aget(path, params=params, **extra)
         elif method == 'post':
-            resp = await self.async_client.apost(path, params=params, json=json_data)
+            resp = await self.async_client.apost(path, params=params, json=json_data, **extra)
         elif method == 'put':
-            resp = await self.async_client.aput(path, params=params, json=json_data)
+            resp = await self.async_client.aput(path, params=params, json=json_data, **extra)
         elif method == 'delete':
-            resp = await self.async_client.adelete(path, params=params, json=json_data)
+            resp = await self.async_client.adelete(path, params=params, json=json_data, **extra)
         else:
-            raise Exception(f"http method is not support: {method}")
+            raise Exception(f'http method is not support: {method}')
         return resp
 
     @classmethod
     def get_api_tool(cls, name, **kwargs: Any) -> BaseTool:
-        description = kwargs.pop("description", "")
+        description = kwargs.pop('description', '')
         obj = cls(**kwargs)
         return MultArgsSchemaTool(name=name,
                                   description=description,