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

langchain/agents/chat/output_parser.py

@@ -1,74 +0,0 @@
-import json
-import re
-from re import Pattern
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-
-from langchain.agents.agent import AgentOutputParser
-from langchain.agents.chat.prompt import FORMAT_INSTRUCTIONS
-
-FINAL_ANSWER_ACTION = "Final Answer:"
-
-
-class ChatOutputParser(AgentOutputParser):
-    """Output parser for the chat agent."""
-
-    format_instructions: str = FORMAT_INSTRUCTIONS
-    """Default formatting instructions"""
-
-    pattern: Pattern = re.compile(r"^.*?`{3}(?:json)?\n(.*?)`{3}.*?$", 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]:
-        """Parse the output from the agent into
-        an AgentAction or AgentFinish object.
-
-        Args:
-            text: The text to parse.
-
-        Returns:
-            An AgentAction or AgentFinish object.
-
-        Raises:
-            OutputParserException: If the output could not be parsed.
-            ValueError: If the action could not be found.
-        """
-
-        includes_answer = FINAL_ANSWER_ACTION in text
-        try:
-            found = self.pattern.search(text)
-            if not found:
-                # Fast fail to parse Final Answer.
-                msg = "action not found"
-                raise ValueError(msg)
-            action = found.group(1)
-            response = json.loads(action.strip())
-            includes_action = "action" in response
-            if includes_answer and includes_action:
-                msg = (
-                    "Parsing LLM output produced a final answer "
-                    f"and a parse-able action: {text}"
-                )
-                raise OutputParserException(msg)
-            return AgentAction(
-                response["action"],
-                response.get("action_input", {}),
-                text,
-            )
-
-        except Exception as exc:
-            if not includes_answer:
-                msg = f"Could not parse LLM output: {text}"
-                raise OutputParserException(msg) from exc
-            output = text.split(FINAL_ANSWER_ACTION)[-1].strip()
-            return AgentFinish({"output": output}, text)
-
-    @property
-    def _type(self) -> str:
-        return "chat"

langchain/agents/chat/prompt.py

@@ -1,29 +0,0 @@
-SYSTEM_MESSAGE_PREFIX = """Answer the following questions as best you can. You have access to the following tools:"""  # noqa: E501
-FORMAT_INSTRUCTIONS = """The way you use the tools is by specifying a json blob.
-Specifically, this json should have a `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).
-
-The only values that should be in the "action" field are: {tool_names}
-
-The $JSON_BLOB should only contain a SINGLE action, do NOT return a list of multiple actions. Here is an example of a valid $JSON_BLOB:
-
-```
-{{{{
-  "action": $TOOL_NAME,
-  "action_input": $INPUT
-}}}}
-```
-
-ALWAYS use the following format:
-
-Question: the input question you must answer
-Thought: you should always think about what to do
-Action:
-```
-$JSON_BLOB
-```
-Observation: the result of the action
-... (this Thought/Action/Observation can repeat N times)
-Thought: I now know the final answer
-Final Answer: the final answer to the original input question"""  # noqa: E501
-SYSTEM_MESSAGE_SUFFIX = """Begin! Reminder to always use the exact characters `Final Answer` when responding."""  # noqa: E501
-HUMAN_MESSAGE = "{input}\n\n{agent_scratchpad}"

langchain/agents/conversational/__init__.py

@@ -1 +0,0 @@
-"""An agent designed to hold a conversation in addition to using tools."""

langchain/agents/conversational/base.py

