langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/agents/format_scratchpad/__init__.py

@@ -1,25 +0,0 @@
-"""Logic for formatting intermediate steps into an agent scratchpad.
-
-Intermediate steps refers to the list of (AgentAction, observation) tuples
-that result from previous iterations of the agent.
-Depending on the prompting strategy you are using, you may want to format these
-differently before passing them into the LLM.
-"""
-
-from langchain.agents.format_scratchpad.log import format_log_to_str
-from langchain.agents.format_scratchpad.log_to_messages import format_log_to_messages
-from langchain.agents.format_scratchpad.openai_functions import (
-    format_to_openai_function_messages,
-    format_to_openai_functions,
-)
-from langchain.agents.format_scratchpad.tools import format_to_tool_messages
-from langchain.agents.format_scratchpad.xml import format_xml
-
-__all__ = [
-    "format_log_to_messages",
-    "format_log_to_str",
-    "format_to_openai_function_messages",
-    "format_to_openai_functions",
-    "format_to_tool_messages",
-    "format_xml",
-]

langchain/agents/format_scratchpad/log.py

@@ -1,25 +0,0 @@
-from langchain_core.agents import AgentAction
-
-
-def format_log_to_str(
-    intermediate_steps: list[tuple[AgentAction, str]],
-    observation_prefix: str = "Observation: ",
-    llm_prefix: str = "Thought: ",
-) -> str:
-    """Construct the scratchpad that lets the agent continue its thought process.
-
-    Args:
-        intermediate_steps: List of tuples of AgentAction and observation strings.
-        observation_prefix: Prefix to append the observation with.
-             Defaults to "Observation: ".
-        llm_prefix: Prefix to append the llm call with.
-                Defaults to "Thought: ".
-
-    Returns:
-        str: The scratchpad.
-    """
-    thoughts = ""
-    for action, observation in intermediate_steps:
-        thoughts += action.log
-        thoughts += f"\n{observation_prefix}{observation}\n{llm_prefix}"
-    return thoughts

langchain/agents/format_scratchpad/log_to_messages.py

@@ -1,26 +0,0 @@
-from langchain_core.agents import AgentAction
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
-
-
-def format_log_to_messages(
-    intermediate_steps: list[tuple[AgentAction, str]],
-    template_tool_response: str = "{observation}",
-) -> list[BaseMessage]:
-    """Construct the scratchpad that lets the agent continue its thought process.
-
-    Args:
-        intermediate_steps: List of tuples of AgentAction and observation strings.
-        template_tool_response: Template to format the observation with.
-             Defaults to "{observation}".
-
-    Returns:
-        List[BaseMessage]: The scratchpad.
-    """
-    thoughts: list[BaseMessage] = []
-    for action, observation in intermediate_steps:
-        thoughts.append(AIMessage(content=action.log))
-        human_message = HumanMessage(
-            content=template_tool_response.format(observation=observation),
-        )
-        thoughts.append(human_message)
-    return thoughts

langchain/agents/format_scratchpad/openai_functions.py

