langchain 0.3.27__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/agents/structured_chat/base.py

@@ -1,304 +0,0 @@
-import re
-from collections.abc import Sequence
-from typing import Any, Optional, Union
-
-from langchain_core._api import deprecated
-from langchain_core.agents import AgentAction
-from langchain_core.callbacks import BaseCallbackManager
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.prompts.chat import (
-    ChatPromptTemplate,
-    HumanMessagePromptTemplate,
-    SystemMessagePromptTemplate,
-)
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-from langchain_core.tools.render import ToolsRenderer
-from pydantic import Field
-
-from langchain.agents.agent import Agent, AgentOutputParser
-from langchain.agents.format_scratchpad import format_log_to_str
-from langchain.agents.output_parsers import JSONAgentOutputParser
-from langchain.agents.structured_chat.output_parser import (
-    StructuredChatOutputParserWithRetries,
-)
-from langchain.agents.structured_chat.prompt import FORMAT_INSTRUCTIONS, PREFIX, SUFFIX
-from langchain.chains.llm import LLMChain
-from langchain.tools.render import render_text_description_and_args
-
-HUMAN_MESSAGE_TEMPLATE = "{input}\n\n{agent_scratchpad}"
-
-
-@deprecated("0.1.0", alternative="create_structured_chat_agent", removal="1.0")
-class StructuredChatAgent(Agent):
-    """Structured Chat Agent."""
-
-    output_parser: AgentOutputParser = Field(
-        default_factory=StructuredChatOutputParserWithRetries,
-    )
-    """Output parser for the agent."""
-
-    @property
-    def observation_prefix(self) -> str:
-        """Prefix to append the observation with."""
-        return "Observation: "
-
-    @property
-    def llm_prefix(self) -> str:
-        """Prefix to append the llm call with."""
-        return "Thought:"
-
-    def _construct_scratchpad(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-    ) -> str:
-        agent_scratchpad = super()._construct_scratchpad(intermediate_steps)
-        if not isinstance(agent_scratchpad, str):
-            msg = "agent_scratchpad should be of type string."
-            raise ValueError(msg)  # noqa: TRY004
-        if agent_scratchpad:
-            return (
-                f"This was your previous work "
-                f"(but I haven't seen any of it! I only see what "
-                f"you return as final answer):\n{agent_scratchpad}"
-            )
-        return agent_scratchpad
-
-    @classmethod
-    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
-        pass
-
-    @classmethod
-    def _get_default_output_parser(
-        cls,
-        llm: Optional[BaseLanguageModel] = None,
-        **kwargs: Any,
-    ) -> AgentOutputParser:
-        return StructuredChatOutputParserWithRetries.from_llm(llm=llm)
-
-    @property
-    def _stop(self) -> list[str]:
-        return ["Observation:"]
-
-    @classmethod
-    def create_prompt(
-        cls,
-        tools: Sequence[BaseTool],
-        prefix: str = PREFIX,
-        suffix: str = SUFFIX,
-        human_message_template: str = HUMAN_MESSAGE_TEMPLATE,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        input_variables: Optional[list[str]] = None,
-        memory_prompts: Optional[list[BasePromptTemplate]] = None,
-    ) -> BasePromptTemplate:
-        tool_strings = []
-        for tool in tools:
-            args_schema = re.sub("}", "}}", re.sub("{", "{{", str(tool.args)))
-            tool_strings.append(f"{tool.name}: {tool.description}, args: {args_schema}")
-        formatted_tools = "\n".join(tool_strings)
-        tool_names = ", ".join([tool.name for tool in tools])
-        format_instructions = format_instructions.format(tool_names=tool_names)
-        template = f"{prefix}\n\n{formatted_tools}\n\n{format_instructions}\n\n{suffix}"
-        if input_variables is None:
-            input_variables = ["input", "agent_scratchpad"]
-        _memory_prompts = memory_prompts or []
-        messages = [
-            SystemMessagePromptTemplate.from_template(template),
-            *_memory_prompts,
-            HumanMessagePromptTemplate.from_template(human_message_template),
-        ]
-        return ChatPromptTemplate(input_variables=input_variables, messages=messages)  # type: ignore[arg-type]
-
-    @classmethod
-    def from_llm_and_tools(
-        cls,
-        llm: BaseLanguageModel,
-        tools: Sequence[BaseTool],
-        callback_manager: Optional[BaseCallbackManager] = None,
-        output_parser: Optional[AgentOutputParser] = None,
-        prefix: str = PREFIX,
-        suffix: str = SUFFIX,
-        human_message_template: str = HUMAN_MESSAGE_TEMPLATE,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        input_variables: Optional[list[str]] = None,
-        memory_prompts: Optional[list[BasePromptTemplate]] = None,
-        **kwargs: Any,
-    ) -> Agent:
-        """Construct an agent from an LLM and tools."""
-        cls._validate_tools(tools)
-        prompt = cls.create_prompt(
-            tools,
-            prefix=prefix,
-            suffix=suffix,
-            human_message_template=human_message_template,
-            format_instructions=format_instructions,
-            input_variables=input_variables,
-            memory_prompts=memory_prompts,
-        )
-        llm_chain = LLMChain(
-            llm=llm,
-            prompt=prompt,
-            callback_manager=callback_manager,
-        )
-        tool_names = [tool.name for tool in tools]
-        _output_parser = output_parser or cls._get_default_output_parser(llm=llm)
-        return cls(
-            llm_chain=llm_chain,
-            allowed_tools=tool_names,
-            output_parser=_output_parser,
-            **kwargs,
-        )
-
-    @property
-    def _agent_type(self) -> str:
-        raise ValueError
-
-
-def create_structured_chat_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    tools_renderer: ToolsRenderer = render_text_description_and_args,
-    *,
-    stop_sequence: Union[bool, list[str]] = True,
-) -> Runnable:
-    """Create an agent aimed at supporting tools with multiple inputs.
-
-    Args:
-        llm: LLM to use as the 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 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
-            then passed into the LLM. Default is `render_text_description`.
-
-    Returns:
-        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.
-
-    Examples:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.chat_models import ChatOpenAI
-            from langchain.agents import AgentExecutor, create_structured_chat_agent
-
-            prompt = hub.pull("hwchase17/structured-chat-agent")
-            model = ChatOpenAI()
-            tools = ...
-
-            agent = create_structured_chat_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-            # Using with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    "chat_history": [
-                        HumanMessage(content="hi! my name is bob"),
-                        AIMessage(content="Hello Bob! How can I assist you today?"),
-                    ],
-                }
-            )
-
-    Prompt:
-
-        The prompt must have input keys:
-            * `tools`: contains descriptions and arguments for each tool.
-            * `tool_names`: contains all tool names.
-            * `agent_scratchpad`: contains previous agent actions and tool outputs as a string.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-
-            system = '''Respond to the human as helpfully and accurately as possible. You have access to the following tools:
-
-            {tools}
-
-            Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
-
-            Valid "action" values: "Final Answer" or {tool_names}
-
-            Provide only ONE action per $JSON_BLOB, as shown:
-
-            ```
-            {{
-              "action": $TOOL_NAME,
-              "action_input": $INPUT
-            }}
-            ```
-
-            Follow this format:
-
-            Question: input question to answer
-            Thought: consider previous and subsequent steps
-            Action:
-            ```
-            $JSON_BLOB
-            ```
-            Observation: action result
-            ... (repeat Thought/Action/Observation N times)
-            Thought: I know what to respond
-            Action:
-            ```
-            {{
-              "action": "Final Answer",
-              "action_input": "Final response to human"
-            }}
-
-            Begin! Reminder to ALWAYS respond with a valid json blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB```then Observation'''
-
-            human = '''{input}
-
-            {agent_scratchpad}
-
-            (reminder to respond in a JSON blob no matter what)'''
-
-            prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", system),
-                    MessagesPlaceholder("chat_history", optional=True),
-                    ("human", human),
-                ]
-            )
-    """  # noqa: E501
-    missing_vars = {"tools", "tool_names", "agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables),
-    )
-    if missing_vars:
-        msg = f"Prompt missing required variables: {missing_vars}"
-        raise ValueError(msg)
-
-    prompt = prompt.partial(
-        tools=tools_renderer(list(tools)),
-        tool_names=", ".join([t.name for t in tools]),
-    )
-    if stop_sequence:
-        stop = ["\nObservation"] if stop_sequence is True else stop_sequence
-        llm_with_stop = llm.bind(stop=stop)
-    else:
-        llm_with_stop = llm
-
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: format_log_to_str(x["intermediate_steps"]),
-        )
-        | prompt
-        | llm_with_stop
-        | JSONAgentOutputParser()
-    )

