feat: add Perplexity Search component

Signed-off-by: James Liounis <james.liounis@perplexity.ai>

Author: jliounis

src/backend/tests/unit/components/perplexity/__init__.py

@@ -0,0 +1,156 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from lfx.components.perplexity.perplexity_search import PerplexitySearchComponent
+from lfx.schema import Data, DataFrame
+
+from tests.base import ComponentTestBaseWithoutClient
+
+
+class TestPerplexitySearchComponent(ComponentTestBaseWithoutClient):
+    @pytest.fixture
+    def component_class(self):
+        return PerplexitySearchComponent
+
+    @pytest.fixture
+    def default_kwargs(self):
+        return {
+            "api_key": "test-key",
+            "query": "what is langflow",
+            "max_results": 3,
+        }
+
+    @pytest.fixture
+    def file_names_mapping(self):
+        return []
+
+    @pytest.fixture
+    def fake_search_response(self):
+        return {
+            "results": [
+                {
+                    "title": "Result One",
+                    "url": "https://example.com/one",
+                    "snippet": "First snippet.",
+                    "date": "2025-01-01",
+                    "last_updated": "2025-01-02",
+                },
+                {
+                    "title": "Result Two",
+                    "url": "https://example.com/two",
+                    "snippet": "Second snippet.",
+                    "date": "2025-02-01",
+                    "last_updated": "2025-02-02",
+                },
+            ],
+            "id": "abc",
+            "server_time": "2025-03-01T00:00:00Z",
+        }
+
+    def test_component_initialization(self, component_class):
+        component = component_class()
+        frontend_node = component.to_frontend_node()
+        node_data = frontend_node["data"]["node"]
+
+        assert node_data["display_name"] == "Perplexity Search API"
+        assert node_data["icon"] == "Perplexity"
+        template = node_data["template"]
+        for input_name in ("api_key", "query", "max_results", "search_recency_filter", "country", "search_mode"):
+            assert input_name in template
+
+    @patch("lfx.components.perplexity.perplexity_search.httpx.Client")
+    def test_fetch_content_success(self, mock_client_cls, component_class, default_kwargs, fake_search_response):
+        mock_response = MagicMock()
+        mock_response.json.return_value = fake_search_response
+        mock_response.raise_for_status.return_value = None
+        mock_client = MagicMock()
+        mock_client.post.return_value = mock_response
+        mock_client_cls.return_value.__enter__.return_value = mock_client
+
+        component = component_class(**default_kwargs)
+        results = component.fetch_content()
+
+        assert isinstance(results, list)
+        assert len(results) == 2
+        assert isinstance(results[0], Data)
+        assert results[0].data["title"] == "Result One"
+        assert results[0].data["url"] == "https://example.com/one"
+        assert results[0].text == "First snippet."
+
+        # Verify the request was sent with the correct attribution header and payload.
+        call_args = mock_client.post.call_args
+        assert call_args.args[0] == "https://api.perplexity.ai/search"
+        sent_headers = call_args.kwargs["headers"]
+        assert sent_headers["Authorization"] == "Bearer test-key"
+        assert sent_headers["Content-Type"] == "application/json"
+        assert "X-Pplx-Integration" in sent_headers
+        assert sent_headers["X-Pplx-Integration"].startswith("langflow/")
+        sent_payload = call_args.kwargs["json"]
+        assert sent_payload == {"query": "what is langflow", "max_results": 3}
+
+    @patch("lfx.components.perplexity.perplexity_search.httpx.Client")
+    def test_fetch_content_optional_filters(self, mock_client_cls, component_class, fake_search_response):
+        mock_response = MagicMock()
+        mock_response.json.return_value = fake_search_response
+        mock_response.raise_for_status.return_value = None
+        mock_client = MagicMock()
+        mock_client.post.return_value = mock_response
+        mock_client_cls.return_value.__enter__.return_value = mock_client
+
+        component = component_class(
+            api_key="test-key",
+            query="langflow",
+            max_results=10,
+            search_recency_filter="week",
+            country="US",
+            search_mode="academic",
+        )
+        component.fetch_content()
+
+        sent_payload = mock_client.post.call_args.kwargs["json"]
+        assert sent_payload["query"] == "langflow"
+        assert sent_payload["max_results"] == 10
+        assert sent_payload["search_recency_filter"] == "week"
+        assert sent_payload["country"] == "US"
+        assert sent_payload["search_mode"] == "academic"
+
+    @patch("lfx.components.perplexity.perplexity_search.httpx.Client")
+    def test_max_results_clamped(self, mock_client_cls, component_class, fake_search_response):
+        mock_response = MagicMock()
+        mock_response.json.return_value = fake_search_response
+        mock_response.raise_for_status.return_value = None
+        mock_client = MagicMock()
+        mock_client.post.return_value = mock_response
+        mock_client_cls.return_value.__enter__.return_value = mock_client
+
+        component = component_class(api_key="test-key", query="langflow", max_results=999)
+        component.fetch_content()
+
+        sent_payload = mock_client.post.call_args.kwargs["json"]
+        assert sent_payload["max_results"] == 20
+
+    def test_missing_query_returns_error(self, component_class):
+        component = component_class(api_key="test-key", query="")
+        results = component.fetch_content()
+        assert len(results) == 1
+        assert "error" in results[0].data
+
+    @patch("lfx.components.perplexity.perplexity_search.httpx.Client")
+    def test_fetch_content_dataframe(self, mock_client_cls, component_class, default_kwargs, fake_search_response):
+        mock_response = MagicMock()
+        mock_response.json.return_value = fake_search_response
+        mock_response.raise_for_status.return_value = None
+        mock_client = MagicMock()
+        mock_client.post.return_value = mock_response
+        mock_client_cls.return_value.__enter__.return_value = mock_client
+
+        component = component_class(**default_kwargs)
+        df = component.fetch_content_dataframe()
+        assert isinstance(df, DataFrame)
+        assert len(df) == 2
+
+    @pytest.mark.asyncio
+    async def test_latest_version(self, component_class, default_kwargs):
+        """Override to skip network call."""
+        component = component_class(**default_kwargs)
+        assert component is not None

