searchapi-haystack 1.0.0__tar.gz → 2.1.0__tar.gz

searchapi_haystack-2.1.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## [integrations/searchapi-v2.0.0] - 2026-10-16
+
+### 🐛 Bug Fixes
+
+- Fix new issues raised by ruff 0.16.0 (#3670)
+
+### 🚜 Refactor
+
+- [**breaking**] Remove from_dict overrides that only call default_from_dict from 14 components (#4059)
+
+### 🧪 Testing
+
+- Test compatible integrations with Python 3.15; update pyproject (#4104)
+
+### 🧹 Chores
+
+- Re-standardize READMEs (#3768)
+- [**breaking**] Drop Python 3.10 support (#4105)
+
+
+## [integrations/searchapi-v1.0.0] - 2026-06-15
+
+### 🚀 Features
+
+- Add searchapi integration (moved from Haystack core) (#3437)
+
+<!-- generated by git-cliff -->

{searchapi_haystack-1.0.0 → searchapi_haystack-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: searchapi-haystack
-Version: 1.0.0
+Version: 2.1.0
 Summary: Haystack integration for SearchApi Web Search
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/searchapi#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -12,14 +12,14 @@ Keywords: AI Search,Haystack,SearchApi,Web Search
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-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 :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: haystack-ai>=2.24.1
 Requires-Dist: httpx>=0.27.0
 Description-Content-Type: text/markdown
@@ -29,6 +29,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/searchapi-haystack.svg)](https://pypi.org/project/searchapi-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/searchapi-haystack.svg)](https://pypi.org/project/searchapi-haystack)
 
+- [Integration page](https://haystack.deepset.ai/integrations/searchapi)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/searchapi/CHANGELOG.md)
 
 ---

{searchapi_haystack-1.0.0 → searchapi_haystack-2.1.0}/README.md

@@ -3,6 +3,7 @@
 [![PyPI - Version](https://img.shields.io/pypi/v/searchapi-haystack.svg)](https://pypi.org/project/searchapi-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/searchapi-haystack.svg)](https://pypi.org/project/searchapi-haystack)
 
+- [Integration page](https://haystack.deepset.ai/integrations/searchapi)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/searchapi/CHANGELOG.md)
 
 ---

{searchapi_haystack-1.0.0 → searchapi_haystack-2.1.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "searchapi-haystack"
 dynamic = ["version"]
 description = "Haystack integration for SearchApi Web Search"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = ["Haystack", "SearchApi", "Web Search", "AI Search"]
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }]
@@ -15,11 +15,11 @@ classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
@@ -131,6 +131,7 @@ ignore = [
     "PLR0912",
     "PLR0913",
     "PLR0915",
+    "PLR0917",
     # Allow `Any` type - used legitimately for dynamic types and SDK boundaries
     "ANN401",
 ]

{searchapi_haystack-1.0.0 → searchapi_haystack-2.1.0}/src/haystack_integrations/components/websearch/searchapi/websearch.py

@@ -5,8 +5,8 @@
 from typing import Any
 
 import httpx
-from haystack import ComponentError, Document, component, default_from_dict, default_to_dict, logging
-from haystack.utils import Secret, deserialize_secrets_inplace
+from haystack import ComponentError, Document, component, default_to_dict, logging
+from haystack.utils import Secret
 
 logger = logging.getLogger(__name__)
 
@@ -34,6 +34,11 @@ class SearchApiWebSearch:
     assert results["documents"]
     assert results["links"]
     ```
+
+    SearchApi's AI answer engines are supported through `search_params`. With `{"engine": "google_ai_mode"}`,
+    `{"engine": "chatgpt"}`, `{"engine": "gemini"}` or `{"engine": "bing_copilot"}`, the first document holds the
+    synthesized answer as Markdown. The following documents and `links` hold the reference links it cites and,
+    for `google_ai_mode` and `chatgpt`, the web results the engine retrieved.
     """
 
     def __init__(
@@ -82,19 +87,6 @@ class SearchApiWebSearch:
             api_key=self.api_key.to_dict(),
         )
 
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "SearchApiWebSearch":
-        """
-        Deserializes the component from a dictionary.
-
-        :param data:
-            The dictionary to deserialize from.
-        :returns:
-            The deserialized component.
-        """
-        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
-        return default_from_dict(cls, data)
-
     @component.output_types(documents=list[Document], links=list[str])
     def run(self, query: str) -> dict[str, list[Document] | list[str]]:
         """
@@ -182,6 +174,11 @@ class SearchApiWebSearch:
     def _parse_response(response: httpx.Response) -> tuple[list[Document], list[str]]:
         json_result = response.json()
 
+        # AI answer engines (google_ai_mode, chatgpt, gemini, bing_copilot) return a
+        # synthesized answer instead of organic results
+        if any(key in json_result for key in ("text_blocks", "markdown", "reference_links")):
+            return SearchApiWebSearch._parse_ai_answer(json_result)
+
         # organic results are the main results from the search engine
         organic_results = []
         if "organic_results" in json_result:
@@ -231,3 +228,55 @@ class SearchApiWebSearch:
 
         links = [result["link"] for result in json_result.get("organic_results", [])]
         return documents, links
+
+    @staticmethod
+    def _parse_ai_answer(json_result: dict[str, Any]) -> tuple[list[Document], list[str]]:
+        """
+        Parse the shared AI answer shape returned by SearchApi's answer engines.
+
+        Engines such as `google_ai_mode`, `chatgpt`, `gemini` and `bing_copilot` return the answer as `markdown`
+        and the sources it cites as `reference_links`. `google_ai_mode` and `chatgpt` also return the `web_results`
+        they retrieved. The answer becomes the first document, each reference link a document after it, followed by
+        any web results. Links are the reference links, then the web result links.
+        """
+        parameters = json_result.get("search_parameters", {})
+        documents: list[Document] = []
+
+        answer = json_result.get("markdown")
+        if answer:
+            documents.append(
+                Document.from_dict({"content": answer, "engine": parameters.get("engine", ""), "type": "ai_answer"})
+            )
+
+        links: list[str] = []
+        for result in json_result.get("reference_links", []) or []:
+            documents.append(
+                Document.from_dict(
+                    {
+                        "title": result.get("title", ""),
+                        "content": result.get("snippet", ""),
+                        "link": result.get("link", ""),
+                        "source": result.get("source", ""),
+                    }
+                )
+            )
+            if result.get("link"):
+                links.append(result["link"])
+
+        for result in json_result.get("web_results", []) or []:
+            link = result.get("link")
+            if link in links:
+                continue
+            documents.append(
+                Document.from_dict(
+                    {
+                        "title": result.get("title", ""),
+                        "content": result.get("snippet", ""),
+                        "link": link or "",
+                    }
+                )
+            )
+            if link:
+                links.append(link)
+
+        return documents, links

{searchapi_haystack-1.0.0 → searchapi_haystack-2.1.0}/tests/test_websearch.py

@@ -8,6 +8,7 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
 import pytest
 from haystack import Document
+from haystack.core.serialization import component_from_dict
 from haystack.utils.auth import Secret
 from httpx import ConnectTimeout, HTTPStatusError, Request, RequestError, Response
 
@@ -397,6 +398,48 @@ def mock_searchapi_search_result_async() -> Generator[MagicMock, None, None]:
         yield mock_get
 
 
+EXAMPLE_AI_ANSWER_RESPONSE = {
+    "search_metadata": {"id": "search_ai_answer", "status": "Success", "created_at": "2026-10-01T00:00:00Z"},
+    "search_parameters": {"engine": "google_ai_mode", "q": "What is pgvector?"},
+    "text_blocks": [
+        {"type": "header", "answer": "pgvector"},
+        {
+            "type": "paragraph",
+            "answer": "pgvector adds vector similarity search to PostgreSQL.",
+            "reference_indexes": [0],
+        },
+        {
+            "type": "unordered_list",
+            "answer": "It supports:",
+            "items": [
+                {"type": "paragraph", "answer": "HNSW indexes"},
+                {"type": "paragraph", "answer": "IVFFlat indexes"},
+            ],
+        },
+        {"type": "table", "table": {"headers": ["Index", "Recall"], "rows": [["HNSW", "0.75"], ["IVFFlat", "0.70"]]}},
+    ],
+    "markdown": "## pgvector\n\npgvector adds vector similarity search to PostgreSQL.[1]",
+    "reference_links": [
+        {
+            "index": 0,
+            "title": "pgvector on GitHub",
+            "link": "https://github.com/pgvector/pgvector",
+            "snippet": "Open-source vector similarity search for Postgres.",
+            "source": "GitHub",
+        },
+        {"index": 1, "title": "Vectors in Postgres", "link": "https://example.com/vectors", "source": "Example"},
+    ],
+    "related_questions": [{"question": "How does HNSW work?"}],
+}
+
+
+@pytest.fixture
+def mock_searchapi_ai_answer_result() -> Generator[MagicMock, None, None]:
+    with patch("haystack_integrations.components.websearch.searchapi.websearch.httpx.get") as mock_get:
+        mock_get.return_value = Mock(status_code=200, json=lambda: EXAMPLE_AI_ANSWER_RESPONSE)
+        yield mock_get
+
+
 class TestSearchApiSearchAPI:
     def test_init_fail_wo_api_key(self, monkeypatch):
         monkeypatch.delenv("SEARCHAPI_API_KEY", raising=False)
@@ -430,7 +473,7 @@ class TestSearchApiSearchAPI:
                 "search_params": {"param": "test params", "engine": "google"},
             },
         }
-        component = SearchApiWebSearch.from_dict(data)
+        component = component_from_dict(SearchApiWebSearch, data, name="component")
         assert component.api_key == Secret.from_env_var("SEARCHAPI_API_KEY")
         assert component.top_k == 10
         assert component.allowed_domains == ["testdomain.com"]
@@ -443,6 +486,75 @@ class TestSearchApiSearchAPI:
         assert documents[0].content == "Satya Nadella"
         assert links == []
 
+    def test_parse_ai_answer_response(self) -> None:
+        documents, links = SearchApiWebSearch._parse_ai_answer(EXAMPLE_AI_ANSWER_RESPONSE)
+
+        assert documents[0].content == EXAMPLE_AI_ANSWER_RESPONSE["markdown"]
+        assert documents[0].meta["engine"] == "google_ai_mode"
+        assert documents[0].meta["type"] == "ai_answer"
+
+        assert [doc.meta["link"] for doc in documents[1:]] == [
+            "https://github.com/pgvector/pgvector",
+            "https://example.com/vectors",
+        ]
+        assert documents[1].content == "Open-source vector similarity search for Postgres."
+        assert documents[1].meta["source"] == "GitHub"
+        assert documents[2].content == ""
+        assert links == ["https://github.com/pgvector/pgvector", "https://example.com/vectors"]
+
+    def test_parse_ai_answer_includes_web_results_after_references(self) -> None:
+        response = {
+            **EXAMPLE_AI_ANSWER_RESPONSE,
+            "search_parameters": {"engine": "google_ai_mode", "q": "What is pgvector?"},
+            "web_results": [
+                {
+                    "title": "pgvector on GitHub",
+                    "link": "https://github.com/pgvector/pgvector",
+                    "displayed_link": "github.com",
+                    "source": "GitHub",
+                    "snippet": "Already cited as a reference link.",
+                },
+                {
+                    "title": "A web result",
+                    "link": "https://example.com/web",
+                    "displayed_link": "example.com",
+                    "source": "Example",
+                    "snippet": "Web snippet.",
+                },
+            ],
+        }
+        documents, links = SearchApiWebSearch._parse_ai_answer(response)
+
+        # A web result that is already a reference link is skipped in both documents and links.
+        assert links == [
+            "https://github.com/pgvector/pgvector",
+            "https://example.com/vectors",
+            "https://example.com/web",
+        ]
+        assert [doc.meta.get("link") for doc in documents].count("https://github.com/pgvector/pgvector") == 1
+        assert documents[-1].meta["link"] == "https://example.com/web"
+        assert documents[-1].content == "Web snippet."
+
+    def test_parse_ai_answer_without_answer_or_references(self) -> None:
+        documents, links = SearchApiWebSearch._parse_ai_answer(
+            {"search_parameters": {"engine": "gemini", "q": "nothing"}, "reference_links": []}
+        )
+        assert documents == []
+        assert links == []
+
+    @pytest.mark.usefixtures("mock_searchapi_ai_answer_result")
+    def test_web_search_ai_answer_engine(self) -> None:
+        ws = SearchApiWebSearch(
+            top_k=2, api_key=Secret.from_token("test-api-key"), search_params={"engine": "google_ai_mode"}
+        )
+        results = ws.run(query="What is pgvector?")
+
+        documents = results["documents"]
+        assert len(documents) == 2
+        assert documents[0].meta["type"] == "ai_answer"
+        assert documents[1].meta["link"] == "https://github.com/pgvector/pgvector"
+        assert results["links"] == ["https://github.com/pgvector/pgvector", "https://example.com/vectors"]
+
     @pytest.mark.parametrize("top_k", [1, 5, 7])
     @pytest.mark.usefixtures("mock_searchapi_search_result")
     def test_web_search_top_k(self, top_k: int) -> None: