ollama-haystack 2.2.0__tar.gz → 2.4.0__tar.gz

{ollama_haystack-2.2.0 → ollama_haystack-2.4.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [integrations/ollama-v2.3.0] - 2025-01-29
+
+### 🚀 Features
+
+- Add `response_format` param to `OllamaChatGenerator` (#1326)
+
+
+## [integrations/ollama-v2.2.0] - 2025-01-16
+
+### 🚀 Features
+
+- Ollama - add support for tools (#1294)
+
+
 ## [integrations/ollama-v2.1.2] - 2024-12-18
 
 ### 🐛 Bug Fixes

{ollama_haystack-2.2.0 → ollama_haystack-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ollama-haystack
-Version: 2.2.0
+Version: 2.4.0
 Summary: An integration between the Ollama LLM framework and Haystack
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/ollama#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -15,11 +15,13 @@ 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
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: haystack-ai
 Requires-Dist: ollama>=0.4.0
+Requires-Dist: pydantic
 Description-Content-Type: text/markdown
 
 # ollama-haystack

{ollama_haystack-2.2.0 → ollama_haystack-2.4.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "ollama-haystack"
 dynamic = ["version"]
 description = 'An integration between the Ollama LLM framework and Haystack'
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = "Apache-2.0"
 keywords = []
 authors = [
@@ -23,10 +23,11 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai", "ollama>=0.4.0"]
+dependencies = ["haystack-ai", "ollama>=0.4.0", "pydantic"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/ollama#readme"
@@ -51,7 +52,6 @@ dependencies = [
     "pytest",
     "pytest-rerunfailures",
     "haystack-pydoc-tools",
-    "jsonschema",  # needed for Tool
 ]
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"
@@ -62,10 +62,6 @@ cov = ["test-cov", "cov-report"]
 cov-retry = ["test-cov-retry", "cov-report"]
 docs = ["pydoc-markdown pydoc/config.yml"]
 
-[[tool.hatch.envs.all.matrix]]
-python = ["3.9", "3.10", "3.11", "3.12"]
-
-
 [tool.hatch.envs.lint]
 installer = "uv"
 detached = true
@@ -165,5 +161,5 @@ markers = [
 addopts = ["--import-mode=importlib"]
 
 [[tool.mypy.overrides]]
-module = ["haystack.*", "haystack_integrations.*", "pytest.*", "ollama.*"]
+module = ["haystack.*", "haystack_integrations.*", "pytest.*", "ollama.*", "pydantic.*"]
 ignore_missing_imports = true

{ollama_haystack-2.2.0 → ollama_haystack-2.4.0}/src/haystack_integrations/components/generators/ollama/chat/chat_generator.py

@@ -1,9 +1,10 @@
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import ChatMessage, StreamingChunk, ToolCall
 from haystack.tools import Tool, _check_duplicate_tool_names, deserialize_tools_inplace
 from haystack.utils.callable_serialization import deserialize_callable, serialize_callable
+from pydantic.json_schema import JsonSchemaValue
 
 from ollama import ChatResponse, Client
 
@@ -40,6 +41,60 @@ def _convert_chatmessage_to_ollama_format(message: ChatMessage) -> Dict[str, Any
     return ollama_msg
 
 
+def _convert_ollama_meta_to_openai_format(intput_response_dict: Dict) -> Dict:
+    """
+    Internal function to convert Ollama metadata to OpenAI format.
+
+    All fields that are not part of the OpenAI metadata are left unchanged in the returned dict.
+
+    Example Ollama metadata:
+    {
+        'model': 'phi4:14b-q4_K_M',
+        'created_at': '2025-03-09T18:38:33.004185821Z',
+        'done': True,
+        'done_reason': 'stop',
+        'total_duration': 86627206961,
+        'load_duration': 23585622554,
+        'prompt_eval_count': 26,
+        'prompt_eval_duration': 3426000000,
+        'eval_count': 298,
+        'eval_duration': 4799921000
+    }
+
+    Example OpenAI metadata:
+    {
+        'model': 'phi4:14b-q4_K_M',
+        'finish_reason': 'stop',
+        'usage': {
+            'completion_tokens': 298,
+            'prompt_tokens': 26,
+            'total_tokens': 324,
+        }
+        'completion_start_time': '2025-03-09T18:38:33.004185821Z',
+        'done': True,
+        'total_duration': 86627206961,
+        'load_duration': 23585622554,
+        'prompt_eval_duration': 3426000000,
+        'eval_duration': 4799921000,
+    }
+    """
+    meta = {key: value for key, value in intput_response_dict.items() if key != "message"}
+
+    if "done_reason" in meta:
+        meta["finish_reason"] = meta.pop("done_reason")
+    if "created_at" in meta:
+        meta["completion_start_time"] = meta.pop("created_at")
+    if "eval_count" in meta and "prompt_eval_count" in meta:
+        eval_count = meta.pop("eval_count")
+        prompt_eval_count = meta.pop("prompt_eval_count")
+        meta["usage"] = {
+            "completion_tokens": eval_count,
+            "prompt_tokens": prompt_eval_count,
+            "total_tokens": eval_count + prompt_eval_count,
+        }
+    return meta
+
+
 def _convert_ollama_response_to_chatmessage(ollama_response: "ChatResponse") -> ChatMessage:
     """
     Converts the non-streaming response from the Ollama API to a ChatMessage with assistant role.
@@ -59,7 +114,7 @@ def _convert_ollama_response_to_chatmessage(ollama_response: "ChatResponse") ->
 
     message = ChatMessage.from_assistant(text=text, tool_calls=tool_calls)
 
-    message.meta.update({key: value for key, value in response_dict.items() if key != "message"})
+    message._meta = _convert_ollama_meta_to_openai_format(response_dict)
     return message
 
 
@@ -97,6 +152,7 @@ class OllamaChatGenerator:
         keep_alive: Optional[Union[float, str]] = None,
         streaming_callback: Optional[Callable[[StreamingChunk], None]] = None,
         tools: Optional[List[Tool]] = None,
+        response_format: Optional[Union[None, Literal["json"], JsonSchemaValue]] = None,
     ):
         """
         :param model:
@@ -124,6 +180,11 @@ class OllamaChatGenerator:
             A list of tools for which the model can prepare calls.
             Not all models support tools. For a list of models compatible with tools, see the
             [models page](https://ollama.com/search?c=tools).
+        :param response_format:
+            The format for structured model outputs. The value can be:
+            - None: No specific structure or format is applied to the response. The response is returned as-is.
+            - "json": The response is formatted as a JSON object.
+            - JSON Schema: The response is formatted as a JSON object that adheres to the specified JSON Schema.
         """
 
         _check_duplicate_tool_names(tools)
@@ -135,7 +196,7 @@ class OllamaChatGenerator:
         self.keep_alive = keep_alive
         self.streaming_callback = streaming_callback
         self.tools = tools
-
+        self.response_format = response_format
         self._client = Client(host=self.url, timeout=self.timeout)
 
     def to_dict(self) -> Dict[str, Any]:
@@ -156,6 +217,7 @@ class OllamaChatGenerator:
             timeout=self.timeout,
             streaming_callback=callback_name,
             tools=serialized_tools,
+            response_format=self.response_format,
         )
 
     @classmethod
@@ -237,6 +299,14 @@ class OllamaChatGenerator:
             msg = "Ollama does not support tools and streaming at the same time. Please choose one."
             raise ValueError(msg)
 
+        if self.response_format and tools:
+            msg = "Ollama does not support tools and response_format at the same time. Please choose one."
+            raise ValueError(msg)
+
+        if self.response_format and stream:
+            msg = "Ollama does not support streaming and response_format at the same time. Please choose one."
+            raise ValueError(msg)
+
         ollama_tools = [{"type": "function", "function": {**t.tool_spec}} for t in tools] if tools else None
 
         ollama_messages = [_convert_chatmessage_to_ollama_format(msg) for msg in messages]
@@ -247,6 +317,7 @@ class OllamaChatGenerator:
             stream=stream,
             keep_alive=self.keep_alive,
             options=generation_kwargs,
+            format=self.response_format,
         )
 
         if stream:

{ollama_haystack-2.2.0 → ollama_haystack-2.4.0}/tests/test_chat_generator.py

@@ -97,13 +97,12 @@ def test_convert_chatmessage_to_ollama_invalid():
 
 
 def test_convert_ollama_response_to_chatmessage():
-    model = "some_model"
-
     ollama_response = ChatResponse(
-        model=model,
+        model="some_model",
         created_at="2023-12-12T14:13:43.416799Z",
         message={"role": "assistant", "content": "Hello! How are you today?"},
         done=True,
+        done_reason="stop",
         total_duration=5191566416,
         load_duration=2154458,
         prompt_eval_count=26,
@@ -117,6 +116,22 @@ def test_convert_ollama_response_to_chatmessage():
     assert observed.role == "assistant"
     assert observed.text == "Hello! How are you today?"
 
+    assert observed.meta == {
+        "finish_reason": "stop",
+        "usage": {
+            "completion_tokens": 298,
+            "prompt_tokens": 26,
+            "total_tokens": 324,
+        },
+        "completion_start_time": "2023-12-12T14:13:43.416799Z",
+        "load_duration": 2154458,
+        "total_duration": 5191566416,
+        "eval_duration": 4799921000,
+        "prompt_eval_duration": 383809000,
+        "done": True,
+        "model": "some_model",
+    }
+
 
 def test_convert_ollama_response_to_chatmessage_with_tools():
     model = "some_model"
@@ -165,6 +180,7 @@ class TestOllamaChatGenerator:
         assert component.streaming_callback is None
         assert component.tools is None
         assert component.keep_alive is None
+        assert component.response_format is None
 
     def test_init(self, tools):
         component = OllamaChatGenerator(
@@ -175,6 +191,7 @@ class TestOllamaChatGenerator:
             keep_alive="10m",
             streaming_callback=print_streaming_chunk,
             tools=tools,
+            response_format={"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "number"}}},
         )
 
         assert component.model == "llama2"
@@ -184,6 +201,10 @@ class TestOllamaChatGenerator:
         assert component.keep_alive == "10m"
         assert component.streaming_callback is print_streaming_chunk
         assert component.tools == tools
+        assert component.response_format == {
+            "type": "object",
+            "properties": {"name": {"type": "string"}, "age": {"type": "number"}},
+        }
 
     def test_init_fail_with_duplicate_tool_names(self, tools):
 
@@ -206,9 +227,11 @@ class TestOllamaChatGenerator:
             generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"},
             tools=[tool],
             keep_alive="5m",
+            response_format={"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "number"}}},
         )
         data = component.to_dict()
-        assert data == {
+
+        expected_dict = {
             "type": "haystack_integrations.components.generators.ollama.chat.chat_generator.OllamaChatGenerator",
             "init_parameters": {
                 "timeout": 120,
@@ -235,9 +258,24 @@ class TestOllamaChatGenerator:
                         },
                     },
                 ],
+                "response_format": {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"}, "age": {"type": "number"}},
+                },
             },
         }
 
+        # add outputs_to_string, inputs_from_state and outputs_to_state tool parameters for compatibility with
+        # haystack-ai>=2.12.0
+        if hasattr(tool, "outputs_to_string"):
+            expected_dict["init_parameters"]["tools"][0]["data"]["outputs_to_string"] = tool.outputs_to_string
+        if hasattr(tool, "inputs_from_state"):
+            expected_dict["init_parameters"]["tools"][0]["data"]["inputs_from_state"] = tool.inputs_from_state
+        if hasattr(tool, "outputs_to_state"):
+            expected_dict["init_parameters"]["tools"][0]["data"]["outputs_to_state"] = tool.outputs_to_state
+
+        assert data == expected_dict
+
     def test_from_dict(self):
         tool = Tool(
             name="name",
@@ -273,6 +311,10 @@ class TestOllamaChatGenerator:
                         },
                     },
                 ],
+                "response_format": {
+                    "type": "object",
+                    "properties": {"name": {"type": "string"}, "age": {"type": "number"}},
+                },
             },
         }
         component = OllamaChatGenerator.from_dict(data)
@@ -286,6 +328,10 @@ class TestOllamaChatGenerator:
         }
         assert component.timeout == 120
         assert component.tools == [tool]
+        assert component.response_format == {
+            "type": "object",
+            "properties": {"name": {"type": "string"}, "age": {"type": "number"}},
+        }
 
     @patch("haystack_integrations.components.generators.ollama.chat.chat_generator.Client")
     def test_run(self, mock_client):
@@ -319,6 +365,7 @@ class TestOllamaChatGenerator:
             tools=None,
             options={},
             keep_alive=None,
+            format=None,
         )
 
         assert "replies" in result
@@ -456,3 +503,54 @@ class TestOllamaChatGenerator:
         assert isinstance(tool_call, ToolCall)
         assert tool_call.tool_name == "weather"
         assert tool_call.arguments == {"city": "Paris"}
+
+    @pytest.mark.integration
+    def test_run_with_response_format(self):
+        response_format = {
+            "type": "object",
+            "properties": {"capital": {"type": "string"}, "population": {"type": "number"}},
+        }
+        chat_generator = OllamaChatGenerator(model="llama3.2:3b", response_format=response_format)
+
+        message = ChatMessage.from_user("What's the capital of France and its population?")
+        response = chat_generator.run([message])
+
+        assert isinstance(response, dict)
+        assert isinstance(response["replies"], list)
+
+        # Parse the response text as JSON and verify its structure
+        response_data = json.loads(response["replies"][0].text)
+        assert isinstance(response_data, dict)
+        assert "capital" in response_data
+        assert isinstance(response_data["capital"], str)
+        assert "population" in response_data
+        assert isinstance(response_data["population"], (int, float))
+        assert response_data["capital"] == "Paris"
+
+    def test_run_with_streaming_and_format(self):
+        response_format = {
+            "type": "object",
+            "properties": {"answer": {"type": "string"}},
+        }
+        streaming_callback = Mock()
+        chat_generator = OllamaChatGenerator(
+            model="llama3.2:3b", streaming_callback=streaming_callback, response_format=response_format
+        )
+
+        chat_messages = [
+            ChatMessage.from_user("What is the largest city in the United Kingdom by population?"),
+            ChatMessage.from_assistant("London is the largest city in the United Kingdom by population"),
+            ChatMessage.from_user("And what is the second largest?"),
+        ]
+        with pytest.raises(ValueError):
+            chat_generator.run([chat_messages])
+
+    def test_run_with_tools_and_format(self, tools):
+        response_format = {
+            "type": "object",
+            "properties": {"capital": {"type": "string"}, "population": {"type": "number"}},
+        }
+        chat_generator = OllamaChatGenerator(model="llama3.2:3b", tools=tools, response_format=response_format)
+        message = ChatMessage.from_user("What's the weather in Paris?")
+        with pytest.raises(ValueError):
+            chat_generator.run([message])