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

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

@@ -1,14 +1,14 @@
 Metadata-Version: 2.1
 Name: langchain-ollama
-Version: 0.3.1
+Version: 0.3.3
 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: <4.0,>=3.9
-Requires-Dist: ollama<1,>=0.4.4
-Requires-Dist: langchain-core<1.0.0,>=0.3.51
+Requires-Python: >=3.9
+Requires-Dist: ollama<1.0.0,>=0.4.8
+Requires-Dist: langchain-core<1.0.0,>=0.3.60
 Description-Content-Type: text/markdown
 
 # langchain-ollama

{langchain_ollama-0.3.1 → langchain_ollama-0.3.3}/langchain_ollama/__init__.py

@@ -3,7 +3,6 @@
 It provides infrastructure for interacting with the Ollama service.
 """
 
-
 from importlib import metadata
 
 from langchain_ollama.chat_models import ChatOllama

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

@@ -1,21 +1,14 @@
 """Ollama chat models."""
 
 import json
+from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
 from operator import itemgetter
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
     Final,
-    Iterator,
-    List,
     Literal,
-    Mapping,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     Union,
     cast,
 )
@@ -33,10 +26,12 @@ from langchain_core.messages import (
     AIMessageChunk,
     BaseMessage,
     BaseMessageChunk,
+    ChatMessage,
     HumanMessage,
     SystemMessage,
     ToolCall,
     ToolMessage,
+    is_data_content_block,
 )
 from langchain_core.messages.ai import UsageMetadata
 from langchain_core.messages.tool import tool_call
@@ -153,7 +148,7 @@ def _parse_arguments_from_tool_call(
 
 def _get_tool_calls_from_response(
     response: Mapping[str, Any],
-) -> List[ToolCall]:
+) -> list[ToolCall]:
     """Get tool calls from ollama response."""
     tool_calls = []
     if "message" in response:
@@ -180,6 +175,20 @@ def _lc_tool_call_to_openai_tool_call(tool_call: ToolCall) -> dict:
     }
 
 
+def _get_image_from_data_content_block(block: dict) -> str:
+    """Format standard data content block to format expected by Ollama."""
+    if block["type"] == "image":
+        if block["source_type"] == "base64":
+            return block["data"]
+        else:
+            error_message = "Image data only supported through in-line base64 format."
+            raise ValueError(error_message)
+
+    else:
+        error_message = f"Blocks of type {block['type']} not supported."
+        raise ValueError(error_message)
+
+
 def _is_pydantic_class(obj: Any) -> bool:
     return isinstance(obj, type) and is_basemodel_subclass(obj)
 
@@ -341,7 +350,7 @@ class ChatOllama(BaseChatModel):
     model: str
     """Model name to use."""
 
-    extract_reasoning: Optional[Union[bool, Tuple[str, str]]] = False
+    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.
@@ -399,7 +408,7 @@ class ChatOllama(BaseChatModel):
     to a specific number will make the model generate the same text for
     the same prompt."""
 
-    stop: Optional[List[str]] = None
+    stop: Optional[list[str]] = None
     """Sets the stop tokens to use."""
 
     tfs_z: Optional[float] = None
@@ -427,8 +436,22 @@ class ChatOllama(BaseChatModel):
     """Base url the model is hosted under."""
 
     client_kwargs: Optional[dict] = {}
