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

bisheng_langchain/agents/llm_functions_agent/base.py

@@ -8,7 +8,6 @@ from bisheng_langchain.chat_models.proxy_llm import ProxyChatLLM
 from langchain.agents import BaseSingleActionAgent
 from langchain.callbacks.base import BaseCallbackManager
 from langchain.callbacks.manager import Callbacks
-from langchain.chat_models.openai import ChatOpenAI
 from langchain.prompts.chat import (BaseMessagePromptTemplate, ChatPromptTemplate,
                                     HumanMessagePromptTemplate, MessagesPlaceholder)
 from langchain.schema import AgentAction, AgentFinish, BasePromptTemplate, OutputParserException
@@ -18,6 +17,7 @@ from langchain.tools import BaseTool
 from langchain.tools.convert_to_openai import format_tool_to_openai_function
 from langchain_core.agents import AgentActionMessageLog
 from langchain_core.pydantic_v1 import root_validator
+from langchain_openai import ChatOpenAI
 
 
 def _convert_agent_action_to_messages(agent_action: AgentAction,

bisheng_langchain/chains/__init__.py

@@ -4,10 +4,11 @@ from bisheng_langchain.chains.conversational_retrieval.base import Conversationa
 from bisheng_langchain.chains.retrieval.retrieval_chain import RetrievalChain
 from bisheng_langchain.chains.router.multi_rule import MultiRuleChain
 from bisheng_langchain.chains.router.rule_router import RuleBasedRouter
+from bisheng_langchain.chains.transform import TransformChain
 
 from .loader_output import LoaderOutputChain
 
 __all__ = [
     'StuffDocumentsChain', 'LoaderOutputChain', 'AutoGenChain', 'RuleBasedRouter',
-    'MultiRuleChain', 'RetrievalChain', 'ConversationalRetrievalChain'
+    'MultiRuleChain', 'RetrievalChain', 'ConversationalRetrievalChain', 'TransformChain'
 ]

bisheng_langchain/chains/transform.py

@@ -0,0 +1,85 @@
+"""Chain that runs an arbitrary python function."""
+import functools
+import inspect
+import logging
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+from langchain.chains.base import Chain
+from langchain_core.callbacks import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun
+from langchain_core.pydantic_v1 import Field
+
+logger = logging.getLogger(__name__)
+
+
+class TransformChain(Chain):
+    """Chain that transforms the chain output.
+
+    Example:
+        .. code-block:: python
+
+            from langchain.chains import TransformChain
+            transform_chain = TransformChain(input_variables=["text"],
+             output_variables["entities"], transform=func())
+    """
+
+    input_variables: List[str]
+    """The keys expected by the transform's input dictionary."""
+    output_variables: List[str]
+    """The keys returned by the transform's output dictionary."""
+    transform_cb: Callable[[Dict[str, str]], Dict[str, str]] = Field(alias='transform')
+    """The transform function."""
+    atransform_cb: Optional[Callable[[Dict[str, Any]],
+                                     Awaitable[Dict[str, Any]]]] = Field(None, alias='atransform')
+    """The async coroutine transform function."""
+
+    @staticmethod
+    @functools.lru_cache
+    def _log_once(msg: str) -> None:
+        """Log a message once.
+
+        :meta private:
+        """
+        logger.warning(msg)
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Expect input keys.
+
+        :meta private:
+        """
+        return self.input_variables
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Return output keys.
+
+        :meta private:
+        """
+        return self.output_variables
+
+    def _call(
+        self,
+        inputs: Dict[str, str],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Dict[str, str]:
+        new_arg_supported = inspect.signature(self.transform_cb).parameters.get('run_manager')
+        if new_arg_supported:
+            return self.transform_cb(inputs, run_manager)
+        else:
+            return self.transform_cb(inputs)
+
+    async def _acall(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
+    ) -> Dict[str, Any]:
+        if self.atransform_cb is not None:
+            new_arg_supported = inspect.signature(self.transform_cb).parameters.get('run_manager')
+            if new_arg_supported:
+                return await self.atransform_cb(inputs, run_manager)
+            else:
+                return await self.atransform_cb(inputs)
+        else:
+            self._log_once("TransformChain's atransform is not provided, falling"
+                           ' back to synchronous transform')
+            return self._call(inputs, run_manager)

bisheng_langchain/chat_models/host_llm.py

@@ -200,6 +200,7 @@ class BaseHostChatLLM(BaseChatModel):
             max_tokens = kwargs.get('max_tokens')
             do_sample = kwargs.get('do_sample')
             params = {
+                'stream': False,
                 'messages': messages,
                 'model': self.model_name,
                 'top_p': top_p,
@@ -285,6 +286,7 @@ class BaseHostChatLLM(BaseChatModel):
             except Exception as e:
                 raise ValueError(f'exception in host llm infer: [{e}]') from e
 
+        text_haf = ''
         async for response in _acompletion_with_retry(**kwargs):
             is_error = False
             if response:
@@ -292,10 +294,19 @@ class BaseHostChatLLM(BaseChatModel):
                     is_error = True
                 elif response.startswith('data:'):
                     text = response[len('data:'):].strip()
-                    if text.startswith('{'):
-                        yield (is_error, response[len('data:'):])
-                    else:
-                        logger.info('agenerate_no_json text=%s', text)
+                    if text == '[DONE]':
+                        break
+                    try:
+                        json.loads(text_haf + text)
+                        yield (is_error, text_haf + text)
+                        text_haf = ''
+                    except Exception:
+                        # 拆包了
+                        if text_haf.startswith('{'):
+                            text_haf = text
+                            continue
+                        logger.error(f'response_not_json response={response}')
+
                     if is_error:
                         break
                 elif response.startswith('{'):
@@ -521,6 +532,7 @@ class HostQwen1_5Chat(BaseHostChatLLM):
         """Return type of chat model."""
         return 'qwen1.5_chat'
 
+
 class HostLlama2Chat(BaseHostChatLLM):
     # Llama-2-7b-chat-hf, Llama-2-13b-chat-hf, Llama-2-70b-chat-hf
     model_name: str = Field('Llama-2-7b-chat-hf', alias='model')
@@ -549,6 +561,7 @@ class CustomLLMChat(BaseHostChatLLM):
         """Return type of chat model."""
         return 'custom_llm_chat'
 
+
 class HostYuanChat(BaseHostChatLLM):
     # use custom llm chat api, api should compatiable with openai definition
     model_name: str = Field('Yuan2-2B-Janus-hf', alias='model')
@@ -562,7 +575,8 @@ class HostYuanChat(BaseHostChatLLM):
     def _llm_type(self) -> str:
         """Return type of chat model."""
         return 'yuan2'
-    
+
+
 class HostYiChat(BaseHostChatLLM):
     # use custom llm chat api, api should compatiable with openai definition
     model_name: str = Field('Yi-34B-Chat', alias='model')

bisheng_langchain/chat_models/qwen.py

@@ -13,7 +13,7 @@ from langchain.callbacks.manager import AsyncCallbackManagerForLLMRun, CallbackM
 from langchain.chat_models.base import BaseChatModel
 from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
-                                       HumanMessage, SystemMessage)
+                                       HumanMessage, SystemMessage, ToolMessage)
 from langchain.utils import get_from_dict_or_env
 from langchain_core.pydantic_v1 import Field, root_validator
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
@@ -60,11 +60,24 @@ def _convert_dict_to_message(_dict: Mapping[str, Any]) -> BaseMessage:
             additional_kwargs = {'function_call': dict(_dict['function_call'])}
         else:
             additional_kwargs = {}
+        if _dict.get("tool_calls"):
+            additional_kwargs = {'tool_calls': _dict['tool_calls']}
+        else:
+            additional_kwargs = {}
         return AIMessage(content=content, additional_kwargs=additional_kwargs)
     elif role == 'system':
         return SystemMessage(content=_dict['content'])
     elif role == 'function':
         return FunctionMessage(content=_dict['content'], name=_dict['name'])
+    elif role == "tool":
+        additional_kwargs = {}
+        if "name" in _dict:
+            additional_kwargs["name"] = _dict["name"]
+        return ToolMessage(
+            content=_dict.get("content", ""),
+            tool_call_id=_dict.get("tool_call_id"),
+            additional_kwargs=additional_kwargs,
+        )
     else:
         return ChatMessage(content=_dict['content'], role=role)
 
@@ -78,6 +91,8 @@ def _convert_message_to_dict(message: BaseMessage) -> dict:
         message_dict = {'role': 'assistant', 'content': message.content}
         if 'function_call' in message.additional_kwargs:
             message_dict['function_call'] = message.additional_kwargs['function_call']
+        if "tool_calls" in message.additional_kwargs:
+            message_dict["tool_calls"] = message.additional_kwargs["tool_calls"]
     elif isinstance(message, SystemMessage):
         message_dict = {'role': 'system', 'content': message.content}
     elif isinstance(message, FunctionMessage):
@@ -86,6 +101,12 @@ def _convert_message_to_dict(message: BaseMessage) -> dict:
             'content': message.content,
             'name': message.name,
         }