@@ -1,178 +0,0 @@
-"""An agent designed to hold a conversation in addition to using tools."""
-
-from __future__ import annotations
-
-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.prompts import PromptTemplate
-from langchain_core.tools import BaseTool
-from pydantic import Field
-from typing_extensions import override
-
-from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
-from langchain.agents.agent import Agent, AgentOutputParser
-from langchain.agents.agent_types import AgentType
-from langchain.agents.conversational.output_parser import ConvoOutputParser
-from langchain.agents.conversational.prompt import FORMAT_INSTRUCTIONS, PREFIX, SUFFIX
-from langchain.agents.utils import validate_tools_single_input
-from langchain.chains import LLMChain
-
-
-@deprecated(
-    "0.1.0",
-    message=AGENT_DEPRECATION_WARNING,
-    removal="1.0",
-)
-class ConversationalAgent(Agent):
-    """An agent that holds a conversation in addition to using tools."""
-
-    ai_prefix: str = "AI"
-    """Prefix to use before AI output."""
-    output_parser: AgentOutputParser = Field(default_factory=ConvoOutputParser)
-    """Output parser for the agent."""
-
-    @classmethod
-    @override
-    def _get_default_output_parser(
-        cls,
-        ai_prefix: str = "AI",
-        **kwargs: Any,
-    ) -> AgentOutputParser:
-        return ConvoOutputParser(ai_prefix=ai_prefix)
-
-    @property
-    def _agent_type(self) -> str:
-        """Return Identifier of agent type."""
-        return AgentType.CONVERSATIONAL_REACT_DESCRIPTION
-
-    @property
-    def observation_prefix(self) -> str:
-        """Prefix to append the observation with.
-
-        Returns:
-            "Observation: "
-        """
-        return "Observation: "
-
-    @property
-    def llm_prefix(self) -> str:
-        """Prefix to append the llm call with.
-
-        Returns:
-            "Thought: "
-        """
-        return "Thought:"
-
-    @classmethod
-    def create_prompt(
-        cls,
-        tools: Sequence[BaseTool],
-        prefix: str = PREFIX,
-        suffix: str = SUFFIX,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        ai_prefix: str = "AI",
-        human_prefix: str = "Human",
-        input_variables: Optional[list[str]] = None,
-    ) -> PromptTemplate:
-        """Create prompt in the style of the zero-shot agent.
-
-        Args:
-            tools: List of tools the agent will have access to, used to format the
-                prompt.
-            prefix: String to put before the list of tools. Defaults to PREFIX.
-            suffix: String to put after the list of tools. Defaults to SUFFIX.
-            format_instructions: Instructions on how to use the tools. Defaults to
-                FORMAT_INSTRUCTIONS
-            ai_prefix: String to use before AI output. Defaults to "AI".
-            human_prefix: String to use before human output.
-                Defaults to "Human".
-            input_variables: List of input variables the final prompt will expect.
-                Defaults to ["input", "chat_history", "agent_scratchpad"].
-
-        Returns:
-            A PromptTemplate with the template assembled from the pieces here.
-        """
-        tool_strings = "\n".join(
-            [f"> {tool.name}: {tool.description}" for tool in tools],
-        )
-        tool_names = ", ".join([tool.name for tool in tools])
-        format_instructions = format_instructions.format(
-            tool_names=tool_names,
-            ai_prefix=ai_prefix,
-            human_prefix=human_prefix,
-        )
-        template = f"{prefix}\n\n{tool_strings}\n\n{format_instructions}\n\n{suffix}"
-        if input_variables is None:
-            input_variables = ["input", "chat_history", "agent_scratchpad"]
-        return PromptTemplate(template=template, input_variables=input_variables)
-
-    @classmethod
-    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
-        super()._validate_tools(tools)
-        validate_tools_single_input(cls.__name__, tools)
-
-    @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,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        ai_prefix: str = "AI",
-        human_prefix: str = "Human",
-        input_variables: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> Agent:
-        """Construct an agent from an LLM and tools.
-
-        Args:
-            llm: The language model to use.
-            tools: A list of tools to use.
-            callback_manager: The callback manager to use. Default is None.
-            output_parser: The output parser to use. Default is None.
-            prefix: The prefix to use in the prompt. Default is PREFIX.
-            suffix: The suffix to use in the prompt. Default is SUFFIX.
-            format_instructions: The format instructions to use.
-                Default is FORMAT_INSTRUCTIONS.
-            ai_prefix: The prefix to use before AI output. Default is "AI".
-            human_prefix: The prefix to use before human output.
-                Default is "Human".
-            input_variables: The input variables to use. Default is None.
-            **kwargs: Any additional keyword arguments to pass to the agent.
-
-        Returns:
-            An agent.
-        """
-        cls._validate_tools(tools)
-        prompt = cls.create_prompt(
-            tools,
-            ai_prefix=ai_prefix,
-            human_prefix=human_prefix,
-            prefix=prefix,
-            suffix=suffix,
-            format_instructions=format_instructions,
-            input_variables=input_variables,
-        )
-        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(
-            ai_prefix=ai_prefix,
-        )
-        return cls(
-            llm_chain=llm_chain,
-            allowed_tools=tool_names,
-            ai_prefix=ai_prefix,
-            output_parser=_output_parser,
-            **kwargs,
-        )

langchain/agents/conversational/output_parser.py

