lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/cohere/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .cohere_embeddings import CohereEmbeddingsComponent
+    from .cohere_models import CohereComponent
+    from .cohere_rerank import CohereRerankComponent
+
+_dynamic_imports = {
+    "CohereComponent": "cohere_models",
+    "CohereEmbeddingsComponent": "cohere_embeddings",
+    "CohereRerankComponent": "cohere_rerank",
+}
+
+__all__ = [
+    "CohereComponent",
+    "CohereEmbeddingsComponent",
+    "CohereRerankComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import cohere components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/cohere/cohere_embeddings.py

@@ -0,0 +1,81 @@
+from typing import Any
+
+import cohere
+from langchain_cohere import CohereEmbeddings
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import Embeddings
+from lfx.io import DropdownInput, FloatInput, IntInput, MessageTextInput, Output, SecretStrInput
+
+HTTP_STATUS_OK = 200
+
+
+class CohereEmbeddingsComponent(LCModelComponent):
+    display_name = "Cohere Embeddings"
+    description = "Generate embeddings using Cohere models."
+    icon = "Cohere"
+    name = "CohereEmbeddings"
+
+    inputs = [
+        SecretStrInput(name="api_key", display_name="Cohere API Key", required=True, real_time_refresh=True),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            advanced=False,
+            options=[
+                "embed-english-v2.0",
+                "embed-multilingual-v2.0",
+                "embed-english-light-v2.0",
+                "embed-multilingual-light-v2.0",
+            ],
+            value="embed-english-v2.0",
+            refresh_button=True,
+            combobox=True,
+        ),
+        MessageTextInput(name="truncate", display_name="Truncate", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", value=3, advanced=True),
+        MessageTextInput(name="user_agent", display_name="User Agent", advanced=True, value="langchain"),
+        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        data = None
+        try:
+            data = CohereEmbeddings(
+                cohere_api_key=self.api_key,
+                model=self.model_name,
+                truncate=self.truncate,
+                max_retries=self.max_retries,
+                user_agent=self.user_agent,
+                request_timeout=self.request_timeout or None,
+            )
+        except Exception as e:
+            msg = (
+                "Unable to create Cohere Embeddings. ",
+                "Please verify the API key and model parameters, and try again.",
+            )
+            raise ValueError(msg) from e
+        # added status if not the return data would be serialised to create the status
+        return data
+
+    def get_model(self):
+        try:
+            co = cohere.ClientV2(self.api_key)
+            response = co.models.list(endpoint="embed")
+            models = response.models
+            return [model.name for model in models]
+        except Exception as e:
+            msg = f"Failed to fetch Cohere models. Error: {e}"
+            raise ValueError(msg) from e
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):
+        if field_name in {"model_name", "api_key"}:
+            if build_config.get("api_key", {}).get("value", None):
+                build_config["model_name"]["options"] = self.get_model()
+        else:
+            build_config["model_name"]["options"] = field_value
+        return build_config

lfx/components/cohere/cohere_models.py

@@ -0,0 +1,46 @@
+from langchain_cohere import ChatCohere
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import SecretStrInput, SliderInput
+
+
+class CohereComponent(LCModelComponent):
+    display_name = "Cohere Language Models"
+    description = "Generate text using Cohere LLMs."
+    documentation = "https://python.langchain.com/docs/integrations/llms/cohere/"
+    icon = "Cohere"
+    name = "CohereModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        SecretStrInput(
+            name="cohere_api_key",
+            display_name="Cohere API Key",
+            info="The Cohere API Key to use for the Cohere model.",
+            advanced=False,
+            value="COHERE_API_KEY",
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.75,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        cohere_api_key = self.cohere_api_key
+        temperature = self.temperature
+
+        api_key = SecretStr(cohere_api_key).get_secret_value() if cohere_api_key else None
+
+        return ChatCohere(
+            temperature=temperature or 0.75,
+            cohere_api_key=api_key,
+        )

lfx/components/cohere/cohere_rerank.py

@@ -0,0 +1,51 @@
+from lfx.base.compressors.model import LCCompressorComponent
+from lfx.field_typing import BaseDocumentCompressor
+from lfx.inputs.inputs import SecretStrInput
+from lfx.io import DropdownInput
+from lfx.template.field.base import Output
+
+
+class CohereRerankComponent(LCCompressorComponent):
+    display_name = "Cohere Rerank"
+    description = "Rerank documents using the Cohere API."
+    name = "CohereRerank"
+    icon = "Cohere"
+
+    inputs = [
+        *LCCompressorComponent.inputs,
+        SecretStrInput(
+            name="api_key",
+            display_name="Cohere API Key",
+        ),
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            options=[
+                "rerank-english-v3.0",
+                "rerank-multilingual-v3.0",
+                "rerank-english-v2.0",
+                "rerank-multilingual-v2.0",
+            ],
+            value="rerank-english-v3.0",
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Reranked Documents",
+            name="reranked_documents",
+            method="compress_documents",
+        ),
+    ]
+
+    def build_compressor(self) -> BaseDocumentCompressor:  # type: ignore[type-var]
+        try:
+            from langchain_cohere import CohereRerank
+        except ImportError as e:
+            msg = "Please install langchain-cohere to use the Cohere model."
+            raise ImportError(msg) from e
+        return CohereRerank(
+            cohere_api_key=self.api_key,
+            model=self.model,
+            top_n=self.top_n,
+        )

