langchain 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

langchain/agents/openai_assistant/base.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import json
 from json import JSONDecodeError
 from time import sleep
@@ -742,5 +743,5 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
             )
             in_progress = run.status in ("in_progress", "queued")
             if in_progress:
-                sleep(self.check_every_ms / 1000)
+                await asyncio.sleep(self.check_every_ms / 1000)
         return run

langchain/chains/combine_documents/stuff.py

@@ -27,13 +27,14 @@ def create_stuff_documents_chain(
     output_parser: Optional[BaseOutputParser] = None,
     document_prompt: Optional[BasePromptTemplate] = None,
     document_separator: str = DEFAULT_DOCUMENT_SEPARATOR,
+    document_variable_name: str = DOCUMENTS_KEY,
 ) -> Runnable[Dict[str, Any], Any]:
     """Create a chain for passing a list of Documents to a model.
 
     Args:
         llm: Language model.
-        prompt: Prompt template. Must contain input variable "context", which will be
-            used for passing in the formatted documents.
+        prompt: Prompt template. Must contain input variable "context" (override by
+            setting document_variable), which will be used for passing in the formatted documents.
         output_parser: Output parser. Defaults to StrOutputParser.
         document_prompt: Prompt used for formatting each document into a string. Input
             variables can be "page_content" or any metadata keys that are in all
@@ -42,6 +43,8 @@ def create_stuff_documents_chain(
             automatically retrieved from the `Document.metadata` dictionary. Default to
             a prompt that only contains `Document.page_content`.
         document_separator: String separator to use between formatted document strings.
+        document_variable_name: Variable name to use for the formatted documents in the prompt.
+            Defaults to "context".
 
     Returns:
         An LCEL Runnable. The input is a dictionary that must have a "context" key that
@@ -78,11 +81,12 @@ def create_stuff_documents_chain(
 
     def format_docs(inputs: dict) -> str:
         return document_separator.join(
-            format_document(doc, _document_prompt) for doc in inputs[DOCUMENTS_KEY]
+            format_document(doc, _document_prompt)
+            for doc in inputs[document_variable_name]
         )
 
     return (
-        RunnablePassthrough.assign(**{DOCUMENTS_KEY: format_docs}).with_config(
+        RunnablePassthrough.assign(**{document_variable_name: format_docs}).with_config(
             run_name="format_inputs"
         )
         | prompt

langchain/chat_models/base.py

@@ -1,34 +1,107 @@
+from __future__ import annotations
+
+import warnings
 from importlib import util
-from typing import Any, Optional
+from typing import (
+    Any,
+    AsyncIterator,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+    overload,
+)
 
 from langchain_core._api import beta
-from langchain_core.language_models.chat_models import (
+from langchain_core.language_models import (
     BaseChatModel,
+    LanguageModelInput,
     SimpleChatModel,
+)
+from langchain_core.language_models.chat_models import (
     agenerate_from_stream,
     generate_from_stream,
 )
+from langchain_core.messages import AnyMessage, BaseMessage
+from langchain_core.pydantic_v1 import BaseModel
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.runnables.schema import StreamEvent
+from langchain_core.tools import BaseTool
+from langchain_core.tracers import RunLog, RunLogPatch
+from typing_extensions import TypeAlias
 
 __all__ = [
+    "init_chat_model",
+    # For backwards compatibility
     "BaseChatModel",
     "SimpleChatModel",
     "generate_from_stream",
     "agenerate_from_stream",
-    "init_chat_model",
 ]
 
 
+@overload
+def init_chat_model(  # type: ignore[overload-overlap]
+    model: str,
+    *,
+    model_provider: Optional[str] = None,
+    configurable_fields: Literal[None] = None,
+    config_prefix: Optional[str] = None,
+    **kwargs: Any,
+) -> BaseChatModel: ...
+
+
+@overload
+def init_chat_model(
+    model: Literal[None] = None,
+    *,
+    model_provider: Optional[str] = None,
+    configurable_fields: Literal[None] = None,
+    config_prefix: Optional[str] = None,
+    **kwargs: Any,
+) -> _ConfigurableModel: ...
+
+
+@overload
+def init_chat_model(
+    model: Optional[str] = None,
+    *,
+    model_provider: Optional[str] = None,
+    configurable_fields: Union[Literal["any"], List[str], Tuple[str, ...]] = ...,
+    config_prefix: Optional[str] = None,
+    **kwargs: Any,
+) -> _ConfigurableModel: ...
+
+
 # FOR CONTRIBUTORS: If adding support for a new provider, please append the provider
 # name to the supported list in the docstring below. Do *not* change the order of the
 # existing providers.
 @beta()
 def init_chat_model(
-    model: str, *, model_provider: Optional[str] = None, **kwargs: Any
-) -> BaseChatModel:
+    model: Optional[str] = None,
+    *,
+    model_provider: Optional[str] = None,
+    configurable_fields: Optional[
+        Union[Literal["any"], List[str], Tuple[str, ...]]
+    ] = None,
+    config_prefix: Optional[str] = None,
+    **kwargs: Any,
+) -> Union[BaseChatModel, _ConfigurableModel]:
     """Initialize a ChatModel from the model name and provider.
 
     Must have the integration package corresponding to the model provider installed.
 