langchain/agents/structured_chat/output_parser.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import re
-from re import Pattern
-from typing import Optional, Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from langchain_core.language_models import BaseLanguageModel
-from pydantic import Field
-
-from langchain.agents.agent import AgentOutputParser
-from langchain.agents.structured_chat.prompt import FORMAT_INSTRUCTIONS
-from langchain.output_parsers import OutputFixingParser
-
-logger = logging.getLogger(__name__)
-
-
-class StructuredChatOutputParser(AgentOutputParser):
-    """Output parser for the structured chat agent."""
-
-    format_instructions: str = FORMAT_INSTRUCTIONS
-    """Default formatting instructions"""
-
-    pattern: Pattern = re.compile(r"```(?:json\s+)?(\W.*?)```", re.DOTALL)
-    """Regex pattern to parse the output."""
-
-    def get_format_instructions(self) -> str:
-        """Returns formatting instructions for the given output parser."""
-        return self.format_instructions
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        try:
-            action_match = self.pattern.search(text)
-            if action_match is not None:
-                response = json.loads(action_match.group(1).strip(), strict=False)
-                if isinstance(response, list):
-                    # gpt turbo frequently ignores the directive to emit a single action
-                    logger.warning("Got multiple action responses: %s", response)
-                    response = response[0]
-                if response["action"] == "Final Answer":
-                    return AgentFinish({"output": response["action_input"]}, text)
-                return AgentAction(
-                    response["action"],
-                    response.get("action_input", {}),
-                    text,
-                )
-            return AgentFinish({"output": text}, text)
-        except Exception as e:
-            msg = f"Could not parse LLM output: {text}"
-            raise OutputParserException(msg) from e
-
-    @property
-    def _type(self) -> str:
-        return "structured_chat"
-
-
-class StructuredChatOutputParserWithRetries(AgentOutputParser):
-    """Output parser with retries for the structured chat agent."""
-
-    base_parser: AgentOutputParser = Field(default_factory=StructuredChatOutputParser)
-    """The base parser to use."""
-    output_fixing_parser: Optional[OutputFixingParser] = None
-    """The output fixing parser to use."""
-
-    def get_format_instructions(self) -> str:
-        return FORMAT_INSTRUCTIONS
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        try:
-            if self.output_fixing_parser is not None:
-                return self.output_fixing_parser.parse(text)
-            return self.base_parser.parse(text)
-        except Exception as e:
-            msg = f"Could not parse LLM output: {text}"
-            raise OutputParserException(msg) from e
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: Optional[BaseLanguageModel] = None,
-        base_parser: Optional[StructuredChatOutputParser] = None,
-    ) -> StructuredChatOutputParserWithRetries:
-        if llm is not None:
-            base_parser = base_parser or StructuredChatOutputParser()
-            output_fixing_parser: OutputFixingParser = OutputFixingParser.from_llm(
-                llm=llm,
-                parser=base_parser,
-            )
-            return cls(output_fixing_parser=output_fixing_parser)
-        if base_parser is not None:
-            return cls(base_parser=base_parser)
-        return cls()
-
-    @property
-    def _type(self) -> str:
-        return "structured_chat_with_retries"

