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

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,111 +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,50 +0,0 @@
-"""Interface for tools."""
-
-from typing import Optional
-
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
-from langchain_core.tools import BaseTool, tool
-from typing_extensions import override
-
-
-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."""
-
-    @override
-    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}]."
-        )
-
-    @override
-    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)

langchain/agents/xml/base.py

@@ -1,237 +0,0 @@
-from collections.abc import Sequence
-from typing import Any, Union
-
-from langchain_core._api import deprecated
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.callbacks import Callbacks
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts.base import BasePromptTemplate
-from langchain_core.prompts.chat import AIMessagePromptTemplate, 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 typing_extensions import override
-
-from langchain.agents.agent import BaseSingleActionAgent
-from langchain.agents.format_scratchpad import format_xml
-from langchain.agents.output_parsers import XMLAgentOutputParser
-from langchain.agents.xml.prompt import agent_instructions
-from langchain.chains.llm import LLMChain
-
-
-@deprecated("0.1.0", alternative="create_xml_agent", removal="1.0")
-class XMLAgent(BaseSingleActionAgent):
-    """Agent that uses XML tags.
-
-    Args:
-        tools: list of tools the agent can choose from
-        llm_chain: The LLMChain to call to predict the next action
-
-    Examples:
-
-        .. code-block:: python
-
-            from langchain.agents import XMLAgent
-            from langchain
-
-            tools = ...
-            model =
-
-    """
-
-    tools: list[BaseTool]
-    """List of tools this agent has access to."""
-    llm_chain: LLMChain
-    """Chain to use to predict action."""
-
-    @property
-    @override
-    def input_keys(self) -> list[str]:
-        return ["input"]
-
-    @staticmethod
-    def get_default_prompt() -> ChatPromptTemplate:
-        """Return the default prompt for the XML agent."""
-        base_prompt = ChatPromptTemplate.from_template(agent_instructions)
-        return base_prompt + AIMessagePromptTemplate.from_template(
-            "{intermediate_steps}",
-        )
-
-    @staticmethod
-    def get_default_output_parser() -> XMLAgentOutputParser:
-        """Return an XMLAgentOutputParser."""
-        return XMLAgentOutputParser()
-
-    @override
-    def plan(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> Union[AgentAction, AgentFinish]:
-        log = ""
-        for action, observation in intermediate_steps:
-            log += (
-                f"<tool>{action.tool}</tool><tool_input>{action.tool_input}"
-                f"</tool_input><observation>{observation}</observation>"
-            )
-        tools = ""
-        for tool in self.tools:
-            tools += f"{tool.name}: {tool.description}\n"
-        inputs = {
-            "intermediate_steps": log,
-            "tools": tools,
-            "question": kwargs["input"],
-            "stop": ["</tool_input>", "</final_answer>"],
-        }
-        response = self.llm_chain(inputs, callbacks=callbacks)
-        return response[self.llm_chain.output_key]
-
-    @override
-    async def aplan(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> Union[AgentAction, AgentFinish]:
-        log = ""
-        for action, observation in intermediate_steps:
-            log += (
-                f"<tool>{action.tool}</tool><tool_input>{action.tool_input}"
-                f"</tool_input><observation>{observation}</observation>"
-            )
-        tools = ""
-        for tool in self.tools:
-            tools += f"{tool.name}: {tool.description}\n"
-        inputs = {
-            "intermediate_steps": log,
-            "tools": tools,
-            "question": kwargs["input"],
-            "stop": ["</tool_input>", "</final_answer>"],
-        }
-        response = await self.llm_chain.acall(inputs, callbacks=callbacks)
-        return response[self.llm_chain.output_key]
-
-
-def create_xml_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: BasePromptTemplate,
-    tools_renderer: ToolsRenderer = render_text_description,
-    *,
-    stop_sequence: Union[bool, list[str]] = True,
-) -> Runnable:
-    """Create an agent that uses XML to format its logic.
-
-    Args:
-        llm: LLM to use as the agent.
-        tools: Tools this agent has access to.
-        prompt: The prompt to use, must have input keys
-            `tools`: contains descriptions for each tool.
-            `agent_scratchpad`: contains previous agent actions and tool outputs.
-        tools_renderer: This controls how the tools are converted into a string and
-            then passed into the LLM. Default is `render_text_description`.
-        stop_sequence: bool or list of str.
-            If True, adds a stop token of "</tool_input>" 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.
-
-    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 import hub
-            from langchain_community.chat_models import ChatAnthropic
-            from langchain.agents import AgentExecutor, create_xml_agent
-
-            prompt = hub.pull("hwchase17/xml-agent-convo")
-            model = ChatAnthropic(model="claude-3-haiku-20240307")
-            tools = ...
-
-            agent = create_xml_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-            # Use with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    # Notice that chat_history is a string
-                    # since this prompt is aimed at LLMs, not chat models
-                    "chat_history": "Human: My name is Bob\\nAI: Hello Bob!",
-                }
-            )
-
-    Prompt:
-
-        The prompt must have input keys:
-            * `tools`: contains descriptions for each tool.
-            * `agent_scratchpad`: contains previous agent actions and tool outputs as an XML string.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import PromptTemplate
-
-            template = '''You are a helpful assistant. Help the user answer any questions.
-
-            You have access to the following tools:
-
-            {tools}
-
-            In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags. You will then get back a response in the form <observation></observation>
-            For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
-
-            <tool>search</tool><tool_input>weather in SF</tool_input>
-            <observation>64 degrees</observation>
-
-            When you are done, respond with a final answer between <final_answer></final_answer>. For example:
-
-            <final_answer>The weather in SF is 64 degrees</final_answer>
-
-            Begin!
-
-            Previous Conversation:
-            {chat_history}
-
-            Question: {input}
-            {agent_scratchpad}'''
-            prompt = PromptTemplate.from_template(template)
-
-    """  # noqa: E501
-    missing_vars = {"tools", "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)),
-    )
-
-    if stop_sequence:
-        stop = ["</tool_input>"] 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_xml(x["intermediate_steps"]),
-        )
-        | prompt
-        | llm_with_stop
-        | XMLAgentOutputParser()
-    )

langchain/agents/xml/prompt.py

@@ -1,21 +0,0 @@
-# TODO: deprecate
-agent_instructions = """You are a helpful assistant. Help the user answer any questions.
-
-You have access to the following tools:
-
-{tools}
-
-In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags. \
-You will then get back a response in the form <observation></observation>
-For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
-
-<tool>search</tool><tool_input>weather in SF</tool_input>
-<observation>64 degrees</observation>
-
-When you are done, respond with a final answer between <final_answer></final_answer>. For example:
-
-<final_answer>The weather in SF is 64 degrees</final_answer>
-
-Begin!
-
-Question: {question}"""  # noqa: E501

langchain/base_language.py

@@ -1,7 +0,0 @@
-"""Deprecated module for BaseLanguageModel class, kept for backwards compatibility."""
-
-from __future__ import annotations
-
-from langchain_core.language_models import BaseLanguageModel
-
-__all__ = ["BaseLanguageModel"]

langchain/cache.py

@@ -1,72 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.cache import (
-        AstraDBCache,
-        AstraDBSemanticCache,
-        AzureCosmosDBSemanticCache,
-        CassandraCache,
-        CassandraSemanticCache,
-        FullLLMCache,
-        FullMd5LLMCache,
-        GPTCache,
-        InMemoryCache,
-        MomentoCache,
-        RedisCache,
-        RedisSemanticCache,
-        SQLAlchemyCache,
-        SQLAlchemyMd5Cache,
-        SQLiteCache,
-        UpstashRedisCache,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "FullLLMCache": "langchain_community.cache",
-    "SQLAlchemyCache": "langchain_community.cache",
-    "SQLiteCache": "langchain_community.cache",
-    "UpstashRedisCache": "langchain_community.cache",
-    "RedisCache": "langchain_community.cache",
-    "RedisSemanticCache": "langchain_community.cache",
-    "GPTCache": "langchain_community.cache",
-    "MomentoCache": "langchain_community.cache",
-    "InMemoryCache": "langchain_community.cache",
-    "CassandraCache": "langchain_community.cache",
-    "CassandraSemanticCache": "langchain_community.cache",
-    "FullMd5LLMCache": "langchain_community.cache",
-    "SQLAlchemyMd5Cache": "langchain_community.cache",
-    "AstraDBCache": "langchain_community.cache",
-    "AstraDBSemanticCache": "langchain_community.cache",
-    "AzureCosmosDBSemanticCache": "langchain_community.cache",
-}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "AstraDBCache",
-    "AstraDBSemanticCache",
-    "AzureCosmosDBSemanticCache",
-    "CassandraCache",
-    "CassandraSemanticCache",
-    "FullLLMCache",
-    "FullMd5LLMCache",
-    "GPTCache",
-    "InMemoryCache",
-    "MomentoCache",
-    "RedisCache",
-    "RedisSemanticCache",
-    "SQLAlchemyCache",
-    "SQLAlchemyMd5Cache",
-    "SQLiteCache",
-    "UpstashRedisCache",
-]