+    .. versionadded:: 0.2.7
+
+    .. versionchanged:: 0.2.8
+
     Args:
         model: The name of the model, e.g. "gpt-4o", "claude-3-opus-20240229".
         model_provider: The model provider. Supported model_provider values and the
@@ -55,19 +128,43 @@ def init_chat_model(
                 - gemini... -> google_vertexai
                 - command... -> cohere
                 - accounts/fireworks... -> fireworks
+        configurable_fields: Which model parameters are
+            configurable:
+                - None: No configurable fields.
+                - "any": All fields are configurable. *See Security Note below.*
+                - Union[List[str], Tuple[str, ...]]: Specified fields are configurable.
+
+            Fields are assumed to have config_prefix stripped if there is a
+            config_prefix. If model is specified, then defaults to None. If model is
+            not specified, then defaults to ``("model", "model_provider")``.
+
+            ***Security Note***: Setting ``configurable_fields="any"`` means fields like
+            api_key, base_url, etc. can be altered at runtime, potentially redirecting
+            model requests to a different service/user. Make sure that if you're
+            accepting untrusted configurations that you enumerate the
+            ``configurable_fields=(...)`` explicitly.
+
+        config_prefix: If config_prefix is a non-empty string then model will be
+            configurable at runtime via the
+            ``config["configurable"]["{config_prefix}_{param}"]`` keys. If
+            config_prefix is an empty string then model will be configurable via
+            ``config["configurable"]["{param}"]``.
         kwargs: Additional keyword args to pass to
             ``<<selected ChatModel>>.__init__(model=model_name, **kwargs)``.
 
     Returns:
-        The BaseChatModel corresponding to the model_name and model_provider specified.
+        A BaseChatModel corresponding to the model_name and model_provider specified if
+        configurability is inferred to be False. If configurable, a chat model emulator
+        that initializes the underlying model at runtime once a config is passed in.
 
     Raises:
         ValueError: If model_provider cannot be inferred or isn't supported.
         ImportError: If the model provider integration package is not installed.
 
-    Example:
+    Initialize non-configurable models:
         .. code-block:: python
 
+            # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
             from langchain.chat_models import init_chat_model
 
             gpt_4o = init_chat_model("gpt-4o", model_provider="openai", temperature=0)
@@ -77,7 +174,125 @@ def init_chat_model(
             gpt_4o.invoke("what's your name")
             claude_opus.invoke("what's your name")
             gemini_15.invoke("what's your name")
+
+
+    Create a partially configurable model with no default model:
+        .. code-block:: python
+
+            # pip install langchain langchain-openai langchain-anthropic
+            from langchain.chat_models import init_chat_model
+
+            # We don't need to specify configurable=True if a model isn't specified.
+            configurable_model = init_chat_model(temperature=0)
+
+            configurable_model.invoke(
+                "what's your name",
+                config={"configurable": {"model": "gpt-4o"}}
+            )
+            # GPT-4o response
+
+            configurable_model.invoke(
+                "what's your name",
+                config={"configurable": {"model": "claude-3-5-sonnet-20240620"}}
+            )
+            # claude-3.5 sonnet response
+
+    Create a fully configurable model with a default model and a config prefix:
+        .. code-block:: python
+
+            # pip install langchain langchain-openai langchain-anthropic
+            from langchain.chat_models import init_chat_model
+
+            configurable_model_with_default = init_chat_model(
+                "gpt-4o",
+                model_provider="openai",
+                configurable_fields="any",  # this allows us to configure other params like temperature, max_tokens, etc at runtime.
+                config_prefix="foo",
+                temperature=0
+            )
+
+            configurable_model_with_default.invoke("what's your name")
+            # GPT-4o response with temperature 0
+
+            configurable_model_with_default.invoke(
+                "what's your name",
+                config={
+                    "configurable": {
+                        "foo_model": "claude-3-5-sonnet-20240620",
+                        "foo_model_provider": "anthropic",
+                        "foo_temperature": 0.6
+                    }
+                }
+            )
+            # Claude-3.5 sonnet response with temperature 0.6
+
+    Bind tools to a configurable model:
+        You can call any ChatModel declarative methods on a configurable model in the
+        same way that you would with a normal model.
+
+        .. code-block:: python
+
+            # pip install langchain langchain-openai langchain-anthropic
+            from langchain.chat_models import init_chat_model
+            from langchain_core.pydantic_v1 import BaseModel, Field
+
+            class GetWeather(BaseModel):
+                '''Get the current weather in a given location'''
+
+                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+            class GetPopulation(BaseModel):
+                '''Get the current population in a given location'''
+
+                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+
+            configurable_model = init_chat_model(
+                "gpt-4o",
+                configurable_fields=("model", "model_provider"),
+                temperature=0
+            )
+
+            configurable_model_with_tools = configurable_model.bind_tools([GetWeather, GetPopulation])
+            configurable_model_with_tools.invoke(
+                "Which city is hotter today and which is bigger: LA or NY?"
+            )
+            # GPT-4o response with tool calls
+
+            configurable_model_with_tools.invoke(
+                "Which city is hotter today and which is bigger: LA or NY?",
+                config={"configurable": {"model": "claude-3-5-sonnet-20240620"}}
+            )
+            # Claude-3.5 sonnet response with tools
     """  # noqa: E501
+    if not model and not configurable_fields:
+        configurable_fields = ("model", "model_provider")
+    config_prefix = config_prefix or ""
+    if config_prefix and not configurable_fields:
+        warnings.warn(
+            f"{config_prefix=} has been set but no fields are configurable. Set "
+            f"`configurable_fields=(...)` to specify the model params that are "
+            f"configurable."
+        )
+
+    if not configurable_fields:
+        return _init_chat_model_helper(
+            cast(str, model), model_provider=model_provider, **kwargs
+        )
+    else:
+        if model:
+            kwargs["model"] = model
+        if model_provider:
+            kwargs["model_provider"] = model_provider
+        return _ConfigurableModel(
+            default_config=kwargs,
+            config_prefix=config_prefix,
+            configurable_fields=configurable_fields,
+        )
+
+
+def _init_chat_model_helper(
+    model: str, *, model_provider: Optional[str] = None, **kwargs: Any
+) -> BaseChatModel:
     model_provider = model_provider or _attempt_infer_model_provider(model)
     if not model_provider:
         raise ValueError(
@@ -200,3 +415,386 @@ def _check_pkg(pkg: str) -> None:
             f"Unable to import {pkg_kebab}. Please install with "
             f"`pip install -U {pkg_kebab}`"
         )
+
+
+def _remove_prefix(s: str, prefix: str) -> str:
+    if s.startswith(prefix):
+        s = s[len(prefix) :]
+    return s
+
+
+_DECLARATIVE_METHODS = ("bind_tools", "with_structured_output")
+
+
+class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
+    def __init__(
+        self,
+        *,
+        default_config: Optional[dict] = None,
+        configurable_fields: Union[Literal["any"], List[str], Tuple[str, ...]] = "any",
+        config_prefix: str = "",
+        queued_declarative_operations: Sequence[Tuple[str, Tuple, Dict]] = (),
+    ) -> None:
+        self._default_config: dict = default_config or {}
+        self._configurable_fields: Union[Literal["any"], List[str]] = (
+            configurable_fields
+            if configurable_fields == "any"
+            else list(configurable_fields)
+        )
+        self._config_prefix = (
+            config_prefix + "_"
+            if config_prefix and not config_prefix.endswith("_")
+            else config_prefix
+        )
+        self._queued_declarative_operations: List[Tuple[str, Tuple, Dict]] = list(
+            queued_declarative_operations
+        )
+
+    def __getattr__(self, name: str) -> Any:
+        if name in _DECLARATIVE_METHODS:
+            # Declarative operations that cannot be applied until after an actual model
+            # object is instantiated. So instead of returning the actual operation,
+            # we record the operation and its arguments in a queue. This queue is
+            # then applied in order whenever we actually instantiate the model (in
+            # self._model()).
+            def queue(*args: Any, **kwargs: Any) -> _ConfigurableModel:
+                queued_declarative_operations = list(
+                    self._queued_declarative_operations
+                )
+                queued_declarative_operations.append((name, args, kwargs))
+                return _ConfigurableModel(
+                    default_config=dict(self._default_config),
+                    configurable_fields=list(self._configurable_fields)
+                    if isinstance(self._configurable_fields, list)
+                    else self._configurable_fields,
+                    config_prefix=self._config_prefix,
+                    queued_declarative_operations=queued_declarative_operations,
+                )
+
+            return queue
+        elif self._default_config and (model := self._model()) and hasattr(model, name):
+            return getattr(model, name)
+        else:
+            msg = f"{name} is not a BaseChatModel attribute"
+            if self._default_config:
+                msg += " and is not implemented on the default model"
+            msg += "."
+            raise AttributeError(msg)
+
+    def _model(self, config: Optional[RunnableConfig] = None) -> Runnable:
+        params = {**self._default_config, **self._model_params(config)}
+        model = _init_chat_model_helper(**params)
+        for name, args, kwargs in self._queued_declarative_operations:
+            model = getattr(model, name)(*args, **kwargs)
+        return model
+
+    def _model_params(self, config: Optional[RunnableConfig]) -> dict:
+        config = config or {}
+        model_params = {
+            _remove_prefix(k, self._config_prefix): v
+            for k, v in config.get("configurable", {}).items()
+            if k.startswith(self._config_prefix)
+        }
+        if self._configurable_fields != "any":
+            model_params = {
+                k: v for k, v in model_params.items() if k in self._configurable_fields
+            }
+        return model_params
+
+    def with_config(
+        self,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> _ConfigurableModel:
+        """Bind config to a Runnable, returning a new Runnable."""
+        config = RunnableConfig(**(config or {}), **cast(RunnableConfig, kwargs))
+        model_params = self._model_params(config)
+        remaining_config = {k: v for k, v in config.items() if k != "configurable"}
+        remaining_config["configurable"] = {
+            k: v
+            for k, v in config.get("configurable", {}).items()
+            if _remove_prefix(k, self._config_prefix) not in model_params
+        }
+        queued_declarative_operations = list(self._queued_declarative_operations)
+        if remaining_config:
+            queued_declarative_operations.append(
+                ("with_config", (), {"config": remaining_config})
+            )
+        return _ConfigurableModel(
+            default_config={**self._default_config, **model_params},
+            configurable_fields=list(self._configurable_fields)
+            if isinstance(self._configurable_fields, list)
+            else self._configurable_fields,
+            config_prefix=self._config_prefix,
+            queued_declarative_operations=queued_declarative_operations,
+        )
+
+    @property
+    def InputType(self) -> TypeAlias:
+        """Get the input type for this runnable."""
+        from langchain_core.prompt_values import (
+            ChatPromptValueConcrete,
+            StringPromptValue,
+        )
+
+        # This is a version of LanguageModelInput which replaces the abstract
+        # base class BaseMessage with a union of its subclasses, which makes
+        # for a much better schema.
+        return Union[
+            str,
+            Union[StringPromptValue, ChatPromptValueConcrete],
+            List[AnyMessage],
+        ]
+
+    def invoke(
+        self,
+        input: LanguageModelInput,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Any:
+        return self._model(config).invoke(input, config=config, **kwargs)
+
+    async def ainvoke(
+        self,
+        input: LanguageModelInput,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Any:
+        return await self._model(config).ainvoke(input, config=config, **kwargs)
+
+    def stream(
+        self,
+        input: LanguageModelInput,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Optional[Any],
+    ) -> Iterator[Any]:
+        yield from self._model(config).stream(input, config=config, **kwargs)
+
+    async def astream(
+        self,
+        input: LanguageModelInput,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Optional[Any],
+    ) -> AsyncIterator[Any]:
+        async for x in self._model(config).astream(input, config=config, **kwargs):
+            yield x
+
+    def batch(
+        self,
+        inputs: List[LanguageModelInput],
+        config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
+        *,
+        return_exceptions: bool = False,
+        **kwargs: Optional[Any],
+    ) -> List[Any]:
+        config = config or None
+        # If <= 1 config use the underlying models batch implementation.
+        if config is None or isinstance(config, dict) or len(config) <= 1:
+            if isinstance(config, list):
+                config = config[0]
+            return self._model(config).batch(
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            )
+        # If multiple configs default to Runnable.batch which uses executor to invoke
+        # in parallel.
+        else:
+            return super().batch(
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            )
+
+    async def abatch(
+        self,
+        inputs: List[LanguageModelInput],
+        config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
+        *,
+        return_exceptions: bool = False,
+        **kwargs: Optional[Any],
+    ) -> List[Any]:
+        config = config or None
+        # If <= 1 config use the underlying models batch implementation.
+        if config is None or isinstance(config, dict) or len(config) <= 1:
+            if isinstance(config, list):
+                config = config[0]
+            return await self._model(config).abatch(
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            )
+        # If multiple configs default to Runnable.batch which uses executor to invoke
+        # in parallel.
+        else:
+            return await super().abatch(
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            )
+
+    def batch_as_completed(
+        self,
+        inputs: Sequence[LanguageModelInput],
+        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        *,
+        return_exceptions: bool = False,
+        **kwargs: Any,
+    ) -> Iterator[Tuple[int, Union[Any, Exception]]]:
+        config = config or None
+        # If <= 1 config use the underlying models batch implementation.
+        if config is None or isinstance(config, dict) or len(config) <= 1:
+            if isinstance(config, list):
+                config = config[0]
+            yield from self._model(cast(RunnableConfig, config)).batch_as_completed(  # type: ignore[call-overload]
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            )
+        # If multiple configs default to Runnable.batch which uses executor to invoke
+        # in parallel.
+        else:
+            yield from super().batch_as_completed(  # type: ignore[call-overload]
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            )
+
+    async def abatch_as_completed(
+        self,
+        inputs: Sequence[LanguageModelInput],
+        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        *,
+        return_exceptions: bool = False,
+        **kwargs: Any,
+    ) -> AsyncIterator[Tuple[int, Any]]:
+        config = config or None
+        # If <= 1 config use the underlying models batch implementation.
+        if config is None or isinstance(config, dict) or len(config) <= 1:
+            if isinstance(config, list):
+                config = config[0]
+            async for x in self._model(
+                cast(RunnableConfig, config)
+            ).abatch_as_completed(  # type: ignore[call-overload]
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            ):
+                yield x
+        # If multiple configs default to Runnable.batch which uses executor to invoke
+        # in parallel.
+        else:
+            async for x in super().abatch_as_completed(  # type: ignore[call-overload]
+                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            ):
+                yield x
+
+    def transform(
+        self,
+        input: Iterator[LanguageModelInput],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Optional[Any],
+    ) -> Iterator[Any]:
+        for x in self._model(config).transform(input, config=config, **kwargs):
+            yield x
+
+    async def atransform(
+        self,
+        input: AsyncIterator[LanguageModelInput],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Optional[Any],
+    ) -> AsyncIterator[Any]:
+        async for x in self._model(config).atransform(input, config=config, **kwargs):
+            yield x
+
+    @overload
+    def astream_log(
+        self,
+        input: Any,
+        config: Optional[RunnableConfig] = None,
+        *,
+        diff: Literal[True] = True,
+        with_streamed_output_list: bool = True,
+        include_names: Optional[Sequence[str]] = None,
+        include_types: Optional[Sequence[str]] = None,
+        include_tags: Optional[Sequence[str]] = None,
+        exclude_names: Optional[Sequence[str]] = None,
+        exclude_types: Optional[Sequence[str]] = None,
+        exclude_tags: Optional[Sequence[str]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[RunLogPatch]: ...
+
+    @overload
+    def astream_log(
+        self,
+        input: Any,
+        config: Optional[RunnableConfig] = None,
+        *,
+        diff: Literal[False],
+        with_streamed_output_list: bool = True,
+        include_names: Optional[Sequence[str]] = None,
+        include_types: Optional[Sequence[str]] = None,
+        include_tags: Optional[Sequence[str]] = None,
+        exclude_names: Optional[Sequence[str]] = None,
+        exclude_types: Optional[Sequence[str]] = None,
+        exclude_tags: Optional[Sequence[str]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[RunLog]: ...
+
+    async def astream_log(
+        self,
+        input: Any,
+        config: Optional[RunnableConfig] = None,
+        *,
+        diff: bool = True,
+        with_streamed_output_list: bool = True,
+        include_names: Optional[Sequence[str]] = None,
+        include_types: Optional[Sequence[str]] = None,
+        include_tags: Optional[Sequence[str]] = None,
+        exclude_names: Optional[Sequence[str]] = None,
+        exclude_types: Optional[Sequence[str]] = None,
+        exclude_tags: Optional[Sequence[str]] = None,
+        **kwargs: Any,
+    ) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
+        async for x in self._model(config).astream_log(  # type: ignore[call-overload, misc]
+            input,
+            config=config,
+            diff=diff,
+            with_streamed_output_list=with_streamed_output_list,
+            include_names=include_names,
+            include_types=include_types,
+            include_tags=include_tags,
+            exclude_tags=exclude_tags,
+            exclude_types=exclude_types,
+            exclude_names=exclude_names,
+            **kwargs,
+        ):
+            yield x
+
+    async def astream_events(
+        self,
+        input: Any,
+        config: Optional[RunnableConfig] = None,
+        *,
+        version: Literal["v1", "v2"],
+        include_names: Optional[Sequence[str]] = None,
+        include_types: Optional[Sequence[str]] = None,
+        include_tags: Optional[Sequence[str]] = None,
+        exclude_names: Optional[Sequence[str]] = None,
+        exclude_types: Optional[Sequence[str]] = None,
+        exclude_tags: Optional[Sequence[str]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[StreamEvent]:
+        async for x in self._model(config).astream_events(
+            input,
+            config=config,
+            version=version,
+            include_names=include_names,
+            include_types=include_types,
+            include_tags=include_tags,
+            exclude_tags=exclude_tags,
+            exclude_types=exclude_types,
+            exclude_names=exclude_names,
+            **kwargs,
+        ):
+            yield x
+
+    # Explicitly added to satisfy downstream linters.
+    def bind_tools(
+        self,
+        tools: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool]],
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, BaseMessage]:
+        return self.__getattr__("bind_tools")(tools, **kwargs)
+
+    # Explicitly added to satisfy downstream linters.
+    def with_structured_output(
+        self, schema: Union[Dict, Type[BaseModel]], **kwargs: Any
+    ) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
+        return self.__getattr__("with_structured_output")(schema, **kwargs)

langchain/retrievers/multi_vector.py

@@ -19,6 +19,8 @@ class SearchType(str, Enum):
 
     similarity = "similarity"
     """Similarity search."""
+    similarity_score_threshold = "similarity_score_threshold"
+    """Similarity search with a score threshold."""
     mmr = "mmr"
     """Maximal Marginal Relevance reranking of similarity search."""
 
@@ -64,6 +66,13 @@ class MultiVectorRetriever(BaseRetriever):
             sub_docs = self.vectorstore.max_marginal_relevance_search(
                 query, **self.search_kwargs
             )
+        elif self.search_type == SearchType.similarity_score_threshold:
+            sub_docs_and_similarities = (
+                self.vectorstore.similarity_search_with_relevance_scores(
+                    query, **self.search_kwargs
+                )
+            )
+            sub_docs = [sub_doc for sub_doc, _ in sub_docs_and_similarities]
         else:
             sub_docs = self.vectorstore.similarity_search(query, **self.search_kwargs)
 
@@ -89,6 +98,13 @@ class MultiVectorRetriever(BaseRetriever):
             sub_docs = await self.vectorstore.amax_marginal_relevance_search(
                 query, **self.search_kwargs
             )
+        elif self.search_type == SearchType.similarity_score_threshold:
+            sub_docs_and_similarities = (
+                await self.vectorstore.asimilarity_search_with_relevance_scores(
+                    query, **self.search_kwargs
+                )
+            )
+            sub_docs = [sub_doc for sub_doc, _ in sub_docs_and_similarities]
         else:
             sub_docs = await self.vectorstore.asimilarity_search(
                 query, **self.search_kwargs

{langchain-0.2.7.dist-info → langchain-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain
-Version: 0.2.7
+Version: 0.2.9
 Summary: Building applications with LLMs through composability
 Home-page: https://github.com/langchain-ai/langchain
 License: MIT
@@ -15,7 +15,7 @@ Requires-Dist: PyYAML (>=5.3)
 Requires-Dist: SQLAlchemy (>=1.4,<3)
 Requires-Dist: aiohttp (>=3.8.3,<4.0.0)
 Requires-Dist: async-timeout (>=4.0.0,<5.0.0) ; python_version < "3.11"
-Requires-Dist: langchain-core (>=0.2.12,<0.3.0)
+Requires-Dist: langchain-core (>=0.2.20,<0.3.0)
 Requires-Dist: langchain-text-splitters (>=0.2.0,<0.3.0)
 Requires-Dist: langsmith (>=0.1.17,<0.2.0)
 Requires-Dist: numpy (>=1,<2) ; python_version < "3.12"

{langchain-0.2.7.dist-info → langchain-0.2.9.dist-info}/RECORD

@@ -111,7 +111,7 @@ langchain/agents/mrkl/base.py,sha256=cj73s3Z0JxQotFgqhnxEDNkZT4nlL69g3ZleHkUuma4
 langchain/agents/mrkl/output_parser.py,sha256=YQGSjQq5pR4kFUg1HrOS3laV6xgtHgtIOQ_TtJY0UFI,3720
 langchain/agents/mrkl/prompt.py,sha256=2dTMP2lAWiLvCtuEijgQRjbKDlbPEnmx77duMwdJ7e4,641
 langchain/agents/openai_assistant/__init__.py,sha256=Xssaqoxrix3hn1gKSOLmDRQzTxAoJk0ProGXmXQe8Mw,114
-langchain/agents/openai_assistant/base.py,sha256=GEY-Wq6OgPMesE76oNF0Tr2fn_g27R4UXhYUHAOOkvM,28228
+langchain/agents/openai_assistant/base.py,sha256=L_YWEbv9f2MBUae7wpWIka3RroKzU_XXwVpbdP5XfAE,28257
 langchain/agents/openai_functions_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain/agents/openai_functions_agent/agent_token_buffer_memory.py,sha256=t3J3Qku4lvs-EGTbPRzhrxAwTVBoEj4tu5wbl5u2-N0,3764
 langchain/agents/openai_functions_agent/base.py,sha256=sMPCrDXhJDZ_fnkpy0fJ0Ptfm02w0_3_JXm9Nktq3NQ,13498
@@ -221,7 +221,7 @@ langchain/chains/combine_documents/map_reduce.py,sha256=s9Z3r-STCqBs3cnbrsaE6Cxw
 langchain/chains/combine_documents/map_rerank.py,sha256=oZAWR7_4v_L9PZDve3PVA-f3kU2WJiBTP98NqSwB2Is,9039
 langchain/chains/combine_documents/reduce.py,sha256=kpUPpvs2dr1ewqdisaw8-O_m0_uu_uKO6wXfzevZjo8,13894
 langchain/chains/combine_documents/refine.py,sha256=CZJ0-KpIVd2AUucYJPPvW93d9FXfZVZgkOMXUqLrv6Y,9138
-langchain/chains/combine_documents/stuff.py,sha256=K6MMICU8zjwMT-9JAfomAe5VxKgrKVGcKzX4eN8CKgM,10959
+langchain/chains/combine_documents/stuff.py,sha256=zvoTEVO9ML-mrt7rz0hjqe95A7q-lr9YnkHdGi8Xyis,11209
 langchain/chains/constitutional_ai/__init__.py,sha256=Woq_Efl5d-MSTkhpg7HLts3kXysJVZLiz3tr05NTf5Q,107
 langchain/chains/constitutional_ai/base.py,sha256=ANJ2nkpYt8cJ7_PoBVDm3DDGSTO1-oT3h8DFoH2gQRQ,6342
 langchain/chains/constitutional_ai/models.py,sha256=qa5pmegx6iPmL7hJzhb6ytUkIZMSqbeRzua_M2hx_PE,284
@@ -360,7 +360,7 @@ langchain/chat_models/azure_openai.py,sha256=aRNol2PNC49PmvdZnwjhQeMFRDOOelPNAXz
 langchain/chat_models/azureml_endpoint.py,sha256=6mxXm8UFXataLp0NYRGA88V3DpiNKPo095u_JGj7XGE,863
 langchain/chat_models/baichuan.py,sha256=3-GveFoF5ZNyLdRNK6V4i3EDDjdseOTFWbCMhDbtO9w,643
 langchain/chat_models/baidu_qianfan_endpoint.py,sha256=CZrX2SMpbE9H7wBXNC6rGvw-YqQl9zjuJrClYQxEzuI,715
-langchain/chat_models/base.py,sha256=i8CvjUZlRdrbEFT3RmoONDhip3HzZaS-DdxK-MrBmtw,7268
+langchain/chat_models/base.py,sha256=5fPcdb1ZaFuYPI0tIKQ1z5Qo8gLD50ICHOkX-x6wwP8,30099
 langchain/chat_models/bedrock.py,sha256=HRV3T_0mEnZ8LvJJqAA_UVpt-_03G715oIgomRJw55M,757
 langchain/chat_models/cohere.py,sha256=EYOECHX-nKRhZVfCfmFGZ2lr51PzaB5OvOEqmBCu1fI,633
 langchain/chat_models/databricks.py,sha256=5_QkC5lG4OldaHC2FS0XylirJouyZx1YT95SKwc12M0,653
@@ -890,7 +890,7 @@ langchain/retrievers/merger_retriever.py,sha256=uzwpkarGfgByXbqCFYNHXL-mczqfTgJI
 langchain/retrievers/metal.py,sha256=E9KmySjhmpq_kZhDhOLS8sH4KpbOnWUodR4-3Kd2E30,629
 langchain/retrievers/milvus.py,sha256=f_vi-uodWcS5PyYq-8QD8S7Bx1t_uVswQtqG2D35XnE,796
 langchain/retrievers/multi_query.py,sha256=2G90v5RxXiqM5JWIz6k8cgSdcrJ4uSGR6cebbCYFhbU,7049
-langchain/retrievers/multi_vector.py,sha256=0bt0wTfm1Ha21fH3Ikoln-iXzbnyHIh6lWI1vrmZMaI,3920
+langchain/retrievers/multi_vector.py,sha256=rb5gDEAzhzHURJ-VfKGnvq7erZ-xWklnk8RQCBTNsds,4731
 langchain/retrievers/outline.py,sha256=uNuqhoHkfDx73ZEYbHbFjVmJfW-eAdLUzyC9EuoV608,635
 langchain/retrievers/parent_document_retriever.py,sha256=Xhy2tnAl1dmrajt-iu78BiFFp2SEGoy0Zi2lIlljDFY,5236
 langchain/retrievers/pinecone_hybrid_search.py,sha256=oEbmHdKIZ86H1O8GhzNC1KVfKb_xAJdRJXpODMY6X3Y,674
@@ -1334,8 +1334,8 @@ langchain/vectorstores/xata.py,sha256=HW_Oi5Hz8rH2JaUhRNWQ-3hLYmNzD8eAz6K5YqPArm
 langchain/vectorstores/yellowbrick.py,sha256=-lnjGcRE8Q1nEPOTdbKYTw5noS2cy2ce1ePOU804-_o,624
 langchain/vectorstores/zep.py,sha256=RJ2auxoA6uHHLEZknw3_jeFmYJYVt-PWKMBcNMGV6TM,798
 langchain/vectorstores/zilliz.py,sha256=XhPPIUfKPFJw0_svCoBgCnNkkBLoRVVcyuMfOnE5IxU,609
-langchain-0.2.7.dist-info/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
-langchain-0.2.7.dist-info/METADATA,sha256=71aSC-MAJ-zNdn8p7yQZk_yPm2LNozC_okAyOvqd0Yg,6854
-langchain-0.2.7.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langchain-0.2.7.dist-info/entry_points.txt,sha256=IgKjoXnkkVC8Nm7ggiFMCNAk01ua6RVTb9cmZTVNm5w,58
-langchain-0.2.7.dist-info/RECORD,,
+langchain-0.2.9.dist-info/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
+langchain-0.2.9.dist-info/METADATA,sha256=rRRjxzIaypaG1Ho9TlqNp6ruV5ii_yDIhFFC714s8xo,6854
+langchain-0.2.9.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+langchain-0.2.9.dist-info/entry_points.txt,sha256=IgKjoXnkkVC8Nm7ggiFMCNAk01ua6RVTb9cmZTVNm5w,58
+langchain-0.2.9.dist-info/RECORD,,