langchain-core 0.3.0.dev1__tar.gz → 0.3.0.dev3__tar.gz

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-core
-Version: 0.3.0.dev1
+Version: 0.3.0.dev3
 Summary: Building applications with LLMs through composability
 Home-page: https://github.com/langchain-ai/langchain
 License: MIT
@@ -13,9 +13,9 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: PyYAML (>=5.3)
 Requires-Dist: jsonpatch (>=1.33,<2.0)
-Requires-Dist: langsmith (>=0.1.75,<0.2.0)
+Requires-Dist: langsmith (>=0.1.112,<0.2.0)
 Requires-Dist: packaging (>=23.2,<25)
-Requires-Dist: pydantic (>=2,<3)
+Requires-Dist: pydantic (>=2.9,<3.0)
 Requires-Dist: tenacity (>=8.1.0,<9.0.0,!=8.4.0)
 Requires-Dist: typing-extensions (>=4.7)
 Project-URL: Repository, https://github.com/langchain-ai/langchain

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/_api/deprecation.py

@@ -144,7 +144,7 @@ def deprecated(
         _package: str = package,
     ) -> T:
         """Implementation of the decorator returned by `deprecated`."""
-        from langchain_core.utils.pydantic import FieldInfoV1
+        from langchain_core.utils.pydantic import FieldInfoV1, FieldInfoV2
 
         def emit_warning() -> None:
             """Emit the warning."""
@@ -238,6 +238,25 @@ def deprecated(
                         exclude=obj.exclude,
                     ),
                 )
+        elif isinstance(obj, FieldInfoV2):
+            wrapped = None
+            if not _obj_type:
+                _obj_type = "attribute"
+            if not _name:
+                raise ValueError(f"Field {obj} must have a name to be deprecated.")
+            old_doc = obj.description
+
+            def finalize(wrapper: Callable[..., Any], new_doc: str) -> T:
+                return cast(
+                    T,
+                    FieldInfoV2(
+                        default=obj.default,
+                        default_factory=obj.default_factory,
+                        description=new_doc,
+                        alias=obj.alias,
+                        exclude=obj.exclude,
+                    ),
+                )
 
         elif isinstance(obj, property):
             if not _obj_type:

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/documents/base.py

@@ -9,7 +9,6 @@ from typing import Any, Dict, Generator, List, Literal, Optional, Union, cast
 from pydantic import ConfigDict, Field, model_validator
 
 from langchain_core.load.serializable import Serializable
-from langchain_core.utils.pydantic import v1_repr
 
 PathLike = Union[str, PurePath]
 
@@ -297,7 +296,3 @@ class Document(BaseMedia):
             return f"page_content='{self.page_content}' metadata={self.metadata}"
         else:
             return f"page_content='{self.page_content}'"
-
-    def __repr__(self) -> str:
-        # TODO(0.3): Remove this override after confirming unit tests!
-        return v1_repr(self)

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/example_selectors/length_based.py

@@ -3,7 +3,8 @@
 import re
 from typing import Callable, Dict, List
 
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, Field, model_validator
+from typing_extensions import Self
 
 from langchain_core.example_selectors.base import BaseExampleSelector
 from langchain_core.prompts.prompt import PromptTemplate
@@ -28,7 +29,7 @@ class LengthBasedExampleSelector(BaseExampleSelector, BaseModel):
     max_length: int = 2048
     """Max length for the prompt, beyond which examples are cut."""
 
-    example_text_lengths: List[int] = []  #: :meta private:
+    example_text_lengths: List[int] = Field(default_factory=list)  # :meta private:
     """Length of each example."""
 
     def add_example(self, example: Dict[str, str]) -> None:
@@ -52,17 +53,14 @@ class LengthBasedExampleSelector(BaseExampleSelector, BaseModel):
 
         self.add_example(example)
 
