langchain-ollama 0.2.3__tar.gz → 0.3.1__tar.gz

{langchain_ollama-0.2.3 → langchain_ollama-0.3.1}/PKG-INFO

@@ -1,22 +1,14 @@
 Metadata-Version: 2.1
 Name: langchain-ollama
-Version: 0.2.3
+Version: 0.3.1
 Summary: An integration package connecting Ollama and LangChain
-Home-page: https://github.com/langchain-ai/langchain
 License: MIT
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: langchain-core (>=0.3.33,<0.4.0)
-Requires-Dist: ollama (>=0.4.4,<1)
-Project-URL: Repository, https://github.com/langchain-ai/langchain
-Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain-ollama%3D%3D0%22&expanded=true
 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: <4.0,>=3.9
+Requires-Dist: ollama<1,>=0.4.4
+Requires-Dist: langchain-core<1.0.0,>=0.3.51
 Description-Content-Type: text/markdown
 
 # langchain-ollama
@@ -63,4 +55,3 @@ from langchain_ollama import OllamaLLM
 llm = OllamaLLM(model="llama3")
 llm.invoke("The meaning of life is")
 ```
-

{langchain_ollama-0.2.3 → langchain_ollama-0.3.1}/langchain_ollama/chat_models.py

@@ -7,12 +7,14 @@ from typing import (
     AsyncIterator,
     Callable,
     Dict,
+    Final,
     Iterator,
     List,
     Literal,
     Mapping,
     Optional,
     Sequence,
+    Tuple,
     Type,
     Union,
     cast,
@@ -30,6 +32,7 @@ from langchain_core.messages import (
     AIMessage,
     AIMessageChunk,
     BaseMessage,
+    BaseMessageChunk,
     HumanMessage,
     SystemMessage,
     ToolCall,
@@ -47,15 +50,19 @@ from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResu
 from langchain_core.runnables import Runnable, RunnableMap, RunnablePassthrough
 from langchain_core.tools import BaseTool
 from langchain_core.utils.function_calling import (
-    _convert_any_typed_dicts_to_pydantic as convert_any_typed_dicts_to_pydantic,
+    convert_to_json_schema,
+    convert_to_openai_tool,
 )
-from langchain_core.utils.function_calling import convert_to_openai_tool
 from langchain_core.utils.pydantic import TypeBaseModel, is_basemodel_subclass
 from ollama import AsyncClient, Client, Message, Options
 from pydantic import BaseModel, PrivateAttr, model_validator
 from pydantic.json_schema import JsonSchemaValue
+from pydantic.v1 import BaseModel as BaseModelV1
 from typing_extensions import Self, is_typeddict
 
+DEFAULT_THINK_TOKEN_START: Final[str] = "<think>"
+DEFAULT_THINK_TOKEN_END: Final[str] = "</think>"
+
 
 def _get_usage_metadata_from_generation_info(
     generation_info: Optional[Mapping[str, Any]],
@@ -124,13 +131,17 @@ def _parse_arguments_from_tool_call(
     if "function" not in raw_tool_call:
         return None
     arguments = raw_tool_call["function"]["arguments"]
-    parsed_arguments = {}
+    parsed_arguments: dict = {}
     if isinstance(arguments, dict):
         for key, value in arguments.items():
             if isinstance(value, str):
-                parsed_arguments[key] = _parse_json_string(
+                parsed_value = _parse_json_string(
                     value, skip=True, raw_tool_call=raw_tool_call
                 )
+                if isinstance(parsed_value, (dict, list)):
+                    parsed_arguments[key] = parsed_value
+                else:
+                    parsed_arguments[key] = value
             else:
                 parsed_arguments[key] = value
     else:
@@ -228,7 +239,7 @@ class ChatOllama(BaseChatModel):
                 ("human", "Return the words Hello World!"),
             ]
             for chunk in llm.stream(messages):
-                print(chunk)
+                print(chunk.text(), end="")
 
 
         .. code-block:: python
@@ -330,6 +341,13 @@ class ChatOllama(BaseChatModel):
     model: str
     """Model name to use."""
 
+    extract_reasoning: Optional[Union[bool, Tuple[str, str]]] = False
+    """Whether to extract the reasoning tokens in think blocks.
+    Extracts `chunk.content` to `chunk.additional_kwargs.reasoning_content`.
+    If a tuple is supplied, they are assumed to be the (start, end) tokens.
+    If `extract_reasoning=True`, the tokens will default to (<think>, </think>).
+    """
+
     mirostat: Optional[int] = None
     """Enable Mirostat sampling for controlling perplexity.
     (default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)"""
@@ -563,6 +581,28 @@ class ChatOllama(BaseChatModel):
 
         return ollama_messages
 
+    def _extract_reasoning(
+        self, message_chunk: BaseMessageChunk, is_thinking: bool
+    ) -> Tuple[BaseMessageChunk, bool]:
+        """Mutate a message chunk to extract reasoning content."""
+        if not self.extract_reasoning:
+            return message_chunk, is_thinking
+        elif self.extract_reasoning is True:
+            start_token = DEFAULT_THINK_TOKEN_START
+            end_token = DEFAULT_THINK_TOKEN_END
+        else:
+            start_token, end_token = cast(tuple, self.extract_reasoning)
+        if start_token in message_chunk.content:
+            is_thinking = True
+        content = message_chunk.content
+        if is_thinking:
+            message_chunk.additional_kwargs["reasoning_content"] = content
+            message_chunk.content = ""
+        if end_token in content:
+            is_thinking = False
+
+        return message_chunk, is_thinking
+
     async def _acreate_chat_stream(
         self,
         messages: List[BaseMessage],
@@ -599,35 +639,17 @@ class ChatOllama(BaseChatModel):
         **kwargs: Any,
     ) -> ChatGenerationChunk:
         final_chunk = None
-        for stream_resp in self._create_chat_stream(messages, stop, **kwargs):
-            if not isinstance(stream_resp, str):
-                chunk = ChatGenerationChunk(
-                    message=AIMessageChunk(
-                        content=(
-                            stream_resp["message"]["content"]
-                            if "message" in stream_resp
-                            and "content" in stream_resp["message"]
-                            else ""
-                        ),
-                        usage_metadata=_get_usage_metadata_from_generation_info(
-                            stream_resp
-                        ),
-                        tool_calls=_get_tool_calls_from_response(stream_resp),
-                    ),
-                    generation_info=(
-                        dict(stream_resp) if stream_resp.get("done") is True else None
-                    ),
+        for chunk in self._iterate_over_stream(messages, stop, **kwargs):
+            if final_chunk is None:
+                final_chunk = chunk
+            else:
+                final_chunk += chunk
+            if run_manager:
+                run_manager.on_llm_new_token(
+                    chunk.text,
+                    chunk=chunk,
+                    verbose=verbose,
                 )
-                if final_chunk is None:
-                    final_chunk = chunk
-                else:
-                    final_chunk += chunk
-                if run_manager:
-                    run_manager.on_llm_new_token(
-                        chunk.text,
-                        chunk=chunk,
-                        verbose=verbose,
-                    )
         if final_chunk is None:
             raise ValueError("No data received from Ollama stream.")
 
@@ -642,35 +664,17 @@ class ChatOllama(BaseChatModel):
         **kwargs: Any,
     ) -> ChatGenerationChunk:
         final_chunk = None
-        async for stream_resp in self._acreate_chat_stream(messages, stop, **kwargs):
-            if not isinstance(stream_resp, str):
-                chunk = ChatGenerationChunk(
-                    message=AIMessageChunk(
-                        content=(
-                            stream_resp["message"]["content"]
-                            if "message" in stream_resp
-                            and "content" in stream_resp["message"]
-                            else ""
-                        ),
-                        usage_metadata=_get_usage_metadata_from_generation_info(
-                            stream_resp
-                        ),
-                        tool_calls=_get_tool_calls_from_response(stream_resp),
-                    ),
-                    generation_info=(
-                        dict(stream_resp) if stream_resp.get("done") is True else None
-                    ),
+        async for chunk in self._aiterate_over_stream(messages, stop, **kwargs):
+            if final_chunk is None:
+                final_chunk = chunk
+            else:
+                final_chunk += chunk
+            if run_manager:
+                await run_manager.on_llm_new_token(
+                    chunk.text,
+                    chunk=chunk,
+                    verbose=verbose,
                 )
-                if final_chunk is None:
-                    final_chunk = chunk
-                else:
-                    final_chunk += chunk
-                if run_manager:
-                    await run_manager.on_llm_new_token(
-                        chunk.text,
-                        chunk=chunk,
-                        verbose=verbose,
-                    )
         if final_chunk is None:
             raise ValueError("No data received from Ollama stream.")
 
@@ -707,18 +711,19 @@ class ChatOllama(BaseChatModel):
                 content=final_chunk.text,
                 usage_metadata=cast(AIMessageChunk, final_chunk.message).usage_metadata,
                 tool_calls=cast(AIMessageChunk, final_chunk.message).tool_calls,
+                additional_kwargs=final_chunk.message.additional_kwargs,
             ),
             generation_info=generation_info,
         )
         return ChatResult(generations=[chat_generation])
 
-    def _stream(
+    def _iterate_over_stream(
         self,
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
+        is_thinking = False
         for stream_resp in self._create_chat_stream(messages, stop, **kwargs):
             if not isinstance(stream_resp, str):
                 chunk = ChatGenerationChunk(
@@ -738,20 +743,39 @@ class ChatOllama(BaseChatModel):
                         dict(stream_resp) if stream_resp.get("done") is True else None
                     ),
                 )
-                if run_manager:
-                    run_manager.on_llm_new_token(
-                        chunk.text,
-                        verbose=self.verbose,
+                if chunk.generation_info and (
+                    model := chunk.generation_info.get("model")
+                ):
+                    chunk.generation_info["model_name"] = model  # backwards compat
+                if self.extract_reasoning:
+                    message, is_thinking = self._extract_reasoning(
+                        chunk.message, is_thinking
                     )
+                    chunk.message = message
                 yield chunk
 
-    async def _astream(
+    def _stream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[ChatGenerationChunk]:
+        for chunk in self._iterate_over_stream(messages, stop, **kwargs):
+            if run_manager:
+                run_manager.on_llm_new_token(
+                    chunk.text,
+                    verbose=self.verbose,
+                )
+            yield chunk
+
+    async def _aiterate_over_stream(
         self,
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
+        is_thinking = False
         async for stream_resp in self._acreate_chat_stream(messages, stop, **kwargs):
             if not isinstance(stream_resp, str):
                 chunk = ChatGenerationChunk(
@@ -771,13 +795,32 @@ class ChatOllama(BaseChatModel):
                         dict(stream_resp) if stream_resp.get("done") is True else None
                     ),
                 )
-                if run_manager:
-                    await run_manager.on_llm_new_token(
-                        chunk.text,
-                        verbose=self.verbose,
+                if chunk.generation_info and (
+                    model := chunk.generation_info.get("model")
+                ):
+                    chunk.generation_info["model_name"] = model  # backwards compat
+                if self.extract_reasoning:
+                    message, is_thinking = self._extract_reasoning(
+                        chunk.message, is_thinking
                     )
+                    chunk.message = message
                 yield chunk
 
+    async def _astream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatGenerationChunk]:
+        async for chunk in self._aiterate_over_stream(messages, stop, **kwargs):
+            if run_manager:
+                await run_manager.on_llm_new_token(
+                    chunk.text,
+                    verbose=self.verbose,
+                )
+            yield chunk
+
     async def _agenerate(
         self,
         messages: List[BaseMessage],
@@ -794,6 +837,7 @@ class ChatOllama(BaseChatModel):
                 content=final_chunk.text,
                 usage_metadata=cast(AIMessageChunk, final_chunk.message).usage_metadata,
                 tool_calls=cast(AIMessageChunk, final_chunk.message).tool_calls,
+                additional_kwargs=final_chunk.message.additional_kwargs,
             ),
             generation_info=generation_info,
         )
@@ -831,9 +875,7 @@ class ChatOllama(BaseChatModel):
         self,
         schema: Union[Dict, type],
         *,
-        method: Literal[
-            "function_calling", "json_mode", "json_schema"
-        ] = "function_calling",
+        method: Literal["function_calling", "json_mode", "json_schema"] = "json_schema",
         include_raw: bool = False,
         **kwargs: Any,
     ) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
@@ -857,10 +899,10 @@ class ChatOllama(BaseChatModel):
 
             method: The method for steering model generation, one of:
 
-                - "function_calling":
-                    Uses Ollama's tool-calling API
                 - "json_schema":
                     Uses Ollama's structured output API: https://ollama.com/blog/structured-outputs
+                - "function_calling":
+                    Uses Ollama's tool-calling API
                 - "json_mode":
                     Specifies ``format="json"``. Note that if using JSON mode then you
                     must include instructions for formatting the output into the
@@ -891,7 +933,11 @@ class ChatOllama(BaseChatModel):
 
             Added support for structured output API via ``format`` parameter.
 
-        .. dropdown:: Example: schema=Pydantic class, method="function_calling", include_raw=False
+        .. versionchanged:: 0.3.0
+
+            Updated default ``method`` to ``"json_schema"``.
+
+        .. dropdown:: Example: schema=Pydantic class, method="json_schema", include_raw=False
 
             .. code-block:: python
 
@@ -924,7 +970,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="function_calling", include_raw=True
+        .. dropdown:: Example: schema=Pydantic class, method="json_schema", include_raw=True
 
             .. code-block:: python
 
@@ -953,7 +999,7 @@ class ChatOllama(BaseChatModel):
                 #     'parsing_error': None
                 # }
 
-        .. dropdown:: Example: schema=Pydantic class, method="json_schema", include_raw=False
+        .. dropdown:: Example: schema=Pydantic class, method="function_calling", include_raw=False
 
             .. code-block:: python
 
@@ -974,7 +1020,7 @@ class ChatOllama(BaseChatModel):
 
                 llm = ChatOllama(model="llama3.1", temperature=0)
                 structured_llm = llm.with_structured_output(
-                    AnswerWithJustification, method="json_schema"
+                    AnswerWithJustification, method="function_calling"
                 )
 
                 structured_llm.invoke(
@@ -1076,6 +1122,7 @@ class ChatOllama(BaseChatModel):
                 #     'parsing_error': None
                 # }
         """  # noqa: E501, D301
+        _ = kwargs.pop("strict", None)
         if kwargs:
             raise ValueError(f"Received unsupported arguments {kwargs}")
         is_pydantic_schema = _is_pydantic_class(schema)
@@ -1090,7 +1137,7 @@ class ChatOllama(BaseChatModel):
             llm = self.bind_tools(
                 [schema],
                 tool_choice=tool_name,
-                structured_output_format={
+                ls_structured_output_format={
                     "kwargs": {"method": method},
                     "schema": formatted_tool,
                 },
@@ -1107,7 +1154,7 @@ class ChatOllama(BaseChatModel):
         elif method == "json_mode":
             llm = self.bind(
                 format="json",
-                structured_output_format={
+                ls_structured_output_format={
                     "kwargs": {"method": method},
                     "schema": schema,
                 },
@@ -1125,9 +1172,13 @@ class ChatOllama(BaseChatModel):
                 )
             if is_pydantic_schema:
                 schema = cast(TypeBaseModel, schema)
+                if issubclass(schema, BaseModelV1):
+                    response_format = schema.schema()
+                else:
+                    response_format = schema.model_json_schema()
                 llm = self.bind(
-                    format=schema.model_json_schema(),
-                    structured_output_format={
+                    format=response_format,
+                    ls_structured_output_format={
                         "kwargs": {"method": method},
                         "schema": schema,
                     },
@@ -1135,20 +1186,17 @@ class ChatOllama(BaseChatModel):
                 output_parser = PydanticOutputParser(pydantic_object=schema)
             else:
                 if is_typeddict(schema):
-                    schema = cast(type, schema)
-                    response_format = convert_any_typed_dicts_to_pydantic(
-                        schema, visited={}
-                    ).schema()  # type: ignore[attr-defined]
+                    response_format = convert_to_json_schema(schema)
                     if "required" not in response_format:
                         response_format["required"] = list(
                             response_format["properties"].keys()
                         )
                 else:
                     # is JSON schema
-                    response_format = schema
+                    response_format = cast(dict, schema)
                 llm = self.bind(
                     format=response_format,
-                    structured_output_format={
+                    ls_structured_output_format={
                         "kwargs": {"method": method},
                         "schema": response_format,
                     },

{langchain_ollama-0.2.3 → langchain_ollama-0.3.1}/langchain_ollama/embeddings.py

@@ -164,6 +164,11 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     """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)
+    """
+
     num_thread: Optional[int] = None
     """Sets the number of threads to use during computation.
     By default, Ollama will detect this for optimal performance.
@@ -235,7 +240,7 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     def embed_documents(self, texts: List[str]) -> List[List[float]]:
         """Embed search docs."""
         embedded_docs = self._client.embed(
-            self.model, texts, options=self._default_params
+            self.model, texts, options=self._default_params, keep_alive=self.keep_alive
         )["embeddings"]
         return embedded_docs
 
@@ -245,9 +250,11 @@ class OllamaEmbeddings(BaseModel, Embeddings):
 
     async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
         """Embed search docs."""
-        embedded_docs = (await self._async_client.embed(self.model, texts))[
-            "embeddings"
-        ]
+        embedded_docs = (
+            await self._async_client.embed(
+                self.model, texts, keep_alive=self.keep_alive
+            )
+        )["embeddings"]
         return embedded_docs
 
     async def aembed_query(self, text: str) -> List[float]:

{langchain_ollama-0.2.3 → langchain_ollama-0.3.1}/langchain_ollama/llms.py

@@ -84,6 +84,11 @@ class OllamaLLM(BaseLLM):
     """The temperature of the model. Increasing the temperature will
     make the model answer more creatively. (Default: 0.8)"""
 
+    seed: Optional[int] = None
+    """Sets the random number seed to use for generation. Setting this
+    to a specific number will make the model generate the same text for
+    the same prompt."""
+
     stop: Optional[List[str]] = None
     """Sets the stop tokens to use."""
 
@@ -150,6 +155,7 @@ class OllamaLLM(BaseLLM):
                 "repeat_last_n": self.repeat_last_n,
                 "repeat_penalty": self.repeat_penalty,
                 "temperature": self.temperature,
+                "seed": self.seed,
                 "stop": self.stop if stop is None else stop,
                 "tfs_z": self.tfs_z,
                 "top_k": self.top_k,

langchain_ollama-0.3.1/pyproject.toml

@@ -0,0 +1,90 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+authors = []
+requires-python = "<4.0,>=3.9"
+dependencies = [
+    "ollama<1,>=0.4.4",
+    "langchain-core<1.0.0,>=0.3.51",
+]
+name = "langchain-ollama"
+version = "0.3.1"
+description = "An integration package connecting Ollama and LangChain"
+readme = "README.md"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+"Source Code" = "https://github.com/langchain-ai/langchain/tree/master/libs/partners/ollama"
+"Release Notes" = "https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain-ollama%3D%3D0%22&expanded=true"
+repository = "https://github.com/langchain-ai/langchain"
+
+[dependency-groups]
+test = [
+    "pytest<8.0.0,>=7.4.3",
+    "pytest-asyncio<1.0.0,>=0.23.2",
+    "syrupy<5.0.0,>=4.0.2",
+    "pytest-socket<1.0.0,>=0.7.0",
+    "pytest-watcher<1.0.0,>=0.3.4",
+    "langchain-core",
+    "langchain-tests",
+]
+codespell = [
+    "codespell<3.0.0,>=2.2.6",
+]
+test_integration = []
+lint = [
+    "ruff<1.0.0,>=0.1.8",
+]
+dev = [
+    "langchain-core",
+]
+typing = [
+    "mypy<2.0.0,>=1.7.1",
+    "langchain-core",
+]
+
+[tool.uv.sources.langchain-core]
+path = "../../core"
+editable = true
+
+[tool.uv.sources.langchain-tests]
+path = "../../standard-tests"
+editable = true
+
+[tool.mypy]
+disallow_untyped_defs = "True"
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "T201",
+    "D",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = [
+    "D",
+]
+
+[tool.coverage.run]
+omit = [
+    "tests/*",
+]
+
+[tool.pytest.ini_options]
+addopts = "--snapshot-warn-unused --strict-markers --strict-config --durations=5"
+markers = [
+    "compile: mark placeholder test used to compile integration tests without running them",
+]
+asyncio_mode = "auto"

langchain_ollama-0.3.1/tests/integration_tests/chat_models/test_chat_models.py

@@ -0,0 +1,92 @@
+"""Ollama specific chat model integration tests"""
+
+from typing import List, Optional
+
+import pytest
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated, TypedDict
+
+from langchain_ollama import ChatOllama
+
+
+@pytest.mark.parametrize(("method"), [("function_calling"), ("json_schema")])
+def test_structured_output(method: str) -> None:
+    """Test to verify structured output via tool calling and ``format`` parameter."""
+
+    class Joke(BaseModel):
+        """Joke to tell user."""
+
+        setup: str = Field(description="question to set up a joke")
+        punchline: str = Field(description="answer to resolve the joke")
+
+    llm = ChatOllama(model="llama3.1", temperature=0)
+    query = "Tell me a joke about cats."
+
+    # Pydantic
+    structured_llm = llm.with_structured_output(Joke, method=method)  # type: ignore[arg-type]
+    result = structured_llm.invoke(query)
+    assert isinstance(result, Joke)
+
+    for chunk in structured_llm.stream(query):
+        assert isinstance(chunk, Joke)
+
+    # JSON Schema
+    structured_llm = llm.with_structured_output(Joke.model_json_schema(), method=method)  # type: ignore[arg-type]
+    result = structured_llm.invoke(query)
+    assert isinstance(result, dict)
+    assert set(result.keys()) == {"setup", "punchline"}
+
+    for chunk in structured_llm.stream(query):
+        assert isinstance(chunk, dict)
+    assert isinstance(chunk, dict)  # for mypy
+    assert set(chunk.keys()) == {"setup", "punchline"}
+
+    # Typed Dict
+    class JokeSchema(TypedDict):
+        """Joke to tell user."""
+
+        setup: Annotated[str, "question to set up a joke"]
+        punchline: Annotated[str, "answer to resolve the joke"]
+
+    structured_llm = llm.with_structured_output(JokeSchema, method=method)  # type: ignore[arg-type]
+    result = structured_llm.invoke(query)
+    assert isinstance(result, dict)
+    assert set(result.keys()) == {"setup", "punchline"}
+
+    for chunk in structured_llm.stream(query):
+        assert isinstance(chunk, dict)
+    assert isinstance(chunk, dict)  # for mypy
+    assert set(chunk.keys()) == {"setup", "punchline"}
+
+
+@pytest.mark.parametrize(("model"), [("llama3.1")])
+def test_structured_output_deeply_nested(model: str) -> None:
+    """Test to verify structured output with a nested objects."""
+    llm = ChatOllama(model=model, temperature=0)
+
+    class Person(BaseModel):
+        """Information about a person."""
+
+        name: Optional[str] = Field(default=None, description="The name of the person")
+        hair_color: Optional[str] = Field(
+            default=None, description="The color of the person's hair if known"
+        )
+        height_in_meters: Optional[str] = Field(
+            default=None, description="Height measured in meters"
+        )
+
+    class Data(BaseModel):
+        """Extracted data about people."""
+
+        people: List[Person]
+
+    chat = llm.with_structured_output(Data)  # type: ignore[arg-type]
+    text = (
+        "Alan Smith is 6 feet tall and has blond hair."
+        "Alan Poe is 3 feet tall and has grey hair."
+    )
+    result = chat.invoke(text)
+    assert isinstance(result, Data)
+
+    for chunk in chat.stream(text):
+        assert isinstance(chunk, Data)

langchain_ollama-0.3.1/tests/integration_tests/chat_models/test_chat_models_reasoning.py

@@ -0,0 +1,162 @@
+"""Ollama specific chat model integration tests for reasoning models."""
+
+import pytest
+from langchain_core.messages import AIMessageChunk, BaseMessageChunk, HumanMessage
+from pydantic import ValidationError
+
+from langchain_ollama import ChatOllama
+
+SAMPLE = "What is 3^3?"
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_messages_stream_no_reasoning(model: str) -> None:
+    """Test deepseek model without parsing."""
+    llm = ChatOllama(model=model, num_ctx=2**12)
+    messages = [
+        {
+            "role": "user",
+            "content": SAMPLE,
+        }
+    ]
+    result = None
+    for chunk in llm.stream(messages):
+        assert isinstance(chunk, BaseMessageChunk)
+        if result is None:
+            result = chunk
+            continue
+        result += chunk
+    assert isinstance(result, AIMessageChunk)
+    assert result.content
+    assert "<think>" in result.content and "</think>" in result.content
+    assert "reasoning_content" not in result.additional_kwargs
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_messages_stream_bool(model: str) -> None:
+    """Test deepseek model with reasoning bool=True"""
+    llm = ChatOllama(model=model, num_ctx=2**12, extract_reasoning=True)
+    messages = [
+        {
+            "role": "user",
+            "content": SAMPLE,
+        }
+    ]
+    result = None
+    for chunk in llm.stream(messages):
+        assert isinstance(chunk, BaseMessageChunk)
+        if result is None:
+            result = chunk
+            continue
+        result += chunk
+    assert isinstance(result, AIMessageChunk)
+    assert result.content
+    assert "<think>" not in result.content and "</think>" not in result.content
+    assert "reasoning_content" in result.additional_kwargs
+    assert len(result.additional_kwargs["reasoning_content"]) > 0
+    assert "<think>" in result.additional_kwargs["reasoning_content"]
+    assert "</think>" in result.additional_kwargs["reasoning_content"]
+    clean_content = (
+        result.additional_kwargs["reasoning_content"]
+        .replace("<think>", "")
+        .replace("</think>", "")
+        .strip()
+    )
+    assert len(clean_content) > 0
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_messages_stream_tuple(model: str) -> None:
+    """Test deepseek model with reasoning with tuple=..."""
+    llm = ChatOllama(
+        model=model, num_ctx=2**12, extract_reasoning=("<think>", "</think>")
+    )
+    messages = [
+        {
+            "role": "user",
+            "content": SAMPLE,
+        }
+    ]
+    result = None
+    for chunk in llm.stream(messages):
+        assert isinstance(chunk, BaseMessageChunk)
+        if result is None:
+            result = chunk
+            continue
+        result += chunk
+    assert isinstance(result, AIMessageChunk)
+    assert result.content
+    assert "<think>" not in result.content and "</think>" not in result.content
+    assert "reasoning_content" in result.additional_kwargs
+    assert len(result.additional_kwargs["reasoning_content"]) > 0
+    assert "<think>" in result.additional_kwargs["reasoning_content"]
+    assert "</think>" in result.additional_kwargs["reasoning_content"]
+    clean_content = (
+        result.additional_kwargs["reasoning_content"]
+        .replace("<think>", "")
+        .replace("</think>", "")
+        .strip()
+    )
+    assert len(clean_content) > 0
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_messages_invoke_no_reasoning(model: str) -> None:
+    """Test deepseek model without parsing using invoke."""
+    llm = ChatOllama(model=model, num_ctx=2**12)
+    message = HumanMessage(content=SAMPLE)
+    result = llm.invoke([message])
+    assert result.content
+    assert "<think>" in result.content and "</think>" in result.content
+    assert "reasoning_content" not in result.additional_kwargs
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_messages_invoke_bool(model: str) -> None:
+    """Test deepseek model with reasoning bool=True using invoke"""
+    llm = ChatOllama(model=model, num_ctx=2**12, extract_reasoning=True)
+    message = HumanMessage(content=SAMPLE)
+    result = llm.invoke([message])
+    assert result.content
+    assert "<think>" not in result.content and "</think>" not in result.content
+    assert "reasoning_content" in result.additional_kwargs
+    assert len(result.additional_kwargs["reasoning_content"]) > 0
+    assert "<think>" in result.additional_kwargs["reasoning_content"]
+    assert "</think>" in result.additional_kwargs["reasoning_content"]
+    clean_content = (
+        result.additional_kwargs["reasoning_content"]
+        .replace("<think>", "")
+        .replace("</think>", "")
+        .strip()
+    )
+    assert len(clean_content) > 0
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_messages_invoke_tuple(model: str) -> None:
+    """Test deepseek model with reasoning with tuple=... using invoke"""
+    llm = ChatOllama(
+        model=model, num_ctx=2**12, extract_reasoning=("<think>", "</think>")
+    )
+    message = HumanMessage(content=SAMPLE)
+    result = llm.invoke([message])
+    assert result.content
+    assert "<think>" not in result.content and "</think>" not in result.content
+    assert "reasoning_content" in result.additional_kwargs
+    assert len(result.additional_kwargs["reasoning_content"]) > 0
+    assert "<think>" in result.additional_kwargs["reasoning_content"]
+    assert "</think>" in result.additional_kwargs["reasoning_content"]
+    clean_content = (
+        result.additional_kwargs["reasoning_content"]
+        .replace("<think>", "")
+        .replace("</think>", "")
+        .strip()
+    )
+    assert len(clean_content) > 0
+
+
+@pytest.mark.parametrize(("model"), [("deepseek-r1:1.5b")])
+def test_deepseek_invalid(model: str) -> None:
+    """Test deepseek model with reasoning raises ValidationError"""
+    with pytest.raises(ValidationError):
+        _ = ChatOllama(model=model, extract_reasoning={"invalid": "data"})  # type: ignore[arg-type]

langchain_ollama-0.3.1/tests/integration_tests/chat_models/test_chat_models_standard.py

@@ -0,0 +1,29 @@
+"""Test chat model integration using standard integration tests."""
+
+from typing import Type
+
+from langchain_tests.integration_tests import ChatModelIntegrationTests
+
+from langchain_ollama.chat_models import ChatOllama
+
+
+class TestChatOllama(ChatModelIntegrationTests):
+    @property
+    def chat_model_class(self) -> Type[ChatOllama]:
+        return ChatOllama
+
+    @property
+    def chat_model_params(self) -> dict:
+        return {"model": "llama3.1"}
+
+    @property
+    def supports_image_inputs(self) -> bool:
+        return True
+
+    @property
+    def supports_json_mode(self) -> bool:
+        return True
+
+    @property
+    def has_tool_choice(self) -> bool:
+        return False

langchain_ollama-0.3.1/tests/integration_tests/test_compile.py

@@ -0,0 +1,7 @@
+import pytest
+
+
+@pytest.mark.compile
+def test_placeholder() -> None:
+    """Used for compiling integration tests without running any real tests."""
+    pass

langchain_ollama-0.3.1/tests/integration_tests/test_embeddings.py

@@ -0,0 +1,17 @@
+"""Test Ollama embeddings."""
+
+from typing import Type
+
+from langchain_tests.integration_tests import EmbeddingsIntegrationTests
+
+from langchain_ollama.embeddings import OllamaEmbeddings
+
+
+class TestOllamaEmbeddings(EmbeddingsIntegrationTests):
+    @property
+    def embeddings_class(self) -> Type[OllamaEmbeddings]:
+        return OllamaEmbeddings
+
+    @property
+    def embedding_model_params(self) -> dict:
+        return {"model": "llama3:latest"}

langchain_ollama-0.3.1/tests/integration_tests/test_llms.py

@@ -0,0 +1,66 @@
+"""Test OllamaLLM llm."""
+
+from langchain_ollama.llms import OllamaLLM
+
+MODEL_NAME = "llama3"
+
+
+def test_stream() -> None:
+    """Test streaming tokens from OpenAI."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    for token in llm.stream("I'm Pickle Rick"):
+        assert isinstance(token, str)
+
+
+async def test_astream() -> None:
+    """Test streaming tokens from OpenAI."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    async for token in llm.astream("I'm Pickle Rick"):
+        assert isinstance(token, str)
+
+
+async def test_abatch() -> None:
+    """Test streaming tokens from OllamaLLM."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    result = await llm.abatch(["I'm Pickle Rick", "I'm not Pickle Rick"])
+    for token in result:
+        assert isinstance(token, str)
+
+
+async def test_abatch_tags() -> None:
+    """Test batch tokens from OllamaLLM."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    result = await llm.abatch(
+        ["I'm Pickle Rick", "I'm not Pickle Rick"], config={"tags": ["foo"]}
+    )
+    for token in result:
+        assert isinstance(token, str)
+
+
+def test_batch() -> None:
+    """Test batch tokens from OllamaLLM."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    result = llm.batch(["I'm Pickle Rick", "I'm not Pickle Rick"])
+    for token in result:
+        assert isinstance(token, str)
+
+
+async def test_ainvoke() -> None:
+    """Test invoke tokens from OllamaLLM."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    result = await llm.ainvoke("I'm Pickle Rick", config={"tags": ["foo"]})
+    assert isinstance(result, str)
+
+
+def test_invoke() -> None:
+    """Test invoke tokens from OllamaLLM."""
+    llm = OllamaLLM(model=MODEL_NAME)
+
+    result = llm.invoke("I'm Pickle Rick", config=dict(tags=["foo"]))
+    assert isinstance(result, str)

langchain_ollama-0.3.1/tests/unit_tests/test_chat_models.py

@@ -0,0 +1,25 @@
+"""Test chat model integration."""
+import json
+from typing import Dict, Type
+
+from langchain_tests.unit_tests import ChatModelUnitTests
+
+from langchain_ollama.chat_models import ChatOllama, _parse_arguments_from_tool_call
+
+
+class TestChatOllama(ChatModelUnitTests):
+    @property
+    def chat_model_class(self) -> Type[ChatOllama]:
+        return ChatOllama
+
+    @property
+    def chat_model_params(self) -> Dict:
+        return {"model": "llama3-groq-tool-use"}
+
+
+def test__parse_arguments_from_tool_call() -> None:
+    raw_response = '{"model":"sample-model","message":{"role":"assistant","content":"","tool_calls":[{"function":{"name":"get_profile_details","arguments":{"arg_1":"12345678901234567890123456"}}}]},"done":false}'  # noqa: E501
+    raw_tool_calls = json.loads(raw_response)["message"]["tool_calls"]
+    response = _parse_arguments_from_tool_call(raw_tool_calls[0])
+    assert response is not None
+    assert isinstance(response["arg_1"], str)

langchain_ollama-0.3.1/tests/unit_tests/test_embeddings.py

@@ -0,0 +1,8 @@
+"""Test embedding model integration."""
+
+from langchain_ollama.embeddings import OllamaEmbeddings
+
+
+def test_initialization() -> None:
+    """Test embedding model initialization."""
+    OllamaEmbeddings(model="llama3", keep_alive=1)

langchain_ollama-0.3.1/tests/unit_tests/test_imports.py

@@ -0,0 +1,12 @@
+from langchain_ollama import __all__
+
+EXPECTED_ALL = [
+    "OllamaLLM",
+    "ChatOllama",
+    "OllamaEmbeddings",
+    "__version__",
+]
+
+
+def test_all_imports() -> None:
+    assert sorted(EXPECTED_ALL) == sorted(__all__)

langchain_ollama-0.3.1/tests/unit_tests/test_llms.py

@@ -0,0 +1,28 @@
+"""Test Ollama Chat API wrapper."""
+
+from langchain_ollama import OllamaLLM
+
+
+def test_initialization() -> None:
+    """Test integration initialization."""
+    OllamaLLM(model="llama3")
+
+
+def test_model_params() -> None:
+    # Test standard tracing params
+    llm = OllamaLLM(model="llama3")
+    ls_params = llm._get_ls_params()
+    assert ls_params == {
+        "ls_provider": "ollama",
+        "ls_model_type": "llm",
+        "ls_model_name": "llama3",
+    }
+
+    llm = OllamaLLM(model="llama3", num_predict=3)
+    ls_params = llm._get_ls_params()
+    assert ls_params == {
+        "ls_provider": "ollama",
+        "ls_model_type": "llm",
+        "ls_model_name": "llama3",
+        "ls_max_tokens": 3,
+    }

langchain_ollama-0.2.3/pyproject.toml

@@ -1,99 +0,0 @@
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.poetry]
-name = "langchain-ollama"
-version = "0.2.3"
-description = "An integration package connecting Ollama and LangChain"
-authors = []
-readme = "README.md"
-repository = "https://github.com/langchain-ai/langchain"
-license = "MIT"
-
-[tool.mypy]
-disallow_untyped_defs = "True"
-
-[tool.poetry.urls]
-"Source Code" = "https://github.com/langchain-ai/langchain/tree/master/libs/partners/ollama"
-"Release Notes" = "https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain-ollama%3D%3D0%22&expanded=true"
-
-[tool.poetry.dependencies]
-python = ">=3.9,<4.0"
-ollama = ">=0.4.4,<1"
-langchain-core = "^0.3.33"
-
-[tool.ruff.lint]
-select = [
-  "E",    # pycodestyle
-  "F",    # pyflakes
-  "I",    # isort
-  "T201", # print
-  "D",    # pydocstyle
-
-]
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"
-
-[tool.ruff.lint.per-file-ignores]
-"tests/**" = ["D"] # ignore docstring checks for tests
-
-[tool.coverage.run]
-omit = ["tests/*"]
-
-[tool.pytest.ini_options]
-addopts = "--snapshot-warn-unused --strict-markers --strict-config --durations=5"
-markers = [
-  "compile: mark placeholder test used to compile integration tests without running them",
-]
-asyncio_mode = "auto"
-
-[tool.poetry.group.test]
-optional = true
-
-[tool.poetry.group.codespell]
-optional = true
-
-[tool.poetry.group.test_integration]
-optional = true
-
-[tool.poetry.group.lint]
-optional = true
-
-[tool.poetry.group.dev]
-optional = true
-
-[tool.poetry.group.test.dependencies]
-pytest = "^7.4.3"
-pytest-asyncio = "^0.23.2"
-syrupy = "^4.0.2"
-pytest-socket = "^0.7.0"
-pytest-watcher = "^0.3.4"
-
-[tool.poetry.group.codespell.dependencies]
-codespell = "^2.2.6"
-
-[tool.poetry.group.test_integration.dependencies]
-
-[tool.poetry.group.lint.dependencies]
-ruff = "^0.1.8"
-
-[tool.poetry.group.typing.dependencies]
-mypy = "^1.7.1"
-
-[tool.poetry.group.test.dependencies.langchain-core]
-path = "../../core"
-develop = true
-
-[tool.poetry.group.test.dependencies.langchain-tests]
-path = "../../standard-tests"
-develop = true
-
-[tool.poetry.group.typing.dependencies.langchain-core]
-path = "../../core"
-develop = true
-
-[tool.poetry.group.dev.dependencies.langchain-core]
-path = "../../core"
-develop = true