@@ -1,51 +0,0 @@
-import re
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-
-from langchain.agents.agent import AgentOutputParser
-from langchain.agents.conversational.prompt import FORMAT_INSTRUCTIONS
-
-
-class ConvoOutputParser(AgentOutputParser):
-    """Output parser for the conversational agent."""
-
-    ai_prefix: str = "AI"
-    """Prefix to use before AI output."""
-
-    format_instructions: str = FORMAT_INSTRUCTIONS
-    """Default formatting instructions"""
-
-    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]:
-        """Parse the output from the agent into
-        an AgentAction or AgentFinish object.
-
-        Args:
-            text: The text to parse.
-
-        Returns:
-            An AgentAction or AgentFinish object.
-        """
-
-        if f"{self.ai_prefix}:" in text:
-            return AgentFinish(
-                {"output": text.split(f"{self.ai_prefix}:")[-1].strip()},
-                text,
-            )
-        regex = r"Action: (.*?)[\n]*Action Input: ([\s\S]*)"
-        match = re.search(regex, text, re.DOTALL)
-        if not match:
-            msg = f"Could not parse LLM output: `{text}`"
-            raise OutputParserException(msg)
-        action = match.group(1)
-        action_input = match.group(2)
-        return AgentAction(action.strip(), action_input.strip(" ").strip('"'), text)
-
-    @property
-    def _type(self) -> str:
-        return "conversational"

langchain/agents/conversational/prompt.py

@@ -1,35 +0,0 @@
-PREFIX = """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 tool 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.
-
-TOOLS:
-------
-
-Assistant has access to the following tools:"""  # noqa: E501
-FORMAT_INSTRUCTIONS = """To use a tool, please use the following format:
-
-```
-Thought: Do I need to use a tool? Yes
-Action: the action to take, should be one of [{tool_names}]
-Action Input: the input to the action
-Observation: the result of the action
-```
-
-When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
-
-```
-Thought: Do I need to use a tool? No
-{ai_prefix}: [your response here]
-```"""  # noqa: E501
-
-SUFFIX = """Begin!
-
-Previous conversation history:
-{chat_history}
-
-New input: {input}
-{agent_scratchpad}"""

langchain/agents/conversational_chat/__init__.py

@@ -1 +0,0 @@
-"""An agent designed to hold a conversation in addition to using tools."""

langchain/agents/conversational_chat/base.py