-    @validator("example_text_lengths", always=True)
-    def calculate_example_text_lengths(cls, v: List[int], values: Dict) -> List[int]:
-        """Calculate text lengths if they don't exist."""
-        # Check if text lengths were passed in
-        if v:
-            return v
-        # If they were not, calculate them
-        example_prompt = values["example_prompt"]
-        get_text_length = values["get_text_length"]
-        string_examples = [example_prompt.format(**eg) for eg in values["examples"]]
-        return [get_text_length(eg) for eg in string_examples]
+    @model_validator(mode="after")
+    def post_init(self) -> Self:
+        """Validate that the examples are formatted correctly."""
+        if self.example_text_lengths:
+            return self
+        string_examples = [self.example_prompt.format(**eg) for eg in self.examples]
+        self.example_text_lengths = [self.get_text_length(eg) for eg in string_examples]
+        return self
 
     def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:
         """Select which examples to use based on the input lengths.

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/indexing/in_memory.py

@@ -32,7 +32,7 @@ class InMemoryDocumentIndex(DocumentIndex):
         for item in items:
             if item.id is None:
                 id_ = str(uuid.uuid4())
-                item_ = item.copy()
+                item_ = item.model_copy()
                 item_.id = id_
             else:
                 item_ = item
@@ -79,4 +79,4 @@ class InMemoryDocumentIndex(DocumentIndex):
             counts_by_doc.append((document, count))
 
         counts_by_doc.sort(key=lambda x: x[1], reverse=True)
-        return [doc.copy() for doc, count in counts_by_doc[: self.top_k]]
+        return [doc.model_copy() for doc, count in counts_by_doc[: self.top_k]]

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/language_models/base.py

@@ -18,7 +18,7 @@ from typing import (
     Union,
 )
 
-from pydantic import BaseModel, ConfigDict, Field, validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 from typing_extensions import TypeAlias, TypedDict
 
 from langchain_core._api import deprecated
@@ -134,7 +134,7 @@ class BaseLanguageModel(
         arbitrary_types_allowed=True,
     )
 
-    @validator("verbose", pre=True, always=True, allow_reuse=True)
+    @field_validator("verbose", mode="before")
     def set_verbose(cls, verbose: Optional[bool]) -> bool:
         """If verbose is None, set it.
 

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/load/load.py

