lfx-nightly 0.1.13.dev3__py3-none-any.whl → 0.1.13.dev5__py3-none-any.whl

lfx/base/composio/composio_base.py

@@ -284,6 +284,21 @@ class ComposioBaseComponent(Component):
     # Track all auth field names discovered across all toolkits
     _all_auth_field_names: set[str] = set()
 
+    @classmethod
+    def get_actions_cache(cls) -> dict[str, dict[str, Any]]:
+        """Get the class-level actions cache."""
+        return cls._actions_cache
+
+    @classmethod
+    def get_action_schema_cache(cls) -> dict[str, dict[str, Any]]:
+        """Get the class-level action schema cache."""
+        return cls._action_schema_cache
+
+    @classmethod
+    def get_all_auth_field_names(cls) -> set[str]:
+        """Get all auth field names discovered across toolkits."""
+        return cls._all_auth_field_names
+
     outputs = [
         Output(name="dataFrame", display_name="DataFrame", method="as_dataframe"),
     ]
@@ -403,11 +418,11 @@ class ComposioBaseComponent(Component):
 
         # Try to load from the class-level cache
         toolkit_slug = self.app_name.lower()
-        if toolkit_slug in self.__class__._actions_cache:
+        if toolkit_slug in self.__class__.get_actions_cache():
             # Deep-copy so that any mutation on this instance does not affect the
             # cached master copy.
-            self._actions_data = copy.deepcopy(self.__class__._actions_cache[toolkit_slug])
-            self._action_schemas = copy.deepcopy(self.__class__._action_schema_cache.get(toolkit_slug, {}))
+            self._actions_data = copy.deepcopy(self.__class__.get_actions_cache()[toolkit_slug])
+            self._action_schemas = copy.deepcopy(self.__class__.get_action_schema_cache().get(toolkit_slug, {}))
             logger.debug(f"Loaded actions for {toolkit_slug} from in-process cache")
             return
 
@@ -630,8 +645,8 @@ class ComposioBaseComponent(Component):
 
             # Cache actions for this toolkit so subsequent component instances
             # can reuse them without hitting the Composio API again.
-            self.__class__._actions_cache[toolkit_slug] = copy.deepcopy(self._actions_data)
-            self.__class__._action_schema_cache[toolkit_slug] = copy.deepcopy(self._action_schemas)
+            self.__class__.get_actions_cache()[toolkit_slug] = copy.deepcopy(self._actions_data)
+            self.__class__.get_action_schema_cache()[toolkit_slug] = copy.deepcopy(self._action_schemas)
 
         except ValueError as e:
             logger.debug(f"Could not populate Composio actions for {self.app_name}: {e}")
@@ -1313,7 +1328,7 @@ class ComposioBaseComponent(Component):
 
         self._auth_dynamic_fields.add(name)
         # Also add to class-level cache for better tracking
-        self.__class__._all_auth_field_names.add(name)
+        self.__class__.get_all_auth_field_names().add(name)
 
     def _render_custom_auth_fields(self, build_config: dict, schema: dict[str, Any], mode: str) -> None:
         """Render fields for custom auth based on schema auth_config_details sections."""
@@ -1378,7 +1393,7 @@ class ComposioBaseComponent(Component):
                         if name:
                             names.add(name)
                             # Add to class-level cache for tracking all discovered auth fields
-                            self.__class__._all_auth_field_names.add(name)
+                            self.__class__.get_all_auth_field_names().add(name)
         # Only use names discovered from the toolkit schema; do not add aliases
         return names
 
@@ -1443,7 +1458,7 @@ class ComposioBaseComponent(Component):
         # Check if we need to populate actions - but also check cache availability
         actions_available = bool(self._actions_data)
         toolkit_slug = getattr(self, "app_name", "").lower()
-        cached_actions_available = toolkit_slug in self.__class__._actions_cache
+        cached_actions_available = toolkit_slug in self.__class__.get_actions_cache()
 
         should_populate = False
 
