lfx-keenable 0.1.0__tar.gz

lfx_keenable-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+dist/
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+*.pyc

lfx_keenable-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Keenable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lfx_keenable-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: lfx-keenable
+Version: 0.1.0
+Summary: Keenable web-search and page-fetch components as a standalone Langflow Extension Bundle.
+Project-URL: Homepage, https://keenable.ai
+Project-URL: Documentation, https://docs.keenable.ai
+Project-URL: Repository, https://github.com/keenableai/lfx-keenable
+Author-email: Keenable <hello@keenable.ai>
+License: MIT
+License-File: LICENSE
+Keywords: agents,bundle,extension,keenable,langflow,lfx,search,web-search
+Requires-Python: <3.15,>=3.10
+Requires-Dist: httpx<1.0,>=0.27
+Requires-Dist: lfx<2.0.0,>=1.10.0
+Description-Content-Type: text/markdown
+
+# lfx-keenable
+
+[Keenable](https://keenable.ai) web-search and page-fetch components for
+[Langflow](https://langflow.org), packaged as a standalone **Langflow Extension
+Bundle**. Two components ship in the `keenable` bundle group:
+
+- **Keenable Search** — web search built for AI agents.
+- **Keenable Fetch** — fetch a page and return its main content as markdown.
+
+Both are **keyless by default**: with no API key they call Keenable's public
+endpoints; provide a key to use the authenticated endpoints (required for
+`mode="realtime"` and for higher rate limits).
+
+## Install
+
+```bash
+pip install lfx-keenable
+```
+
+The bundle registers automatically via the `langflow.extensions` entry-point.
+Restart your Langflow server; the components appear in the palette under the
+**keenable** group, and work as agent tools (the query / URL inputs are
+tool-enabled).
+
+## Configuration
+
+- **API key (optional).** Set it on the component, or via the `KEENABLE_API_KEY`
+  environment variable. Blank → the keyless public endpoint is used.
+- **Endpoint (optional).** `KEENABLE_API_URL` overrides the base URL (HTTPS
+  enforced; plain `http` only for loopback). The base URL is never a
+  component/LLM-settable input — that would be an SSRF foothold.
+
+## Components
+
+### Keenable Search
+
+`query` plus optional per-query filters — `site`, `mode` (`pro` | `realtime`),
+and publication / index date bounds (`published_after`/`before`,
+`acquired_after`/`before`). Returns a table of results
+(`title`, `url`, `description`, `published_at`, `acquired_at`). There is no
+`max_results` input — the API returns a fixed-size result set as-is.
+
+### Keenable Fetch
+
+`url` → the page's main content as markdown plus metadata (`title`,
+`description`, `author`, `published_at` when available). Rejects non-`http(s)`
+schemes and private/internal hosts client-side before sending.
+
+## Develop
+
+```bash
+cd lfx-keenable
+pip install -e .
+lfx extension validate .
+pytest                       # unit tests (offline; transport mocked)
+```
+
+## License
+
+MIT © Keenable

lfx_keenable-0.1.0/README.md

@@ -0,0 +1,60 @@
+# lfx-keenable
+
+[Keenable](https://keenable.ai) web-search and page-fetch components for
+[Langflow](https://langflow.org), packaged as a standalone **Langflow Extension
+Bundle**. Two components ship in the `keenable` bundle group:
+
+- **Keenable Search** — web search built for AI agents.
+- **Keenable Fetch** — fetch a page and return its main content as markdown.
+
+Both are **keyless by default**: with no API key they call Keenable's public
+endpoints; provide a key to use the authenticated endpoints (required for
+`mode="realtime"` and for higher rate limits).
+
+## Install
+
+```bash
+pip install lfx-keenable
+```
+
+The bundle registers automatically via the `langflow.extensions` entry-point.
+Restart your Langflow server; the components appear in the palette under the
+**keenable** group, and work as agent tools (the query / URL inputs are
+tool-enabled).
+
+## Configuration
+
+- **API key (optional).** Set it on the component, or via the `KEENABLE_API_KEY`
+  environment variable. Blank → the keyless public endpoint is used.
+- **Endpoint (optional).** `KEENABLE_API_URL` overrides the base URL (HTTPS
+  enforced; plain `http` only for loopback). The base URL is never a
+  component/LLM-settable input — that would be an SSRF foothold.
+
+## Components
+
+### Keenable Search
+
+`query` plus optional per-query filters — `site`, `mode` (`pro` | `realtime`),
+and publication / index date bounds (`published_after`/`before`,
+`acquired_after`/`before`). Returns a table of results
+(`title`, `url`, `description`, `published_at`, `acquired_at`). There is no
+`max_results` input — the API returns a fixed-size result set as-is.
+
+### Keenable Fetch
+
+`url` → the page's main content as markdown plus metadata (`title`,
+`description`, `author`, `published_at` when available). Rejects non-`http(s)`
+schemes and private/internal hosts client-side before sending.
+
+## Develop
+
+```bash
+cd lfx-keenable
+pip install -e .
+lfx extension validate .
+pytest                       # unit tests (offline; transport mocked)
+```
+
+## License
+
+MIT © Keenable

lfx_keenable-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "lfx-keenable"
+version = "0.1.0"
+description = "Keenable web-search and page-fetch components as a standalone Langflow Extension Bundle."
+readme = "README.md"
+requires-python = ">=3.10,<3.15"
+license = { text = "MIT" }
+authors = [
+    { name = "Keenable", email = "hello@keenable.ai" },
+]
+keywords = ["langflow", "lfx", "extension", "bundle", "keenable", "search", "web-search", "agents"]
+
+# Runtime deps: lfx (the BUNDLE_API surface) plus httpx for the HTTP transport.
+# httpx is already an lfx dependency, but we list it as a direct runtime dep so
+# the bundle keeps building even if lfx changes its transitive deps later.
+dependencies = [
+    "lfx>=1.10.0,<2.0.0",
+    "httpx>=0.27,<1.0",
+]
+
+[project.urls]
+Homepage = "https://keenable.ai"
+Documentation = "https://docs.keenable.ai"
+Repository = "https://github.com/keenableai/lfx-keenable"
+
+# Manifest-shipping distributions are discovered via the ``langflow.extensions``
+# entry-point. The value is the dotted path to the package containing
+# ``extension.json``; the loader walks ``importlib.metadata.files()`` from there
+# to find the manifest.
+[project.entry-points."langflow.extensions"]
+lfx-keenable = "lfx_keenable"
+
+[dependency-groups]
+test = [
+    "pytest>=8.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+# extension.json + components live inside the lfx_keenable package so
+# ``importlib.metadata.files(dist)`` finds them and the loader resolves
+# bundles[].path relative to the manifest's directory.
+packages = ["src/lfx_keenable"]
+include = ["src/lfx_keenable/extension.json", "src/lfx_keenable/components/**/*.py"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/lfx_keenable",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+]

lfx_keenable-0.1.0/src/lfx_keenable/__init__.py

@@ -0,0 +1,16 @@
+"""lfx-keenable: Keenable Search + Fetch bundle for Langflow.
+
+This package is the distribution unit ``lfx-keenable``. At runtime Langflow's
+loader discovers ``extension.json`` shipped alongside this ``__init__.py`` and
+registers the components under the namespaced IDs
+``ext:keenable:KeenableSearchComponent@official`` and
+``ext:keenable:KeenableFetchComponent@official``.
+
+Both components are keyless by default — they call Keenable's public endpoints
+with no API key, and use the authenticated endpoints when a key is configured.
+"""
+
+from lfx_keenable.components.keenable.keenable_fetch import KeenableFetchComponent
+from lfx_keenable.components.keenable.keenable_search import KeenableSearchComponent
+
+__all__ = ["KeenableFetchComponent", "KeenableSearchComponent"]

lfx_keenable-0.1.0/src/lfx_keenable/components/keenable/__init__.py

@@ -0,0 +1,4 @@
+from .keenable_fetch import KeenableFetchComponent
+from .keenable_search import KeenableSearchComponent
+
+__all__ = ["KeenableFetchComponent", "KeenableSearchComponent"]

lfx_keenable-0.1.0/src/lfx_keenable/components/keenable/_client.py

@@ -0,0 +1,183 @@
+"""Shared transport for the Keenable Langflow components.
+
+One place for the parts of the Keenable contract that both the search and the
+fetch component need: keyed-vs-keyless endpoint selection, the attribution
+headers, HTTPS-only base-URL resolution, the client-side SSRF guard, and turning
+a non-2xx response into a single, readable error string. The components import
+these helpers; this module itself defines no ``Component`` subclass, so the
+bundle loader ignores it for discovery.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import os
+from importlib import metadata
+from typing import Any
+from urllib.parse import urlsplit
+
+import httpx
+
+try:
+    _VERSION = metadata.version("lfx-keenable")
+except metadata.PackageNotFoundError:  # pragma: no cover - editable/source checkout
+    _VERSION = "unknown"
+
+# Tagged User-Agent so Keenable can attribute traffic from this integration.
+_USER_AGENT = f"keenable-langflow/{_VERSION}"
+
+# The load-bearing attribution signal: the Keenable backend segments traffic by
+# this header (adoption dashboards). The User-Agent above is a secondary tag.
+_ATTRIBUTION_TITLE = "Langflow"
+
+# Endpoint comes from the environment, never from a component/LLM-settable input
+# (an arbitrary base URL would be an SSRF foothold).
+_DEFAULT_BASE_URL = "https://api.keenable.ai"
+_BASE_URL_ENV = "KEENABLE_API_URL"
+
+
+class KeenableError(Exception):
+    """A Keenable transport/API error, carrying a message safe to show a user."""
+
+
+def resolve_base_url() -> str:
+    """Resolve the API base URL from ``KEENABLE_API_URL`` and enforce HTTPS."""
+    base = (os.environ.get(_BASE_URL_ENV) or _DEFAULT_BASE_URL).rstrip("/")
+    parsed = urlsplit(base)
+    # A usable absolute URL needs a host; bail out clearly on e.g. "https://"
+    # rather than letting a malformed base produce a broken request URL later.
+    if parsed.hostname:
+        if parsed.scheme == "https":
+            return base
+        # Permit plain http only for local development against a loopback host.
+        if parsed.scheme == "http" and parsed.hostname in {"localhost", "127.0.0.1", "::1"}:
+            return base
+    msg = f"{_BASE_URL_ENV} must be an https:// URL with a host, got {base!r}"
+    raise KeenableError(msg)
+
+
+def reject_private_fetch_target(url: str) -> None:
+    """Refuse obviously private/internal fetch targets before sending (SSRF).
+
+    The backend enforces this server-side too, but a client-side guard avoids
+    leaking an internal hostname in a request and is required by our integration
+    contract. Hostnames that are not IP literals are passed through — the
+    backend's SSRF guard is the backstop for those.
+    """
+    host = (urlsplit(url).hostname or "").strip().lower()
+    if not host:
+        msg = f"Refusing to fetch a URL with no host: {url!r}"
+        raise KeenableError(msg)
+    if host in {"localhost", "metadata.google.internal"}:
+        msg = f"Refusing to fetch a private/internal host: {host!r}"
+        raise KeenableError(msg)
+    try:
+        ip = ipaddress.ip_address(host)
+    except ValueError:
+        return
+    if (
+        ip.is_loopback
+        or ip.is_private
+        or ip.is_link_local
+        or ip.is_reserved
+        or ip.is_multicast
+        or ip.is_unspecified
+    ):
+        msg = f"Refusing to fetch a private/internal address: {host!r}"
+        raise KeenableError(msg)
+
+
+def _headers(api_key: str | None) -> dict[str, str]:
+    headers = {"User-Agent": _USER_AGENT, "X-Keenable-Title": _ATTRIBUTION_TITLE}
+    if api_key:
+        headers["X-API-Key"] = api_key
+    return headers
+
+
+def _select_path(api_key: str | None, public_path: str, keyed_path: str) -> str:
+    return keyed_path if api_key else public_path
+
+
+def _raise_for_status(response: httpx.Response) -> None:
+    """Map a non-2xx Keenable response to a readable :class:`KeenableError`."""
+    if response.is_success:
+        return
+    detail = ""
+    try:
+        body = response.json()
+        if isinstance(body, dict):
+            detail = str(body.get("message") or body.get("error") or body.get("detail") or "")
+    except ValueError:
+        detail = (response.text or "").strip()
+    label = {
+        401: "Keenable authentication failed (401)",
+        402: "Keenable: insufficient credits (402)",
+        429: "Keenable rate limit exceeded (429)",
+    }.get(response.status_code, f"Keenable API error ({response.status_code})")
+    raise KeenableError(f"{label}: {detail}" if detail else label)
+
+
+def _decode(response: httpx.Response) -> dict[str, Any]:
+    _raise_for_status(response)
+    try:
+        data = response.json()
+    except ValueError as e:
+        snippet = (response.text or "")[:200]
+        msg = f"Keenable API returned a non-JSON response: {snippet!r}"
+        raise KeenableError(msg) from e
+    if not isinstance(data, dict):
+        msg = f"Unexpected response from the Keenable API: {data!r}"
+        raise KeenableError(msg)
+    return data
+
+
+def keenable_post(
+    public_path: str,
+    keyed_path: str,
+    payload: dict[str, Any],
+    api_key: str | None,
+    timeout: float,
+) -> dict[str, Any]:
+    """POST ``payload`` to the keyed or keyless endpoint and return the body."""
+    path = _select_path(api_key, public_path, keyed_path)
+    url = f"{resolve_base_url()}{path}"
+    headers = {**_headers(api_key), "Content-Type": "application/json"}
+    try:
+        with httpx.Client(timeout=timeout) as client:
+            response = client.post(url, json=payload, headers=headers)
+    except httpx.RequestError as e:
+        msg = f"Could not reach the Keenable API: {e!r}"
+        raise KeenableError(msg) from e
+    return _decode(response)
+
+
+def keenable_get(
+    public_path: str,
+    keyed_path: str,
+    params: dict[str, Any],
+    api_key: str | None,
+    timeout: float,
+) -> dict[str, Any]:
+    """GET the keyed or keyless endpoint with query ``params``; return the body."""
+    path = _select_path(api_key, public_path, keyed_path)
+    url = f"{resolve_base_url()}{path}"
+    try:
+        with httpx.Client(timeout=timeout) as client:
+            response = client.get(url, params=params, headers=_headers(api_key))
+    except httpx.RequestError as e:
+        msg = f"Could not reach the Keenable API: {e!r}"
+        raise KeenableError(msg) from e
+    return _decode(response)
+
+
+def resolve_api_key(raw: Any) -> str | None:
+    """The non-blank component key, else ``KEENABLE_API_KEY``, else ``None``.
+
+    Langflow resolves a ``SecretStrInput`` to a plain string at runtime; an
+    empty/whitespace value means "no key", in which case we fall back to the
+    environment and finally to the keyless public endpoints.
+    """
+    key = raw.strip() if isinstance(raw, str) else ""
+    if not key:
+        key = (os.environ.get("KEENABLE_API_KEY") or "").strip()
+    return key or None

lfx_keenable-0.1.0/src/lfx_keenable/components/keenable/keenable_fetch.py

@@ -0,0 +1,92 @@
+"""Keenable page-fetch component for Langflow."""
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import FloatInput, MessageTextInput, Output, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+from lfx_keenable.components.keenable._client import (
+    KeenableError,
+    keenable_get,
+    reject_private_fetch_target,
+    resolve_api_key,
+)
+
+
+class KeenableFetchComponent(Component):
+    """Fetch a web page via Keenable and return its main content as markdown.
+
+    The companion to :class:`KeenableSearchComponent`: give it a URL (e.g. one
+    found via search) and it returns ``{url, title, content, ...}``. Keyless by
+    default; rejects non-http(s) and private/internal URLs before sending.
+    """
+
+    display_name = "Keenable Fetch"
+    description = "Fetch a web page via Keenable and return its content as markdown. Keyless by default."
+    documentation = "https://github.com/keenableai/lfx-keenable"
+    icon = "Keenable"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="Keenable API Key",
+            required=False,
+            info=(
+                "Optional. With no key the keyless public fetch endpoint is used. "
+                "Falls back to the KEENABLE_API_KEY environment variable."
+            ),
+        ),
+        MessageTextInput(
+            name="url",
+            display_name="URL",
+            info="The URL of the page to fetch and extract as markdown.",
+            required=True,
+            tool_mode=True,
+        ),
+        FloatInput(
+            name="timeout",
+            display_name="Timeout (s)",
+            info="Request timeout in seconds.",
+            value=30.0,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Page", name="dataframe", method="fetch"),
+    ]
+
+    def fetch_page(self) -> list[Data]:
+        """Fetch one page and return its extracted content as a single Data."""
+        try:
+            url = (self.url or "").strip()
+            if not url.lower().startswith(("http://", "https://")):
+                msg = f"Refusing to fetch a non-http(s) URL: {url!r}"
+                raise KeenableError(msg)
+            reject_private_fetch_target(url)
+
+            api_key = resolve_api_key(self.api_key)
+            data = keenable_get(
+                "/v1/fetch/public",
+                "/v1/fetch",
+                {"url": url},
+                api_key,
+                float(self.timeout or 30.0),
+            )
+            result = Data(text=data.get("content") or "", data=data)
+            self.status = result
+        except KeenableError as e:
+            logger.error(str(e))
+            error = Data(data={"error": str(e)})
+            self.status = error
+            return [error]
+        else:
+            return [result]
+
+    def fetch(self) -> DataFrame:
+        """Fetched page as a single-row DataFrame (the component's output)."""
+        return DataFrame(self.fetch_page())
+
+    def run_model(self) -> DataFrame:
+        return self.fetch()

lfx_keenable-0.1.0/src/lfx_keenable/components/keenable/keenable_search.py

@@ -0,0 +1,145 @@
+"""Keenable web-search component for Langflow."""
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import DropdownInput, FloatInput, MessageTextInput, Output, SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+from lfx_keenable.components.keenable._client import KeenableError, keenable_post, resolve_api_key
+
+
+class KeenableSearchComponent(Component):
+    """Query the Keenable web-search API built for AI agents.
+
+    Keyless by default: with no API key the keyless public endpoint
+    (``/v1/search/public``) is used. Provide an API key (or set
+    ``KEENABLE_API_KEY``) to use the authenticated endpoint — required for
+    ``mode="realtime"`` and for higher rate limits.
+    """
+
+    display_name = "Keenable Search"
+    description = "Web search built for AI agents, powered by Keenable. Keyless by default."
+    documentation = "https://github.com/keenableai/lfx-keenable"
+    icon = "Keenable"
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="Keenable API Key",
+            required=False,
+            info=(
+                "Optional. With no key the keyless public search endpoint is used. "
+                "Falls back to the KEENABLE_API_KEY environment variable. A key is "
+                "required for mode='realtime' and lifts rate limits."
+            ),
+        ),
+        MessageTextInput(
+            name="query",
+            display_name="Search Query",
+            info="The search query to run.",
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="site",
+            display_name="Site",
+            info="Restrict results to a single domain, e.g. 'github.com'.",
+            advanced=True,
+            tool_mode=True,
+        ),
+        DropdownInput(
+            name="mode",
+            display_name="Search Mode",
+            info=(
+                "'pro' (default, deeper retrieval) or 'realtime' (low latency). "
+                "'realtime' requires an API key — it is not available keyless."
+            ),
+            options=["pro", "realtime"],
+            value="pro",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="published_after",
+            display_name="Published After",
+            info="Only pages published on or after this date (YYYY-MM-DD).",
+            advanced=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="published_before",
+            display_name="Published Before",
+            info="Only pages published on or before this date (YYYY-MM-DD).",
+            advanced=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="acquired_after",
+            display_name="Indexed After",
+            info="Only pages indexed by Keenable on or after this date (YYYY-MM-DD).",
+            advanced=True,
+            tool_mode=True,
+        ),
+        MessageTextInput(
+            name="acquired_before",
+            display_name="Indexed Before",
+            info="Only pages indexed by Keenable on or before this date (YYYY-MM-DD).",
+            advanced=True,
+            tool_mode=True,
+        ),
+        FloatInput(
+            name="timeout",
+            display_name="Timeout (s)",
+            info="Request timeout in seconds.",
+            value=30.0,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Results", name="dataframe", method="search"),
+    ]
+
+    def fetch_results(self) -> list[Data]:
+        """Call the Keenable search API and return one Data per result."""
+        try:
+            api_key = resolve_api_key(self.api_key)
+            payload: dict = {"query": self.query, "mode": self.mode or "pro"}
+            for field in (
+                "site",
+                "published_after",
+                "published_before",
+                "acquired_after",
+                "acquired_before",
+            ):
+                value = getattr(self, field, None)
+                if value:
+                    payload[field] = value
+
+            data = keenable_post(
+                "/v1/search/public",
+                "/v1/search",
+                payload,
+                api_key,
+                float(self.timeout or 30.0),
+            )
+            results = data.get("results")
+            if not isinstance(results, list):
+                msg = f"Unexpected response from the Keenable search API: {data!r}"
+                raise KeenableError(msg)
+            # The API returns a fixed-size result set as-is (no max_results param).
+            out = [Data(text=(item.get("title") or item.get("url") or ""), data=item) for item in results]
+            self.status = out
+        except KeenableError as e:
+            logger.error(str(e))
+            error = Data(data={"error": str(e)})
+            self.status = error
+            return [error]
+        else:
+            return out
+
+    def search(self) -> DataFrame:
+        """Search results as a DataFrame (the component's table output)."""
+        return DataFrame(self.fetch_results())
+
+    def run_model(self) -> DataFrame:
+        return self.search()

lfx_keenable-0.1.0/src/lfx_keenable/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-keenable",
+  "version": "0.1.0",
+  "name": "Keenable Search",
+  "description": "Keenable web-search and page-fetch components as a standalone Langflow Extension Bundle. Keyless by default.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "keenable",
+      "path": "components/keenable"
+    }
+  ]
+}