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

langchain/agents/xml/base.py

@@ -1,231 +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 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
-    def input_keys(self) -> list[str]:
-        return ["input"]
-
-    @staticmethod
-    def get_default_prompt() -> ChatPromptTemplate:
-        base_prompt = ChatPromptTemplate.from_template(agent_instructions)
-        return base_prompt + AIMessagePromptTemplate.from_template(
-            "{intermediate_steps}",
-        )
-
-    @staticmethod
-    def get_default_output_parser() -> XMLAgentOutputParser:
-        return XMLAgentOutputParser()
-
-    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]
-
-    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",
-]

langchain/callbacks/__init__.py

@@ -1,139 +0,0 @@
-"""**Callback handlers** allow listening to events in LangChain.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseCallbackHandler --> <name>CallbackHandler  # Example: AimCallbackHandler
-"""
-
-from typing import TYPE_CHECKING, Any
-
-from langchain_core.callbacks import (
-    FileCallbackHandler,
-    StdOutCallbackHandler,
-    StreamingStdOutCallbackHandler,
-)
-from langchain_core.tracers.context import (
-    collect_runs,
-    tracing_enabled,
-    tracing_v2_enabled,
-)
-from langchain_core.tracers.langchain import LangChainTracer
-
-from langchain._api import create_importer
-from langchain.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
-from langchain.callbacks.streaming_stdout_final_only import (
-    FinalStreamingStdOutCallbackHandler,
-)
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.aim_callback import AimCallbackHandler
-    from langchain_community.callbacks.argilla_callback import ArgillaCallbackHandler
-    from langchain_community.callbacks.arize_callback import ArizeCallbackHandler
-    from langchain_community.callbacks.arthur_callback import ArthurCallbackHandler
-    from langchain_community.callbacks.clearml_callback import ClearMLCallbackHandler
-    from langchain_community.callbacks.comet_ml_callback import CometCallbackHandler
-    from langchain_community.callbacks.context_callback import ContextCallbackHandler
-    from langchain_community.callbacks.flyte_callback import FlyteCallbackHandler
-    from langchain_community.callbacks.human import HumanApprovalCallbackHandler
-    from langchain_community.callbacks.infino_callback import InfinoCallbackHandler
-    from langchain_community.callbacks.labelstudio_callback import (
-        LabelStudioCallbackHandler,
-    )
-    from langchain_community.callbacks.llmonitor_callback import (
-        LLMonitorCallbackHandler,
-    )
-    from langchain_community.callbacks.manager import (
-        get_openai_callback,
-        wandb_tracing_enabled,
-    )
-    from langchain_community.callbacks.mlflow_callback import MlflowCallbackHandler
-    from langchain_community.callbacks.openai_info import OpenAICallbackHandler
-    from langchain_community.callbacks.promptlayer_callback import (
-        PromptLayerCallbackHandler,
-    )
-    from langchain_community.callbacks.sagemaker_callback import (
-        SageMakerCallbackHandler,
-    )
-    from langchain_community.callbacks.streamlit import StreamlitCallbackHandler
-    from langchain_community.callbacks.streamlit.streamlit_callback_handler import (
-        LLMThoughtLabeler,
-    )
-    from langchain_community.callbacks.trubrics_callback import TrubricsCallbackHandler
-    from langchain_community.callbacks.wandb_callback import WandbCallbackHandler
-    from langchain_community.callbacks.whylabs_callback import WhyLabsCallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "AimCallbackHandler": "langchain_community.callbacks.aim_callback",
-    "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback",
-    "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback",
-    "PromptLayerCallbackHandler": "langchain_community.callbacks.promptlayer_callback",
-    "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback",
-    "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback",
-    "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback",
-    "ContextCallbackHandler": "langchain_community.callbacks.context_callback",
-    "HumanApprovalCallbackHandler": "langchain_community.callbacks.human",
-    "InfinoCallbackHandler": "langchain_community.callbacks.infino_callback",
-    "MlflowCallbackHandler": "langchain_community.callbacks.mlflow_callback",
-    "LLMonitorCallbackHandler": "langchain_community.callbacks.llmonitor_callback",
-    "OpenAICallbackHandler": "langchain_community.callbacks.openai_info",
-    "LLMThoughtLabeler": (
-        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
-    ),
-    "StreamlitCallbackHandler": "langchain_community.callbacks.streamlit",
-    "WandbCallbackHandler": "langchain_community.callbacks.wandb_callback",
-    "WhyLabsCallbackHandler": "langchain_community.callbacks.whylabs_callback",
-    "get_openai_callback": "langchain_community.callbacks.manager",
-    "wandb_tracing_enabled": "langchain_community.callbacks.manager",
-    "FlyteCallbackHandler": "langchain_community.callbacks.flyte_callback",
-    "SageMakerCallbackHandler": "langchain_community.callbacks.sagemaker_callback",
-    "LabelStudioCallbackHandler": "langchain_community.callbacks.labelstudio_callback",
-    "TrubricsCallbackHandler": "langchain_community.callbacks.trubrics_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "AimCallbackHandler",
-    "ArgillaCallbackHandler",
-    "ArizeCallbackHandler",
-    "ArthurCallbackHandler",
-    "AsyncIteratorCallbackHandler",
-    "ClearMLCallbackHandler",
-    "CometCallbackHandler",
-    "ContextCallbackHandler",
-    "FileCallbackHandler",
-    "FinalStreamingStdOutCallbackHandler",
-    "FlyteCallbackHandler",
-    "HumanApprovalCallbackHandler",
-    "InfinoCallbackHandler",
-    "LLMThoughtLabeler",
-    "LLMonitorCallbackHandler",
-    "LabelStudioCallbackHandler",
-    "LangChainTracer",
-    "MlflowCallbackHandler",
-    "OpenAICallbackHandler",
-    "PromptLayerCallbackHandler",
-    "SageMakerCallbackHandler",
-    "StdOutCallbackHandler",
-    "StreamingStdOutCallbackHandler",
-    "StreamlitCallbackHandler",
-    "TrubricsCallbackHandler",
-    "WandbCallbackHandler",
-    "WhyLabsCallbackHandler",
-    "collect_runs",
-    "get_openai_callback",
-    "tracing_enabled",
-    "tracing_v2_enabled",
-    "wandb_tracing_enabled",
-]

