langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/agents/initialize.py

@@ -1,5 +1,6 @@
 """Load agent."""
 
+import contextlib
 from collections.abc import Sequence
 from typing import Any, Optional
 
@@ -59,35 +60,42 @@ def initialize_agent(
     if agent is None and agent_path is None:
         agent = AgentType.ZERO_SHOT_REACT_DESCRIPTION
     if agent is not None and agent_path is not None:
-        raise ValueError(
+        msg = (
             "Both `agent` and `agent_path` are specified, "
             "but at most only one should be."
         )
+        raise ValueError(msg)
     if agent is not None:
         if agent not in AGENT_TO_CLASS:
-            raise ValueError(
+            msg = (
                 f"Got unknown agent type: {agent}. "
                 f"Valid types are: {AGENT_TO_CLASS.keys()}."
             )
+            raise ValueError(msg)
         tags_.append(agent.value if isinstance(agent, AgentType) else agent)
         agent_cls = AGENT_TO_CLASS[agent]
         agent_kwargs = agent_kwargs or {}
         agent_obj = agent_cls.from_llm_and_tools(
-            llm, tools, callback_manager=callback_manager, **agent_kwargs
+            llm,
+            tools,
+            callback_manager=callback_manager,
+            **agent_kwargs,
         )
     elif agent_path is not None:
         agent_obj = load_agent(
-            agent_path, llm=llm, tools=tools, callback_manager=callback_manager
+            agent_path,
+            llm=llm,
+            tools=tools,
+            callback_manager=callback_manager,
         )
-        try:
+        with contextlib.suppress(NotImplementedError):
             # TODO: Add tags from the serialized object directly.
-            tags_.append(agent_obj._agent_type)
-        except NotImplementedError:
-            pass
+            tags_.append(agent_obj._agent_type)  # noqa: SLF001
     else:
-        raise ValueError(
+        msg = (
             "Somehow both `agent` and `agent_path` are None, this should never happen."
         )
+        raise ValueError(msg)
     return AgentExecutor.from_agent_and_tools(
         agent=agent_obj,
         tools=tools,

langchain/agents/json_chat/base.py

@@ -16,7 +16,7 @@ def create_json_chat_agent(
     llm: BaseLanguageModel,
     tools: Sequence[BaseTool],
     prompt: ChatPromptTemplate,
-    stop_sequence: Union[bool, list[str]] = True,
+    stop_sequence: Union[bool, list[str]] = True,  # noqa: FBT001,FBT002
     tools_renderer: ToolsRenderer = render_text_description,
     template_tool_response: str = TEMPLATE_TOOL_RESPONSE,
 ) -> Runnable:
@@ -27,10 +27,10 @@ def create_json_chat_agent(
         tools: Tools this agent has access to.
         prompt: The prompt to use. See Prompt section below for more.
         stop_sequence: bool or list of str.
-            If True, adds a stop token of "Observation:" to avoid hallucinates. 
+            If True, adds a stop token of "Observation:" to avoid hallucinates.
             If False, does not add a stop token.
             If a list of str, uses the provided list as the stop tokens.
-            
+
             Default is True. You may to set this to False if the LLM you are using
             does not support stop sequences.
         tools_renderer: This controls how the tools are converted into a string and
@@ -43,7 +43,7 @@ def create_json_chat_agent(
         A Runnable sequence representing an agent. It takes as input all the same input
         variables as the prompt passed in does. It returns as output either an
         AgentAction or AgentFinish.
-        
+
     Raises:
         ValueError: If the prompt is missing required variables.
         ValueError: If the template_tool_response is missing
@@ -79,18 +79,18 @@ def create_json_chat_agent(
             )
 
     Prompt:
-    
+
         The prompt must have input keys:
             * `tools`: contains descriptions and arguments for each tool.
             * `tool_names`: contains all tool names.
             * `agent_scratchpad`: must be a MessagesPlaceholder. Contains previous agent actions and tool outputs as messages.
-        
+
         Here's an example:
 
         .. code-block:: python
 
             from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-            
+
             system = '''Assistant is a large language model trained by OpenAI.
 
             Assistant is designed to be able to assist with a wide range of tasks, from answering \
@@ -110,7 +110,7 @@ def create_json_chat_agent(
             and provide valuable insights and information on a wide range of topics. Whether \
             you need help with a specific question or just want to have a conversation about \
             a particular topic, Assistant is here to assist.'''
-            
+
             human = '''TOOLS
             ------
             Assistant can ask the user to use tools to look up information that may be helpful in \
@@ -151,7 +151,7 @@ def create_json_chat_agent(
             blob with a single action, and NOTHING else):
 
             {input}'''
-            
+
             prompt = ChatPromptTemplate.from_messages(
                 [
                     ("system", system),
@@ -160,17 +160,18 @@ def create_json_chat_agent(
                     MessagesPlaceholder("agent_scratchpad"),
                 ]
             )
+
     """  # noqa: E501
     missing_vars = {"tools", "tool_names", "agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables)
+        prompt.input_variables + list(prompt.partial_variables),
     )
     if missing_vars:
-        raise ValueError(f"Prompt missing required variables: {missing_vars}")
+        msg = f"Prompt missing required variables: {missing_vars}"
+        raise ValueError(msg)
 
     if "{observation}" not in template_tool_response:
-        raise ValueError(
-            "Template tool response missing required variable 'observation'"
-        )
+        msg = "Template tool response missing required variable 'observation'"
+        raise ValueError(msg)
 
     prompt = prompt.partial(
         tools=tools_renderer(list(tools)),
@@ -182,14 +183,14 @@ def create_json_chat_agent(
     else:
         llm_to_use = llm
 
-    agent = (
+    return (
         RunnablePassthrough.assign(
             agent_scratchpad=lambda x: format_log_to_messages(
-                x["intermediate_steps"], template_tool_response=template_tool_response
-            )
+                x["intermediate_steps"],
+                template_tool_response=template_tool_response,
+            ),
         )
         | prompt
         | llm_to_use
         | JSONAgentOutputParser()
     )
-    return agent

langchain/agents/json_chat/prompt.py

@@ -1,9 +1,8 @@
-# flake8: noqa
-TEMPLATE_TOOL_RESPONSE = """TOOL RESPONSE: 
+TEMPLATE_TOOL_RESPONSE = """TOOL RESPONSE:
 ---------------------
 {observation}
 
 USER'S INPUT
 --------------------
 
-Okay, so what is the response to my last comment? If using information obtained from the tools you must mention it explicitly without mentioning the tool names - I have forgotten all TOOL RESPONSES! Remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else - even if you just want to respond to the user. Do NOT respond with anything except a JSON snippet no matter what!"""
+Okay, so what is the response to my last comment? If using information obtained from the tools you must mention it explicitly without mentioning the tool names - I have forgotten all TOOL RESPONSES! Remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else - even if you just want to respond to the user. Do NOT respond with anything except a JSON snippet no matter what!"""  # noqa: E501

langchain/agents/load_tools.py

@@ -3,7 +3,8 @@ from typing import Any
 from langchain._api import create_importer
 
 _importer = create_importer(
-    __package__, fallback_module="langchain_community.agent_toolkits.load_tools"
+    __package__,
+    fallback_module="langchain_community.agent_toolkits.load_tools",
 )
 
 

langchain/agents/loading.py

@@ -20,11 +20,15 @@ URL_BASE = "https://raw.githubusercontent.com/hwchase17/langchain-hub/master/age
 
 
 def _load_agent_from_tools(
-    config: dict, llm: BaseLanguageModel, tools: list[Tool], **kwargs: Any
+    config: dict,
+    llm: BaseLanguageModel,
+    tools: list[Tool],
+    **kwargs: Any,
 ) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     config_type = config.pop("_type")
     if config_type not in AGENT_TO_CLASS:
-        raise ValueError(f"Loading {config_type} agent not supported")
+        msg = f"Loading {config_type} agent not supported"
+        raise ValueError(msg)
 
     agent_cls = AGENT_TO_CLASS[config_type]
     combined_config = {**config, **kwargs}
@@ -53,23 +57,27 @@ def load_agent_from_config(
         ValueError: If agent type is not specified in the config.
     """
     if "_type" not in config:
-        raise ValueError("Must specify an agent Type in config")
+        msg = "Must specify an agent Type in config"
+        raise ValueError(msg)
     load_from_tools = config.pop("load_from_llm_and_tools", False)
     if load_from_tools:
         if llm is None:
-            raise ValueError(
+            msg = (
                 "If `load_from_llm_and_tools` is set to True, then LLM must be provided"
             )
+            raise ValueError(msg)
         if tools is None:
-            raise ValueError(
+            msg = (
                 "If `load_from_llm_and_tools` is set to True, "
                 "then tools must be provided"
             )
+            raise ValueError(msg)
         return _load_agent_from_tools(config, llm, tools, **kwargs)
     config_type = config.pop("_type")
 
     if config_type not in AGENT_TO_CLASS:
-        raise ValueError(f"Loading {config_type} agent not supported")
+        msg = f"Loading {config_type} agent not supported"
+        raise ValueError(msg)
 
     agent_cls = AGENT_TO_CLASS[config_type]
     if "llm_chain" in config:
@@ -77,11 +85,12 @@ def load_agent_from_config(
     elif "llm_chain_path" in config:
         config["llm_chain"] = load_chain(config.pop("llm_chain_path"))
     else:
-        raise ValueError("One of `llm_chain` and `llm_chain_path` should be specified.")
+        msg = "One of `llm_chain` and `llm_chain_path` should be specified."
+        raise ValueError(msg)
     if "output_parser" in config:
         logger.warning(
             "Currently loading output parsers on agent is not supported, "
-            "will just use the default one."
+            "will just use the default one.",
         )
         del config["output_parser"]
 
@@ -91,7 +100,8 @@ def load_agent_from_config(
 
 @deprecated("0.1.0", removal="1.0")
 def load_agent(
-    path: Union[str, Path], **kwargs: Any
+    path: Union[str, Path],
+    **kwargs: Any,
 ) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     """Unified method for loading an agent from LangChainHub or local fs.
 
@@ -107,32 +117,32 @@ def load_agent(
             Hub is attempted.
     """
     if isinstance(path, str) and path.startswith("lc://"):
-        raise RuntimeError(
+        msg = (
             "Loading from the deprecated github-based Hub is no longer supported. "
             "Please use the new LangChain Hub at https://smith.langchain.com/hub "
             "instead."
         )
+        raise RuntimeError(msg)
     return _load_agent_from_file(path, **kwargs)
 
 
 def _load_agent_from_file(
-    file: Union[str, Path], **kwargs: Any
+    file: Union[str, Path],
+    **kwargs: Any,
 ) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     """Load agent from file."""
     valid_suffixes = {"json", "yaml"}
     # Convert file to Path object.
-    if isinstance(file, str):
-        file_path = Path(file)
-    else:
-        file_path = file
+    file_path = Path(file) if isinstance(file, str) else file
     # Load from either json or yaml.
     if file_path.suffix[1:] == "json":
-        with open(file_path) as f:
+        with file_path.open() as f:
             config = json.load(f)
     elif file_path.suffix[1:] == "yaml":
-        with open(file_path) as f:
+        with file_path.open() as f:
             config = yaml.safe_load(f)
     else:
-        raise ValueError(f"Unsupported file type, must be one of {valid_suffixes}.")
+        msg = f"Unsupported file type, must be one of {valid_suffixes}."
+        raise ValueError(msg)
     # Load the agent from the config now.
     return load_agent_from_config(config, **kwargs)

langchain/agents/mrkl/base.py

@@ -12,6 +12,7 @@ from langchain_core.prompts import PromptTemplate
 from langchain_core.tools import BaseTool, Tool
 from langchain_core.tools.render import render_text_description
 from pydantic import Field
+from typing_extensions import override
 
 from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
 from langchain.agents.agent import Agent, AgentExecutor, AgentOutputParser
@@ -51,6 +52,7 @@ class ZeroShotAgent(Agent):
     output_parser: AgentOutputParser = Field(default_factory=MRKLOutputParser)
 
     @classmethod
+    @override
     def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
         return MRKLOutputParser()
 
@@ -104,7 +106,7 @@ class ZeroShotAgent(Agent):
         tool_strings = render_text_description(list(tools))
         tool_names = ", ".join([tool.name for tool in tools])
         format_instructions = format_instructions.format(tool_names=tool_names)
-        template = "\n\n".join([prefix, tool_strings, format_instructions, suffix])
+        template = f"{prefix}\n\n{tool_strings}\n\n{format_instructions}\n\n{suffix}"
         if input_variables:
             return PromptTemplate(template=template, input_variables=input_variables)
         return PromptTemplate.from_template(template)
@@ -162,15 +164,17 @@ class ZeroShotAgent(Agent):
     def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
         validate_tools_single_input(cls.__name__, tools)
         if len(tools) == 0:
-            raise ValueError(
+            msg = (
                 f"Got no tools for {cls.__name__}. At least one tool must be provided."
             )
+            raise ValueError(msg)
         for tool in tools:
             if tool.description is None:
-                raise ValueError(
+                msg = (
                     f"Got a tool {tool.name} without a description. For this agent, "
                     f"a description must always be provided."
                 )
+                raise ValueError(msg)
         super()._validate_tools(tools)
 
 
@@ -184,7 +188,10 @@ class MRKLChain(AgentExecutor):
 
     @classmethod
     def from_chains(
-        cls, llm: BaseLanguageModel, chains: list[ChainConfig], **kwargs: Any
+        cls,
+        llm: BaseLanguageModel,
+        chains: list[ChainConfig],
+        **kwargs: Any,
     ) -> AgentExecutor:
         """User-friendly way to initialize the MRKL chain.
 

langchain/agents/mrkl/output_parser.py

@@ -53,12 +53,11 @@ class MRKLOutputParser(AgentOutputParser):
                 start_index = text.find(FINAL_ANSWER_ACTION) + len(FINAL_ANSWER_ACTION)
                 end_index = text.find("\n\n", start_index)
                 return AgentFinish(
-                    {"output": text[start_index:end_index].strip()}, text[:end_index]
-                )
-            else:
-                raise OutputParserException(
-                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+                    {"output": text[start_index:end_index].strip()},
+                    text[:end_index],
                 )
+            msg = f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+            raise OutputParserException(msg)
 
         if action_match:
             action = action_match.group(1).strip()
@@ -70,29 +69,34 @@ class MRKLOutputParser(AgentOutputParser):
 
             return AgentAction(action, tool_input, text)
 
-        elif includes_answer:
+        if includes_answer:
             return AgentFinish(
-                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()}, text
+                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()},
+                text,
             )
 
         if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            msg = f"Could not parse LLM output: `{text}`"
             raise OutputParserException(
-                f"Could not parse LLM output: `{text}`",
+                msg,
                 observation=MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
                 llm_output=text,
                 send_to_llm=True,
             )
-        elif not re.search(
-            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        if not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)",
+            text,
+            re.DOTALL,
         ):
+            msg = f"Could not parse LLM output: `{text}`"
             raise OutputParserException(
-                f"Could not parse LLM output: `{text}`",
+                msg,
                 observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
                 llm_output=text,
                 send_to_llm=True,
             )
-        else:
-            raise OutputParserException(f"Could not parse LLM output: `{text}`")
+        msg = f"Could not parse LLM output: `{text}`"
+        raise OutputParserException(msg)
 
     @property
     def _type(self) -> str:

langchain/agents/mrkl/prompt.py

@@ -1,5 +1,4 @@
-# flake8: noqa
-PREFIX = """Answer the following questions as best you can. You have access to the following tools:"""
+PREFIX = """Answer the following questions as best you can. You have access to the following tools:"""  # noqa: E501
 FORMAT_INSTRUCTIONS = """Use the following format:
 
 Question: the input question you must answer