langchain/agents/structured_chat/prompt.py

@@ -1,34 +0,0 @@
-PREFIX = """Respond to the human as helpfully and accurately as possible. You have access to the following tools:"""  # noqa: E501
-FORMAT_INSTRUCTIONS = """Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
-
-Valid "action" values: "Final Answer" or {tool_names}
-
-Provide only ONE action per $JSON_BLOB, as shown:
-
-```
-{{{{
-  "action": $TOOL_NAME,
-  "action_input": $INPUT
-}}}}
-```
-
-Follow this format:
-
-Question: input question to answer
-Thought: consider previous and subsequent steps
-Action:
-```
-$JSON_BLOB
-```
-Observation: action result
-... (repeat Thought/Action/Observation N times)
-Thought: I know what to respond
-Action:
-```
-{{{{
-  "action": "Final Answer",
-  "action_input": "Final response to human"
-}}}}
-```"""  # noqa: E501
-SUFFIX = """Begin! Reminder to ALWAYS respond with a valid json blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB```then Observation:.
-Thought:"""  # noqa: E501

langchain/agents/tool_calling_agent/base.py

@@ -1,110 +0,0 @@
-from collections.abc import Sequence
-from typing import Callable
-
-from langchain_core.agents import AgentAction
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.messages import BaseMessage
-from langchain_core.prompts.chat import ChatPromptTemplate
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-
-from langchain.agents.format_scratchpad.tools import (
-    format_to_tool_messages,
-)
-from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
-
-MessageFormatter = Callable[[Sequence[tuple[AgentAction, str]]], list[BaseMessage]]
-
-
-def create_tool_calling_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    *,
-    message_formatter: MessageFormatter = format_to_tool_messages,
-) -> Runnable:
-    """Create an agent that uses tools.
-
-    Args:
-        llm: LLM to use as the agent.
-        tools: Tools this agent has access to.
-        prompt: The prompt to use. See Prompt section below for more on the expected
-            input variables.
-        message_formatter: Formatter function to convert (AgentAction, tool output)
-            tuples into FunctionMessages.
-
-    Returns:
-        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.
-
-    Example:
-
-        .. code-block:: python
-
-            from langchain.agents import AgentExecutor, create_tool_calling_agent, tool
-            from langchain_anthropic import ChatAnthropic
-            from langchain_core.prompts import ChatPromptTemplate
-
-            prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are a helpful assistant"),
-                    ("placeholder", "{chat_history}"),
-                    ("human", "{input}"),
-                    ("placeholder", "{agent_scratchpad}"),
-                ]
-            )
-            model = ChatAnthropic(model="claude-3-opus-20240229")
-
-            @tool
-            def magic_function(input: int) -> int:
-                \"\"\"Applies a magic function to an input.\"\"\"
-                return input + 2
-
-            tools = [magic_function]
-
-            agent = create_tool_calling_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
-
-            agent_executor.invoke({"input": "what is the value of magic_function(3)?"})
-
-            # Using with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    "chat_history": [
-                        HumanMessage(content="hi! my name is bob"),
-                        AIMessage(content="Hello Bob! How can I assist you today?"),
-                    ],
-                }
-            )
-
-    Prompt:
-
-        The agent prompt must have an `agent_scratchpad` key that is a
-            ``MessagesPlaceholder``. Intermediate agent actions and tool output
-            messages will be passed in here.
-    """
-    missing_vars = {"agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables),
-    )
-    if missing_vars:
-        msg = f"Prompt missing required variables: {missing_vars}"
-        raise ValueError(msg)
-
-    if not hasattr(llm, "bind_tools"):
-        msg = "This function requires a bind_tools() method be implemented on the LLM."
-        raise ValueError(
-            msg,
-        )
-    llm_with_tools = llm.bind_tools(tools)
-
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: message_formatter(x["intermediate_steps"]),
-        )
-        | prompt
-        | llm_with_tools
-        | ToolsAgentOutputParser()
-    )