+    elif isinstance(message, ToolMessage):
+        message_dict = {
+            "role": "tool",
+            "content": message.content,
+            "tool_call_id": message.tool_call_id,
+        }
     else:
         raise ValueError(f'Got unknown type {message}')
     if 'name' in message.additional_kwargs:
@@ -281,7 +302,7 @@ class ChatQWen(BaseChatModel):
             inner_completion = ''
             role = 'assistant'
             params['stream'] = True
-            function_call: Optional[dict] = None
+            tool_calls: Optional[list[dict]] = None
             async for is_error, stream_resp in self.acompletion_with_retry(messages=message_dicts,
                                                                            **params):
                 output = None
@@ -297,18 +318,18 @@ class ChatQWen(BaseChatModel):
                         role = choice['message'].get('role', role)
                         token = choice['message'].get('content', '')
                         inner_completion += token or ''
-                        _function_call = choice['message'].get('function_call')
+                        _tool_calls = choice['message'].get('tool_calls')
                         if run_manager:
                             await run_manager.on_llm_new_token(token)
-                        if _function_call:
-                            if function_call is None:
-                                function_call = _function_call
+                        if _tool_calls:
+                            if tool_calls is None:
+                                tool_calls = _tool_calls
                             else:
-                                function_call['arguments'] += _function_call['arguments']
+                                tool_calls[0]['arguments'] += _tool_calls[0]['arguments']
             message = _convert_dict_to_message({
                 'content': inner_completion,
                 'role': role,
-                'function_call': function_call,
+                'tool_calls': tool_calls,
             })
             return ChatResult(generations=[ChatGeneration(message=message)])
         else:

bisheng_langchain/document_loaders/custom_kv.py

@@ -164,7 +164,7 @@ class CustomKVLoader(BaseLoader):
                 raise Exception('custom_kv parse_error')
         else:
             logger.error(f'custom_kv=create_task resp={resp.text}')
-            raise Exception('custom_kv create task file')
+            raise Exception('custom_kv create task fail')
         content = json.dumps(document_result)
         doc = Document(page_content=content)
         return [doc]

bisheng_langchain/embeddings/host_embedding.py

@@ -6,7 +6,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import requests
 from langchain.embeddings.base import Embeddings
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import BaseModel, Extra, Field, root_validator
+from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -64,11 +64,6 @@ class HostEmbeddings(BaseModel, Embeddings):
 
     url_ep: Optional[str] = None
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
@@ -108,12 +103,14 @@ class HostEmbeddings(BaseModel, Embeddings):
         len_text = len(texts)
         while start_index < len_text:
             inp_local = {
-                'texts':texts[start_index:min(start_index + max_text_to_split, len_text)],
-                'model':self.model,
-                'type':emb_type
-                }
+                'texts': texts[start_index:min(start_index + max_text_to_split, len_text)],
+                'model': self.model,
+                'type': emb_type
+            }
             try:
-                outp_single = self.client(url=self.url_ep, json=inp_local, timeout=self.request_timeout).json()
+                outp_single = self.client(url=self.url_ep,
+                                          json=inp_local,
+                                          timeout=self.request_timeout).json()
                 if outp is None:
                     outp = outp_single
                 else:
@@ -162,6 +159,7 @@ class JINAEmbedding(HostEmbeddings):
     model: str = 'jina'
     embedding_ctx_length: int = 512
 
+
 class CustomHostEmbedding(HostEmbeddings):
     model: str = Field('custom-embedding', alias='model')
     embedding_ctx_length: int = 512

bisheng_langchain/gpts/agent_types/__init__.py

@@ -0,0 +1,10 @@
+from bisheng_langchain.gpts.agent_types.llm_functions_agent import (
+    get_openai_functions_agent_executor, 
+    get_qwen_local_functions_agent_executor
+)
+
+
+__all__ = [
+    "get_openai_functions_agent_executor",
+    "get_qwen_local_functions_agent_executor"
+]

bisheng_langchain/gpts/agent_types/llm_functions_agent.py