-    """Additional kwargs to pass to the httpx Client.
-    For a full list of the params, see [this link](https://pydoc.dev/httpx/latest/httpx.Client.html)
+    """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
+    to synchronous and asynchronous clients.
+    """
+
+    async_client_kwargs: Optional[dict] = {}
+    """Additional kwargs to merge with client_kwargs before
+    passing to the httpx AsyncClient.
+    For a full list of the params, see [this link](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.
+    For a full list of the params, see [this link](https://www.python-httpx.org/api/#client)
     """
 
     _client: Client = PrivateAttr(default=None)  # type: ignore
@@ -443,10 +466,10 @@ class ChatOllama(BaseChatModel):
 
     def _chat_params(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         ollama_messages = self._convert_messages_to_ollama_messages(messages)
 
         if self.stop is not None and stop is not None:
@@ -494,18 +517,27 @@ class ChatOllama(BaseChatModel):
     def _set_clients(self) -> Self:
         """Set clients to use for ollama."""
         client_kwargs = self.client_kwargs or {}
-        self._client = Client(host=self.base_url, **client_kwargs)
-        self._async_client = AsyncClient(host=self.base_url, **client_kwargs)
+
+        sync_client_kwargs = client_kwargs
+        if self.sync_client_kwargs:
+            sync_client_kwargs = {**sync_client_kwargs, **self.sync_client_kwargs}
+
+        async_client_kwargs = client_kwargs
+        if self.async_client_kwargs:
+            async_client_kwargs = {**async_client_kwargs, **self.async_client_kwargs}
+
+        self._client = Client(host=self.base_url, **sync_client_kwargs)
+        self._async_client = AsyncClient(host=self.base_url, **async_client_kwargs)
         return self
 
     def _convert_messages_to_ollama_messages(
-        self, messages: List[BaseMessage]
+        self, messages: list[BaseMessage]
     ) -> Sequence[Message]:
-        ollama_messages: List = []
+        ollama_messages: list = []
         for message in messages:
-            role: Literal["user", "assistant", "system", "tool"]
+            role: str
             tool_call_id: Optional[str] = None
-            tool_calls: Optional[List[Dict[str, Any]]] = None
+            tool_calls: Optional[list[dict[str, Any]]] = None
             if isinstance(message, HumanMessage):
                 role = "user"
             elif isinstance(message, AIMessage):
@@ -520,6 +552,8 @@ class ChatOllama(BaseChatModel):
                 )
             elif isinstance(message, SystemMessage):
                 role = "system"
+            elif isinstance(message, ChatMessage):
+                role = message.role
             elif isinstance(message, ToolMessage):
                 role = "tool"
                 tool_call_id = message.tool_call_id
@@ -531,7 +565,7 @@ class ChatOllama(BaseChatModel):
             if isinstance(message.content, str):
                 content = message.content
             else:
-                for content_part in cast(List[Dict], message.content):
+                for content_part in cast(list[dict], message.content):
                     if content_part.get("type") == "text":
                         content += f"\n{content_part['text']}"
                     elif content_part.get("type") == "tool_use":
@@ -560,7 +594,9 @@ class ChatOllama(BaseChatModel):
                             images.append(image_url_components[1])
                         else:
                             images.append(image_url_components[0])
-
+                    elif is_data_content_block(content_part):
+                        image = _get_image_from_data_content_block(content_part)
+                        images.append(image)
                     else:
                         raise ValueError(
                             "Unsupported message content type. "
@@ -583,7 +619,7 @@ class ChatOllama(BaseChatModel):
 
     def _extract_reasoning(
         self, message_chunk: BaseMessageChunk, is_thinking: bool
-    ) -> Tuple[BaseMessageChunk, bool]:
+    ) -> tuple[BaseMessageChunk, bool]:
         """Mutate a message chunk to extract reasoning content."""
         if not self.extract_reasoning:
             return message_chunk, is_thinking
@@ -605,8 +641,8 @@ class ChatOllama(BaseChatModel):
 
     async def _acreate_chat_stream(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> AsyncIterator[Union[Mapping[str, Any], str]]:
         chat_params = self._chat_params(messages, stop, **kwargs)
@@ -619,8 +655,8 @@ class ChatOllama(BaseChatModel):
 
     def _create_chat_stream(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> Iterator[Union[Mapping[str, Any], str]]:
         chat_params = self._chat_params(messages, stop, **kwargs)
@@ -632,8 +668,8 @@ class ChatOllama(BaseChatModel):
 
     def _chat_stream_with_aggregation(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         verbose: bool = False,
         **kwargs: Any,
@@ -657,8 +693,8 @@ class ChatOllama(BaseChatModel):
 
     async def _achat_stream_with_aggregation(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         verbose: bool = False,
         **kwargs: Any,
@@ -681,7 +717,7 @@ class ChatOllama(BaseChatModel):
         return final_chunk
 
     def _get_ls_params(
-        self, stop: Optional[List[str]] = None, **kwargs: Any
+        self, stop: Optional[list[str]] = None, **kwargs: Any
     ) -> LangSmithParams:
         """Get standard params for tracing."""
         params = self._get_invocation_params(stop=stop, **kwargs)
@@ -697,8 +733,8 @@ class ChatOllama(BaseChatModel):
 
     def _generate(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
@@ -719,13 +755,18 @@ class ChatOllama(BaseChatModel):
 
     def _iterate_over_stream(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = 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):
+                if stream_resp.get("done") is True:
+                    generation_info = dict(stream_resp)
+                    _ = generation_info.pop("message", None)
+                else:
+                    generation_info = None
                 chunk = ChatGenerationChunk(
                     message=AIMessageChunk(
                         content=(
@@ -739,9 +780,7 @@ class ChatOllama(BaseChatModel):
                         ),
                         tool_calls=_get_tool_calls_from_response(stream_resp),
                     ),
-                    generation_info=(
-                        dict(stream_resp) if stream_resp.get("done") is True else None
-                    ),
+                    generation_info=generation_info,
                 )
                 if chunk.generation_info and (
                     model := chunk.generation_info.get("model")
@@ -756,8 +795,8 @@ class ChatOllama(BaseChatModel):
 
     def _stream(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
@@ -771,13 +810,18 @@ class ChatOllama(BaseChatModel):
 
     async def _aiterate_over_stream(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = 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):
+                if stream_resp.get("done") is True:
+                    generation_info = dict(stream_resp)
+                    _ = generation_info.pop("message", None)
+                else:
+                    generation_info = None
                 chunk = ChatGenerationChunk(
                     message=AIMessageChunk(
                         content=(
@@ -791,9 +835,7 @@ class ChatOllama(BaseChatModel):
                         ),
                         tool_calls=_get_tool_calls_from_response(stream_resp),
                     ),
-                    generation_info=(
-                        dict(stream_resp) if stream_resp.get("done") is True else None
-                    ),
+                    generation_info=generation_info,
                 )
                 if chunk.generation_info and (
                     model := chunk.generation_info.get("model")
@@ -808,8 +850,8 @@ class ChatOllama(BaseChatModel):
 
     async def _astream(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
@@ -823,8 +865,8 @@ class ChatOllama(BaseChatModel):
 
     async def _agenerate(
         self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
+        messages: list[BaseMessage],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
@@ -850,7 +892,7 @@ class ChatOllama(BaseChatModel):
 
     def bind_tools(
         self,
-        tools: Sequence[Union[Dict[str, Any], Type, Callable, BaseTool]],
+        tools: Sequence[Union[dict[str, Any], type, Callable, BaseTool]],
         *,
         tool_choice: Optional[Union[dict, str, Literal["auto", "any"], bool]] = None,
         **kwargs: Any,
@@ -873,12 +915,12 @@ class ChatOllama(BaseChatModel):
 
     def with_structured_output(
         self,
-        schema: Union[Dict, type],
+        schema: Union[dict, type],
         *,
         method: Literal["function_calling", "json_mode", "json_schema"] = "json_schema",
         include_raw: bool = False,
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, Union[Dict, BaseModel]]:
+    ) -> Runnable[LanguageModelInput, Union[dict, BaseModel]]:
         """Model wrapper that returns outputs formatted to match the given schema.
 
         Args:

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

@@ -1,6 +1,6 @@
 """Ollama embeddings models."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from langchain_core.embeddings import Embeddings
 from ollama import AsyncClient, Client
@@ -127,8 +127,22 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     """Base url the model is hosted under."""
 
     client_kwargs: Optional[dict] = {}
-    """Additional kwargs to pass to the httpx Client. 
-    For a full list of the params, see [this link](https://pydoc.dev/httpx/latest/httpx.Client.html)
+    """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
+    to synchronous and asynchronous clients.
+    """
+
+    async_client_kwargs: Optional[dict] = {}
+    """Additional kwargs to merge with client_kwargs before
+    passing to the httpx AsyncClient.
+    For a full list of the params, see [this link](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.
+    For a full list of the params, see [this link](https://www.python-httpx.org/api/#client)
     """
 
     _client: Client = PrivateAttr(default=None)  # type: ignore
@@ -188,7 +202,7 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     """The temperature of the model. Increasing the temperature will
     make the model answer more creatively. (Default: 0.8)"""
 
-    stop: Optional[List[str]] = None
+    stop: Optional[list[str]] = None
     """Sets the stop tokens to use."""
 
     tfs_z: Optional[float] = None
@@ -211,7 +225,7 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     )
 
     @property
-    def _default_params(self) -> Dict[str, Any]:
+    def _default_params(self) -> dict[str, Any]:
         """Get the default parameters for calling Ollama."""
         return {
             "mirostat": self.mirostat,
@@ -233,22 +247,31 @@ class OllamaEmbeddings(BaseModel, Embeddings):
     def _set_clients(self) -> Self:
         """Set clients to use for ollama."""
         client_kwargs = self.client_kwargs or {}
-        self._client = Client(host=self.base_url, **client_kwargs)
-        self._async_client = AsyncClient(host=self.base_url, **client_kwargs)
+
+        sync_client_kwargs = client_kwargs
+        if self.sync_client_kwargs:
+            sync_client_kwargs = {**sync_client_kwargs, **self.sync_client_kwargs}
+
+        async_client_kwargs = client_kwargs
+        if self.async_client_kwargs:
+            async_client_kwargs = {**async_client_kwargs, **self.async_client_kwargs}
+
+        self._client = Client(host=self.base_url, **sync_client_kwargs)
+        self._async_client = AsyncClient(host=self.base_url, **async_client_kwargs)
         return self
 
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+    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, keep_alive=self.keep_alive
         )["embeddings"]
         return embedded_docs
 
-    def embed_query(self, text: str) -> List[float]:
+    def embed_query(self, text: str) -> list[float]:
         """Embed query text."""
         return self.embed_documents([text])[0]
 
-    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
         """Embed search docs."""
         embedded_docs = (
             await self._async_client.embed(
@@ -257,6 +280,6 @@ class OllamaEmbeddings(BaseModel, Embeddings):
         )["embeddings"]
         return embedded_docs
 
-    async def aembed_query(self, text: str) -> List[float]:
+    async def aembed_query(self, text: str) -> list[float]:
         """Embed query text."""
         return (await self.aembed_documents([text]))[0]

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

@@ -1,13 +1,9 @@
 """Ollama large language models."""
 
+from collections.abc import AsyncIterator, Iterator, Mapping
 from typing import (
     Any,
-    AsyncIterator,
-    Dict,
-    Iterator,
-    List,
     Literal,
-    Mapping,
     Optional,
     Union,
 )
@@ -89,7 +85,7 @@ class OllamaLLM(BaseLLM):
     to a specific number will make the model generate the same text for
     the same prompt."""
 
-    stop: Optional[List[str]] = None
+    stop: Optional[list[str]] = None
     """Sets the stop tokens to use."""
 
     tfs_z: Optional[float] = None
@@ -117,8 +113,22 @@ class OllamaLLM(BaseLLM):
     """Base url the model is hosted under."""
 
     client_kwargs: Optional[dict] = {}
-    """Additional kwargs to pass to the httpx Client. 
-    For a full list of the params, see [this link](https://pydoc.dev/httpx/latest/httpx.Client.html)
+    """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
+    to synchronous and asynchronous clients.
+    """
+
+    async_client_kwargs: Optional[dict] = {}
+    """Additional kwargs to merge with client_kwargs before
+    passing to the httpx AsyncClient.
+    For a full list of the params, see [this link](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.
+    For a full list of the params, see [this link](https://www.python-httpx.org/api/#client)
     """
 
     _client: Client = PrivateAttr(default=None)  # type: ignore
@@ -134,9 +144,9 @@ class OllamaLLM(BaseLLM):
     def _generate_params(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         **kwargs: Any,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if self.stop is not None and stop is not None:
             raise ValueError("`stop` found in both the input and default params.")
         elif self.stop is not None:
@@ -181,7 +191,7 @@ class OllamaLLM(BaseLLM):
         return "ollama-llm"
 
     def _get_ls_params(
-        self, stop: Optional[List[str]] = None, **kwargs: Any
+        self, stop: Optional[list[str]] = None, **kwargs: Any
     ) -> LangSmithParams:
         """Get standard params for tracing."""
         params = super()._get_ls_params(stop=stop, **kwargs)
@@ -193,14 +203,23 @@ class OllamaLLM(BaseLLM):
     def _set_clients(self) -> Self:
         """Set clients to use for ollama."""
         client_kwargs = self.client_kwargs or {}
-        self._client = Client(host=self.base_url, **client_kwargs)
-        self._async_client = AsyncClient(host=self.base_url, **client_kwargs)
+
+        sync_client_kwargs = client_kwargs
+        if self.sync_client_kwargs:
+            sync_client_kwargs = {**sync_client_kwargs, **self.sync_client_kwargs}
+
+        async_client_kwargs = client_kwargs
+        if self.async_client_kwargs:
+            async_client_kwargs = {**async_client_kwargs, **self.async_client_kwargs}
+
+        self._client = Client(host=self.base_url, **sync_client_kwargs)
+        self._async_client = AsyncClient(host=self.base_url, **async_client_kwargs)
         return self
 
     async def _acreate_generate_stream(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> AsyncIterator[Union[Mapping[str, Any], str]]:
         async for part in await self._async_client.generate(
@@ -211,7 +230,7 @@ class OllamaLLM(BaseLLM):
     def _create_generate_stream(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> Iterator[Union[Mapping[str, Any], str]]:
         yield from self._client.generate(
@@ -221,7 +240,7 @@ class OllamaLLM(BaseLLM):
     async def _astream_with_aggregation(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         verbose: bool = False,
         **kwargs: Any,
@@ -253,7 +272,7 @@ class OllamaLLM(BaseLLM):
     def _stream_with_aggregation(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         verbose: bool = False,
         **kwargs: Any,
@@ -284,8 +303,8 @@ class OllamaLLM(BaseLLM):
 
     def _generate(
         self,
-        prompts: List[str],
-        stop: Optional[List[str]] = None,
+        prompts: list[str],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> LLMResult:
@@ -303,8 +322,8 @@ class OllamaLLM(BaseLLM):
 
     async def _agenerate(
         self,
-        prompts: List[str],
-        stop: Optional[List[str]] = None,
+        prompts: list[str],
+        stop: Optional[list[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> LLMResult:
@@ -323,7 +342,7 @@ class OllamaLLM(BaseLLM):
     def _stream(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[GenerationChunk]:
@@ -345,7 +364,7 @@ class OllamaLLM(BaseLLM):
     async def _astream(
         self,
         prompt: str,
-        stop: Optional[List[str]] = None,
+        stop: Optional[list[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> AsyncIterator[GenerationChunk]:

{langchain_ollama-0.3.1 → langchain_ollama-0.3.3}/pyproject.toml

@@ -6,13 +6,13 @@ build-backend = "pdm.backend"
 
 [project]
 authors = []
-requires-python = "<4.0,>=3.9"
+requires-python = ">=3.9"
 dependencies = [
-    "ollama<1,>=0.4.4",
-    "langchain-core<1.0.0,>=0.3.51",
+    "ollama>=0.4.8,<1.0.0",
+    "langchain-core<1.0.0,>=0.3.60",
 ]
 name = "langchain-ollama"
-version = "0.3.1"
+version = "0.3.3"
 description = "An integration package connecting Ollama and LangChain"
 readme = "README.md"
 
@@ -60,6 +60,9 @@ editable = true
 [tool.mypy]
 disallow_untyped_defs = "True"
 
+[tool.ruff]
+target-version = "py39"
+
 [tool.ruff.lint]
 select = [
     "E",
@@ -67,6 +70,10 @@ select = [
     "I",
     "T201",
     "D",
+    "UP",
+]
+ignore = [
+    "UP007",
 ]
 
 [tool.ruff.lint.pydocstyle]

{langchain_ollama-0.3.1 → langchain_ollama-0.3.3}/tests/integration_tests/chat_models/test_chat_models.py

@@ -1,10 +1,10 @@
 """Ollama specific chat model integration tests"""
 
-from typing import List, Optional
+from typing import Annotated, Optional
 
 import pytest
 from pydantic import BaseModel, Field
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 from langchain_ollama import ChatOllama
 
@@ -78,7 +78,7 @@ def test_structured_output_deeply_nested(model: str) -> None:
     class Data(BaseModel):
         """Extracted data about people."""
 
-        people: List[Person]
+        people: list[Person]
 
     chat = llm.with_structured_output(Data)  # type: ignore[arg-type]
     text = (

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

@@ -0,0 +1,42 @@
+"""Test chat model integration using standard integration tests."""
+
+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_json_mode(self) -> bool:
+        return True
+
+    @property
+    def has_tool_choice(self) -> bool:
+        return False
+
+
+def test_image_model() -> None:
+    class ImageModelTests(ChatModelIntegrationTests):
+        @property
+        def chat_model_class(self) -> type[ChatOllama]:
+            return ChatOllama
+
+        @property
+        def chat_model_params(self) -> dict:
+            return {"model": "gemma3:4b"}
+
+        @property
+        def supports_image_inputs(self) -> bool:
+            return True
+
+    test_instance = ImageModelTests()
+    model = test_instance.chat_model_class(**test_instance.chat_model_params)
+    ImageModelTests().test_image_inputs(model)

{langchain_ollama-0.3.1 → langchain_ollama-0.3.3}/tests/integration_tests/test_embeddings.py

@@ -1,7 +1,5 @@
 """Test Ollama embeddings."""
 
-from typing import Type
-
 from langchain_tests.integration_tests import EmbeddingsIntegrationTests
 
 from langchain_ollama.embeddings import OllamaEmbeddings
@@ -9,7 +7,7 @@ from langchain_ollama.embeddings import OllamaEmbeddings
 
 class TestOllamaEmbeddings(EmbeddingsIntegrationTests):
     @property
-    def embeddings_class(self) -> Type[OllamaEmbeddings]:
+    def embeddings_class(self) -> type[OllamaEmbeddings]:
         return OllamaEmbeddings
 
     @property

langchain_ollama-0.3.3/tests/unit_tests/test_chat_models.py

@@ -0,0 +1,66 @@
+"""Test chat model integration."""
+
+import json
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+import pytest
+from httpx import Client, Request, Response
+from langchain_core.messages import ChatMessage
+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)
+
+
+@contextmanager
+def _mock_httpx_client_stream(
+    *args: Any, **kwargs: Any
+) -> Generator[Response, Any, Any]:
+    yield Response(
+        status_code=200,
+        content='{"message": {"role": "assistant", "content": "The meaning ..."}}',
+        request=Request(method="POST", url="http://whocares:11434"),
+    )
+
+
+def test_arbitrary_roles_accepted_in_chatmessages(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(Client, "stream", _mock_httpx_client_stream)
+
+    llm = ChatOllama(
+        base_url="http://whocares:11434",
+        model="granite3.2",
+        verbose=True,
+        format=None,
+    )
+
+    messages = [
+        ChatMessage(
+            role="somerandomrole",
+            content="I'm ok with you adding any role message now!",
+        ),
+        ChatMessage(role="control", content="thinking"),
+        ChatMessage(role="user", content="What is the meaning of life?"),
+    ]
+
+    llm.invoke(messages)

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

@@ -1,29 +0,0 @@
-"""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/unit_tests/test_chat_models.py

@@ -1,25 +0,0 @@
-"""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)