@@ -1,80 +0,0 @@
-import json
-from collections.abc import Sequence
-
-from langchain_core.agents import AgentAction, AgentActionMessageLog
-from langchain_core.messages import AIMessage, BaseMessage, FunctionMessage
-
-
-def _convert_agent_action_to_messages(
-    agent_action: AgentAction,
-    observation: str,
-) -> list[BaseMessage]:
-    """Convert an agent action to a message.
-
-    This code is used to reconstruct the original AI message from the agent action.
-
-    Args:
-        agent_action: Agent action to convert.
-
-    Returns:
-        AIMessage or the previous messages plus a FunctionMessage that corresponds to
-            the original tool invocation
-    """
-    if isinstance(agent_action, AgentActionMessageLog):
-        return [
-            *list(agent_action.message_log),
-            _create_function_message(agent_action, observation),
-        ]
-    return [AIMessage(content=agent_action.log)]
-
-
-def _create_function_message(
-    agent_action: AgentAction,
-    observation: str,
-) -> FunctionMessage:
-    """Convert agent action and observation into a function message.
-    Args:
-        agent_action: the tool invocation request from the agent.
-        observation: the result of the tool invocation.
-    Returns:
-        FunctionMessage that corresponds to the original tool invocation.
-
-    Raises:
-        ValueError: if the observation cannot be converted to a string.
-    """
-    if not isinstance(observation, str):
-        try:
-            content = json.dumps(observation, ensure_ascii=False)
-        except Exception:
-            content = str(observation)
-    else:
-        content = observation
-    return FunctionMessage(
-        name=agent_action.tool,
-        content=content,
-    )
-
-
-def format_to_openai_function_messages(
-    intermediate_steps: Sequence[tuple[AgentAction, str]],
-) -> list[BaseMessage]:
-    """Convert (AgentAction, tool output) tuples into FunctionMessages.
-
-    Args:
-        intermediate_steps: Steps the LLM has taken to date, along with observations
-
-    Returns:
-        list of messages to send to the LLM for the next prediction
-    Raises:
-        ValueError: if the observation cannot be converted to a string.
-    """
-    messages = []
-
-    for agent_action, observation in intermediate_steps:
-        messages.extend(_convert_agent_action_to_messages(agent_action, observation))
-
-    return messages
-
-
-# Backwards compatibility
-format_to_openai_functions = format_to_openai_function_messages

langchain/agents/format_scratchpad/openai_tools.py

@@ -1,5 +0,0 @@
-from langchain.agents.format_scratchpad.tools import (
-    format_to_tool_messages as format_to_openai_tool_messages,
-)
-
-__all__ = ["format_to_openai_tool_messages"]

langchain/agents/format_scratchpad/tools.py

@@ -1,65 +0,0 @@
-import json
-from collections.abc import Sequence
-
-from langchain_core.agents import AgentAction
-from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
-    ToolMessage,
-)
-
-from langchain.agents.output_parsers.tools import ToolAgentAction
-
-
-def _create_tool_message(
-    agent_action: ToolAgentAction,
-    observation: str,
-) -> ToolMessage:
-    """Convert agent action and observation into a tool message.
-
-    Args:
-        agent_action: the tool invocation request from the agent.
-        observation: the result of the tool invocation.
-    Returns:
-        ToolMessage that corresponds to the original tool invocation.
-
-    Raises:
-        ValueError: if the observation cannot be converted to a string.
-    """
-    if not isinstance(observation, str):
-        try:
-            content = json.dumps(observation, ensure_ascii=False)
-        except Exception:
-            content = str(observation)
-    else:
-        content = observation
-    return ToolMessage(
-        tool_call_id=agent_action.tool_call_id,
-        content=content,
-        additional_kwargs={"name": agent_action.tool},
-    )
-
-
-def format_to_tool_messages(
-    intermediate_steps: Sequence[tuple[AgentAction, str]],
-) -> list[BaseMessage]:
-    """Convert (AgentAction, tool output) tuples into ToolMessages.
-
-    Args:
-        intermediate_steps: Steps the LLM has taken to date, along with observations.
-
-    Returns:
-        list of messages to send to the LLM for the next prediction.
-
-    """
-    messages = []
-    for agent_action, observation in intermediate_steps:
-        if isinstance(agent_action, ToolAgentAction):
-            new_messages = [
-                *list(agent_action.message_log),
-                _create_tool_message(agent_action, observation),
-            ]
-            messages.extend([new for new in new_messages if new not in messages])
-        else:
-            messages.append(AIMessage(content=agent_action.log))
-    return messages

langchain/agents/format_scratchpad/xml.py