@@ -0,0 +1,220 @@
+import json
+
+from bisheng_langchain.gpts.message_types import LiberalFunctionMessage, LiberalToolMessage
+from langchain.tools import BaseTool
+from langchain.tools.render import format_tool_to_openai_tool
+from langchain_core.language_models.base import LanguageModelLike
+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
+
+
+def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageModelLike,
+                                        system_message: str, interrupt_before_action: bool,
+                                        **kwargs):
+
+    async def _get_messages(messages):
+        msgs = []
+        for m in messages:
+            if isinstance(m, LiberalToolMessage):
+                _dict = m.dict()
+                _dict['content'] = str(_dict['content'])
+                m_c = ToolMessage(**_dict)
+                msgs.append(m_c)
+            else:
+                msgs.append(m)
+
+        return [SystemMessage(content=system_message)] + msgs
+
+    if tools:
+        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)
+
+    # Define the function that determines whether to continue or not
+    def should_continue(messages):
+        last_message = messages[-1]
+        # If there is no function call, then we finish
+        if 'tool_calls' not in last_message.additional_kwargs:
+            return 'end'
+        # Otherwise if there is, we continue
+        else:
+            return 'continue'
+
+    # Define the function to execute tools
+    async 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 = await tool_executor.abatch(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)
+
+    # Set the entrypoint as `agent`
+    # This means that this node is the first one called
+    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',
+        # Next, we pass in the function that will determine which node is called next.
+        should_continue,
+        # Finally we pass in a mapping.
+        # The keys are strings, and the values are other nodes.
+        # END is a special node marking that the graph should finish.
+        # What will happen is we will call `should_continue`, and then the output of that
+        # will be matched against the keys in this mapping.
+        # Based on which one it matches, that node will then be called.
+        {
+            # If `tools`, then we call the tool node.
+            'continue': 'action',
+            # Otherwise we finish.
+            '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('action', 'agent')
+
+    # 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()
+    if interrupt_before_action:
+        app.interrupt = ['action:inbox']
+    return app
+
+
+def get_qwen_local_functions_agent_executor(
+    tools: list[BaseTool],
+    llm: LanguageModelLike,
+    system_message: str,
+    interrupt_before_action: bool,
+    **kwargs,
+):
+
+    async def _get_messages(messages):
+        msgs = []
+        for m in messages:
+            if isinstance(m, LiberalFunctionMessage):
+                _dict = m.dict()
+                _dict['content'] = str(_dict['content'])
+                m_c = FunctionMessage(**_dict)
+                msgs.append(m_c)
+            else:
+                msgs.append(m)
+
+        return [SystemMessage(content=system_message)] + msgs
+
+    if tools:
+        llm_with_tools = llm.bind(
+            functions=[format_tool_to_openai_tool(t)['function'] for t in tools])
+    else:
+        llm_with_tools = llm
+    agent = _get_messages | llm_with_tools
+    tool_executor = ToolExecutor(tools)
+
+    # Define the function that determines whether to continue or not
+    def should_continue(messages):
+        last_message = messages[-1]
+        # If there is no function call, then we finish
+        if 'function_call' not in last_message.additional_kwargs:
+            return 'end'
+        # Otherwise if there is, we continue
+        else:
+            return 'continue'
+
+    # Define the function to execute tools
+    async 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]
+        # only one function
+        function = last_message.additional_kwargs['function_call']
+        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 = await tool_executor.abatch(actions, **kwargs)
+        # We use the response to create a ToolMessage
+        tool_messages = [LiberalFunctionMessage(content=responses[0], name=function_name)]
+        return tool_messages
+
+    workflow = MessageGraph()
+
+    # Define the two nodes we will cycle between
+    workflow.add_node('agent', agent)
+    workflow.add_node('action', call_tool)
+
+    # Set the entrypoint as `agent`
+    # This means that this node is the first one called
+    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',
+        # Next, we pass in the function that will determine which node is called next.
+        should_continue,
+        # Finally we pass in a mapping.
+        # The keys are strings, and the values are other nodes.
+        # END is a special node marking that the graph should finish.
+        # What will happen is we will call `should_continue`, and then the output of that
+        # will be matched against the keys in this mapping.
+        # Based on which one it matches, that node will then be called.
+        {
+            # If `tools`, then we call the tool node.
+            'continue': 'action',
+            # Otherwise we finish.
+            '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('action', 'agent')
+
+    # 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()
+    if interrupt_before_action:
+        app.interrupt = ['action:inbox']
+    return app