langchain/agents/tools.py

@@ -1,47 +0,0 @@
-"""Interface for tools."""
-
-from typing import Optional
-
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
-from langchain_core.tools import BaseTool, tool
-
-
-class InvalidTool(BaseTool):
-    """Tool that is run when invalid tool name is encountered by agent."""
-
-    name: str = "invalid_tool"
-    """Name of the tool."""
-    description: str = "Called when tool name is invalid. Suggests valid tool names."
-    """Description of the tool."""
-
-    def _run(
-        self,
-        requested_tool_name: str,
-        available_tool_names: list[str],
-        run_manager: Optional[CallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool."""
-        available_tool_names_str = ", ".join(list(available_tool_names))
-        return (
-            f"{requested_tool_name} is not a valid tool, "
-            f"try one of [{available_tool_names_str}]."
-        )
-
-    async def _arun(
-        self,
-        requested_tool_name: str,
-        available_tool_names: list[str],
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        available_tool_names_str = ", ".join(list(available_tool_names))
-        return (
-            f"{requested_tool_name} is not a valid tool, "
-            f"try one of [{available_tool_names_str}]."
-        )
-
-
-__all__ = ["InvalidTool", "tool"]

langchain/agents/types.py

@@ -1,27 +0,0 @@
-from typing import Union
-
-from langchain.agents.agent import BaseSingleActionAgent
-from langchain.agents.agent_types import AgentType
-from langchain.agents.chat.base import ChatAgent
-from langchain.agents.conversational.base import ConversationalAgent
-from langchain.agents.conversational_chat.base import ConversationalChatAgent
-from langchain.agents.mrkl.base import ZeroShotAgent
-from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
-from langchain.agents.openai_functions_multi_agent.base import OpenAIMultiFunctionsAgent
-from langchain.agents.react.base import ReActDocstoreAgent
-from langchain.agents.self_ask_with_search.base import SelfAskWithSearchAgent
-from langchain.agents.structured_chat.base import StructuredChatAgent
-
-AGENT_TYPE = Union[type[BaseSingleActionAgent], type[OpenAIMultiFunctionsAgent]]
-
-AGENT_TO_CLASS: dict[AgentType, AGENT_TYPE] = {
-    AgentType.ZERO_SHOT_REACT_DESCRIPTION: ZeroShotAgent,
-    AgentType.REACT_DOCSTORE: ReActDocstoreAgent,
-    AgentType.SELF_ASK_WITH_SEARCH: SelfAskWithSearchAgent,
-    AgentType.CONVERSATIONAL_REACT_DESCRIPTION: ConversationalAgent,
-    AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION: ChatAgent,
-    AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION: ConversationalChatAgent,
-    AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION: StructuredChatAgent,
-    AgentType.OPENAI_FUNCTIONS: OpenAIFunctionsAgent,
-    AgentType.OPENAI_MULTI_FUNCTIONS: OpenAIMultiFunctionsAgent,
-}

langchain/agents/utils.py

@@ -1,19 +0,0 @@
-from collections.abc import Sequence
-
-from langchain_core.tools import BaseTool
-
-
-def validate_tools_single_input(class_name: str, tools: Sequence[BaseTool]) -> None:
-    """Validate tools for single input.
-
-    Args:
-        class_name: Name of the class.
-        tools: List of tools to validate.
-
-    Raises:
-        ValueError: If a multi-input tool is found in tools.
-    """
-    for tool in tools:
-        if not tool.is_single_input:
-            msg = f"{class_name} does not support multi-input tool {tool.name}."
-            raise ValueError(msg)