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

langchain_core/prompts/chat.py

@@ -8,10 +8,8 @@ from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Optional,
     TypedDict,
     TypeVar,
-    Union,
     cast,
     overload,
 )
@@ -24,7 +22,6 @@ from pydantic import (
 )
 from typing_extensions import Self, override
 
-from langchain_core._api import deprecated
 from langchain_core.messages import (
     AIMessage,
     AnyMessage,
@@ -62,84 +59,83 @@ class MessagesPlaceholder(BaseMessagePromptTemplate):
 
     Direct usage:
 
-        .. code-block:: python
+        ```python
+        from langchain_core.prompts import MessagesPlaceholder
 
-            from langchain_core.prompts import MessagesPlaceholder
+        prompt = MessagesPlaceholder("history")
+        prompt.format_messages()  # raises KeyError
 
-            prompt = MessagesPlaceholder("history")
-            prompt.format_messages() # raises KeyError
+        prompt = MessagesPlaceholder("history", optional=True)
+        prompt.format_messages()  # returns empty list []
 
-            prompt = MessagesPlaceholder("history", optional=True)
-            prompt.format_messages() # returns empty list []
-
-            prompt.format_messages(
-                history=[
-                    ("system", "You are an AI assistant."),
-                    ("human", "Hello!"),
-                ]
-            )
-            # -> [
-            #     SystemMessage(content="You are an AI assistant."),
-            #     HumanMessage(content="Hello!"),
-            # ]
+        prompt.format_messages(
+            history=[
+                ("system", "You are an AI assistant."),
+                ("human", "Hello!"),
+            ]
+        )
+        # -> [
+        #     SystemMessage(content="You are an AI assistant."),
+        #     HumanMessage(content="Hello!"),
+        # ]
+        ```
 
     Building a prompt with chat history:
 
-        .. code-block:: python
-
-            from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+        ```python
+        from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 
-            prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are a helpful assistant."),
-                    MessagesPlaceholder("history"),
-                    ("human", "{question}")
-                ]
-            )
-            prompt.invoke(
-               {
-                   "history": [("human", "what's 5 + 2"), ("ai", "5 + 2 is 7")],
-                   "question": "now multiply that by 4"
-               }
-            )
-            # -> ChatPromptValue(messages=[
-            #     SystemMessage(content="You are a helpful assistant."),
-            #     HumanMessage(content="what's 5 + 2"),
-            #     AIMessage(content="5 + 2 is 7"),
-            #     HumanMessage(content="now multiply that by 4"),
-            # ])
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", "You are a helpful assistant."),
+                MessagesPlaceholder("history"),
+                ("human", "{question}"),
+            ]
+        )
+        prompt.invoke(
+            {
+                "history": [("human", "what's 5 + 2"), ("ai", "5 + 2 is 7")],
+                "question": "now multiply that by 4",
+            }
+        )
+        # -> ChatPromptValue(messages=[
+        #     SystemMessage(content="You are a helpful assistant."),
+        #     HumanMessage(content="what's 5 + 2"),
+        #     AIMessage(content="5 + 2 is 7"),
+        #     HumanMessage(content="now multiply that by 4"),
+        # ])
+        ```
 
     Limiting the number of messages:
 
-        .. code-block:: python
-
-            from langchain_core.prompts import MessagesPlaceholder
+        ```python
+        from langchain_core.prompts import MessagesPlaceholder
 
-            prompt = MessagesPlaceholder("history", n_messages=1)
-
-            prompt.format_messages(
-                history=[
-                    ("system", "You are an AI assistant."),
-                    ("human", "Hello!"),
-                ]
-            )
-            # -> [
-            #     HumanMessage(content="Hello!"),
-            # ]
+        prompt = MessagesPlaceholder("history", n_messages=1)
 
+        prompt.format_messages(
+            history=[
+                ("system", "You are an AI assistant."),
+                ("human", "Hello!"),
+            ]
+        )
+        # -> [
+        #     HumanMessage(content="Hello!"),
+        # ]
+        ```
     """
 
     variable_name: str
     """Name of variable to use as messages."""
 
     optional: bool = False
-    """If True format_messages can be called with no arguments and will return an empty
-        list. If False then a named argument with name `variable_name` must be passed
-        in, even if the value is an empty list."""
+    """If `True` format_messages can be called with no arguments and will return an
+        empty list. If `False` then a named argument with name `variable_name` must be
+        passed in, even if the value is an empty list."""
 
-    n_messages: Optional[PositiveInt] = None
-    """Maximum number of messages to include. If None, then will include all.
-    Defaults to None."""
+    n_messages: PositiveInt | None = None
+    """Maximum number of messages to include. If `None`, then will include all.
+    """
 
     def __init__(
         self, variable_name: str, *, optional: bool = False, **kwargs: Any
@@ -148,16 +144,13 @@ class MessagesPlaceholder(BaseMessagePromptTemplate):
 
         Args:
             variable_name: Name of variable to use as messages.
-            optional: If True format_messages can be called with no arguments and will
-                return an empty list. If False then a named argument with name
+            optional: If `True` format_messages can be called with no arguments and will
+                return an empty list. If `False` then a named argument with name
                 `variable_name` must be passed in, even if the value is an empty list.
-                Defaults to False.]
         """
         # mypy can't detect the init which is defined in the parent class
         # b/c these are BaseModel classes.
-        super().__init__(  # type: ignore[call-arg]
-            variable_name=variable_name, optional=optional, **kwargs
-        )
+        super().__init__(variable_name=variable_name, optional=optional, **kwargs)
 
     def format_messages(self, **kwargs: Any) -> list[BaseMessage]:
         """Format messages from kwargs.
@@ -201,7 +194,7 @@ class MessagesPlaceholder(BaseMessagePromptTemplate):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.
@@ -234,20 +227,20 @@ class BaseStringMessagePromptTemplate(BaseMessagePromptTemplate, ABC):
         cls,
         template: str,
         template_format: PromptTemplateFormat = "f-string",
-        partial_variables: Optional[dict[str, Any]] = None,
+        partial_variables: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Self:
         """Create a class from a string template.
 
         Args:
             template: a template.
-            template_format: format of the template. Defaults to "f-string".
+            template_format: format of the template.
             partial_variables: A dictionary of variables that can be used to partially
-                               fill in the template. For example, if the template is
-                              `"{variable1} {variable2}"`, and `partial_variables` is
-                              `{"variable1": "foo"}`, then the final prompt will be
-                              `"foo {variable2}"`.
-                              Defaults to None.
+                fill in the template. For example, if the template is
+                `"{variable1} {variable2}"`, and `partial_variables` is
+                `{"variable1": "foo"}`, then the final prompt will be
+                `"foo {variable2}"`.
+
             **kwargs: keyword arguments to pass to the constructor.
 
         Returns:
@@ -263,21 +256,19 @@ class BaseStringMessagePromptTemplate(BaseMessagePromptTemplate, ABC):
     @classmethod
     def from_template_file(
         cls,
-        template_file: Union[str, Path],
-        input_variables: list[str],
+        template_file: str | Path,
         **kwargs: Any,
     ) -> Self:
         """Create a class from a template file.
 
         Args:
             template_file: path to a template file. String or Path.
-            input_variables: list of input variables.
             **kwargs: keyword arguments to pass to the constructor.
 
         Returns:
             A new instance of this class.
         """
-        prompt = PromptTemplate.from_file(template_file, input_variables)
+        prompt = PromptTemplate.from_file(template_file)
         return cls(prompt=prompt, **kwargs)
 
     @abstractmethod
@@ -338,7 +329,7 @@ class BaseStringMessagePromptTemplate(BaseMessagePromptTemplate, ABC):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.
@@ -385,20 +376,20 @@ class ChatMessagePromptTemplate(BaseStringMessagePromptTemplate):
 
 
 class _TextTemplateParam(TypedDict, total=False):
-    text: Union[str, dict]
+    text: str | dict
 
 
 class _ImageTemplateParam(TypedDict, total=False):
-    image_url: Union[str, dict]
+    image_url: str | dict
 
 
 class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
     """Human message prompt template. This is a message sent from the user."""
 
-    prompt: Union[
-        StringPromptTemplate,
-        list[Union[StringPromptTemplate, ImagePromptTemplate, DictPromptTemplate]],
-    ]
+    prompt: (
+        StringPromptTemplate
+        | list[StringPromptTemplate | ImagePromptTemplate | DictPromptTemplate]
+    )
     """Prompt template."""
     additional_kwargs: dict = Field(default_factory=dict)
     """Additional keyword arguments to pass to the prompt template."""
@@ -408,13 +399,11 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
     @classmethod
     def from_template(
         cls: type[Self],
-        template: Union[
-            str,
-            list[Union[str, _TextTemplateParam, _ImageTemplateParam, dict[str, Any]]],
-        ],
+        template: str
+        | list[str | _TextTemplateParam | _ImageTemplateParam | dict[str, Any]],
         template_format: PromptTemplateFormat = "f-string",
         *,
-        partial_variables: Optional[dict[str, Any]] = None,
+        partial_variables: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Self:
         """Create a class from a string template.
@@ -422,9 +411,9 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
         Args:
             template: a template.
             template_format: format of the template.
-                Options are: 'f-string', 'mustache', 'jinja2'. Defaults to "f-string".
+                Options are: 'f-string', 'mustache', 'jinja2'.
             partial_variables: A dictionary of variables that can be used too partially.
-                Defaults to None.
+
             **kwargs: keyword arguments to pass to the constructor.
 
         Returns:
@@ -434,7 +423,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
             ValueError: If the template is not a string or list of strings.
         """
         if isinstance(template, str):
-            prompt: Union[StringPromptTemplate, list] = PromptTemplate.from_template(
+            prompt: StringPromptTemplate | list = PromptTemplate.from_template(
                 template,
                 template_format=template_format,
                 partial_variables=partial_variables,
@@ -531,7 +520,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
     @classmethod
     def from_template_file(
         cls: type[Self],
-        template_file: Union[str, Path],
+        template_file: str | Path,
         input_variables: list[str],
         **kwargs: Any,
     ) -> Self:
@@ -545,8 +534,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
         Returns:
             A new instance of this class.
         """
-        template = Path(template_file).read_text()
-        # TODO: .read_text(encoding="utf-8") for v0.4
+        template = Path(template_file).read_text(encoding="utf-8")
         return cls.from_template(template, input_variables=input_variables, **kwargs)
 
     def format_messages(self, **kwargs: Any) -> list[BaseMessage]:
@@ -599,9 +587,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
         for prompt in self.prompt:
             inputs = {var: kwargs[var] for var in prompt.input_variables}
             if isinstance(prompt, StringPromptTemplate):
-                formatted: Union[str, ImageURL, dict[str, Any]] = prompt.format(
-                    **inputs
-                )
+                formatted: str | ImageURL | dict[str, Any] = prompt.format(**inputs)
                 content.append({"type": "text", "text": formatted})
             elif isinstance(prompt, ImagePromptTemplate):
                 formatted = prompt.format(**inputs)
@@ -631,7 +617,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
         for prompt in self.prompt:
             inputs = {var: kwargs[var] for var in prompt.input_variables}
             if isinstance(prompt, StringPromptTemplate):
-                formatted: Union[str, ImageURL, dict[str, Any]] = await prompt.aformat(
+                formatted: str | ImageURL | dict[str, Any] = await prompt.aformat(
                     **inputs
                 )
                 content.append({"type": "text", "text": formatted})
@@ -650,7 +636,7 @@ class _StringImageMessagePromptTemplate(BaseMessagePromptTemplate):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.
@@ -697,7 +683,7 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
 
         Args:
             **kwargs: keyword arguments to use for filling in template variables
-                      in all the template messages in this chat template.
+                in all the template messages in this chat template.
 
         Returns:
             formatted string.
@@ -709,7 +695,7 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
 
         Args:
             **kwargs: keyword arguments to use for filling in template variables
-                      in all the template messages in this chat template.
+                in all the template messages in this chat template.
 
         Returns:
             formatted string.
@@ -742,10 +728,18 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
 
     @abstractmethod
     def format_messages(self, **kwargs: Any) -> list[BaseMessage]:
-        """Format kwargs into a list of messages."""
+        """Format kwargs into a list of messages.
+
+        Returns:
+            List of messages.
+        """
 
     async def aformat_messages(self, **kwargs: Any) -> list[BaseMessage]:
-        """Async format kwargs into a list of messages."""
+        """Async format kwargs into a list of messages.
+
+        Returns:
+            List of messages.
+        """
         return self.format_messages(**kwargs)
 
     def pretty_repr(
@@ -755,7 +749,7 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.
@@ -767,17 +761,14 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
         print(self.pretty_repr(html=is_interactive_env()))  # noqa: T201
 
 
-MessageLike = Union[BaseMessagePromptTemplate, BaseMessage, BaseChatPromptTemplate]
+MessageLike = BaseMessagePromptTemplate | BaseMessage | BaseChatPromptTemplate
 
-MessageLikeRepresentation = Union[
-    MessageLike,
-    tuple[
-        Union[str, type],
-        Union[str, list[dict], list[object]],
-    ],
-    str,
-    dict[str, Any],
-]
+MessageLikeRepresentation = (
+    MessageLike
+    | tuple[str | type, str | list[dict] | list[object]]
+    | str
+    | dict[str, Any]
+)
 
 
 class ChatPromptTemplate(BaseChatPromptTemplate):
@@ -786,78 +777,80 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
     Use to create flexible templated prompts for chat models.
 
     Examples:
-
-        .. versionchanged:: 0.2.24
-
+        !!! warning "Behavior changed in 0.2.24"
             You can pass any Message-like formats supported by
-            ``ChatPromptTemplate.from_messages()`` directly to ``ChatPromptTemplate()``
+            `ChatPromptTemplate.from_messages()` directly to `ChatPromptTemplate()`
             init.
 
-        .. code-block:: python
+        ```python
+        from langchain_core.prompts import ChatPromptTemplate
 
-            from langchain_core.prompts import ChatPromptTemplate
-
-            template = ChatPromptTemplate([
+        template = ChatPromptTemplate(
+            [
                 ("system", "You are a helpful AI bot. Your name is {name}."),
                 ("human", "Hello, how are you doing?"),
                 ("ai", "I'm doing well, thanks!"),
                 ("human", "{user_input}"),
-            ])
+            ]
+        )
 
-            prompt_value = template.invoke(
-                {
-                    "name": "Bob",
-                    "user_input": "What is your name?"
-                }
-            )
-            # Output:
-            # ChatPromptValue(
-            #    messages=[
-            #        SystemMessage(content='You are a helpful AI bot. Your name is Bob.'),
-            #        HumanMessage(content='Hello, how are you doing?'),
-            #        AIMessage(content="I'm doing well, thanks!"),
-            #        HumanMessage(content='What is your name?')
-            #    ]
-            #)
+        prompt_value = template.invoke(
+            {
+                "name": "Bob",
+                "user_input": "What is your name?",
+            }
+        )
+        # Output:
+        # ChatPromptValue(
+        #    messages=[
+        #        SystemMessage(content='You are a helpful AI bot. Your name is Bob.'),
+        #        HumanMessage(content='Hello, how are you doing?'),
+        #        AIMessage(content="I'm doing well, thanks!"),
+        #        HumanMessage(content='What is your name?')
+        #    ]
+        # )
+        ```
 
     Messages Placeholder:
 
-        .. code-block:: python
-
-            # In addition to Human/AI/Tool/Function messages,
-            # you can initialize the template with a MessagesPlaceholder
-            # either using the class directly or with the shorthand tuple syntax:
+        ```python
+        # In addition to Human/AI/Tool/Function messages,
+        # you can initialize the template with a MessagesPlaceholder
+        # either using the class directly or with the shorthand tuple syntax:
 
-            template = ChatPromptTemplate([
+        template = ChatPromptTemplate(
+            [
                 ("system", "You are a helpful AI bot."),
                 # Means the template will receive an optional list of messages under
                 # the "conversation" key
-                ("placeholder", "{conversation}")
+                ("placeholder", "{conversation}"),
                 # Equivalently:
                 # MessagesPlaceholder(variable_name="conversation", optional=True)
-            ])
-
-            prompt_value = template.invoke(
-                {
-                    "conversation": [
-                        ("human", "Hi!"),
-                        ("ai", "How can I assist you today?"),
-                        ("human", "Can you make me an ice cream sundae?"),
-                        ("ai", "No.")
-                    ]
-                }
-            )
+            ]
+        )
 
-            # Output:
-            # ChatPromptValue(
-            #    messages=[
-            #        SystemMessage(content='You are a helpful AI bot.'),
-            #        HumanMessage(content='Hi!'),
-            #        AIMessage(content='How can I assist you today?'),
-            #        HumanMessage(content='Can you make me an ice cream sundae?'),
-            #        AIMessage(content='No.'),
-            #    ]
-            #)
+        prompt_value = template.invoke(
+            {
+                "conversation": [
+                    ("human", "Hi!"),
+                    ("ai", "How can I assist you today?"),
+                    ("human", "Can you make me an ice cream sundae?"),
+                    ("ai", "No."),
+                ]
+            }
+        )
+
+        # Output:
+        # ChatPromptValue(
+        #    messages=[
+        #        SystemMessage(content='You are a helpful AI bot.'),
+        #        HumanMessage(content='Hi!'),
+        #        AIMessage(content='How can I assist you today?'),
+        #        HumanMessage(content='Can you make me an ice cream sundae?'),
+        #        AIMessage(content='No.'),
+        #    ]
+        # )
+        ```
 
     Single-variable template:
 
@@ -866,27 +859,28 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         inject the provided argument into that variable location.
 
 
-        .. code-block:: python
-
-            from langchain_core.prompts import ChatPromptTemplate
+        ```python
+        from langchain_core.prompts import ChatPromptTemplate
 
-            template = ChatPromptTemplate([
+        template = ChatPromptTemplate(
+            [
                 ("system", "You are a helpful AI bot. Your name is Carl."),
                 ("human", "{user_input}"),
-            ])
-
-            prompt_value = template.invoke("Hello, there!")
-            # Equivalent to
-            # prompt_value = template.invoke({"user_input": "Hello, there!"})
-
-            # Output:
-            #  ChatPromptValue(
-            #     messages=[
-            #         SystemMessage(content='You are a helpful AI bot. Your name is Carl.'),
-            #         HumanMessage(content='Hello, there!'),
-            #     ]
-            # )
+            ]
+        )
 
+        prompt_value = template.invoke("Hello, there!")
+        # Equivalent to
+        # prompt_value = template.invoke({"user_input": "Hello, there!"})
+
+        # Output:
+        #  ChatPromptValue(
+        #     messages=[
+        #         SystemMessage(content='You are a helpful AI bot. Your name is Carl.'),
+        #         HumanMessage(content='Hello, there!'),
+        #     ]
+        # )
+        ```
     """  # noqa: E501
 
     messages: Annotated[list[MessageLike], SkipValidation()]
@@ -905,12 +899,12 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
 
         Args:
             messages: sequence of message representations.
-                  A message can be represented using the following formats:
-                  (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
-                  (message type, template); e.g., ("human", "{user_input}"),
-                  (4) 2-tuple of (message class, template), (5) a string which is
-                  shorthand for ("human", template); e.g., "{user_input}".
-            template_format: format of the template. Defaults to "f-string".
+                A message can be represented using the following formats:
+                (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
+                (message type, template); e.g., ("human", "{user_input}"),
+                (4) 2-tuple of (message class, template), (5) a string which is
+                shorthand for ("human", template); e.g., "{user_input}".
+            template_format: format of the template.
             input_variables: A list of the names of the variables whose values are
                 required as inputs to the prompt.
             optional_variables: A list of the names of the variables for placeholder
@@ -924,29 +918,29 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
             input_types: A dictionary of the types of the variables the prompt template
                 expects. If not provided, all variables are assumed to be strings.
 
-        Returns:
-            A chat prompt template.
-
         Examples:
             Instantiation from a list of message templates:
 
-            .. code-block:: python
-
-                template = ChatPromptTemplate([
+            ```python
+            template = ChatPromptTemplate(
+                [
                     ("human", "Hello, how are you?"),
                     ("ai", "I'm doing well, thanks!"),
                     ("human", "That's good to hear."),
-                ])
+                ]
+            )
+            ```
 
             Instantiation from mixed message formats:
 
-            .. code-block:: python
-
-                template = ChatPromptTemplate([
+            ```python
+            template = ChatPromptTemplate(
+                [
                     SystemMessage(content="hello"),
                     ("human", "Hello, how are you?"),
-                ])
-
+                ]
+            )
+            ```
         """
         messages_ = [
             _convert_to_message_template(message, template_format)
@@ -976,7 +970,11 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object."""
+        """Get the namespace of the LangChain object.
+
+        Returns:
+            `["langchain", "prompts", "chat"]`
+        """
         return ["langchain", "prompts", "chat"]
 
     def __add__(self, other: Any) -> ChatPromptTemplate:
@@ -1091,41 +1089,6 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         message = HumanMessagePromptTemplate(prompt=prompt_template)
         return cls.from_messages([message])
 
-    @classmethod
-    @deprecated("0.0.1", alternative="from_messages", pending=True)
-    def from_role_strings(
-        cls, string_messages: list[tuple[str, str]]
-    ) -> ChatPromptTemplate:
-        """Create a chat prompt template from a list of (role, template) tuples.
-
-        Args:
-            string_messages: list of (role, template) tuples.
-
-        Returns:
-            a chat prompt template.
-        """
-        return cls(
-            messages=[
-                ChatMessagePromptTemplate.from_template(template, role=role)
-                for role, template in string_messages
-            ]
-        )
-
-    @classmethod
-    @deprecated("0.0.1", alternative="from_messages", pending=True)
-    def from_strings(
-        cls, string_messages: list[tuple[type[BaseMessagePromptTemplate], str]]
-    ) -> ChatPromptTemplate:
-        """Create a chat prompt template from a list of (role class, template) tuples.
-
-        Args:
-            string_messages: list of (role class, template) tuples.
-
-        Returns:
-            a chat prompt template.
-        """
-        return cls.from_messages(string_messages)
-
     @classmethod
     def from_messages(
         cls,
@@ -1137,31 +1100,34 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         Examples:
             Instantiation from a list of message templates:
 
-            .. code-block:: python
-
-                template = ChatPromptTemplate.from_messages([
+            ```python
+            template = ChatPromptTemplate.from_messages(
+                [
                     ("human", "Hello, how are you?"),
                     ("ai", "I'm doing well, thanks!"),
                     ("human", "That's good to hear."),
-                ])
+                ]
+            )
+            ```
 
             Instantiation from mixed message formats:
 
-            .. code-block:: python
-
-                template = ChatPromptTemplate.from_messages([
+            ```python
+            template = ChatPromptTemplate.from_messages(
+                [
                     SystemMessage(content="hello"),
                     ("human", "Hello, how are you?"),
-                ])
-
+                ]
+            )
+            ```
         Args:
             messages: sequence of message representations.
-                  A message can be represented using the following formats:
-                  (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
-                  (message type, template); e.g., ("human", "{user_input}"),
-                  (4) 2-tuple of (message class, template), (5) a string which is
-                  shorthand for ("human", template); e.g., "{user_input}".
-            template_format: format of the template. Defaults to "f-string".
+                A message can be represented using the following formats:
+                (1) BaseMessagePromptTemplate, (2) BaseMessage, (3) 2-tuple of
+                (message type, template); e.g., ("human", "{user_input}"),
+                (4) 2-tuple of (message class, template), (5) a string which is
+                shorthand for ("human", template); e.g., "{user_input}".
+            template_format: format of the template.
 
         Returns:
             a chat prompt template.
@@ -1174,7 +1140,10 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
 
         Args:
             **kwargs: keyword arguments to use for filling in template variables
-                      in all the template messages in this chat template.
+                in all the template messages in this chat template.
+
+        Raises:
+            ValueError: if messages are of unexpected types.
 
         Returns:
             list of formatted messages.
@@ -1199,7 +1168,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
 
         Args:
             **kwargs: keyword arguments to use for filling in template variables
-                      in all the template messages in this chat template.
+                in all the template messages in this chat template.
 
         Returns:
             list of formatted messages.
@@ -1234,23 +1203,21 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
 
 
         Example:
+            ```python
+            from langchain_core.prompts import ChatPromptTemplate
 
-            .. code-block:: python
-
-                from langchain_core.prompts import ChatPromptTemplate
-
-                template = ChatPromptTemplate.from_messages(
-                    [
-                        ("system", "You are an AI assistant named {name}."),
-                        ("human", "Hi I'm {user}"),
-                        ("ai", "Hi there, {user}, I'm {name}."),
-                        ("human", "{input}"),
-                    ]
-                )
-                template2 = template.partial(user="Lucy", name="R2D2")
-
-                template2.format_messages(input="hello")
+            template = ChatPromptTemplate.from_messages(
+                [
+                    ("system", "You are an AI assistant named {name}."),
+                    ("human", "Hi I'm {user}"),
+                    ("ai", "Hi there, {user}, I'm {name}."),
+                    ("human", "{input}"),
+                ]
+            )
+            template2 = template.partial(user="Lucy", name="R2D2")
 
+            template2.format_messages(input="hello")
+            ```
         """
         prompt_dict = self.__dict__.copy()
         prompt_dict["input_variables"] = list(
@@ -1283,10 +1250,14 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
     @overload
     def __getitem__(self, index: slice) -> ChatPromptTemplate: ...
 
-    def __getitem__(
-        self, index: Union[int, slice]
-    ) -> Union[MessageLike, ChatPromptTemplate]:
-        """Use to index into the chat template."""
+    def __getitem__(self, index: int | slice) -> MessageLike | ChatPromptTemplate:
+        """Use to index into the chat template.
+
+        Returns:
+            If index is an int, returns the message at that index.
+            If index is a slice, returns a new `ChatPromptTemplate`
+            containing the messages in that slice.
+        """
         if isinstance(index, slice):
             start, stop, step = index.indices(len(self.messages))
             messages = self.messages[start:stop:step]
@@ -1294,7 +1265,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         return self.messages[index]
 
     def __len__(self) -> int:
-        """Get the length of the chat template."""
+        """Return the length of the chat template."""
         return len(self.messages)
 
     @property
@@ -1302,7 +1273,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         """Name of prompt type. Used for serialization."""
         return "chat"
 
-    def save(self, file_path: Union[Path, str]) -> None:
+    def save(self, file_path: Path | str) -> None:
         """Save prompt to file.
 
         Args:
@@ -1315,7 +1286,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
         """Human-readable representation.
 
         Args:
-            html: Whether to format as HTML. Defaults to False.
+            html: Whether to format as HTML.
 
         Returns:
             Human-readable representation.
@@ -1326,7 +1297,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate):
 
 def _create_template_from_message_type(
     message_type: str,
-    template: Union[str, list],
+    template: str | list,
     template_format: PromptTemplateFormat = "f-string",
 ) -> BaseMessagePromptTemplate:
     """Create a message prompt template from a message type and template string.
@@ -1334,7 +1305,7 @@ def _create_template_from_message_type(
     Args:
         message_type: str the type of the message template (e.g., "human", "ai", etc.)
         template: str the template string.
-        template_format: format of the template. Defaults to "f-string".
+        template_format: format of the template.
 
     Returns:
         a message prompt template of the appropriate type.
@@ -1398,7 +1369,7 @@ def _create_template_from_message_type(
 def _convert_to_message_template(
     message: MessageLikeRepresentation,
     template_format: PromptTemplateFormat = "f-string",
-) -> Union[BaseMessage, BaseMessagePromptTemplate, BaseChatPromptTemplate]:
+) -> BaseMessage | BaseMessagePromptTemplate | BaseChatPromptTemplate:
     """Instantiate a message from a variety of message formats.
 
     The message format can be one of the following:
@@ -1411,7 +1382,7 @@ def _convert_to_message_template(
 
     Args:
         message: a representation of a message in one of the supported formats.
-        template_format: format of the template. Defaults to "f-string".
+        template_format: format of the template.
 
     Returns:
         an instance of a message or a message template.
@@ -1421,9 +1392,9 @@ def _convert_to_message_template(
         ValueError: If 2-tuple does not have 2 elements.
     """
     if isinstance(message, (BaseMessagePromptTemplate, BaseChatPromptTemplate)):
-        message_: Union[
-            BaseMessage, BaseMessagePromptTemplate, BaseChatPromptTemplate
-        ] = message
+        message_: BaseMessage | BaseMessagePromptTemplate | BaseChatPromptTemplate = (
+            message
+        )
     elif isinstance(message, BaseMessage):
         message_ = message
     elif isinstance(message, str):