vllm-haystack 1.2.1__tar.gz → 2.0.0__tar.gz

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [integrations/vllm-v1.3.0] - 2026-07-07
+
+### 🧹 Chores
+
+- Support sync streaming callbacks in async contexts for Haystack 2.x/3.x compatibility (#3534)
+- *(vllm)* Unpin fastapi (#3557)
+
+
+## [integrations/vllm-v1.2.1] - 2026-07-02
+
+### 🚀 Features
+
+- Add Python 3.14 support to vLLM integration (#3528)
+
+### 🐛 Bug Fixes
+
+- Vllm - temporarily pin fastapi (#3450)
+
+
 ## [integrations/vllm-v1.2.0] - 2026-06-05
 
 ### 🚀 Features

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vllm-haystack
-Version: 1.2.1
+Version: 2.0.0
 Summary: Haystack integration for vllm
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/vllm#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -19,8 +19,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: fastapi<0.137
-Requires-Dist: haystack-ai>=2.30.0
+Requires-Dist: haystack-ai>=3.0.0
 Requires-Dist: more-itertools>=9.0.0
 Requires-Dist: openai
 Requires-Dist: tqdm>=4.48.0
@@ -31,6 +30,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/vllm-haystack.svg)](https://pypi.org/project/vllm-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/vllm-haystack.svg)](https://pypi.org/project/vllm-haystack)
 
+- [Integration page](https://haystack.deepset.ai/integrations/vllm)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/vllm/CHANGELOG.md)
 
 ---
@@ -61,4 +61,4 @@ To run the ranker server, use CPU Docker image:
 # ranker server (port 8002)
 docker run --rm -p 8002:8000 -e VLLM_CPU_OMP_THREADS_BIND=0-3 vllm/vllm-openai-cpu:latest \
     --model BAAI/bge-reranker-base --enforce-eager
-```
+```

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/README.md

@@ -3,6 +3,7 @@
 [![PyPI - Version](https://img.shields.io/pypi/v/vllm-haystack.svg)](https://pypi.org/project/vllm-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/vllm-haystack.svg)](https://pypi.org/project/vllm-haystack)
 
+- [Integration page](https://haystack.deepset.ai/integrations/vllm)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/vllm/CHANGELOG.md)
 
 ---
@@ -33,4 +34,4 @@ To run the ranker server, use CPU Docker image:
 # ranker server (port 8002)
 docker run --rm -p 8002:8000 -e VLLM_CPU_OMP_THREADS_BIND=0-3 vllm/vllm-openai-cpu:latest \
     --model BAAI/bge-reranker-base --enforce-eager
-```
+```

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/pyproject.toml

@@ -23,8 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-# fastapi temporarily pinned due to https://github.com/vllm-project/vllm/issues/45596
-dependencies = ["haystack-ai>=2.30.0", "openai", "more_itertools>=9.0.0", "tqdm>=4.48.0", "fastapi<0.137"]
+dependencies = ["haystack-ai>=3.0.0", "openai", "more_itertools>=9.0.0", "tqdm>=4.48.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/vllm#readme"
@@ -128,6 +127,7 @@ ignore = [
     "PLR0912",
     "PLR0913",
     "PLR0915",
+    "PLR0917",
     # Allow `Any` type - used legitimately for dynamic types and SDK boundaries
     "ANN401",
 ]

vllm_haystack-2.0.0/src/haystack_integrations/common/vllm/utils.py

@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from haystack.utils import Secret
+from haystack.utils.http_client import init_http_client
+from openai import AsyncOpenAI, OpenAI
+
+
+def _openai_client_kwargs(
+    api_key: Secret | None,
+    api_base_url: str,
+    timeout: float | None,
+    max_retries: int | None,
+) -> dict[str, Any]:
+    """
+    Build the common keyword arguments for OpenAI clients pointing at a vLLM server.
+
+    A placeholder api key is used when the user did not supply one and no `VLLM_API_KEY` env var is set, because the
+    OpenAI client requires a non-empty value.
+    `timeout` and `max_retries` are only forwarded when provided: when None, the OpenAI client's own defaults apply.
+    """
+    resolved_api_key = "placeholder-api-key"
+    if api_key is not None and (value := api_key.resolve_value()):
+        resolved_api_key = value
+
+    client_kwargs: dict[str, Any] = {"api_key": resolved_api_key, "base_url": api_base_url}
+    if timeout is not None:
+        client_kwargs["timeout"] = timeout
+    if max_retries is not None:
+        client_kwargs["max_retries"] = max_retries
+
+    return client_kwargs
+
+
+def _create_openai_client(
+    api_key: Secret | None,
+    api_base_url: str,
+    timeout: float | None,
+    max_retries: int | None,
+    http_client_kwargs: dict[str, Any] | None,
+) -> OpenAI:
+    """Build a synchronous OpenAI client pointing at a vLLM server."""
+    client_kwargs = _openai_client_kwargs(api_key, api_base_url, timeout, max_retries)
+    sync_http_client = init_http_client(http_client_kwargs, async_client=False)
+    # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
+    # https://github.com/openai/openai-python/blob/main/httpx2.md
+    return OpenAI(http_client=sync_http_client, **client_kwargs)  # type: ignore[arg-type]
+
+
+def _create_async_openai_client(
+    api_key: Secret | None,
+    api_base_url: str,
+    timeout: float | None,
+    max_retries: int | None,
+    http_client_kwargs: dict[str, Any] | None,
+) -> AsyncOpenAI:
+    """Build an asynchronous OpenAI client pointing at a vLLM server."""
+    client_kwargs = _openai_client_kwargs(api_key, api_base_url, timeout, max_retries)
+    async_http_client = init_http_client(http_client_kwargs, async_client=True)
+    # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
+    # https://github.com/openai/openai-python/blob/main/httpx2.md
+    return AsyncOpenAI(http_client=async_http_client, **client_kwargs)  # type: ignore[arg-type]

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/src/haystack_integrations/components/embedders/vllm/document_embedder.py

@@ -12,7 +12,7 @@ from openai import APIError, AsyncOpenAI, OpenAI
 from tqdm import tqdm
 from tqdm.asyncio import tqdm as async_tqdm
 
-from haystack_integrations.common.vllm.utils import _create_openai_clients
+from haystack_integrations.common.vllm.utils import _create_async_openai_client, _create_openai_client
 
 logger = logging.getLogger(__name__)
 
@@ -131,20 +131,40 @@ class VLLMDocumentEmbedder:
 
         self._client: OpenAI | None = None
         self._async_client: AsyncOpenAI | None = None
-        self._is_warmed_up = False
 
     def warm_up(self) -> None:
-        """Create the OpenAI clients."""
-        if self._is_warmed_up:
-            return
-        self._client, self._async_client = _create_openai_clients(
-            api_key=self.api_key,
-            api_base_url=self.api_base_url,
-            timeout=self.timeout,
-            max_retries=self.max_retries,
-            http_client_kwargs=self.http_client_kwargs,
-        )
-        self._is_warmed_up = True
+        """Create the synchronous OpenAI client."""
+        if self._client is None:
+            self._client = _create_openai_client(
+                api_key=self.api_key,
+                api_base_url=self.api_base_url,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                http_client_kwargs=self.http_client_kwargs,
+            )
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous OpenAI client."""
+        if self._async_client is None:
+            self._async_client = _create_async_openai_client(
+                api_key=self.api_key,
+                api_base_url=self.api_base_url,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                http_client_kwargs=self.http_client_kwargs,
+            )
+
+    def close(self) -> None:
+        """Close the synchronous OpenAI client."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    async def close_async(self) -> None:
+        """Close the asynchronous OpenAI client."""
+        if self._async_client is not None:
+            await self._async_client.close()
+            self._async_client = None
 
     def _prepare_texts_to_embed(self, documents: list[Document]) -> dict[str, str]:
         """Concatenate each Document's text with the selected meta fields."""
@@ -254,8 +274,8 @@ class VLLMDocumentEmbedder:
         if not documents:
             return {"documents": [], "meta": {}}
 
-        if not self._is_warmed_up:
-            self.warm_up()
+        self.warm_up()
+        assert self._client is not None  # noqa: S101
 
         texts_to_embed = self._prepare_texts_to_embed(documents)
         doc_ids_to_embeddings, meta = self._embed_batch(texts_to_embed, self.batch_size)
@@ -280,8 +300,8 @@ class VLLMDocumentEmbedder:
         if not documents:
             return {"documents": [], "meta": {}}
 
-        if not self._is_warmed_up:
-            self.warm_up()
+        await self.warm_up_async()
+        assert self._async_client is not None  # noqa: S101
 
         texts_to_embed = self._prepare_texts_to_embed(documents)
         doc_ids_to_embeddings, meta = await self._embed_batch_async(texts_to_embed, self.batch_size)

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/src/haystack_integrations/components/embedders/vllm/text_embedder.py

@@ -9,7 +9,7 @@ from haystack.utils import Secret
 from openai import AsyncOpenAI, OpenAI
 from openai.types import CreateEmbeddingResponse
 
-from haystack_integrations.common.vllm.utils import _create_openai_clients
+from haystack_integrations.common.vllm.utils import _create_async_openai_client, _create_openai_client
 
 
 @component
@@ -103,20 +103,40 @@ class VLLMTextEmbedder:
 
         self._client: OpenAI | None = None
         self._async_client: AsyncOpenAI | None = None
-        self._is_warmed_up = False
 
     def warm_up(self) -> None:
-        """Create the OpenAI clients."""
-        if self._is_warmed_up:
-            return
-        self._client, self._async_client = _create_openai_clients(
-            api_key=self.api_key,
-            api_base_url=self.api_base_url,
-            timeout=self.timeout,
-            max_retries=self.max_retries,
-            http_client_kwargs=self.http_client_kwargs,
-        )
-        self._is_warmed_up = True
+        """Create the synchronous OpenAI client."""
+        if self._client is None:
+            self._client = _create_openai_client(
+                api_key=self.api_key,
+                api_base_url=self.api_base_url,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                http_client_kwargs=self.http_client_kwargs,
+            )
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous OpenAI client."""
+        if self._async_client is None:
+            self._async_client = _create_async_openai_client(
+                api_key=self.api_key,
+                api_base_url=self.api_base_url,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                http_client_kwargs=self.http_client_kwargs,
+            )
+
+    def close(self) -> None:
+        """Close the synchronous OpenAI client."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    async def close_async(self) -> None:
+        """Close the asynchronous OpenAI client."""
+        if self._async_client is not None:
+            await self._async_client.close()
+            self._async_client = None
 
     def _prepare_input(self, text: str) -> dict[str, Any]:
         if not isinstance(text, str):
@@ -155,8 +175,7 @@ class VLLMTextEmbedder:
             - `meta`: Information about the usage of the model.
         """
         kwargs = self._prepare_input(text)
-        if not self._is_warmed_up:
-            self.warm_up()
+        self.warm_up()
         assert self._client is not None  # noqa: S101
         response = self._client.embeddings.create(**kwargs)
         return self._prepare_output(response)
@@ -172,8 +191,7 @@ class VLLMTextEmbedder:
             - `meta`: Information about the usage of the model.
         """
         kwargs = self._prepare_input(text)
-        if not self._is_warmed_up:
-            self.warm_up()
+        await self.warm_up_async()
         assert self._async_client is not None  # noqa: S101
         response = await self._async_client.embeddings.create(**kwargs)
         return self._prepare_output(response)

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/src/haystack_integrations/components/generators/vllm/chat/chat_generator.py

@@ -1,5 +1,6 @@
 import asyncio
 import dataclasses
+import inspect
 import json
 from typing import Any
 
@@ -17,7 +18,6 @@ from haystack.core.component import component
 from haystack.dataclasses import ChatMessage, ToolCall
 from haystack.dataclasses.chat_message import ReasoningContent
 from haystack.dataclasses.streaming_chunk import (
-    AsyncStreamingCallbackT,
     ComponentInfo,
     StreamingCallbackT,
     StreamingChunk,
@@ -37,7 +37,7 @@ from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
 from openai.types.chat import ChatCompletion, ChatCompletionChunk
 from openai.types.chat.chat_completion import Choice
 
-from haystack_integrations.common.vllm.utils import _create_openai_clients
+from haystack_integrations.common.vllm.utils import _create_async_openai_client, _create_openai_client
 
 logger = logging.getLogger(__name__)
 
@@ -255,22 +255,48 @@ class VLLMChatGenerator:
 
         self._client: OpenAI | None = None
         self._async_client: AsyncOpenAI | None = None
-        self._is_warmed_up = False
+        self._tools_warmed_up = False
 
-    def warm_up(self) -> None:
-        """Create the OpenAI clients and warm up tools."""
-        if self._is_warmed_up:
-            return
+    def _warm_up_tools(self) -> None:
+        if not self._tools_warmed_up:
+            warm_up_tools(self.tools)
+            self._tools_warmed_up = True
 
-        self._client, self._async_client = _create_openai_clients(
-            api_key=self.api_key,
-            api_base_url=self.api_base_url,
-            timeout=self.timeout,
-            max_retries=self.max_retries,
-            http_client_kwargs=self.http_client_kwargs,
-        )
-        warm_up_tools(self.tools)
-        self._is_warmed_up = True
+    def warm_up(self) -> None:
+        """Create the synchronous OpenAI client and warm up tools."""
+        self._warm_up_tools()
+        if self._client is None:
+            self._client = _create_openai_client(
+                api_key=self.api_key,
+                api_base_url=self.api_base_url,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                http_client_kwargs=self.http_client_kwargs,
+            )
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous OpenAI client and warm up tools."""
+        self._warm_up_tools()
+        if self._async_client is None:
+            self._async_client = _create_async_openai_client(
+                api_key=self.api_key,
+                api_base_url=self.api_base_url,
+                timeout=self.timeout,
+                max_retries=self.max_retries,
+                http_client_kwargs=self.http_client_kwargs,
+            )
+
+    def close(self) -> None:
+        """Close the synchronous OpenAI client."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    async def close_async(self) -> None:
+        """Close the asynchronous OpenAI client."""
+        if self._async_client is not None:
+            await self._async_client.close()
+            self._async_client = None
 
     def to_dict(self) -> dict[str, Any]:
         """
@@ -385,7 +411,7 @@ class VLLMChatGenerator:
         return [_convert_streaming_chunks_to_chat_message(chunks=chunks)]
 
     async def _handle_async_stream_response(
-        self, chat_completion: AsyncStream[ChatCompletionChunk], callback: AsyncStreamingCallbackT
+        self, chat_completion: AsyncStream[ChatCompletionChunk], callback: StreamingCallbackT
     ) -> list[ChatMessage]:
         """Handle an asynchronous streaming response, extracting reasoning content from vLLM's reasoning chunks."""
         component_info = ComponentInfo.from_component(self)
@@ -423,7 +449,10 @@ class VLLMChatGenerator:
                         content_started = True
 
                 chunks.append(streaming_chunk)
-                await callback(streaming_chunk)
+                # sync callbacks are allowed in async contexts with Haystack >= 3.0, so only await async ones
+                callback_result = callback(streaming_chunk)
+                if inspect.isawaitable(callback_result):
+                    await callback_result
         except asyncio.CancelledError:
             await asyncio.shield(chat_completion.close())
             raise
@@ -448,8 +477,9 @@ class VLLMChatGenerator:
         :param streaming_callback:
             A callback function that is called when a new token is received from the stream.
         :param generation_kwargs:
-            Additional keyword arguments for text generation. These parameters will
-            override the parameters passed during component initialization.
+            Additional keyword arguments for text generation. These are merged per key with the
+            `generation_kwargs` passed at initialization: keys provided here take precedence, keys set only
+            at initialization are kept.
             For details on vLLM API parameters, see
             [vLLM documentation](https://docs.vllm.ai/en/stable/serving/openai_compatible_server/).
         :param tools:
@@ -460,9 +490,9 @@ class VLLMChatGenerator:
             A dictionary with the following key:
             - `replies`: A list containing the generated responses as ChatMessage instances.
         """
+        self.warm_up()
+        assert self._client is not None  # noqa: S101
         messages = _normalize_messages(messages)
-        if not self._is_warmed_up:
-            self.warm_up()
 
         if len(messages) == 0:
             return {"replies": []}
@@ -472,7 +502,6 @@ class VLLMChatGenerator:
         )
 
         api_kwargs = self._prepare_api_call(messages, streaming_callback, generation_kwargs, tools)
-        assert self._client is not None  # noqa: S101
         chat_completion = self._client.chat.completions.create(**api_kwargs)
 
         if streaming_callback is not None:
@@ -506,8 +535,9 @@ class VLLMChatGenerator:
             A callback function that is called when a new token is received from the stream.
             Must be a coroutine.
         :param generation_kwargs:
-            Additional keyword arguments for text generation. These parameters will
-            override the parameters passed during component initialization.
+            Additional keyword arguments for text generation. These are merged per key with the
+            `generation_kwargs` passed at initialization: keys provided here take precedence, keys set only
+            at initialization are kept.
             For details on vLLM API parameters, see
             [vLLM documentation](https://docs.vllm.ai/en/stable/serving/openai_compatible_server/).
         :param tools:
@@ -518,9 +548,9 @@ class VLLMChatGenerator:
             A dictionary with the following key:
             - `replies`: A list containing the generated responses as ChatMessage instances.
         """
+        await self.warm_up_async()
+        assert self._async_client is not None  # noqa: S101
         messages = _normalize_messages(messages)
-        if not self._is_warmed_up:
-            self.warm_up()
 
         if len(messages) == 0:
             return {"replies": []}
@@ -530,7 +560,6 @@ class VLLMChatGenerator:
         )
 
         api_kwargs = self._prepare_api_call(messages, streaming_callback, generation_kwargs, tools)
-        assert self._async_client is not None  # noqa: S101
         chat_completion = await self._async_client.chat.completions.create(**api_kwargs)
 
         if streaming_callback is not None:

{vllm_haystack-1.2.1 → vllm_haystack-2.0.0}/src/haystack_integrations/components/rankers/vllm/ranker.py

@@ -109,24 +109,45 @@ class VLLMRanker:
         self.http_client_kwargs = http_client_kwargs
         self.extra_parameters = extra_parameters
 
-        self._headers = {"Content-Type": "application/json"}
-        if self.api_key is not None and (resolved_key := self.api_key.resolve_value()):
-            self._headers["Authorization"] = f"Bearer {resolved_key}"
-
         self._client: httpx.Client | None = None
         self._async_client: httpx.AsyncClient | None = None
-        self._is_warmed_up = False
 
-    def warm_up(self) -> None:
-        """Create the httpx clients."""
-        if self._is_warmed_up:
-            return
+    def _client_kwargs(self) -> dict[str, Any]:
+        """Build the keyword arguments used to create HTTP clients."""
+        headers = httpx.Headers((self.http_client_kwargs or {}).get("headers"))
+        headers["Content-Type"] = "application/json"
+        if self.api_key is not None and (resolved_key := self.api_key.resolve_value()):
+            headers["Authorization"] = f"Bearer {resolved_key}"
+
+        client_kwargs = self.http_client_kwargs.copy() if self.http_client_kwargs else {}
+        client_kwargs["headers"] = headers
+        return client_kwargs
 
-        client = init_http_client(self.http_client_kwargs, async_client=False)
-        async_client = init_http_client(self.http_client_kwargs, async_client=True)
-        self._client = client if client is not None else httpx.Client()
-        self._async_client = async_client if async_client is not None else httpx.AsyncClient()
-        self._is_warmed_up = True
+    def warm_up(self) -> None:
+        """Create the synchronous HTTP client."""
+        if self._client is None:
+            client = init_http_client(http_client_kwargs=self._client_kwargs(), async_client=False)
+            assert client is not None  # noqa: S101
+            self._client = client
+
+    async def warm_up_async(self) -> None:
+        """Create the asynchronous HTTP client."""
+        if self._async_client is None:
+            client = init_http_client(http_client_kwargs=self._client_kwargs(), async_client=True)
+            assert client is not None  # noqa: S101
+            self._async_client = client
+
+    def close(self) -> None:
+        """Close the synchronous HTTP client."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    async def close_async(self) -> None:
+        """Close the asynchronous HTTP client."""
+        if self._async_client is not None:
+            await self._async_client.aclose()
+            self._async_client = None
 
     def _prepare_texts(self, documents: list[Document]) -> list[str]:
         """Concatenate each Document's text with the selected meta fields."""
@@ -210,13 +231,12 @@ class VLLMRanker:
 
         top_k, score_threshold = self._resolve_run_params(top_k, score_threshold)
 
-        if not self._is_warmed_up:
-            self.warm_up()
+        self.warm_up()
         assert self._client is not None  # noqa: S101
 
         body = self._prepare_request(query, documents, top_k)
         url = f"{self.api_base_url.rstrip('/')}/rerank"
-        response = self._client.post(url, json=body, headers=self._headers)
+        response = self._client.post(url, json=body)
         return self._parse_response(response.json(), documents, score_threshold)
 
     @component.output_types(documents=list[Document], meta=dict[str, Any])
@@ -246,11 +266,10 @@ class VLLMRanker:
 
         top_k, score_threshold = self._resolve_run_params(top_k, score_threshold)
 
-        if not self._is_warmed_up:
-            self.warm_up()
+        await self.warm_up_async()
         assert self._async_client is not None  # noqa: S101
 
         body = self._prepare_request(query, documents, top_k)
         url = f"{self.api_base_url.rstrip('/')}/rerank"
-        response = await self._async_client.post(url, json=body, headers=self._headers)
+        response = await self._async_client.post(url, json=body)
         return self._parse_response(response.json(), documents, score_threshold)