lfx/components/cometapi/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.cometapi.cometapi import CometAPIComponent
+
+_dynamic_imports = {
+    "CometAPIComponent": "cometapi",
+}
+
+__all__ = ["CometAPIComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import cometapi components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/cometapi/cometapi.py

@@ -0,0 +1,166 @@
+import json
+
+import requests
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+from typing_extensions import override
+
+from lfx.base.models.cometapi_constants import MODEL_NAMES
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    IntInput,
+    SecretStrInput,
+    SliderInput,
+    StrInput,
+)
+
+
+class CometAPIComponent(LCModelComponent):
+    """CometAPI component for language models."""
+
+    display_name = "CometAPI"
+    description = "All AI Models in One API 500+ AI Models"
+    icon = "CometAPI"
+    name = "CometAPIModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        SecretStrInput(
+            name="api_key",
+            display_name="CometAPI Key",
+            required=True,
+            info="Your CometAPI key",
+            real_time_refresh=True,
+        ),
+        StrInput(
+            name="app_name",
+            display_name="App Name",
+            info="Your app name for CometAPI rankings",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            info="The model to use for chat completion",
+            options=["Select a model"],
+            value="Select a model",
+            real_time_refresh=True,
+            required=True,
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            info="Additional keyword arguments to pass to the model.",
+            advanced=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.7,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
+            advanced=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            info="Maximum number of tokens to generate",
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="Seed for reproducible outputs.",
+            value=1,
+            advanced=True,
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            info="If enabled, the model will be asked to return a JSON object.",
+            advanced=True,
+        ),
+    ]
+
+    def get_models(self, token_override: str | None = None) -> list[str]:
+        base_url = "https://api.cometapi.com/v1"
+        url = f"{base_url}/models"
+
+        headers = {"Content-Type": "application/json"}
+        # Add Bearer Authorization when API key is available
+        api_key_source = token_override if token_override else getattr(self, "api_key", None)
+        if api_key_source:
+            token = api_key_source.get_secret_value() if isinstance(api_key_source, SecretStr) else str(api_key_source)
+            headers["Authorization"] = f"Bearer {token}"
+
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            # Safely parse JSON; fallback to defaults on failure
+            try:
+                model_list = response.json()
+            except (json.JSONDecodeError, ValueError) as e:
+                self.status = f"Error decoding models response: {e}"
+                return MODEL_NAMES
+            return [model["id"] for model in model_list.get("data", [])]
+        except requests.RequestException as e:
+            self.status = f"Error fetching models: {e}"
+            return MODEL_NAMES
+
+    @override
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        if field_name == "api_key":
+            models = self.get_models(field_value)
+            model_cfg = build_config.get("model_name", {})
+            # Preserve placeholder (fallback to existing value or a generic prompt)
+            placeholder = model_cfg.get("placeholder", model_cfg.get("value", "Select a model"))
+            current_value = model_cfg.get("value")
+
+            options = list(models) if models else []
+            # Ensure current value stays visible even if not present in fetched options
+            if current_value and current_value not in options:
+                options = [current_value, *options]
+
+            model_cfg["options"] = options
+            model_cfg["placeholder"] = placeholder
+            build_config["model_name"] = model_cfg
+        return build_config
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+        model_kwargs = getattr(self, "model_kwargs", {}) or {}
+        json_mode = self.json_mode
+        seed = self.seed
+        # Ensure a valid model was selected
+        if not model_name or model_name == "Select a model":
+            msg = "Please select a valid CometAPI model."
+            raise ValueError(msg)
+        try:
+            # Extract raw API key safely
+            _api_key = api_key.get_secret_value() if isinstance(api_key, SecretStr) else api_key
+            output = ChatOpenAI(
+                model=model_name,
+                api_key=_api_key or None,
+                max_tokens=max_tokens or None,
+                temperature=temperature,
+                model_kwargs=model_kwargs,
+                streaming=bool(self.stream),
+                seed=seed,
+                base_url="https://api.cometapi.com/v1",
+            )
+        except (TypeError, ValueError) as e:
+            msg = "Could not connect to CometAPI."
+            raise ValueError(msg) from e
+
+        if json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output