langchain/callbacks/aim_callback.py

@@ -1,33 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.aim_callback import (
-        AimCallbackHandler,
-        BaseMetadataCallbackHandler,
-        import_aim,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "import_aim": "langchain_community.callbacks.aim_callback",
-    "BaseMetadataCallbackHandler": "langchain_community.callbacks.aim_callback",
-    "AimCallbackHandler": "langchain_community.callbacks.aim_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "AimCallbackHandler",
-    "BaseMetadataCallbackHandler",
-    "import_aim",
-]

langchain/callbacks/argilla_callback.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.argilla_callback import ArgillaCallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ArgillaCallbackHandler",
-]

langchain/callbacks/arize_callback.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.arize_callback import ArizeCallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ArizeCallbackHandler",
-]

langchain/callbacks/arthur_callback.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.arthur_callback import ArthurCallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ArthurCallbackHandler",
-]

langchain/callbacks/base.py

@@ -1,29 +0,0 @@
-"""Base callback handler that can be used to handle callbacks in langchain."""
-
-from __future__ import annotations
-
-from langchain_core.callbacks import (
-    AsyncCallbackHandler,
-    BaseCallbackHandler,
-    BaseCallbackManager,
-    CallbackManagerMixin,
-    Callbacks,
-    ChainManagerMixin,
-    LLMManagerMixin,
-    RetrieverManagerMixin,
-    RunManagerMixin,
-    ToolManagerMixin,
-)
-
-__all__ = [
-    "AsyncCallbackHandler",
-    "BaseCallbackHandler",
-    "BaseCallbackManager",
-    "CallbackManagerMixin",
-    "Callbacks",
-    "ChainManagerMixin",
-    "LLMManagerMixin",
-    "RetrieverManagerMixin",
-    "RunManagerMixin",
-    "ToolManagerMixin",
-]

langchain/callbacks/clearml_callback.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.clearml_callback import ClearMLCallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ClearMLCallbackHandler",
-]

langchain/callbacks/comet_ml_callback.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.comet_ml_callback import CometCallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "CometCallbackHandler",
-]