@@ -2623,7 +2638,7 @@ class ComposioBaseComponent(Component):
         # Add all dynamic auth fields to protected set
         protected.update(self._auth_dynamic_fields)
         # Also protect any auth fields discovered across all instances
-        protected.update(self.__class__._all_auth_field_names)
+        protected.update(self.__class__.get_all_auth_field_names())
 
         for key, cfg in list(build_config.items()):
             if key in protected:

lfx/base/datastax/astradb_base.py

@@ -14,6 +14,7 @@ from lfx.io import (
     SecretStrInput,
     StrInput,
 )
+from lfx.log.logger import logger
 
 
 class AstraDBBaseComponent(Component):
@@ -364,8 +365,8 @@ class AstraDBBaseComponent(Component):
                     "status": db.status if db.status != "ACTIVE" else None,
                     "org_id": db.org_id if db.org_id else None,
                 }
-            except Exception:  # noqa: BLE001
-                pass
+            except Exception as e:  # noqa: BLE001
+                logger.debug("Failed to get metadata for database %s: %s", db.name, e)
 
         return db_info_dict
 

lfx/base/io/chat.py

@@ -6,8 +6,9 @@ class ChatComponent(Component):
     description = "Use as base for chat components."
 
     def get_properties_from_source_component(self):
-        if hasattr(self, "_vertex") and hasattr(self._vertex, "incoming_edges") and self._vertex.incoming_edges:
-            source_id = self._vertex.incoming_edges[0].source_id
+        vertex = self.get_vertex()
+        if vertex and hasattr(vertex, "incoming_edges") and vertex.incoming_edges:
+            source_id = vertex.incoming_edges[0].source_id
             source_vertex = self.graph.get_vertex(source_id)
             component = source_vertex.custom_component
             source = component.display_name
@@ -15,6 +16,6 @@ class ChatComponent(Component):
             possible_attributes = ["model_name", "model_id", "model"]
             for attribute in possible_attributes:
                 if hasattr(component, attribute) and getattr(component, attribute):
-                    return getattr(component, attribute), icon, source, component._id
-            return source, icon, component.display_name, component._id
+                    return getattr(component, attribute), icon, source, component.get_id()
+            return source, icon, component.display_name, component.get_id()
         return None, None, None, None

lfx/base/mcp/util.py

@@ -85,6 +85,46 @@ ALLOWED_HEADERS = {
 }
 
 
