nvidia-haystack 0.1.8__tar.gz → 0.3.0__tar.gz

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/CHANGELOG.md

@@ -1,10 +1,20 @@
 # Changelog
 
-## [integrations/nvidia-v0.1.7] - 2025-04-03
+## [integrations/nvidia-v0.2.0] - 2025-06-05
 
-### 📚 Documentation
+### 🚀 Features
+
+- Add NvidiaChatGenerator based on OpenAIChatGenerator (#1776)
+
+
+## [integrations/nvidia-v0.1.8] - 2025-05-28
+
+### 🌀 Miscellaneous
+
+- Add pins for Nvidia (#1846)
+
+## [integrations/nvidia-v0.1.7] - 2025-04-03
 
-- Update changelog for integrations/nvidia (#1365)
 
 ### 🧪 Testing
 
@@ -30,9 +40,6 @@
 
 - Add nvidia latest embedding models (#1364)
 
-### 📚 Documentation
-
-- Update changelog for integrations/nvidia (#1353)
 
 ## [integrations/nvidia-v0.1.5] - 2025-02-04
 

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-haystack
-Version: 0.1.8
+Version: 0.3.0
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/nvidia#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/nvidia
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
-Requires-Dist: haystack-ai
+Requires-Dist: haystack-ai>=2.13.0
 Requires-Dist: requests>=2.25.0
 Requires-Dist: tqdm>=4.21.0
 Description-Content-Type: text/markdown
@@ -54,7 +54,7 @@ pip install hatch
 With `hatch` installed, to run all the tests:
 
 ```
-hatch run test
+hatch run test:all
 ```
 
 > Note: integration tests will be skipped unless the env var NVIDIA_API_KEY is set. The api key needs to be valid
@@ -63,13 +63,19 @@ hatch run test
 To only run unit tests:
 
 ```
-hatch run test -m "not integration"
+hatch run test:unit
 ```
 
-To run the linters `ruff` and `mypy`:
+To format your code and perform linting using Ruff (with automatic fixes), run:
 
 ```
-hatch run lint:all
+hatch run fmt
+```
+
+To check for static type errors, run:
+
+```console
+$ hatch run test:types
 ```
 
 ## License

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/README.md

@@ -29,7 +29,7 @@ pip install hatch
 With `hatch` installed, to run all the tests:
 
 ```
-hatch run test
+hatch run test:all
 ```
 
 > Note: integration tests will be skipped unless the env var NVIDIA_API_KEY is set. The api key needs to be valid
@@ -38,13 +38,19 @@ hatch run test
 To only run unit tests:
 
 ```
-hatch run test -m "not integration"
+hatch run test:unit
 ```
 
-To run the linters `ruff` and `mypy`:
+To format your code and perform linting using Ruff (with automatic fixes), run:
 
 ```
-hatch run lint:all
+hatch run fmt
+```
+
+To check for static type errors, run:
+
+```console
+$ hatch run test:types
 ```
 
 ## License

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai", "requests>=2.25.0", "tqdm>=4.21.0"]
+dependencies = ["haystack-ai>=2.13.0", "requests>=2.25.0", "tqdm>=4.21.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/nvidia#readme"
@@ -43,34 +43,42 @@ git_describe_command = 'git describe --tags --match="integrations/nvidia-v[0-9]*
 
 [tool.hatch.envs.default]
 installer = "uv"
-dependencies = [
-  "coverage[toml]>=6.5",
-  "pytest",
-  "pytest-rerunfailures",
-  "haystack-pydoc-tools",
-  "requests_mock",
-]
+dependencies = ["haystack-pydoc-tools", "ruff"]
+
 [tool.hatch.envs.default.scripts]
-test = "pytest {args:tests}"
-test-cov = "coverage run -m pytest {args:tests}"
-test-cov-retry = "test-cov --reruns 3 --reruns-delay 30 -x"
-cov-report = ["- coverage combine", "coverage report"]
-cov = ["test-cov", "cov-report"]
-cov-retry = ["test-cov-retry", "cov-report"]
 docs = ["pydoc-markdown pydoc/config.yml"]
+fmt = "ruff check --fix {args} && ruff format {args}"
+fmt-check = "ruff check {args} && ruff format --check {args}"
 
-[tool.hatch.envs.lint]
-installer = "uv"
-detached = true
-dependencies = ["pip", "black>=23.1.0", "mypy>=1.0.0", "ruff>=0.0.243"]
-[tool.hatch.envs.lint.scripts]
-typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
-style = [
-  "ruff check {args:}",
-  "black --check --diff {args:.}",
+[tool.hatch.envs.test]
+dependencies = [
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-rerunfailures",
+    "mypy",
+    "pip",
+    "requests_mock",
+    "pytz"
 ]
-fmt = ["black {args:.}", "ruff check --fix {args:}", "style"]
-all = ["style", "typing"]
+
+[tool.hatch.envs.test.scripts]
+unit = 'pytest -m "not integration" {args:tests}'
+integration = 'pytest -m "integration" {args:tests}'
+all = 'pytest {args:tests}'
+cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
+
+types = """mypy -p haystack_integrations.components.embedders.nvidia \
+-p haystack_integrations.components.generators.nvidia \
+-p haystack_integrations.components.rankers.nvidia \
+-p haystack_integrations.utils.nvidia {args}"""
+
+[tool.mypy]
+install_types = true
+non_interactive = true
+check_untyped_defs = true
+disallow_incomplete_defs = true
+
 
 [tool.black]
 target-version = ["py38"]
@@ -151,26 +159,9 @@ omit = ["*/tests/*", "*/__init__.py"]
 show_missing = true
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
-
-[[tool.mypy.overrides]]
-module = [
-  "nvidia.*",
-  "haystack.*",
-  "haystack_integrations.*",
-  "pytest.*",
-  "numpy.*",
-  "requests_mock.*",
-  "pydantic.*",
-]
-ignore_missing_imports = true
-
 [tool.pytest.ini_options]
 addopts = "--strict-markers"
 markers = [
   "integration: integration tests",
-  "unit: unit tests",
-  "embedders: embedders tests",
-  "generators: generators tests",
-  "chat_generators: chat_generators tests",
 ]
 log_cli = true

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/src/haystack_integrations/components/embedders/nvidia/document_embedder.py

@@ -11,7 +11,7 @@ from haystack.utils import Secret, deserialize_secrets_inplace
 from tqdm import tqdm
 
 from haystack_integrations.components.embedders.nvidia.truncate import EmbeddingTruncateMode
-from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Model, NimBackend, url_validation
+from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Client, Model, NimBackend, url_validation
 
 logger = logging.getLogger(__name__)
 
@@ -122,7 +122,9 @@ class NvidiaDocumentEmbedder:
                 UserWarning,
                 stacklevel=2,
             )
-            self.model = self.backend.model = name
+            self.model = name
+            if self.backend:
+                self.backend.model = name
         else:
             error_message = "No locally hosted model was found."
             raise ValueError(error_message)
@@ -143,7 +145,7 @@ class NvidiaDocumentEmbedder:
             api_url=self.api_url,
             api_key=self.api_key,
             model_kwargs=model_kwargs,
-            client=self.__class__.__name__,
+            client=Client.NVIDIA_DOCUMENT_EMBEDDER,
             timeout=self.timeout,
         )
         if not self.model and self.backend.model:
@@ -232,7 +234,7 @@ class NvidiaDocumentEmbedder:
         return all_embeddings, {"usage": {"prompt_tokens": usage_prompt_tokens, "total_tokens": usage_total_tokens}}
 
     @component.output_types(documents=List[Document], meta=Dict[str, Any])
-    def run(self, documents: List[Document]):
+    def run(self, documents: List[Document]) -> Dict[str, Union[List[Document], Dict[str, Any]]]:
         """
         Embed a list of Documents.
 

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/src/haystack_integrations/components/embedders/nvidia/text_embedder.py

@@ -10,7 +10,7 @@ from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.utils import Secret, deserialize_secrets_inplace
 
 from haystack_integrations.components.embedders.nvidia.truncate import EmbeddingTruncateMode
-from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Model, NimBackend, url_validation
+from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Client, Model, NimBackend, url_validation
 
 logger = logging.getLogger(__name__)
 
@@ -112,7 +112,9 @@ class NvidiaTextEmbedder:
                 UserWarning,
                 stacklevel=2,
             )
-            self.model = self.backend.model = name
+            self.model = name
+            if self.backend:
+                self.backend.model = name
         else:
             error_message = "No locally hosted model was found."
             raise ValueError(error_message)
@@ -134,7 +136,7 @@ class NvidiaTextEmbedder:
             api_key=self.api_key,
             model_kwargs=model_kwargs,
             timeout=self.timeout,
-            client=self.__class__.__name__,
+            client=Client.NVIDIA_TEXT_EMBEDDER,
         )
         self._initialized = True
 
@@ -185,7 +187,7 @@ class NvidiaTextEmbedder:
         return default_from_dict(cls, data)
 
     @component.output_types(embedding=List[float], meta=Dict[str, Any])
-    def run(self, text: str):
+    def run(self, text: str) -> Dict[str, Union[List[float], Dict[str, Any]]]:
         """
         Embed a string.
 

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/src/haystack_integrations/components/generators/nvidia/__init__.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .chat.chat_generator import NvidiaChatGenerator
 from .generator import NvidiaGenerator
 
-__all__ = ["NvidiaGenerator"]
+__all__ = ["NvidiaChatGenerator", "NvidiaGenerator"]

nvidia_haystack-0.3.0/src/haystack_integrations/components/generators/nvidia/chat/chat_generator.py

@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import component, default_to_dict, logging
+from haystack.components.generators.chat import OpenAIChatGenerator
+from haystack.dataclasses import StreamingCallbackT
+from haystack.tools import Tool, Toolset, serialize_tools_or_toolset
+from haystack.utils import serialize_callable
+from haystack.utils.auth import Secret
+
+from haystack_integrations.utils.nvidia import DEFAULT_API_URL
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class NvidiaChatGenerator(OpenAIChatGenerator):
+    """
+    Enables text generation using NVIDIA generative models.
+    For supported models, see [NVIDIA Docs](https://build.nvidia.com/models).
+
+    Users can pass any text generation parameters valid for the NVIDIA Chat Completion API
+    directly to this component via the `generation_kwargs` parameter in `__init__` or the `generation_kwargs`
+    parameter in `run` method.
+
+    This component uses the ChatMessage format for structuring both input and output,
+    ensuring coherent and contextually relevant responses in chat-based text generation scenarios.
+    Details on the ChatMessage format can be found in the
+    [Haystack docs](https://docs.haystack.deepset.ai/docs/data-classes#chatmessage)
+
+    For more details on the parameters supported by the NVIDIA API, refer to the
+    [NVIDIA Docs](https://build.nvidia.com/models).
+
+    Usage example:
+    ```python
+    from haystack_integrations.components.generators.nvidia import NvidiaChatGenerator
+    from haystack.dataclasses import ChatMessage
+
+    messages = [ChatMessage.from_user("What's Natural Language Processing?")]
+
+    client = NvidiaChatGenerator()
+    response = client.run(messages)
+    print(response)
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: Secret = Secret.from_env_var("NVIDIA_API_KEY"),
+        model: str = "meta/llama-3.1-8b-instruct",
+        streaming_callback: Optional[StreamingCallbackT] = None,
+        api_base_url: Optional[str] = os.getenv("NVIDIA_API_URL", DEFAULT_API_URL),
+        generation_kwargs: Optional[Dict[str, Any]] = None,
+        tools: Optional[Union[List[Tool], Toolset]] = None,
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+        http_client_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Creates an instance of NvidiaChatGenerator.
+
+        :param api_key:
+            The NVIDIA API key.
+        :param model:
+            The name of the NVIDIA chat completion model to use.
+        :param streaming_callback:
+            A callback function that is called when a new token is received from the stream.
+            The callback function accepts StreamingChunk as an argument.
+        :param api_base_url:
+            The NVIDIA API Base url.
+        :param generation_kwargs:
+            Other parameters to use for the model. These parameters are all sent directly to
+            the NVIDIA API endpoint. See [NVIDIA API docs](https://docs.nvcf.nvidia.com/ai/generative-models/)
+            for more details.
+            Some of the supported parameters:
+            - `max_tokens`: The maximum number of tokens the output text can have.
+            - `temperature`: What sampling temperature to use. Higher values mean the model will take more risks.
+                Try 0.9 for more creative applications and 0 (argmax sampling) for ones with a well-defined answer.
+            - `top_p`: An alternative to sampling with temperature, called nucleus sampling, where the model
+                considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens
+                comprising the top 10% probability mass are considered.
+            - `stream`: Whether to stream back partial progress. If set, tokens will be sent as data-only server-sent
+                events as they become available, with the stream terminated by a data: [DONE] message.
+        :param tools:
+            A list of tools or a Toolset for which the model can prepare calls. This parameter can accept either a
+            list of `Tool` objects or a `Toolset` instance.
+        :param timeout:
+            The timeout for the NVIDIA API call.
+        :param max_retries:
+            Maximum number of retries to contact NVIDIA after an internal error.
+            If not set, it defaults to either the `NVIDIA_MAX_RETRIES` environment variable, or set to 5.
+        :param http_client_kwargs:
+            A dictionary of keyword arguments to configure a custom `httpx.Client`or `httpx.AsyncClient`.
+            For more information, see the [HTTPX documentation](https://www.python-httpx.org/api/#client).
+        """
+        super(NvidiaChatGenerator, self).__init__(  # noqa: UP008
+            api_key=api_key,
+            model=model,
+            streaming_callback=streaming_callback,
+            api_base_url=api_base_url,
+            generation_kwargs=generation_kwargs,
+            tools=tools,
+            timeout=timeout,
+            max_retries=max_retries,
+            http_client_kwargs=http_client_kwargs,
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize this component to a dictionary.
+
+        :returns:
+            The serialized component as a dictionary.
+        """
+        callback_name = serialize_callable(self.streaming_callback) if self.streaming_callback else None
+
+        return default_to_dict(
+            self,
+            model=self.model,
+            streaming_callback=callback_name,
+            api_base_url=self.api_base_url,
+            generation_kwargs=self.generation_kwargs,
+            api_key=self.api_key.to_dict(),
+            tools=serialize_tools_or_toolset(self.tools),
+            timeout=self.timeout,
+            max_retries=self.max_retries,
+            http_client_kwargs=self.http_client_kwargs,
+        )

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/src/haystack_integrations/components/generators/nvidia/generator.py

@@ -4,12 +4,12 @@
 
 import os
 import warnings
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.utils.auth import Secret, deserialize_secrets_inplace
 
-from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Model, NimBackend, is_hosted, url_validation
+from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Client, Model, NimBackend, is_hosted, url_validation
 
 
 @component
@@ -104,7 +104,9 @@ class NvidiaGenerator:
                 UserWarning,
                 stacklevel=2,
             )
-            self._model = self.backend.model = name
+            self._model = name
+            if self.backend:
+                self.backend.model = name
         else:
             error_message = "No locally hosted model was found."
             raise ValueError(error_message)
@@ -123,7 +125,7 @@ class NvidiaGenerator:
             api_key=self._api_key,
             model_kwargs=self._model_arguments,
             timeout=self.timeout,
-            client=self.__class__.__name__,
+            client=Client.NVIDIA_GENERATOR,
         )
 
         if not self.is_hosted and not self._model:
@@ -169,7 +171,7 @@ class NvidiaGenerator:
         return default_from_dict(cls, data)
 
     @component.output_types(replies=List[str], meta=List[Dict[str, Any]])
-    def run(self, prompt: str):
+    def run(self, prompt: str) -> Dict[str, Union[List[str], List[Dict[str, Any]]]]:
         """
         Queries the model with the provided prompt.
 

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/src/haystack_integrations/components/rankers/nvidia/ranker.py

@@ -10,7 +10,7 @@ from haystack import Document, component, default_from_dict, default_to_dict, lo
 from haystack.utils import Secret, deserialize_secrets_inplace
 
 from haystack_integrations.components.rankers.nvidia.truncate import RankerTruncateMode
-from haystack_integrations.utils.nvidia import DEFAULT_API_URL, NimBackend, is_hosted, url_validation
+from haystack_integrations.utils.nvidia import DEFAULT_API_URL, Client, NimBackend, is_hosted, url_validation
 
 logger = logging.getLogger(__name__)
 
@@ -162,7 +162,7 @@ class NvidiaRanker:
         :raises ValueError: If the API key is required for hosted NVIDIA NIMs.
         """
         if not self._initialized:
-            model_kwargs = {}
+            model_kwargs: Dict[str, Any] = {}
             if self.truncate is not None:
                 model_kwargs.update(truncate=str(self.truncate))
             self.backend = NimBackend(
@@ -172,9 +172,9 @@ class NvidiaRanker:
                 api_key=self.api_key,
                 model_kwargs=model_kwargs,
                 timeout=self.timeout,
-                client=self.__class__.__name__,
+                client=Client.NVIDIA_RANKER,
             )
-            if not self.is_hosted and not self._model:
+            if not self.is_hosted and not self.model:
                 if self.backend.model:
                     self.model = self.backend.model
             self._initialized = True

{nvidia_haystack-0.1.8 → nvidia_haystack-0.3.0}/src/haystack_integrations/utils/nvidia/__init__.py

@@ -2,8 +2,9 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .client import Client
 from .models import DEFAULT_API_URL, Model
 from .nim_backend import NimBackend
 from .utils import is_hosted, url_validation
 
-__all__ = ["DEFAULT_API_URL", "Model", "NimBackend", "is_hosted", "url_validation", "validate_hosted_model"]
+__all__ = ["DEFAULT_API_URL", "Client", "Model", "NimBackend", "is_hosted", "url_validation", "validate_hosted_model"]

nvidia_haystack-0.3.0/src/haystack_integrations/utils/nvidia/client.py

@@ -0,0 +1,26 @@
+from enum import Enum
+
+
+class Client(Enum):
+    """
+    Client to use for NVIDIA NIMs.
+    """
+
+    NVIDIA_GENERATOR = "NvidiaGenerator"
+    NVIDIA_TEXT_EMBEDDER = "NvidiaTextEmbedder"
+    NVIDIA_DOCUMENT_EMBEDDER = "NvidiaDocumentEmbedder"
+    NVIDIA_RANKER = "NvidiaRanker"
+
+    def __str__(self) -> str:
+        """Convert a Client enum to a string."""
+        return self.value
+
+    @staticmethod
+    def from_str(string: str) -> "Client":
+        """Convert a string to a Client enum."""
+        enum_map = {e.value: e for e in Client}
+        mode = enum_map.get(string)
+        if mode is None:
+            msg = f"Unknown client '{string}' to use for NVIDIA NIMs. Supported modes are: {list(enum_map.keys())}"
+            raise ValueError(msg)
+        return mode