langchain-ollama 0.3.6__tar.gz → 0.3.8__tar.gz

{langchain_ollama-0.3.6 → langchain_ollama-0.3.8}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: langchain-ollama
-Version: 0.3.6
+Version: 0.3.8
 Summary: An integration package connecting Ollama and LangChain
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/partners/ollama
 Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain-ollama%3D%3D0%22&expanded=true
 Project-URL: repository, https://github.com/langchain-ai/langchain
 Requires-Python: >=3.9
-Requires-Dist: ollama<1.0.0,>=0.5.1
-Requires-Dist: langchain-core<1.0.0,>=0.3.70
+Requires-Dist: ollama<1.0.0,>=0.5.3
+Requires-Dist: langchain-core<1.0.0,>=0.3.76
 Description-Content-Type: text/markdown
 
 # langchain-ollama

{langchain_ollama-0.3.6 → langchain_ollama-0.3.8}/langchain_ollama/__init__.py

@@ -10,6 +10,7 @@ service.
     exist locally. This is useful for ensuring that the model is available before
     attempting to use it, especially in environments where models may not be
     pre-downloaded.
+
 """
 
 from importlib import metadata
@@ -19,6 +20,8 @@ from langchain_ollama.embeddings import OllamaEmbeddings
 from langchain_ollama.llms import OllamaLLM
 
 try:
+    if __package__ is None:
+        raise metadata.PackageNotFoundError
     __version__ = metadata.version(__package__)
 except metadata.PackageNotFoundError:
     # Case where package metadata is not available.

{langchain_ollama-0.3.6 → langchain_ollama-0.3.8}/langchain_ollama/_utils.py

@@ -1,11 +1,11 @@
-"""Utility functions for validating Ollama models."""
+"""Utility function to validate Ollama models."""
 
 from httpx import ConnectError
 from ollama import Client, ResponseError
 
 
 def validate_model(client: Client, model_name: str) -> None:
-    """Validate that a model exists in the Ollama instance.
+    """Validate that a model exists in the local Ollama instance.
 
     Args:
         client: The Ollama client.
@@ -29,7 +29,10 @@ def validate_model(client: Client, model_name: str) -> None:
             )
             raise ValueError(msg)
     except ConnectError as e:
-        msg = "Failed to connect to Ollama. Please check that Ollama is downloaded, running and accessible. https://ollama.com/download"  # noqa: E501
+        msg = (
+            "Failed to connect to Ollama. Please check that Ollama is downloaded, "
+            "running and accessible. https://ollama.com/download"
+        )
         raise ValueError(msg) from e
     except ResponseError as e:
         msg = (

{langchain_ollama-0.3.6 → langchain_ollama-0.3.8}/langchain_ollama/chat_models.py

@@ -87,8 +87,8 @@ def _parse_json_string(
 ) -> Any:
     """Attempt to parse a JSON string for tool calling.
 
-    It first tries to use the standard json.loads. If that fails, it falls
-    back to ast.literal_eval to safely parse Python literals, which is more
+    It first tries to use the standard ``json.loads``. If that fails, it falls
+    back to ``ast.literal_eval`` to safely parse Python literals, which is more
     robust against models using single quotes or containing apostrophes.
 
     Args:
@@ -100,7 +100,8 @@ def _parse_json_string(
         The parsed JSON string or Python literal.
 
     Raises:
-        OutputParserException: If the string is invalid and skip=False.
+        OutputParserException: If the string is invalid and ``skip=False``.
+
     """
     try:
         return json.loads(json_string)
@@ -138,14 +139,20 @@ def _parse_arguments_from_tool_call(
 
     Band-aid fix for issue in Ollama with inconsistent tool call argument structure.
     Should be removed/changed if fixed upstream.
+
     See https://github.com/ollama/ollama/issues/6155
+
     """
     if "function" not in raw_tool_call:
         return None
+    function_name = raw_tool_call["function"]["name"]
     arguments = raw_tool_call["function"]["arguments"]
     parsed_arguments: dict = {}
     if isinstance(arguments, dict):
         for key, value in arguments.items():
+            # Filter out metadata fields like 'functionName' that echo function name
+            if key == "functionName" and value == function_name:
+                continue
             if isinstance(value, str):
                 parsed_value = _parse_json_string(
                     value, skip=True, raw_tool_call=raw_tool_call
@@ -222,7 +229,7 @@ class ChatOllama(BaseChatModel):
 
         .. code-block:: bash
 
-            ollama pull mistral:v0.3
+            ollama pull gpt-oss:20b
             pip install -U langchain-ollama
 
     Key init args — completion params:
@@ -255,7 +262,8 @@ class ChatOllama(BaseChatModel):
             from langchain_ollama import ChatOllama
 
             llm = ChatOllama(
-                model = "llama3",
+                model = "gpt-oss:20b",
+                validate_model_on_init = True,
                 temperature = 0.8,
                 num_predict = 256,
                 # other params ...
@@ -277,10 +285,7 @@ class ChatOllama(BaseChatModel):
     Stream:
         .. code-block:: python
 
-            messages = [
-                ("human", "Return the words Hello World!"),
-            ]
-            for chunk in llm.stream(messages):
+            for chunk in llm.stream("Return the words Hello World!"):
                 print(chunk.text(), end="")
 
 
@@ -307,10 +312,7 @@ class ChatOllama(BaseChatModel):
     Async:
         .. code-block:: python
 
-            messages = [
-                ("human", "Hello how are you!"),
-            ]
-            await llm.ainvoke(messages)
+            await llm.ainvoke("Hello how are you!")
 
         .. code-block:: python
 
@@ -318,10 +320,7 @@ class ChatOllama(BaseChatModel):
 
         .. code-block:: python
 
-            messages = [
-                ("human", "Say hello world!"),
-            ]
-            async for chunk in llm.astream(messages):
+            async for chunk in llm.astream("Say hello world!"):
                 print(chunk.content)
 
         .. code-block:: python
@@ -349,10 +348,7 @@ class ChatOllama(BaseChatModel):
 
 
             json_llm = ChatOllama(format="json")
-            messages = [
-                ("human", "Return a query for the weather in a random location and time of day with two keys: location and time_of_day. Respond using JSON only."),
-            ]
-            llm.invoke(messages).content
+            llm.invoke("Return a query for the weather in a random location and time of day with two keys: location and time_of_day. Respond using JSON only.").content
 
         .. code-block:: python
 
@@ -399,17 +395,16 @@ class ChatOllama(BaseChatModel):
 
             llm = ChatOllama(
                 model = "deepseek-r1:8b",
+                validate_model_on_init = True,
                 reasoning= True,
             )
 
-            user_message = HumanMessage(content="how many r in the word strawberry?")
-            messages: List[Any] = [user_message]
-            llm.invoke(messages)
+            llm.invoke("how many r in the word strawberry?")
 
             # or, on an invocation basis:
 
-            llm.invoke(messages, reasoning=True)
-            # or llm.stream(messages, reasoning=True)
+            llm.invoke("how many r in the word strawberry?", reasoning=True)
+            # or llm.stream("how many r in the word strawberry?", reasoning=True)
 
             # If not provided, the invocation will default to the ChatOllama reasoning
             # param provided (None by default).
@@ -418,13 +413,12 @@ class ChatOllama(BaseChatModel):
 
             AIMessage(content='The word "strawberry" contains **three \'r\' letters**. Here\'s a breakdown for clarity:\n\n- The spelling of "strawberry" has two parts ... be 3.\n\nTo be thorough, let\'s confirm with an online source or common knowledge.\n\nI can recall that "strawberry" has: s-t-r-a-w-b-e-r-r-y — yes, three r\'s.\n\nPerhaps it\'s misspelled by some, but standard is correct.\n\nSo I think the response should be 3.\n'}, response_metadata={'model': 'deepseek-r1:8b', 'created_at': '2025-07-08T19:33:55.891269Z', 'done': True, 'done_reason': 'stop', 'total_duration': 98232561292, 'load_duration': 28036792, 'prompt_eval_count': 10, 'prompt_eval_duration': 40171834, 'eval_count': 3615, 'eval_duration': 98163832416, 'model_name': 'deepseek-r1:8b'}, id='run--18f8269f-6a35-4a7c-826d-b89d52c753b3-0', usage_metadata={'input_tokens': 10, 'output_tokens': 3615, 'total_tokens': 3625})
 
-
     """  # noqa: E501, pylint: disable=line-too-long
 
     model: str
     """Model name to use."""
 
-    reasoning: Optional[bool] = None
+    reasoning: Optional[Union[bool, str]] = None
     """Controls the reasoning/thinking mode for
     `supported models <https://ollama.com/search?c=thinking>`__.
 
@@ -437,7 +431,13 @@ class ChatOllama(BaseChatModel):
     - ``None`` (Default): The model will use its default reasoning behavior. Note
       however, if the model's default behavior *is* to perform reasoning, think tags
       ()``<think>`` and ``</think>``) will be present within the main response content
-      unless you set ``reasoning`` to ``True``."""
+      unless you set ``reasoning`` to ``True``.
+    - ``str``: e.g. ``'low'``, ``'medium'``, ``'high'``. Enables reasoning with a custom
+      intensity level. Currently, this is only supported ``gpt-oss``. See the
+      `Ollama docs <https://github.com/ollama/ollama-python/blob/da79e987f0ac0a4986bf396f043b36ef840370bc/ollama/_types.py#L210>`__
+      for more information.
+
+    """
 
     validate_model_on_init: bool = False
     """Whether to validate the model exists in Ollama locally on initialization.
@@ -447,26 +447,26 @@ class ChatOllama(BaseChatModel):
 
     mirostat: Optional[int] = None
     """Enable Mirostat sampling for controlling perplexity.
-    (default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)"""
+    (default: ``0``, ``0`` = disabled, ``1`` = Mirostat, ``2`` = Mirostat 2.0)"""
 
     mirostat_eta: Optional[float] = None
     """Influences how quickly the algorithm responds to feedback
     from the generated text. A lower learning rate will result in
     slower adjustments, while a higher learning rate will make
-    the algorithm more responsive. (Default: 0.1)"""
+    the algorithm more responsive. (Default: ``0.1``)"""
 
     mirostat_tau: Optional[float] = None
     """Controls the balance between coherence and diversity
     of the output. A lower value will result in more focused and
-    coherent text. (Default: 5.0)"""
+    coherent text. (Default: ``5.0``)"""
 
     num_ctx: Optional[int] = None
     """Sets the size of the context window used to generate the
-    next token. (Default: 2048)	"""
+    next token. (Default: ``2048``)	"""
 
     num_gpu: Optional[int] = None
-    """The number of GPUs to use. On macOS it defaults to 1 to
-    enable metal support, 0 to disable."""
+    """The number of GPUs to use. On macOS it defaults to ``1`` to
+    enable metal support, ``0`` to disable."""
 
     num_thread: Optional[int] = None
     """Sets the number of threads to use during computation.
@@ -476,20 +476,20 @@ class ChatOllama(BaseChatModel):
 
     num_predict: Optional[int] = None
     """Maximum number of tokens to predict when generating text.
-    (Default: 128, -1 = infinite generation, -2 = fill context)"""
+    (Default: ``128``, ``-1`` = infinite generation, ``-2`` = fill context)"""
 
     repeat_last_n: Optional[int] = None
     """Sets how far back for the model to look back to prevent
-    repetition. (Default: 64, 0 = disabled, -1 = num_ctx)"""
+    repetition. (Default: ``64``, ``0`` = disabled, ``-1`` = ``num_ctx``)"""
 
     repeat_penalty: Optional[float] = None
-    """Sets how strongly to penalize repetitions. A higher value (e.g., 1.5)
-    will penalize repetitions more strongly, while a lower value (e.g., 0.9)
-    will be more lenient. (Default: 1.1)"""
+    """Sets how strongly to penalize repetitions. A higher value (e.g., ``1.5``)
+    will penalize repetitions more strongly, while a lower value (e.g., ``0.9``)
+    will be more lenient. (Default: ``1.1``)"""
 
     temperature: Optional[float] = None
     """The temperature of the model. Increasing the temperature will
-    make the model answer more creatively. (Default: 0.8)"""
+    make the model answer more creatively. (Default: ``0.8``)"""
 
     seed: Optional[int] = None
     """Sets the random number seed to use for generation. Setting this
@@ -501,21 +501,21 @@ class ChatOllama(BaseChatModel):
 
     tfs_z: Optional[float] = None
     """Tail free sampling is used to reduce the impact of less probable
-    tokens from the output. A higher value (e.g., 2.0) will reduce the
-    impact more, while a value of 1.0 disables this setting. (default: 1)"""
+    tokens from the output. A higher value (e.g., ``2.0``) will reduce the
+    impact more, while a value of ``1.0`` disables this setting. (default: ``1``)"""
 
     top_k: Optional[int] = None
-    """Reduces the probability of generating nonsense. A higher value (e.g. 100)
-    will give more diverse answers, while a lower value (e.g. 10)
-    will be more conservative. (Default: 40)"""
+    """Reduces the probability of generating nonsense. A higher value (e.g. ``100``)
+    will give more diverse answers, while a lower value (e.g. ``10``)
+    will be more conservative. (Default: ``40``)"""
 
     top_p: Optional[float] = None
-    """Works together with top-k. A higher value (e.g., 0.95) will lead
-    to more diverse text, while a lower value (e.g., 0.5) will
-    generate more focused and conservative text. (Default: 0.9)"""
+    """Works together with top-k. A higher value (e.g., ``0.95``) will lead
+    to more diverse text, while a lower value (e.g., ``0.5``) will
+    generate more focused and conservative text. (Default: ``0.9``)"""
 
     format: Optional[Union[Literal["", "json"], JsonSchemaValue]] = None
-    """Specify the format of the output (options: "json", JSON schema)."""
+    """Specify the format of the output (options: ``'json'``, JSON schema)."""
 
     keep_alive: Optional[Union[int, str]] = None
     """How long the model will stay loaded into memory."""
@@ -525,32 +525,35 @@ class ChatOllama(BaseChatModel):
 
     client_kwargs: Optional[dict] = {}
     """Additional kwargs to pass to the httpx clients.
+
     These arguments are passed to both synchronous and async clients.
-    Use sync_client_kwargs and async_client_kwargs to pass different arguments
+
+    Use ``sync_client_kwargs`` and ``async_client_kwargs`` to pass different arguments
     to synchronous and asynchronous clients.
+
     """
 
     async_client_kwargs: Optional[dict] = {}
-    """Additional kwargs to merge with client_kwargs before
+    """Additional kwargs to merge with ``client_kwargs`` before
     passing to the httpx AsyncClient.
+
     `Full list of params. <https://www.python-httpx.org/api/#asyncclient>`__
+
     """
 
     sync_client_kwargs: Optional[dict] = {}
-    """Additional kwargs to merge with client_kwargs before
+    """Additional kwargs to merge with ``client_kwargs`` before
     passing to the httpx Client.
+
     `Full list of params. <https://www.python-httpx.org/api/#client>`__
+
     """
 
     _client: Client = PrivateAttr()
-    """
-    The client to use for making requests.
-    """
+    """The client to use for making requests."""
 
     _async_client: AsyncClient = PrivateAttr()
-    """
-    The async client to use for making requests.
-    """
+    """The async client to use for making requests."""
 
     def _chat_params(
         self,
@@ -658,8 +661,10 @@ class ChatOllama(BaseChatModel):
             if isinstance(message.content, str):
                 content = message.content
             else:
-                for content_part in cast(list[dict], message.content):
-                    if content_part.get("type") == "text":
+                for content_part in message.content:
+                    if isinstance(content_part, str):
+                        content += f"\n{content_part}"
+                    elif content_part.get("type") == "text":
                         content += f"\n{content_part['text']}"
                     elif content_part.get("type") == "tool_use":
                         continue
@@ -1044,8 +1049,7 @@ class ChatOllama(BaseChatModel):
         """Model wrapper that returns outputs formatted to match the given schema.
 
         Args:
-            schema:
-                The output schema. Can be passed in as:
+            schema: The output schema. Can be passed in as:
 
                 - a Pydantic class,
                 - a JSON schema
@@ -1061,35 +1065,35 @@ class ChatOllama(BaseChatModel):
 
             method: The method for steering model generation, one of:
 
-                - "json_schema":
+                - ``'json_schema'``:
                     Uses Ollama's `structured output API <https://ollama.com/blog/structured-outputs>`__
-                - "function_calling":
+                - ``'function_calling'``:
                     Uses Ollama's tool-calling API
-                - "json_mode":
-                    Specifies ``format="json"``. Note that if using JSON mode then you
+                - ``'json_mode'``:
+                    Specifies ``format='json'``. Note that if using JSON mode then you
                     must include instructions for formatting the output into the
                     desired schema into the model call.
 
             include_raw:
                 If False then only the parsed structured output is returned. If
                 an error occurs during model output parsing it will be raised. If True
-                then both the raw model response (a BaseMessage) and the parsed model
+                then both the raw model response (a ``BaseMessage``) and the parsed model
                 response will be returned. If an error occurs during output parsing it
                 will be caught and returned as well. The final output is always a dict
-                with keys "raw", "parsed", and "parsing_error".
+                with keys ``'raw'``, ``'parsed'``, and ``'parsing_error'``.
 
             kwargs: Additional keyword args aren't supported.
 
         Returns:
             A Runnable that takes same inputs as a :class:`langchain_core.language_models.chat.BaseChatModel`.
 
-            | If ``include_raw`` is False and ``schema`` is a Pydantic class, Runnable outputs an instance of ``schema`` (i.e., a Pydantic object). Otherwise, if ``include_raw`` is False then Runnable outputs a dict.
+            If ``include_raw`` is False and ``schema`` is a Pydantic class, Runnable outputs an instance of ``schema`` (i.e., a Pydantic object). Otherwise, if ``include_raw`` is False then Runnable outputs a dict.
 
-            | If ``include_raw`` is True, then Runnable outputs a dict with keys:
+            If ``include_raw`` is True, then Runnable outputs a dict with keys:
 
-            - "raw": BaseMessage
-            - "parsed": None if there was a parsing error, otherwise the type depends on the ``schema`` as described above.
-            - "parsing_error": Optional[BaseException]
+            - ``'raw'``: ``BaseMessage``
+            - ``'parsed'``: None if there was a parsing error, otherwise the type depends on the ``schema`` as described above.
+            - ``'parsing_error'``: Optional[BaseException]
 
         .. versionchanged:: 0.2.2
 
@@ -1097,7 +1101,7 @@ class ChatOllama(BaseChatModel):
 
         .. versionchanged:: 0.3.0
 
-            Updated default ``method`` to ``"json_schema"``.
+            Updated default ``method`` to ``'json_schema'``.
 
         .. dropdown:: Example: schema=Pydantic class, method="json_schema", include_raw=False
 
@@ -1132,7 +1136,7 @@ class ChatOllama(BaseChatModel):
                 #     justification='Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume or density of the objects may differ.'
                 # )
 
-        .. dropdown:: Example: schema=Pydantic class, method="json_schema", include_raw=True
+        .. dropdown:: Example: ``schema=Pydantic`` class, ``method='json_schema'``, ``include_raw=True``
 
             .. code-block:: python
 
@@ -1161,7 +1165,7 @@ class ChatOllama(BaseChatModel):
                 #     'parsing_error': None
                 # }
 
-        .. dropdown:: Example: schema=Pydantic class, method="function_calling", include_raw=False
+        .. dropdown:: Example: ``schema=Pydantic`` class, ``method='function_calling'``, ``include_raw=False``
 
             .. code-block:: python
 
@@ -1225,7 +1229,7 @@ class ChatOllama(BaseChatModel):
                 #     'justification': 'Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.'
                 # }
 
-        .. dropdown:: Example: schema=OpenAI function schema, method="function_calling", include_raw=False
+        .. dropdown:: Example: ``schema=OpenAI`` function schema, ``method='function_calling'``, ``include_raw=False``
 
             .. code-block:: python
 
@@ -1255,7 +1259,7 @@ class ChatOllama(BaseChatModel):
                 #     'justification': 'Both a pound of bricks and a pound of feathers weigh one pound. The weight is the same, but the volume and density of the two substances differ.'
                 # }
 
-        .. dropdown:: Example: schema=Pydantic class, method="json_mode", include_raw=True
+        .. dropdown:: Example: ``schema=Pydantic`` class, ``method='json_mode'``, ``include_raw=True``
 
             .. code-block::
 
@@ -1283,6 +1287,7 @@ class ChatOllama(BaseChatModel):
                 #     'parsed': AnswerWithJustification(answer='They are both the same weight.', justification='Both a pound of bricks and a pound of feathers weigh one pound. The difference lies in the volume and density of the materials, not the weight.'),
                 #     'parsing_error': None
                 # }
+
         """  # noqa: E501, D301
         _ = kwargs.pop("strict", None)
         if kwargs:

{langchain_ollama-0.3.6 → langchain_ollama-0.3.8}/langchain_ollama/embeddings.py

@@ -21,12 +21,12 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     """Ollama embedding model integration.
 
     Set up a local Ollama instance:
-        Install the Ollama package and set up a local Ollama instance
-        using the instructions here: https://github.com/ollama/ollama .
+        `Install the Ollama package <https://github.com/ollama/ollama>`__ and set up a
+        local Ollama instance.
 
         You will need to choose a model to serve.
 
-        You can view a list of available models via the model library (https://ollama.com/library).
+        You can view a list of available models via `the model library <https://ollama.com/library>`__.
 
         To fetch a model from the Ollama model library use ``ollama pull <name-of-model>``.
 
@@ -39,8 +39,8 @@ class OllamaEmbeddings(BaseModel, Embeddings):
         This will download the default tagged version of the model.
         Typically, the default points to the latest, smallest sized-parameter model.
 
-        * On Mac, the models will be downloaded to ~/.ollama/models
-        * On Linux (or WSL), the models will be stored at /usr/share/ollama/.ollama/models
+        * On Mac, the models will be downloaded to ``~/.ollama/models``
+        * On Linux (or WSL), the models will be stored at ``/usr/share/ollama/.ollama/models``
 
         You can specify the exact version of the model of interest
         as such ``ollama pull vicuna:13b-v1.5-16k-q4_0``.
@@ -122,6 +122,7 @@ class OllamaEmbeddings(BaseModel, Embeddings):
         .. code-block:: python
 
             [-0.009100092574954033, 0.005071679595857859, -0.0029193938244134188]
+
     """  # noqa: E501
 
     model: str
@@ -131,6 +132,7 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     """Whether to validate the model exists in ollama locally on initialization.
 
     .. versionadded:: 0.3.4
+
     """
 
     base_url: Optional[str] = None
@@ -138,60 +140,62 @@ class OllamaEmbeddings(BaseModel, Embeddings):
 
     client_kwargs: Optional[dict] = {}
     """Additional kwargs to pass to the httpx clients.
+
     These arguments are passed to both synchronous and async clients.
-    Use sync_client_kwargs and async_client_kwargs to pass different arguments
+
+    Use ``sync_client_kwargs`` and ``async_client_kwargs`` to pass different arguments
     to synchronous and asynchronous clients.
+
     """
 
     async_client_kwargs: Optional[dict] = {}
-    """Additional kwargs to merge with client_kwargs before passing to the httpx
+    """Additional kwargs to merge with ``client_kwargs`` before passing to the httpx
     AsyncClient.
 
     For a full list of the params, see the `HTTPX documentation <https://www.python-httpx.org/api/#asyncclient>`__.
+
     """
 
     sync_client_kwargs: Optional[dict] = {}
-    """Additional kwargs to merge with client_kwargs before passing to the HTTPX Client.
+    """Additional kwargs to merge with ``client_kwargs`` before
+    passing to the HTTPX Client.
 
     For a full list of the params, see the `HTTPX documentation <https://www.python-httpx.org/api/#client>`__.
+
     """
 
     _client: Optional[Client] = PrivateAttr(default=None)
-    """
-    The client to use for making requests.
-    """
+    """The client to use for making requests."""
 
     _async_client: Optional[AsyncClient] = PrivateAttr(default=None)
-    """
-    The async client to use for making requests.
-    """
+    """The async client to use for making requests."""
 
     mirostat: Optional[int] = None
     """Enable Mirostat sampling for controlling perplexity.
-    (default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)"""
+    (default: ``0``, ``0`` = disabled, ``1`` = Mirostat, ``2`` = Mirostat 2.0)"""
 
     mirostat_eta: Optional[float] = None
     """Influences how quickly the algorithm responds to feedback
     from the generated text. A lower learning rate will result in
     slower adjustments, while a higher learning rate will make
-    the algorithm more responsive. (Default: 0.1)"""
+    the algorithm more responsive. (Default: ``0.1``)"""
 
     mirostat_tau: Optional[float] = None
     """Controls the balance between coherence and diversity
     of the output. A lower value will result in more focused and
-    coherent text. (Default: 5.0)"""
+    coherent text. (Default: ``5.0``)"""
 
     num_ctx: Optional[int] = None
     """Sets the size of the context window used to generate the
-    next token. (Default: 2048)	"""
+    next token. (Default: ``2048``)	"""
 
     num_gpu: Optional[int] = None
-    """The number of GPUs to use. On macOS it defaults to 1 to
-    enable metal support, 0 to disable."""
+    """The number of GPUs to use. On macOS it defaults to ``1`` to
+    enable metal support, ``0`` to disable."""
 
     keep_alive: Optional[int] = None
-    """controls how long the model will stay loaded into memory
-    following the request (default: 5m)
+    """Controls how long the model will stay loaded into memory
+    following the request (default: ``5m``)
     """
 
     num_thread: Optional[int] = None
@@ -202,34 +206,34 @@ class OllamaEmbeddings(BaseModel, Embeddings):
 
     repeat_last_n: Optional[int] = None
     """Sets how far back for the model to look back to prevent
-    repetition. (Default: 64, 0 = disabled, -1 = num_ctx)"""
+    repetition. (Default: ``64``, ``0`` = disabled, ``-1`` = ``num_ctx``)"""
 
     repeat_penalty: Optional[float] = None
-    """Sets how strongly to penalize repetitions. A higher value (e.g., 1.5)
-    will penalize repetitions more strongly, while a lower value (e.g., 0.9)
-    will be more lenient. (Default: 1.1)"""
+    """Sets how strongly to penalize repetitions. A higher value (e.g., ``1.5``)
+    will penalize repetitions more strongly, while a lower value (e.g., ``0.9``)
+    will be more lenient. (Default: ``1.1``)"""
 
     temperature: Optional[float] = None
     """The temperature of the model. Increasing the temperature will
-    make the model answer more creatively. (Default: 0.8)"""
+    make the model answer more creatively. (Default: ``0.8``)"""
 
     stop: Optional[list[str]] = None
     """Sets the stop tokens to use."""
 
     tfs_z: Optional[float] = None
     """Tail free sampling is used to reduce the impact of less probable
-    tokens from the output. A higher value (e.g., 2.0) will reduce the
-    impact more, while a value of 1.0 disables this setting. (default: 1)"""
+    tokens from the output. A higher value (e.g., ``2.0``) will reduce the
+    impact more, while a value of ``1.0`` disables this setting. (default: ``1``)"""
 
     top_k: Optional[int] = None
-    """Reduces the probability of generating nonsense. A higher value (e.g. 100)
-    will give more diverse answers, while a lower value (e.g. 10)
-    will be more conservative. (Default: 40)"""
+    """Reduces the probability of generating nonsense. A higher value (e.g. ``100``)
+    will give more diverse answers, while a lower value (e.g. ``10``)
+    will be more conservative. (Default: ``40``)"""
 
     top_p: Optional[float] = None
-    """Works together with top-k. A higher value (e.g., 0.95) will lead
-    to more diverse text, while a lower value (e.g., 0.5) will
-    generate more focused and conservative text. (Default: 0.9)"""
+    """Works together with top-k. A higher value (e.g., ``0.95``) will lead
+    to more diverse text, while a lower value (e.g., ``0.5``) will
+    generate more focused and conservative text. (Default: ``0.9``)"""
 
     model_config = ConfigDict(
         extra="forbid",
@@ -256,7 +260,7 @@ class OllamaEmbeddings(BaseModel, Embeddings):
 
     @model_validator(mode="after")
     def _set_clients(self) -> Self:
-        """Set clients to use for ollama."""
+        """Set clients to use for Ollama."""
         client_kwargs = self.client_kwargs or {}
 
         sync_client_kwargs = client_kwargs