+def create_mcp_http_client_with_ssl_option(
+    headers: dict[str, str] | None = None,
+    timeout: httpx.Timeout | None = None,
+    auth: httpx.Auth | None = None,
+    *,
+    verify_ssl: bool = True,
+) -> httpx.AsyncClient:
+    """Create an httpx AsyncClient with configurable SSL verification.
+
+    This is a custom factory that extends the standard MCP client factory
+    to support disabling SSL verification for self-signed certificates.
+
+    Args:
+        headers: Optional headers to include with all requests.
+        timeout: Request timeout as httpx.Timeout object.
+        auth: Optional authentication handler.
+        verify_ssl: Whether to verify SSL certificates (default: True).
+
+    Returns:
+        Configured httpx.AsyncClient instance.
+    """
+    kwargs: dict[str, Any] = {
+        "follow_redirects": True,
+        "verify": verify_ssl,
+    }
+
+    if timeout is None:
+        kwargs["timeout"] = httpx.Timeout(30.0)
+    else:
+        kwargs["timeout"] = timeout
+
+    if headers is not None:
+        kwargs["headers"] = headers
+
+    if auth is not None:
+        kwargs["auth"] = auth
+
+    return httpx.AsyncClient(**kwargs)
+
+
 def validate_headers(headers: dict[str, str]) -> dict[str, str]:
     """Validate and sanitize HTTP headers according to RFC 7230.
 
@@ -695,7 +735,7 @@ class MCPSessionManager:
 
         Args:
             session_id: Unique identifier for this session
-            connection_params: Connection parameters including URL, headers, timeouts
+            connection_params: Connection parameters including URL, headers, timeouts, verify_ssl
             preferred_transport: If set to "sse", skip Streamable HTTP and go directly to SSE
 
         Returns:
@@ -711,6 +751,19 @@ class MCPSessionManager:
         # Track which transport succeeded
         used_transport: list[str] = []
 
+        # Get verify_ssl option from connection params, default to True
+        verify_ssl = connection_params.get("verify_ssl", True)
+
+        # Create custom httpx client factory with SSL verification option
+        def custom_httpx_factory(
+            headers: dict[str, str] | None = None,
+            timeout: httpx.Timeout | None = None,
+            auth: httpx.Auth | None = None,
+        ) -> httpx.AsyncClient:
+            return create_mcp_http_client_with_ssl_option(
+                headers=headers, timeout=timeout, auth=auth, verify_ssl=verify_ssl
+            )
+
         async def session_task():
             """Background task that keeps the session alive."""
             streamable_error = None
@@ -725,6 +778,7 @@ class MCPSessionManager:
                         url=connection_params["url"],
                         headers=connection_params["headers"],
                         timeout=connection_params["timeout_seconds"],
+                        httpx_client_factory=custom_httpx_factory,
                     ) as (read, write, _):
                         session = ClientSession(read, write)
                         async with session:
@@ -765,6 +819,7 @@ class MCPSessionManager:
                         connection_params["headers"],
                         connection_params["timeout_seconds"],
                         sse_read_timeout,
+                        httpx_client_factory=custom_httpx_factory,
                     ) as (read, write):
                         session = ClientSession(read, write)
                         async with session:
@@ -1216,6 +1271,8 @@ class MCPStreamableHttpClient:
         headers: dict[str, str] | None = None,
         timeout_seconds: int = 30,
         sse_read_timeout_seconds: int = 30,
+        *,
+        verify_ssl: bool = True,
     ) -> list[StructuredTool]:
         """Connect to MCP server using Streamable HTTP transport with SSE fallback (SDK style)."""
         # Validate and sanitize headers early
@@ -1233,12 +1290,13 @@ class MCPStreamableHttpClient:
                 msg = f"Invalid Streamable HTTP or SSE URL ({url}): {error_msg}"
                 raise ValueError(msg)
             # Store connection parameters for later use in run_tool
-            # Include SSE read timeout for fallback
+            # Include SSE read timeout for fallback and SSL verification option
             self._connection_params = {
                 "url": url,
                 "headers": validated_headers,
                 "timeout_seconds": timeout_seconds,
                 "sse_read_timeout_seconds": sse_read_timeout_seconds,
+                "verify_ssl": verify_ssl,
             }
         elif headers:
             self._connection_params["headers"] = validated_headers
@@ -1258,11 +1316,18 @@ class MCPStreamableHttpClient:
         return response.tools
 
     async def connect_to_server(
-        self, url: str, headers: dict[str, str] | None = None, sse_read_timeout_seconds: int = 30
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        sse_read_timeout_seconds: int = 30,
+        *,
+        verify_ssl: bool = True,
     ) -> list[StructuredTool]:
         """Connect to MCP server using Streamable HTTP with SSE fallback transport (SDK style)."""
         return await asyncio.wait_for(
-            self._connect_to_server(url, headers, sse_read_timeout_seconds=sse_read_timeout_seconds),
+            self._connect_to_server(
+                url, headers, sse_read_timeout_seconds=sse_read_timeout_seconds, verify_ssl=verify_ssl
+            ),
             timeout=get_settings_service().settings.mcp_server_timeout,
         )
 
@@ -1493,7 +1558,8 @@ async def update_tools(
         client = mcp_stdio_client
     elif mode in ["Streamable_HTTP", "SSE"]:
         # Streamable HTTP connection with SSE fallback
-        tools = await mcp_streamable_http_client.connect_to_server(url, headers=headers)
+        verify_ssl = server_config.get("verify_ssl", True)
+        tools = await mcp_streamable_http_client.connect_to_server(url, headers=headers, verify_ssl=verify_ssl)
         client = mcp_streamable_http_client
     else:
         logger.error(f"Invalid MCP server mode for '{server_name}': {mode}")

lfx/base/models/watsonx_constants.py

@@ -0,0 +1,12 @@
+from .model_metadata import create_model_metadata
+
+# Granite Embedding models
+WATSONX_EMBEDDING_MODELS_DETAILED = [
+    create_model_metadata(provider="IBM Watsonx", name="ibm/granite-embedding-125m-english", icon="IBMWatsonx"),
+    create_model_metadata(provider="IBM Watsonx", name="ibm/granite-embedding-278m-multilingual", icon="IBMWatsonx"),
+    create_model_metadata(provider="IBM Watsonx", name="ibm/granite-embedding-30m-english", icon="IBMWatsonx"),
+    create_model_metadata(provider="IBM Watsonx", name="ibm/granite-embedding-107m-multilingual", icon="IBMWatsonx"),
+    create_model_metadata(provider="IBM Watsonx", name="ibm/granite-embedding-30m-sparse", icon="IBMWatsonx"),
+]
+
+WATSONX_EMBEDDING_MODEL_NAMES = [metadata["name"] for metadata in WATSONX_EMBEDDING_MODELS_DETAILED]

lfx/cli/commands.py

@@ -43,7 +43,7 @@ def serve_command(
     host: str = typer.Option("127.0.0.1", "--host", "-h", help="Host to bind the server to"),
     port: int = typer.Option(8000, "--port", "-p", help="Port to bind the server to"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show diagnostic output and execution details"),  # noqa: FBT001, FBT003
-    env_file: Path | None = typer.Option(  # noqa: B008
+    env_file: Path | None = typer.Option(
         None,
         "--env-file",
         help="Path to the .env file containing environment variables",

lfx/components/agents/agent.py

@@ -161,7 +161,7 @@ class AgentComponent(ToolCallingAgentComponent):
                 },
             ],
         ),
-        *LCToolsAgentComponent._base_inputs,
+        *LCToolsAgentComponent.get_base_inputs(),
         # removed memory inputs from agent component
         # *memory_inputs,
         BoolInput(

lfx/components/agents/cuga_agent.py

@@ -185,7 +185,7 @@ class CugaComponent(ToolCallingAgentComponent):
                 },
             ],
         ),
-        *LCToolsAgentComponent._base_inputs,
+        *LCToolsAgentComponent.get_base_inputs(),
         BoolInput(
             name="add_current_date_tool",
             display_name="Current Date",

lfx/components/agents/mcp_component.py

@@ -61,6 +61,7 @@ class MCPToolsComponent(ComponentWithCache):
         "mcp_server",
         "tool",
         "use_cache",
+        "verify_ssl",
     ]
 
     display_name = "MCP Tools"
@@ -86,6 +87,16 @@ class MCPToolsComponent(ComponentWithCache):
             value=False,
             advanced=True,
         ),
+        BoolInput(
+            name="verify_ssl",
+            display_name="Verify SSL Certificate",
+            info=(
+                "Enable SSL certificate verification for HTTPS connections. "
+                "Disable only for development/testing with self-signed certificates."
+            ),
+            value=True,
+            advanced=True,
+        ),
         DropdownInput(
             name="tool",
             display_name="Tool",
@@ -210,6 +221,11 @@ class MCPToolsComponent(ComponentWithCache):
                 self.tools = []
                 return [], {"name": server_name, "config": server_config}
 
+            # Add verify_ssl option to server config if not present
+            if "verify_ssl" not in server_config:
+                verify_ssl = getattr(self, "verify_ssl", True)
+                server_config["verify_ssl"] = verify_ssl
+
             _, tool_list, tool_cache = await update_tools(
                 server_name=server_name,
                 server_config=server_config,

lfx/components/amazon/amazon_bedrock_converse.py

@@ -16,7 +16,7 @@ class AmazonBedrockConverseComponent(LCModelComponent):
     beta = True
 
     inputs = [
-        *LCModelComponent._base_inputs,
+        *LCModelComponent.get_base_inputs(),
         DropdownInput(
             name="model_id",
             display_name="Model ID",

lfx/components/apify/apify_actor.py

@@ -92,7 +92,7 @@ class ApifyActorsComponent(Component):
         """Run the Actor and return node output."""
         input_ = json.loads(self.run_input)
         fields = ApifyActorsComponent.parse_dataset_fields(self.dataset_fields) if self.dataset_fields else None
-        res = self._run_actor(self.actor_id, input_, fields=fields)
+        res = self.run_actor(self.actor_id, input_, fields=fields)
         if self.flatten_dataset:
             res = [ApifyActorsComponent.flatten(item) for item in res]
         data = [Data(data=item) for item in res]
@@ -159,7 +159,7 @@ class ApifyActorsComponent(Component):
                 # retrieve if nested, just in case
                 input_dict = input_dict.get("run_input", input_dict)
 
-                res = parent._run_actor(actor_id, input_dict)
+                res = parent.run_actor(actor_id, input_dict)
                 return "\n\n".join([ApifyActorsComponent.dict_to_json_str(item) for item in res])
 
         return ApifyActorRun
@@ -256,7 +256,7 @@ class ApifyActorsComponent(Component):
         valid_chars = string.ascii_letters + string.digits + "_-"
         return "".join(char if char in valid_chars else "_" for char in actor_id)
 
-    def _run_actor(self, actor_id: str, run_input: dict, fields: list[str] | None = None) -> list[dict]:
+    def run_actor(self, actor_id: str, run_input: dict, fields: list[str] | None = None) -> list[dict]:
         """Run an Apify Actor and return the output dataset.
 
         Args:

lfx/components/datastax/astradb_vectorstore.py

@@ -227,7 +227,7 @@ class AstraDBVectorStoreComponent(AstraDBBaseComponent, LCVectorStoreComponent):
                 for provider in providers.reranking_providers.values()
                 for model in provider.models
             ]
-        except (AttributeError, KeyError) as e:
+        except Exception as e:  # noqa: BLE001
             self.log(f"Hybrid search not available: {e}")
             return {
                 "available": False,

lfx/components/mistral/mistral_embeddings.py

@@ -1,4 +1,4 @@
-from langchain_mistralai.embeddings import MistralAIEmbeddings
+from langchain_mistralai import MistralAIEmbeddings
 from pydantic.v1 import SecretStr
 
 from lfx.base.models.model import LCModelComponent

lfx/components/models/embedding_model.py

@@ -3,7 +3,9 @@ from typing import Any
 from langchain_openai import OpenAIEmbeddings
 
 from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.base.models.ollama_constants import OLLAMA_EMBEDDING_MODELS
 from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.base.models.watsonx_constants import WATSONX_EMBEDDING_MODEL_NAMES
 from lfx.field_typing import Embeddings
 from lfx.io import (
     BoolInput,
@@ -29,11 +31,11 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
         DropdownInput(
             name="provider",
             display_name="Model Provider",
-            options=["OpenAI"],
+            options=["OpenAI", "Ollama", "WatsonX"],
             value="OpenAI",
             info="Select the embedding model provider",
             real_time_refresh=True,
-            options_metadata=[{"icon": "OpenAI"}],
+            options_metadata=[{"icon": "OpenAI"}, {"icon": "Ollama"}, {"icon": "WatsonxAI"}],
         ),
         DropdownInput(
             name="model",
@@ -56,6 +58,13 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
             info="Base URL for the API. Leave empty for default.",
             advanced=True,
         ),
+        # Watson-specific inputs
+        MessageTextInput(
+            name="project_id",
+            display_name="Project ID",
+            info="Watson AI Project ID (required for WatsonX)",
+            show=False,
+        ),
         IntInput(
             name="dimensions",
             display_name="Dimensions",
@@ -102,13 +111,82 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 show_progress_bar=show_progress_bar,
                 model_kwargs=model_kwargs,
             )
+
+        if provider == "Ollama":
+            try:
+                from langchain_ollama import OllamaEmbeddings
+            except ImportError:
+                try:
+                    from langchain_community.embeddings import OllamaEmbeddings
+                except ImportError:
+                    msg = "Please install langchain-ollama: pip install langchain-ollama"
+                    raise ImportError(msg) from None
+
+            return OllamaEmbeddings(
+                model=model,
+                base_url=api_base or "http://localhost:11434",
+                **model_kwargs,
+            )
+
+        if provider == "WatsonX":
+            try:
+                from langchain_ibm import WatsonxEmbeddings
+            except ImportError:
+                msg = "Please install langchain-ibm: pip install langchain-ibm"
+                raise ImportError(msg) from None
+
+            if not api_key:
+                msg = "Watson AI API key is required when using WatsonX provider"
+                raise ValueError(msg)
+
+            project_id = self.project_id
+
+            if not project_id:
+                msg = "Project ID is required for WatsonX"
+                raise ValueError(msg)
+
+            params = {
+                "model_id": model,
+                "url": api_base or "https://us-south.ml.cloud.ibm.com",
+                "apikey": api_key,
+            }
+
+            params["project_id"] = project_id
+
+            return WatsonxEmbeddings(**params)
+
         msg = f"Unknown provider: {provider}"
         raise ValueError(msg)
 
     def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
-        if field_name == "provider" and field_value == "OpenAI":
-            build_config["model"]["options"] = OPENAI_EMBEDDING_MODEL_NAMES
-            build_config["model"]["value"] = OPENAI_EMBEDDING_MODEL_NAMES[0]
-            build_config["api_key"]["display_name"] = "OpenAI API Key"
-            build_config["api_base"]["display_name"] = "OpenAI API Base URL"
+        if field_name == "provider":
+            if field_value == "OpenAI":
+                build_config["model"]["options"] = OPENAI_EMBEDDING_MODEL_NAMES
+                build_config["model"]["value"] = OPENAI_EMBEDDING_MODEL_NAMES[0]
+                build_config["api_key"]["display_name"] = "OpenAI API Key"
+                build_config["api_key"]["required"] = True
+                build_config["api_key"]["show"] = True
+                build_config["api_base"]["display_name"] = "OpenAI API Base URL"
+                build_config["project_id"]["show"] = False
+
+            elif field_value == "Ollama":
+                build_config["model"]["options"] = OLLAMA_EMBEDDING_MODELS
+                build_config["model"]["value"] = OLLAMA_EMBEDDING_MODELS[0]
+                build_config["api_key"]["display_name"] = "API Key (Optional)"
+                build_config["api_key"]["required"] = False
+                build_config["api_key"]["show"] = False
+                build_config["api_base"]["display_name"] = "Ollama Base URL"
+                build_config["api_base"]["value"] = "http://localhost:11434"
+                build_config["project_id"]["show"] = False
+
+            elif field_value == "WatsonX":
+                build_config["model"]["options"] = WATSONX_EMBEDDING_MODEL_NAMES
+                build_config["model"]["value"] = WATSONX_EMBEDDING_MODEL_NAMES[0]
+                build_config["api_key"]["display_name"] = "Watson AI API Key"
+                build_config["api_key"]["required"] = True
+                build_config["api_key"]["show"] = True
+                build_config["api_base"]["display_name"] = "Watson AI URL"
+                build_config["api_base"]["value"] = "https://us-south.ml.cloud.ibm.com"
+                build_config["project_id"]["show"] = True
+
         return build_config