src/backend/tests/unit/components/perplexity/test_perplexity_search.py

@@ -6,13 +6,16 @@
 
 if TYPE_CHECKING:
     from .perplexity import PerplexityComponent
+    from .perplexity_search import PerplexitySearchComponent
 
 _dynamic_imports = {
     "PerplexityComponent": "perplexity",
+    "PerplexitySearchComponent": "perplexity_search",
 }
 
 __all__ = [
     "PerplexityComponent",
+    "PerplexitySearchComponent",
 ]
 
 

src/lfx/src/lfx/components/perplexity/__init__.py

@@ -0,0 +1,156 @@
+import importlib.metadata
+
+import httpx
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DropdownInput, IntInput, MessageTextInput, SecretStrInput, StrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+PERPLEXITY_SEARCH_URL = "https://api.perplexity.ai/search"
+INTEGRATION_SLUG = "langflow"
+DEFAULT_TIMEOUT = 90.0
+
+
+def _get_integration_header() -> str:
+    """Return the X-Pplx-Integration header value for outgoing requests."""
+    for package in ("langflow", "langflow-base", "lfx"):
+        try:
+            version = importlib.metadata.version(package)
+        except importlib.metadata.PackageNotFoundError:
+            continue
+        return f"{INTEGRATION_SLUG}/{version}"
+    return f"{INTEGRATION_SLUG}/unknown"
+
+
+class PerplexitySearchComponent(Component):
+    display_name = "Perplexity Search API"
+    description = (
+        "Search the web with the Perplexity Search API. Returns ranked, "
+        "LLM-friendly results with snippets, URLs, and freshness metadata."
+    )
+    documentation = "https://docs.perplexity.ai/api-reference/search-post"
+    icon = "Perplexity"
+    name = "PerplexitySearch"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="Perplexity API Key",
+            required=True,
+            info="Your Perplexity API key.",
+        ),
+        MessageTextInput(
+            name="query",
+            display_name="Search Query",
+            info="The search query to send to Perplexity.",
+            tool_mode=True,
+        ),
+        IntInput(
+            name="max_results",
+            display_name="Max Results",
+            info="Maximum number of search results to return (1-20).",
+            value=5,
+        ),
+        DropdownInput(
+            name="search_recency_filter",
+            display_name="Search Recency Filter",
+            info="Restrict results to content published within the given window.",
+            options=["hour", "day", "week", "month", "year"],
+            value=None,
+            advanced=True,
+        ),
+        StrInput(
+            name="country",
+            display_name="Country",
+            info="ISO 3166-1 alpha-2 country code to bias results (e.g. US, GB).",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="search_mode",
+            display_name="Search Mode",
+            info="Search mode: web (default), academic, or sec.",
+            options=["web", "academic", "sec"],
+            value=None,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Search Results", name="results", method="fetch_content"),
+        Output(display_name="Table", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def _build_payload(self) -> dict:
+        max_results = self.max_results or 5
+        max_results = max(1, min(int(max_results), 20))
+        payload: dict = {"query": self.query, "max_results": max_results}
+        if self.search_recency_filter:
+            payload["search_recency_filter"] = self.search_recency_filter
+        if self.country:
+            payload["country"] = self.country
+        if self.search_mode:
+            payload["search_mode"] = self.search_mode
+        return payload
+
+    def fetch_content(self) -> list[Data]:
+        if not self.query:
+            error_message = "Query is required."
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "X-Pplx-Integration": _get_integration_header(),
+        }
+        payload = self._build_payload()
+
+        try:
+            with httpx.Client(timeout=DEFAULT_TIMEOUT) as client:
+                response = client.post(PERPLEXITY_SEARCH_URL, json=payload, headers=headers)
+            response.raise_for_status()
+            search_results = response.json()
+        except httpx.TimeoutException:
+            error_message = f"Request timed out ({DEFAULT_TIMEOUT}s). Please try again or adjust parameters."
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except httpx.HTTPStatusError as exc:
+            error_message = f"HTTP error occurred: {exc.response.status_code} - {exc.response.text}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except httpx.RequestError as exc:
+            error_message = f"Request error occurred: {exc}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+        except ValueError as exc:
+            error_message = f"Invalid response format: {exc}"
+            logger.error(error_message)
+            return [Data(text=error_message, data={"error": error_message})]
+
+        data_results: list[Data] = []
+        for result in search_results.get("results", []):
+            snippet = result.get("snippet", "") or ""
+            data_results.append(
+                Data(
+                    text=snippet,
+                    data={
+                        "title": result.get("title"),
+                        "url": result.get("url"),
+                        "snippet": snippet,
+                        "date": result.get("date"),
+                        "last_updated": result.get("last_updated"),
+                    },
+                )
+            )
+
+        if not data_results:
+            data_results.append(Data(text="No results found.", data={"results": []}))
+
+        self.status = data_results
+        return data_results
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        return DataFrame(self.fetch_content())