lfx/components/composio/__init__.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .agentql_composio import ComposioAgentQLAPIComponent
+    from .agiled_composio import ComposioAgiledAPIComponent
+    from .airtable_composio import ComposioAirtableAPIComponent
+    from .apollo_composio import ComposioApolloAPIComponent
+    from .asana_composio import ComposioAsanaAPIComponent
+    from .attio_composio import ComposioAttioAPIComponent
+    from .bitbucket_composio import ComposioBitbucketAPIComponent
+    from .bolna_composio import ComposioBolnaAPIComponent
+    from .brightdata_composio import ComposioBrightdataAPIComponent
+    from .calendly_composio import ComposioCalendlyAPIComponent
+    from .canva_composio import ComposioCanvaAPIComponent
+    from .canvas_composio import ComposioCanvasAPIComponent
+    from .coda_composio import ComposioCodaAPIComponent
+    from .composio_api import ComposioAPIComponent
+    from .contentful_composio import ComposioContentfulAPIComponent
+    from .digicert_composio import ComposioDigicertAPIComponent
+    from .discord_composio import ComposioDiscordAPIComponent
+    from .elevenlabs_composio import ComposioElevenLabsAPIComponent
+    from .exa_composio import ComposioExaAPIComponent
+    from .figma_composio import ComposioFigmaAPIComponent
+    from .finage_composio import ComposioFinageAPIComponent
+    from .firecrawl_composio import ComposioFirecrawlAPIComponent
+    from .fireflies_composio import ComposioFirefliesAPIComponent
+    from .fixer_composio import ComposioFixerAPIComponent
+    from .flexisign_composio import ComposioFlexisignAPIComponent
+    from .freshdesk_composio import ComposioFreshdeskAPIComponent
+    from .github_composio import ComposioGitHubAPIComponent
+    from .gmail_composio import ComposioGmailAPIComponent
+    from .googlebigquery_composio import ComposioGoogleBigQueryAPIComponent
+    from .googlecalendar_composio import ComposioGoogleCalendarAPIComponent
+    from .googleclassroom_composio import ComposioGoogleclassroomAPIComponent
+    from .googledocs_composio import ComposioGoogleDocsAPIComponent
+    from .googlemeet_composio import ComposioGooglemeetAPIComponent
+    from .googlesheets_composio import ComposioGoogleSheetsAPIComponent
+    from .googletasks_composio import ComposioGoogleTasksAPIComponent
+    from .heygen_composio import ComposioHeygenAPIComponent
+    from .instagram_composio import ComposioInstagramAPIComponent
+    from .jira_composio import ComposioJiraAPIComponent
+    from .jotform_composio import ComposioJotformAPIComponent
+    from .klaviyo_composio import ComposioKlaviyoAPIComponent
+    from .linear_composio import ComposioLinearAPIComponent
+    from .listennotes_composio import ComposioListennotesAPIComponent
+    from .mem0_composio import ComposioMem0APIComponent
+    from .miro_composio import ComposioMiroAPIComponent
+    from .missive_composio import ComposioMissiveAPIComponent
+    from .notion_composio import ComposioNotionAPIComponent
+    from .onedrive_composio import ComposioOneDriveAPIComponent
+    from .outlook_composio import ComposioOutlookAPIComponent
+    from .pandadoc_composio import ComposioPandadocAPIComponent
+    from .peopledatalabs_composio import ComposioPeopleDataLabsAPIComponent
+    from .perplexityai_composio import ComposioPerplexityAIAPIComponent
+    from .reddit_composio import ComposioRedditAPIComponent
+    from .serpapi_composio import ComposioSerpAPIComponent
+    from .slack_composio import ComposioSlackAPIComponent
+    from .slackbot_composio import ComposioSlackbotAPIComponent
+    from .snowflake_composio import ComposioSnowflakeAPIComponent
+    from .supabase_composio import ComposioSupabaseAPIComponent
+    from .tavily_composio import ComposioTavilyAPIComponent
+    from .timelinesai_composio import ComposioTimelinesAIAPIComponent
+    from .todoist_composio import ComposioTodoistAPIComponent
+    from .wrike_composio import ComposioWrikeAPIComponent
+    from .youtube_composio import ComposioYoutubeAPIComponent
+
+
+_dynamic_imports = {
+    "ComposioAPIComponent": "composio_api",
+    "ComposioCanvaAPIComponent": "canva_composio",
+    "ComposioCodaAPIComponent": "coda_composio",
+    "ComposioSlackAPIComponent": "slack_composio",
+    "ComposioRedditAPIComponent": "reddit_composio",
+    "ComposioSlackbotAPIComponent": "slackbot_composio",
+    "ComposioPeopleDataLabsAPIComponent": "peopledatalabs_composio",
+    "ComposioPerplexityAIAPIComponent": "perplexityai_composio",
+    "ComposioSupabaseAPIComponent": "supabase_composio",
+    "ComposioSerpAPIComponent": "serpapi_composio",
+    "ComposioSnowflakeAPIComponent": "snowflake_composio",
+    "ComposioTodoistAPIComponent": "todoist_composio",
+    "ComposioTavilyAPIComponent": "tavily_composio",
+    "ComposioYoutubeAPIComponent": "youtube_composio",
+    "ComposioAgentQLAPIComponent": "agentql_composio",
+    "ComposioAgiledAPIComponent": "agiled_composio",
+    "ComposioAirtableAPIComponent": "airtable_composio",
+    "ComposioApolloAPIComponent": "apollo_composio",
+    "ComposioAsanaAPIComponent": "asana_composio",
+    "ComposioAttioAPIComponent": "attio_composio",
+    "ComposioBitbucketAPIComponent": "bitbucket_composio",
+    "ComposioBolnaAPIComponent": "bolna_composio",
+    "ComposioBrightdataAPIComponent": "brightdata_composio",
+    "ComposioCalendlyAPIComponent": "calendly_composio",
+    "ComposioCanvasAPIComponent": "canvas_composio",
+    "ComposioContentfulAPIComponent": "contentful_composio",
+    "ComposioDigicertAPIComponent": "digicert_composio",
+    "ComposioDiscordAPIComponent": "discord_composio",
+    "ComposioElevenLabsAPIComponent": "elevenlabs_composio",
+    "ComposioExaAPIComponent": "exa_composio",
+    "ComposioFigmaAPIComponent": "figma_composio",
+    "ComposioFinageAPIComponent": "finage_composio",
+    "ComposioFirecrawlAPIComponent": "firecrawl_composio",
+    "ComposioFirefliesAPIComponent": "fireflies_composio",
+    "ComposioFixerAPIComponent": "fixer_composio",
+    "ComposioFlexisignAPIComponent": "flexisign_composio",
+    "ComposioFreshdeskAPIComponent": "freshdesk_composio",
+    "ComposioGitHubAPIComponent": "github_composio",
+    "ComposioGmailAPIComponent": "gmail_composio",
+    "ComposioGoogleBigQueryAPIComponent": "googlebigquery_composio",
+    "ComposioGoogleCalendarAPIComponent": "googlecalendar_composio",
+    "ComposioGoogleclassroomAPIComponent": "googleclassroom_composio",
+    "ComposioGoogleDocsAPIComponent": "googledocs_composio",
+    "ComposioGooglemeetAPIComponent": "googlemeet_composio",
+    "ComposioGoogleSheetsAPIComponent": "googlesheets_composio",
+    "ComposioGoogleTasksAPIComponent": "googletasks_composio",
+    "ComposioHeygenAPIComponent": "heygen_composio",
+    "ComposioInstagramAPIComponent": "instagram_composio",
+    "ComposioJiraAPIComponent": "jira_composio",
+    "ComposioJotformAPIComponent": "jotform_composio",
+    "ComposioKlaviyoAPIComponent": "klaviyo_composio",
+    "ComposioLinearAPIComponent": "linear_composio",
+    "ComposioListennotesAPIComponent": "listennotes_composio",
+    "ComposioMem0APIComponent": "mem0_composio",
+    "ComposioMiroAPIComponent": "miro_composio",
+    "ComposioMissiveAPIComponent": "missive_composio",
+    "ComposioNotionAPIComponent": "notion_composio",
+    "ComposioOneDriveAPIComponent": "onedrive_composio",
+    "ComposioOutlookAPIComponent": "outlook_composio",
+    "ComposioPandadocAPIComponent": "pandadoc_composio",
+    "ComposioTimelinesAIAPIComponent": "timelinesai_composio",
+    "ComposioWrikeAPIComponent": "wrike_composio",
+}
+
+# Always expose all components - individual failures will be handled on import
+__all__ = [
+    "ComposioAPIComponent",
+    "ComposioAgentQLAPIComponent",
+    "ComposioAgiledAPIComponent",
+    "ComposioAirtableAPIComponent",
+    "ComposioApolloAPIComponent",
+    "ComposioAsanaAPIComponent",
+    "ComposioAttioAPIComponent",
+    "ComposioBitbucketAPIComponent",
+    "ComposioBolnaAPIComponent",
+    "ComposioBrightdataAPIComponent",
+    "ComposioCalendlyAPIComponent",
+    "ComposioCalendlyAPIComponent",
+    "ComposioCanvaAPIComponent",
+    "ComposioCanvasAPIComponent",
+    "ComposioCodaAPIComponent",
+    "ComposioContentfulAPIComponent",
+    "ComposioDigicertAPIComponent",
+    "ComposioDiscordAPIComponent",
+    "ComposioElevenLabsAPIComponent",
+    "ComposioExaAPIComponent",
+    "ComposioFigmaAPIComponent",
+    "ComposioFinageAPIComponent",
+    "ComposioFirecrawlAPIComponent",
+    "ComposioFirefliesAPIComponent",
+    "ComposioFixerAPIComponent",
+    "ComposioFlexisignAPIComponent",
+    "ComposioFreshdeskAPIComponent",
+    "ComposioGitHubAPIComponent",
+    "ComposioGmailAPIComponent",
+    "ComposioGoogleBigQueryAPIComponent",
+    "ComposioGoogleCalendarAPIComponent",
+    "ComposioGoogleDocsAPIComponent",
+    "ComposioGoogleSheetsAPIComponent",
+    "ComposioGoogleTasksAPIComponent",
+    "ComposioGoogleclassroomAPIComponent",
+    "ComposioGooglemeetAPIComponent",
+    "ComposioHeygenAPIComponent",
+    "ComposioInstagramAPIComponent",
+    "ComposioJiraAPIComponent",
+    "ComposioJotformAPIComponent",
+    "ComposioKlaviyoAPIComponent",
+    "ComposioKlaviyoAPIComponent",
+    "ComposioLinearAPIComponent",
+    "ComposioLinearAPIComponent",
+    "ComposioListennotesAPIComponent",
+    "ComposioMem0APIComponent",
+    "ComposioMiroAPIComponent",
+    "ComposioMissiveAPIComponent",
+    "ComposioNotionAPIComponent",
+    "ComposioOneDriveAPIComponent",
+    "ComposioOutlookAPIComponent",
+    "ComposioPandadocAPIComponent",
+    "ComposioPeopleDataLabsAPIComponent",
+    "ComposioPerplexityAIAPIComponent",
+    "ComposioRedditAPIComponent",
+    "ComposioSerpAPIComponent",
+    "ComposioSlackAPIComponent",
+    "ComposioSlackbotAPIComponent",
+    "ComposioSnowflakeAPIComponent",
+    "ComposioSupabaseAPIComponent",
+    "ComposioTavilyAPIComponent",
+    "ComposioTimelinesAIAPIComponent",
+    "ComposioTodoistAPIComponent",
+    "ComposioWrikeAPIComponent",
+    "ComposioYoutubeAPIComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import composio components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/composio/agentql_composio.py

@@ -0,0 +1,11 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioAgentQLAPIComponent(ComposioBaseComponent):
+    display_name: str = "AgentQL"
+    icon = "AgentQL"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "agentql"
+
+    def set_default_tools(self):
+        """Set the default tools for AgentQL component."""

lfx/components/composio/agiled_composio.py

@@ -0,0 +1,11 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioAgiledAPIComponent(ComposioBaseComponent):
+    display_name: str = "Agiled"
+    icon = "Agiled"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "agiled"
+
+    def set_default_tools(self):
+        """Set the default tools for Agiled component."""

lfx/components/composio/airtable_composio.py

@@ -0,0 +1,11 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioAirtableAPIComponent(ComposioBaseComponent):
+    display_name: str = "Airtable"
+    icon = "Airtable"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "airtable"
+
+    def set_default_tools(self):
+        """Set the default tools for Airtable component."""