@@ -1,183 +0,0 @@
-"""An agent designed to hold a conversation in addition to using tools."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import Any, Optional
-
-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.messages import AIMessage, BaseMessage, HumanMessage
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.prompts.chat import (
-    ChatPromptTemplate,
-    HumanMessagePromptTemplate,
-    MessagesPlaceholder,
-    SystemMessagePromptTemplate,
-)
-from langchain_core.tools import BaseTool
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.agents.agent import Agent, AgentOutputParser
-from langchain.agents.conversational_chat.output_parser import ConvoOutputParser
-from langchain.agents.conversational_chat.prompt import (
-    PREFIX,
-    SUFFIX,
-    TEMPLATE_TOOL_RESPONSE,
-)
-from langchain.agents.utils import validate_tools_single_input
-from langchain.chains import LLMChain
-
-
-@deprecated("0.1.0", alternative="create_json_chat_agent", removal="1.0")
-class ConversationalChatAgent(Agent):
-    """An agent designed to hold a conversation in addition to using tools."""
-
-    output_parser: AgentOutputParser = Field(default_factory=ConvoOutputParser)
-    """Output parser for the agent."""
-    template_tool_response: str = TEMPLATE_TOOL_RESPONSE
-    """Template for the tool response."""
-
-    @classmethod
-    @override
-    def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
-        return ConvoOutputParser()
-
-    @property
-    def _agent_type(self) -> str:
-        raise NotImplementedError
-
-    @property
-    def observation_prefix(self) -> str:
-        """Prefix to append the observation with.
-
-        Returns:
-            "Observation: "
-        """
-        return "Observation: "
-
-    @property
-    def llm_prefix(self) -> str:
-        """Prefix to append the llm call with.
-
-        Returns:
-            "Thought: "
-        """
-        return "Thought:"
-
-    @classmethod
-    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
-        super()._validate_tools(tools)
-        validate_tools_single_input(cls.__name__, tools)
-
-    @classmethod
-    def create_prompt(
-        cls,
-        tools: Sequence[BaseTool],
-        system_message: str = PREFIX,
-        human_message: str = SUFFIX,
-        input_variables: Optional[list[str]] = None,
-        output_parser: Optional[BaseOutputParser] = None,
-    ) -> BasePromptTemplate:
-        """Create a prompt for the agent.
-
-        Args:
-            tools: The tools to use.
-            system_message: The system message to use.
-                Defaults to the PREFIX.
-            human_message: The human message to use.
-                Defaults to the SUFFIX.
-            input_variables: The input variables to use. Defaults to None.
-            output_parser: The output parser to use. Defaults to None.
-
-        Returns:
-            A PromptTemplate.
-        """
-        tool_strings = "\n".join(
-            [f"> {tool.name}: {tool.description}" for tool in tools],
-        )
-        tool_names = ", ".join([tool.name for tool in tools])
-        _output_parser = output_parser or cls._get_default_output_parser()
-        format_instructions = human_message.format(
-            format_instructions=_output_parser.get_format_instructions(),
-        )
-        final_prompt = format_instructions.format(
-            tool_names=tool_names,
-            tools=tool_strings,
-        )
-        if input_variables is None:
-            input_variables = ["input", "chat_history", "agent_scratchpad"]
-        messages = [
-            SystemMessagePromptTemplate.from_template(system_message),
-            MessagesPlaceholder(variable_name="chat_history"),
-            HumanMessagePromptTemplate.from_template(final_prompt),
-            MessagesPlaceholder(variable_name="agent_scratchpad"),
-        ]
-        return ChatPromptTemplate(input_variables=input_variables, messages=messages)
-
-    def _construct_scratchpad(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-    ) -> list[BaseMessage]:
-        """Construct the scratchpad that lets the agent continue its thought process."""
-        thoughts: list[BaseMessage] = []
-        for action, observation in intermediate_steps:
-            thoughts.append(AIMessage(content=action.log))
-            human_message = HumanMessage(
-                content=self.template_tool_response.format(observation=observation),
-            )
-            thoughts.append(human_message)
-        return thoughts
-
-    @classmethod
-    def from_llm_and_tools(
-        cls,
-        llm: BaseLanguageModel,
-        tools: Sequence[BaseTool],
-        callback_manager: Optional[BaseCallbackManager] = None,
-        output_parser: Optional[AgentOutputParser] = None,
-        system_message: str = PREFIX,
-        human_message: str = SUFFIX,
-        input_variables: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> Agent:
-        """Construct an agent from an LLM and tools.
-
-        Args:
-            llm: The language model to use.
-            tools: A list of tools to use.
-            callback_manager: The callback manager to use. Default is None.
-            output_parser: The output parser to use. Default is None.
-            system_message: The system message to use. Default is PREFIX.
-            human_message: The human message to use. Default is SUFFIX.
-            input_variables: The input variables to use. Default is None.
-            **kwargs: Any additional arguments.
-
-        Returns:
-            An agent.
-        """
-        cls._validate_tools(tools)
-        _output_parser = output_parser or cls._get_default_output_parser()
-        prompt = cls.create_prompt(
-            tools,
-            system_message=system_message,
-            human_message=human_message,
-            input_variables=input_variables,
-            output_parser=_output_parser,
-        )
-        llm_chain = LLMChain(
-            llm=llm,
-            prompt=prompt,
-            callback_manager=callback_manager,
-        )
-        tool_names = [tool.name for tool in tools]
-        return cls(
-            llm_chain=llm_chain,
-            allowed_tools=tool_names,
-            output_parser=_output_parser,
-            **kwargs,
-        )

langchain/agents/conversational_chat/output_parser.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from langchain_core.utils.json import parse_json_markdown
-
-from langchain.agents import AgentOutputParser
-from langchain.agents.conversational_chat.prompt import FORMAT_INSTRUCTIONS
-
-
-# Define a class that parses output for conversational agents
-class ConvoOutputParser(AgentOutputParser):
-    """Output parser for the conversational agent."""
-
-    format_instructions: str = FORMAT_INSTRUCTIONS
-    """Default formatting instructions"""
-
-    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]:
-        """Attempts to parse the given text into an AgentAction or AgentFinish.
-
-        Raises:
-             OutputParserException if parsing fails.
-        """
-        try:
-            # Attempt to parse the text into a structured format (assumed to be JSON
-            # stored as markdown)
-            response = parse_json_markdown(text)
-
-            # If the response contains an 'action' and 'action_input'
-            if "action" in response and "action_input" in response:
-                action, action_input = response["action"], response["action_input"]
-
-                # If the action indicates a final answer, return an AgentFinish
-                if action == "Final Answer":
-                    return AgentFinish({"output": action_input}, text)
-                # Otherwise, return an AgentAction with the specified action and
-                # input
-                return AgentAction(action, action_input, text)
-            # If the necessary keys aren't present in the response, raise an
-            # exception
-            msg = f"Missing 'action' or 'action_input' in LLM output: {text}"
-            raise OutputParserException(msg)
-        except Exception as e:
-            # If any other exception is raised during parsing, also raise an
-            # OutputParserException
-            msg = f"Could not parse LLM output: {text}"
-            raise OutputParserException(msg) from e
-
-    @property
-    def _type(self) -> str:
-        return "conversational_chat"

langchain/agents/conversational_chat/prompt.py

@@ -1,56 +0,0 @@
-PREFIX = """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."""  # noqa: E501
-
-FORMAT_INSTRUCTIONS = """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
-}}}}
-```"""  # noqa: E501
-
-SUFFIX = """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}}
-
-{format_instructions}
-
-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}}}}"""  # noqa: E501
-
-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."""  # noqa: E501