@@ -18,6 +18,7 @@ DEFAULT_NAMESPACES = [
     "langchain_community",
     "langchain_anthropic",
     "langchain_groq",
+    "langchain_google_genai",
 ]
 
 ALL_SERIALIZABLE_MAPPINGS = {

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/load/mapping.py

@@ -297,6 +297,17 @@ SERIALIZABLE_MAPPING: Dict[Tuple[str, ...], Tuple[str, ...]] = {
         "chat_models",
         "ChatMistralAI",
     ),
+    ("langchain", "chat_models", "bedrock", "ChatBedrock"): (
+        "langchain_aws",
+        "chat_models",
+        "bedrock",
+        "ChatBedrock",
+    ),
+    ("langchain_google_genai", "chat_models", "ChatGoogleGenerativeAI"): (
+        "langchain_google_genai",
+        "chat_models",
+        "ChatGoogleGenerativeAI",
+    ),
     ("langchain", "schema", "output", "ChatGenerationChunk"): (
         "langchain_core",
         "outputs",

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/load/serializable.py

@@ -13,8 +13,6 @@ from typing import (
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import NotRequired
 
-from langchain_core.utils.pydantic import v1_repr
-
 
 class BaseSerialized(TypedDict):
     """Base class for serialized objects.
@@ -259,10 +257,6 @@ class Serializable(BaseModel, ABC):
     def to_json_not_implemented(self) -> SerializedNotImplemented:
         return to_json_not_implemented(self)
 
-    def __repr__(self) -> str:
-        # TODO(0.3): Remove this override after confirming unit tests!
-        return v1_repr(self)
-
 
 def _is_field_useful(inst: Serializable, key: str, value: Any) -> bool:
     """Check if a field is useful as a constructor argument.

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/messages/base.py

@@ -8,7 +8,6 @@ from langchain_core.load.serializable import Serializable
 from langchain_core.utils import get_bolded_text
 from langchain_core.utils._merge import merge_dicts, merge_lists
 from langchain_core.utils.interactive_env import is_interactive_env
-from langchain_core.utils.pydantic import v1_repr
 
 if TYPE_CHECKING:
     from langchain_core.prompts.chat import ChatPromptTemplate
@@ -111,10 +110,6 @@ class BaseMessage(Serializable):
     def pretty_print(self) -> None:
         print(self.pretty_repr(html=is_interactive_env()))  # noqa: T201
 
-    def __repr__(self) -> str:
-        # TODO(0.3): Remove this override after confirming unit tests!
-        return v1_repr(self)
-
 
 def merge_content(
     first_content: Union[str, List[Union[str, Dict]]],
@@ -237,7 +232,7 @@ def message_to_dict(message: BaseMessage) -> dict:
         Message as a dict. The dict will have a "type" key with the message type
         and a "data" key with the message data as a dict.
     """
-    return {"type": message.type, "data": message.dict()}
+    return {"type": message.type, "data": message.model_dump()}
 
 
 def messages_to_dict(messages: Sequence[BaseMessage]) -> List[dict]:

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/messages/utils.py

@@ -29,6 +29,9 @@ from typing import (
     overload,
 )
 
+from pydantic import Discriminator, Field
+from typing_extensions import Annotated
+
 from langchain_core.messages.ai import AIMessage, AIMessageChunk
 from langchain_core.messages.base import BaseMessage, BaseMessageChunk
 from langchain_core.messages.chat import ChatMessage, ChatMessageChunk
@@ -45,19 +48,23 @@ if TYPE_CHECKING:
     from langchain_core.prompt_values import PromptValue
     from langchain_core.runnables.base import Runnable
 
-AnyMessage = Union[
-    AIMessage,
-    HumanMessage,
-    ChatMessage,
-    SystemMessage,
-    FunctionMessage,
-    ToolMessage,
-    AIMessageChunk,
-    HumanMessageChunk,
-    ChatMessageChunk,
-    SystemMessageChunk,
-    FunctionMessageChunk,
-    ToolMessageChunk,
+
+AnyMessage = Annotated[
+    Union[
+        AIMessage,
+        HumanMessage,
+        ChatMessage,
+        SystemMessage,
+        FunctionMessage,
+        ToolMessage,
+        AIMessageChunk,
+        HumanMessageChunk,
+        ChatMessageChunk,
+        SystemMessageChunk,
+        FunctionMessageChunk,
+        ToolMessageChunk,
+    ],
+    Field(discriminator=Discriminator("type")),
 ]
 
 
@@ -521,7 +528,7 @@ def merge_message_runs(
     messages = convert_to_messages(messages)
     merged: List[BaseMessage] = []
     for msg in messages:
-        curr = msg.copy(deep=True)
+        curr = msg.model_copy(deep=True)
         last = merged.pop() if merged else None
         if not last:
             merged.append(curr)
@@ -872,7 +879,7 @@ def _first_max_tokens(
     if idx < len(messages) - 1 and partial_strategy:
         included_partial = False
         if isinstance(messages[idx].content, list):
-            excluded = messages[idx].copy(deep=True)
+            excluded = messages[idx].model_copy(deep=True)
             num_block = len(excluded.content)
             if partial_strategy == "last":
                 excluded.content = list(reversed(excluded.content))
@@ -886,7 +893,7 @@ def _first_max_tokens(
             if included_partial and partial_strategy == "last":
                 excluded.content = list(reversed(excluded.content))
         if not included_partial:
-            excluded = messages[idx].copy(deep=True)
+            excluded = messages[idx].model_copy(deep=True)
             if isinstance(excluded.content, list) and any(
                 isinstance(block, str) or block["type"] == "text"
                 for block in messages[idx].content
@@ -977,11 +984,11 @@ _CHUNK_MSG_MAP = {v: k for k, v in _MSG_CHUNK_MAP.items()}
 
 def _msg_to_chunk(message: BaseMessage) -> BaseMessageChunk:
     if message.__class__ in _MSG_CHUNK_MAP:
-        return _MSG_CHUNK_MAP[message.__class__](**message.dict(exclude={"type"}))
+        return _MSG_CHUNK_MAP[message.__class__](**message.model_dump(exclude={"type"}))
 
     for msg_cls, chunk_cls in _MSG_CHUNK_MAP.items():
         if isinstance(message, msg_cls):
-            return chunk_cls(**message.dict(exclude={"type"}))
+            return chunk_cls(**message.model_dump(exclude={"type"}))
 
     raise ValueError(
         f"Unrecognized message class {message.__class__}. Supported classes are "
@@ -992,11 +999,11 @@ def _msg_to_chunk(message: BaseMessage) -> BaseMessageChunk:
 def _chunk_to_msg(chunk: BaseMessageChunk) -> BaseMessage:
     if chunk.__class__ in _CHUNK_MSG_MAP:
         return _CHUNK_MSG_MAP[chunk.__class__](
-            **chunk.dict(exclude={"type", "tool_call_chunks"})
+            **chunk.model_dump(exclude={"type", "tool_call_chunks"})
         )
     for chunk_cls, msg_cls in _CHUNK_MSG_MAP.items():
         if isinstance(chunk, chunk_cls):
-            return msg_cls(**chunk.dict(exclude={"type", "tool_call_chunks"}))
+            return msg_cls(**chunk.model_dump(exclude={"type", "tool_call_chunks"}))
 
     raise ValueError(
         f"Unrecognized message chunk class {chunk.__class__}. Supported classes are "

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/output_parsers/json.py

@@ -54,8 +54,8 @@ class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
             if issubclass(pydantic_object, pydantic.BaseModel):
                 return pydantic_object.model_json_schema()
             elif issubclass(pydantic_object, pydantic.v1.BaseModel):
-                return pydantic_object.schema()
-        return pydantic_object.schema()
+                return pydantic_object.model_json_schema()
+        return pydantic_object.model_json_schema()
 
     def parse_result(self, result: List[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/output_parsers/openai_functions.py

@@ -275,10 +275,14 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
         else:
             fn_name = _result["name"]
             _args = _result["arguments"]
-            if hasattr(self.pydantic_schema, "model_validate_json"):
-                pydantic_args = self.pydantic_schema[fn_name].model_validate_json(_args)  # type: ignore
+            if isinstance(self.pydantic_schema, dict):
+                pydantic_schema = self.pydantic_schema[fn_name]
+            else:
+                pydantic_schema = self.pydantic_schema
+            if hasattr(pydantic_schema, "model_validate_json"):
+                pydantic_args = pydantic_schema.model_validate_json(_args)  # type: ignore
             else:
-                pydantic_args = self.pydantic_schema[fn_name].parse_raw(_args)  # type: ignore
+                pydantic_args = pydantic_schema.parse_raw(_args)  # type: ignore
         return pydantic_args
 
 

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/output_parsers/pydantic.py

@@ -90,7 +90,7 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
             The format instructions for the JSON output.
         """
         # Copy schema to avoid altering original Pydantic schema.
-        schema = {k: v for k, v in self.pydantic_object.schema().items()}
+        schema = {k: v for k, v in self.pydantic_object.model_json_schema().items()}
 
         # Remove extraneous fields.
         reduced_schema = schema

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/prompts/base.py

@@ -310,7 +310,7 @@ class BasePromptTemplate(
         Raises:
             NotImplementedError: If the prompt type is not implemented.
         """
-        prompt_dict = super().dict(**kwargs)
+        prompt_dict = super().model_dump(**kwargs)
         try:
             prompt_dict["_type"] = self._prompt_type
         except NotImplementedError:

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/runnables/base.py

@@ -204,8 +204,8 @@ class Runnable(Generic[Input, Output], ABC):
             )
         )
 
-        print(sequence.input_schema.schema()) # Show inferred input schema
-        print(sequence.output_schema.schema()) # Show inferred output schema
+        print(sequence.input_schema.model_json_schema()) # Show inferred input schema
+        print(sequence.output_schema.model_json_schema()) # Show inferred output schema
         print(sequence.invoke(2)) # invoke the sequence (note the retry above!!)
 
     Debugging and tracing
@@ -350,6 +350,34 @@ class Runnable(Generic[Input, Output], ABC):
             __root__=root_type,
         )
 
+    def get_input_jsonschema(
+        self, config: Optional[RunnableConfig] = None
+    ) -> Dict[str, Any]:
+        """Get a JSON schema that represents the input to the Runnable.
+
+        Args:
+            config: A config to use when generating the schema.
+
+        Returns:
+            A JSON schema that represents the input to the Runnable.
+
+        Example:
+
+            .. code-block:: python
+
+                from langchain_core.runnables import RunnableLambda
+
+                def add_one(x: int) -> int:
+                    return x + 1
+
+                runnable = RunnableLambda(add_one)
+
+                print(runnable.get_input_jsonschema())
+
+        .. versionadded:: 0.3.0
+        """
+        return self.get_input_schema(config).model_json_schema()
+
     @property
     def output_schema(self) -> Type[BaseModel]:
         """The type of output this Runnable produces specified as a pydantic model."""
@@ -382,6 +410,34 @@ class Runnable(Generic[Input, Output], ABC):
             __root__=root_type,
         )
 
+    def get_output_jsonschema(
+        self, config: Optional[RunnableConfig] = None
+    ) -> Dict[str, Any]:
+        """Get a JSON schema that represents the output of the Runnable.
+
+        Args:
+            config: A config to use when generating the schema.
+
+        Returns:
+            A JSON schema that represents the output of the Runnable.
+
+        Example:
+
+            .. code-block:: python
+
+                from langchain_core.runnables import RunnableLambda
+
+                def add_one(x: int) -> int:
+                    return x + 1
+
+                runnable = RunnableLambda(add_one)
+
+                print(runnable.get_output_jsonschema())
+
+        .. versionadded:: 0.3.0
+        """
+        return self.get_output_schema(config).model_json_schema()
+
     @property
     def config_specs(self) -> List[ConfigurableFieldSpec]:
         """List configurable fields for this Runnable."""
@@ -435,6 +491,21 @@ class Runnable(Generic[Input, Output], ABC):
         )
         return model
 
+    def get_config_jsonschema(
+        self, *, include: Optional[Sequence[str]] = None
+    ) -> Dict[str, Any]:
+        """Get a JSON schema that represents the output of the Runnable.
+
+        Args:
+            include: A list of fields to include in the config schema.
+
+        Returns:
+            A JSON schema that represents the output of the Runnable.
+
+        .. versionadded:: 0.3.0
+        """
+        return self.config_schema(include=include).model_json_schema()
+
     def get_graph(self, config: Optional[RunnableConfig] = None) -> Graph:
         """Return a graph representation of this Runnable."""
         from langchain_core.runnables.graph import Graph
@@ -612,10 +683,10 @@ class Runnable(Generic[Input, Output], ABC):
 
             chain_with_assign = chain.assign(hello=itemgetter("str") | llm)
 
-            print(chain_with_assign.input_schema.schema())
+            print(chain_with_assign.input_schema.model_json_schema())
             # {'title': 'PromptInput', 'type': 'object', 'properties':
             {'question': {'title': 'Question', 'type': 'string'}}}
-            print(chain_with_assign.output_schema.schema()) #
+            print(chain_with_assign.output_schema.model_json_schema()) #
             {'title': 'RunnableSequenceOutput', 'type': 'object', 'properties':
             {'str': {'title': 'Str',
             'type': 'string'}, 'hello': {'title': 'Hello', 'type': 'string'}}}
@@ -3491,7 +3562,8 @@ class RunnableParallel(RunnableSerializable[Input, Dict[str, Any]]):
             The input schema of the Runnable.
         """
         if all(
-            s.get_input_schema(config).schema().get("type", "object") == "object"
+            s.get_input_schema(config).model_json_schema().get("type", "object")
+            == "object"
             for s in self.steps__.values()
         ):
             # This is correct, but pydantic typings/mypy don't think so.

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/runnables/branch.py

@@ -171,7 +171,10 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
         )
 
         for runnable in runnables:
-            if runnable.get_input_schema(config).schema().get("type") is not None:
+            if (
+                runnable.get_input_schema(config).model_json_schema().get("type")
+                is not None
+            ):
                 return runnable.get_input_schema(config)
 
         return super().get_input_schema(config)

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/runnables/configurable.py

@@ -18,6 +18,7 @@ from typing import (
     Union,
     cast,
 )
+from typing import Mapping as Mapping
 from weakref import WeakValueDictionary
 
 from pydantic import BaseModel, ConfigDict
@@ -453,6 +454,9 @@ class RunnableConfigurableFields(DynamicRunnable[Input, Output]):
             return (self.default, config)
 
 
+RunnableConfigurableFields.model_rebuild()
+
+
 # Before Python 3.11 native StrEnum is not available
 class StrEnum(str, enum.Enum):
     """String enum."""

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/runnables/fallbacks.py

@@ -622,7 +622,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
 
                 return self.__class__(
                     **{
-                        **self.dict(),
+                        **self.model_dump(),
                         **{"runnable": new_runnable, "fallbacks": new_fallbacks},
                     }
                 )

{langchain_core-0.3.0.dev1 → langchain_core-0.3.0.dev3}/langchain_core/runnables/utils.py

@@ -6,6 +6,7 @@ import ast
 import asyncio
 import inspect
 import textwrap
+import warnings
 from functools import lru_cache
 from inspect import signature
 from itertools import groupby
@@ -31,13 +32,14 @@ from typing import (
     cast,
 )
 
-from pydantic import BaseModel, ConfigDict, RootModel
+from pydantic import BaseModel, ConfigDict, PydanticDeprecationWarning, RootModel
 from pydantic import create_model as _create_model_base  # pydantic :ignore
 from pydantic.json_schema import (
     DEFAULT_REF_TEMPLATE,
     GenerateJsonSchema,
     JsonSchemaMode,
 )
+from pydantic.v1 import BaseModel as BaseModelV1
 from typing_extensions import TypeGuard
 
 from langchain_core.runnables.schema import StreamEvent
@@ -710,7 +712,7 @@ _SchemaConfig = ConfigDict(arbitrary_types_allowed=True, frozen=True)
 NO_DEFAULT = object()
 
 
-def create_base_class(
+def _create_root_model(
     name: str, type_: Any, default_: object = NO_DEFAULT
 ) -> Type[BaseModel]:
     """Create a base class."""
@@ -754,10 +756,24 @@ def create_base_class(
 
     if default_ is not NO_DEFAULT:
         base_class_attributes["root"] = default_
-    custom_root_type = type(name, (RootModel,), base_class_attributes)
+    with warnings.catch_warnings():
+        if isinstance(type_, type) and issubclass(type_, BaseModelV1):
+            warnings.filterwarnings(
+                action="ignore", category=PydanticDeprecationWarning
+            )
+        custom_root_type = type(name, (RootModel,), base_class_attributes)
     return cast(Type[BaseModel], custom_root_type)
 
 
+@lru_cache(maxsize=256)
+def _create_root_model_cached(
+    __model_name: str,
+    type_: Any,
+    default_: object = NO_DEFAULT,
+) -> Type[BaseModel]:
+    return _create_root_model(__model_name, type_, default_)
+
+
 def create_model(
     __model_name: str,
     **field_definitions: Any,
@@ -782,9 +798,15 @@ def create_model(
 
         arg = field_definitions["__root__"]
         if isinstance(arg, tuple):
-            named_root_model = create_base_class(__model_name, arg[0], arg[1])
+            kwargs = {"type_": arg[0], "default_": arg[1]}
         else:
-            named_root_model = create_base_class(__model_name, arg)
+            kwargs = {"type_": arg}
+
+        try:
+            named_root_model = _create_root_model_cached(__model_name, **kwargs)
+        except TypeError:
+            # something in the arguments into _create_root_model_cached is not hashable
+            named_root_model = _create_root_model(__model_name, **kwargs)
         return named_root_model
     try:
         return _create_model_cached(__model_name, **field_definitions)