@@ -1,52 +0,0 @@
-from typing import Literal, Optional
-
-from langchain_core.agents import AgentAction
-
-
-def _escape(xml: str) -> str:
-    """Replace XML tags with custom safe delimiters."""
-    replacements = {
-        "<tool>": "[[tool]]",
-        "</tool>": "[[/tool]]",
-        "<tool_input>": "[[tool_input]]",
-        "</tool_input>": "[[/tool_input]]",
-        "<observation>": "[[observation]]",
-        "</observation>": "[[/observation]]",
-    }
-    for orig, repl in replacements.items():
-        xml = xml.replace(orig, repl)
-    return xml
-
-
-def format_xml(
-    intermediate_steps: list[tuple[AgentAction, str]],
-    *,
-    escape_format: Optional[Literal["minimal"]] = "minimal",
-) -> str:
-    """Format the intermediate steps as XML.
-
-    Args:
-        intermediate_steps: The intermediate steps.
-        escape_format: The escaping format to use. Currently only 'minimal' is
-            supported, which replaces XML tags with custom delimiters to prevent
-            conflicts.
-
-    Returns:
-        The intermediate steps as XML.
-    """
-    log = ""
-    for action, observation in intermediate_steps:
-        if escape_format == "minimal":
-            # Escape XML tags in tool names and inputs using custom delimiters
-            tool = _escape(action.tool)
-            tool_input = _escape(str(action.tool_input))
-            observation_ = _escape(str(observation))
-        else:
-            tool = action.tool
-            tool_input = str(action.tool_input)
-            observation_ = str(observation)
-        log += (
-            f"<tool>{tool}</tool><tool_input>{tool_input}"
-            f"</tool_input><observation>{observation_}</observation>"
-        )
-    return log

langchain/agents/initialize.py

@@ -1,105 +0,0 @@
-"""Load agent."""
-
-import contextlib
-from collections.abc import Sequence
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks import BaseCallbackManager
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.tools import BaseTool
-
-from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
-from langchain.agents.agent import AgentExecutor
-from langchain.agents.agent_types import AgentType
-from langchain.agents.loading import load_agent
-from langchain.agents.types import AGENT_TO_CLASS
-
-
-@deprecated(
-    "0.1.0",
-    message=AGENT_DEPRECATION_WARNING,
-    removal="1.0",
-)
-def initialize_agent(
-    tools: Sequence[BaseTool],
-    llm: BaseLanguageModel,
-    agent: Optional[AgentType] = None,
-    callback_manager: Optional[BaseCallbackManager] = None,
-    agent_path: Optional[str] = None,
-    agent_kwargs: Optional[dict] = None,
-    *,
-    tags: Optional[Sequence[str]] = None,
-    **kwargs: Any,
-) -> AgentExecutor:
-    """Load an agent executor given tools and LLM.
-
-    Args:
-        tools: List of tools this agent has access to.
-        llm: Language model to use as the agent.
-        agent: Agent type to use. If None and agent_path is also None, will default
-            to AgentType.ZERO_SHOT_REACT_DESCRIPTION. Defaults to None.
-        callback_manager: CallbackManager to use. Global callback manager is used if
-            not provided. Defaults to None.
-        agent_path: Path to serialized agent to use. If None and agent is also None,
-            will default to AgentType.ZERO_SHOT_REACT_DESCRIPTION. Defaults to None.
-        agent_kwargs: Additional keyword arguments to pass to the underlying agent.
-            Defaults to None.
-        tags: Tags to apply to the traced runs. Defaults to None.
-        kwargs: Additional keyword arguments passed to the agent executor.
-
-    Returns:
-        An agent executor.
-
-    Raises:
-        ValueError: If both `agent` and `agent_path` are specified.
-        ValueError: If `agent` is not a valid agent type.
-        ValueError: If both `agent` and `agent_path` are None.
-    """
-    tags_ = list(tags) if tags else []
-    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:
-        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:
-            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,
-        )
-    elif agent_path is not None:
-        agent_obj = load_agent(
-            agent_path,
-            llm=llm,
-            tools=tools,
-            callback_manager=callback_manager,
-        )
-        with contextlib.suppress(NotImplementedError):
-            # TODO: Add tags from the serialized object directly.
-            tags_.append(agent_obj._agent_type)  # noqa: SLF001
-    else:
-        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,
-        callback_manager=callback_manager,
-        tags=tags_,
-        **kwargs,
-    )

langchain/agents/json_chat/base.py

@@ -1,196 +0,0 @@
-from collections.abc import Sequence
-from typing import Union
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts.chat import ChatPromptTemplate
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-from langchain_core.tools.render import ToolsRenderer, render_text_description
-
-from langchain.agents.format_scratchpad import format_log_to_messages
-from langchain.agents.json_chat.prompt import TEMPLATE_TOOL_RESPONSE
-from langchain.agents.output_parsers import JSONAgentOutputParser
-
-
-def create_json_chat_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    stop_sequence: Union[bool, list[str]] = True,  # noqa: FBT001,FBT002
-    tools_renderer: ToolsRenderer = render_text_description,
-    template_tool_response: str = TEMPLATE_TOOL_RESPONSE,
-) -> Runnable:
-    """Create an agent that uses JSON to format its logic, build for Chat Models.
-
-    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`.
-        template_tool_response: Template prompt that uses the tool response (observation)
-            to make the LLM generate the next action to take.
-            Default is TEMPLATE_TOOL_RESPONSE.
-
-    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.
-
-    Raises:
-        ValueError: If the prompt is missing required variables.
-        ValueError: If the template_tool_response is missing
-            the required variable 'observation'.
-
-    Example:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.chat_models import ChatOpenAI
-            from langchain.agents import AgentExecutor, create_json_chat_agent
-
-            prompt = hub.pull("hwchase17/react-chat-json")
-            model = ChatOpenAI()
-            tools = ...
-
-            agent = create_json_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`: 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 \
-            simple questions to providing in-depth explanations and discussions on a wide range of \
-            topics. As a language model, Assistant is able to generate human-like text based on \
-            the input it receives, allowing it to engage in natural-sounding conversations and \
-            provide responses that are coherent and relevant to the topic at hand.
-
-            Assistant is constantly learning and improving, and its capabilities are constantly \
-            evolving. It is able to process and understand large amounts of text, and can use this \
-            knowledge to provide accurate and informative responses to a wide range of questions. \
-            Additionally, Assistant is able to generate its own text based on the input it \
-            receives, allowing it to engage in discussions and provide explanations and \
-            descriptions on a wide range of topics.
-
-            Overall, Assistant is a powerful system that can help with a wide range of tasks \
-            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 \
-            answering the users original question. The tools the human can use are:
-
-            {tools}
-
-            RESPONSE FORMAT INSTRUCTIONS
-            ----------------------------
-
-            When responding to me, please output a response in one of two formats:
-
-            **Option 1:**
-            Use this if you want the human to use a tool.
-            Markdown code snippet formatted in the following schema:
-
-            ```json
-            {{
-                "action": string, \\ The action to take. Must be one of {tool_names}
-                "action_input": string \\ The input to the action
-            }}
-            ```
-
-            **Option #2:**
-            Use this if you want to respond directly to the human. Markdown code snippet formatted \
-            in the following schema:
-
-            ```json
-            {{
-                "action": "Final Answer",
-                "action_input": string \\ You should put what you want to return to use here
-            }}
-            ```
-
-            USER'S INPUT
-            --------------------
-            Here is the user's input (remember to respond with a markdown code snippet of a json \
-            blob with a single action, and NOTHING else):
-
-            {input}'''
-
-            prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", system),
-                    MessagesPlaceholder("chat_history", optional=True),
-                    ("human", human),
-                    MessagesPlaceholder("agent_scratchpad"),
-                ]
-            )
-
-    """  # 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)
-
-    if "{observation}" not in template_tool_response:
-        msg = "Template tool response missing required variable 'observation'"
-        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_to_use = llm.bind(stop=stop)
-    else:
-        llm_to_use = llm
-
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: format_log_to_messages(
-                x["intermediate_steps"],
-                template_tool_response=template_tool_response,
-            ),
-        )
-        | prompt
-        | llm_to_use
-        | JSONAgentOutputParser()
-    )

langchain/agents/json_chat/prompt.py

@@ -1,8 +0,0 @@
-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!"""  # noqa: E501

langchain/agents/load_tools.py

@@ -1,13 +0,0 @@
-from typing import Any
-
-from langchain._api import create_importer
-
-_importer = create_importer(
-    __package__,
-    fallback_module="langchain_community.agent_toolkits.load_tools",
-)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _importer(name)