lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev0__py3-none-any.whl

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

@@ -35,13 +35,33 @@ HTTP_INTERNAL_SERVER_ERROR = 500
 HTTP_UNAUTHORIZED = 401
 HTTP_FORBIDDEN = 403
 
-# MCP Session Manager constants
-settings = get_settings_service().settings
-MAX_SESSIONS_PER_SERVER = (
-    settings.mcp_max_sessions_per_server
-)  # Maximum number of sessions per server to prevent resource exhaustion
-SESSION_IDLE_TIMEOUT = settings.mcp_session_idle_timeout  # 5 minutes idle timeout for sessions
-SESSION_CLEANUP_INTERVAL = settings.mcp_session_cleanup_interval  # Cleanup interval in seconds
+# MCP Session Manager constants - lazy loaded
+_mcp_settings_cache: dict[str, Any] = {}
+
+
+def _get_mcp_setting(key: str, default: Any = None) -> Any:
+    """Lazy load MCP settings from settings service."""
+    if key not in _mcp_settings_cache:
+        settings = get_settings_service().settings
+        _mcp_settings_cache[key] = getattr(settings, key, default)
+    return _mcp_settings_cache[key]
+
+
+def get_max_sessions_per_server() -> int:
+    """Get maximum number of sessions per server to prevent resource exhaustion."""
+    return _get_mcp_setting("mcp_max_sessions_per_server")
+
+
+def get_session_idle_timeout() -> int:
+    """Get 5 minutes idle timeout for sessions."""
+    return _get_mcp_setting("mcp_session_idle_timeout")
+
+
+def get_session_cleanup_interval() -> int:
+    """Get cleanup interval in seconds."""
+    return _get_mcp_setting("mcp_session_cleanup_interval")
+
+
 # RFC 7230 compliant header name pattern: token = 1*tchar
 # tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
 #         "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
@@ -65,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.
 
@@ -432,7 +492,7 @@ class MCPSessionManager:
         """Periodically clean up idle sessions."""
         while True:
             try:
-                await asyncio.sleep(SESSION_CLEANUP_INTERVAL)
+                await asyncio.sleep(get_session_cleanup_interval())
                 await self._cleanup_idle_sessions()
             except asyncio.CancelledError:
                 break
@@ -450,7 +510,7 @@ class MCPSessionManager:
             sessions_to_remove = []
 
             for session_id, session_info in list(sessions.items()):
-                if current_time - session_info["last_used"] > SESSION_IDLE_TIMEOUT:
+                if current_time - session_info["last_used"] > get_session_idle_timeout():
                     sessions_to_remove.append(session_id)
 
             # Clean up idle sessions
@@ -573,7 +633,7 @@ class MCPSessionManager:
                 await self._cleanup_session_by_id(server_key, session_id)
 
         # Check if we've reached the maximum number of sessions for this server
-        if len(sessions) >= MAX_SESSIONS_PER_SERVER:
+        if len(sessions) >= get_max_sessions_per_server():
             # Remove the oldest session
             oldest_session_id = min(sessions.keys(), key=lambda x: sessions[x]["last_used"])
             await logger.ainfo(
@@ -675,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:
@@ -691,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
@@ -705,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:
@@ -745,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:
@@ -1196,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
@@ -1213,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
@@ -1238,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,
         )
 
@@ -1473,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/model_input_constants.py

@@ -14,14 +14,18 @@ class ModelProvidersDict(TypedDict):
     is_active: bool
 
 
-def get_filtered_inputs(component_class):
+def get_filtered_inputs(component_class, provider_name: str | None = None):
     base_input_names = {field.name for field in LCModelComponent.get_base_inputs()}
     component_instance = component_class()
 
-    return [process_inputs(input_) for input_ in component_instance.inputs if input_.name not in base_input_names]
+    return [
+        process_inputs(input_, provider_name)
+        for input_ in component_instance.inputs
+        if input_.name not in base_input_names
+    ]
 
 
-def process_inputs(component_data: Input):
+def process_inputs(component_data: Input, provider_name: str | None = None):
     """Processes and modifies an input configuration based on its type or name.
 
     Adjusts properties such as value, advanced status, real-time refresh, and additional information for specific
@@ -29,6 +33,7 @@ def process_inputs(component_data: Input):
 
     Args:
         component_data: The input configuration to process.
+        provider_name: The name of the provider to process the inputs for.
 
     Returns:
         The modified input configuration.
@@ -43,9 +48,11 @@ def process_inputs(component_data: Input):
         component_data.advanced = True
         component_data.value = True
     elif component_data.name in {"temperature", "base_url"}:
-        component_data = set_advanced_true(component_data)
+        if provider_name not in ["IBM watsonx.ai", "Ollama"]:
+            component_data = set_advanced_true(component_data)
     elif component_data.name == "model_name":
-        component_data = set_real_time_refresh_false(component_data)
+        if provider_name not in ["IBM watsonx.ai"]:
+            component_data = set_real_time_refresh_false(component_data)
         component_data = add_combobox_true(component_data)
         component_data = add_info(
             component_data,
@@ -79,6 +86,28 @@ def create_input_fields_dict(inputs: list[Input], prefix: str) -> dict[str, Inpu
     return {f"{prefix}{input_.name}": input_.to_dict() for input_ in inputs}
 
 
+def _get_ollama_inputs_and_fields():
+    try:
+        from lfx.components.ollama.ollama import ChatOllamaComponent
+
+        ollama_inputs = get_filtered_inputs(ChatOllamaComponent, provider_name="Ollama")
+    except ImportError as e:
+        msg = "Ollama is not installed. Please install it with `pip install langchain-ollama`."
+        raise ImportError(msg) from e
+    return ollama_inputs, create_input_fields_dict(ollama_inputs, "")
+
+
+def _get_watsonx_inputs_and_fields():
+    try:
+        from lfx.components.ibm.watsonx import WatsonxAIComponent
+
+        watsonx_inputs = get_filtered_inputs(WatsonxAIComponent, provider_name="IBM watsonx.ai")
+    except ImportError as e:
+        msg = "IBM watsonx.ai is not installed. Please install it with `pip install langchain-ibm-watsonx`."
+        raise ImportError(msg) from e
+    return watsonx_inputs, create_input_fields_dict(watsonx_inputs, "")
+
+
 def _get_google_generative_ai_inputs_and_fields():
     try:
         from lfx.components.google.google_generative_ai import GoogleGenerativeAIComponent
@@ -293,6 +322,36 @@ try:
 except ImportError:
     pass
 
+try:
+    from lfx.components.ibm.watsonx import WatsonxAIComponent
+
+    watsonx_inputs, watsonx_fields = _get_watsonx_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["IBM watsonx.ai"] = {
+        "fields": watsonx_fields,
+        "inputs": watsonx_inputs,
+        "prefix": "",
+        "component_class": WatsonxAIComponent(),
+        "icon": WatsonxAIComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
+try:
+    from lfx.components.ollama.ollama import ChatOllamaComponent
+
+    ollama_inputs, ollama_fields = _get_ollama_inputs_and_fields()
+    MODEL_PROVIDERS_DICT["Ollama"] = {
+        "fields": ollama_fields,
+        "inputs": ollama_inputs,
+        "prefix": "",
+        "component_class": ChatOllamaComponent(),
+        "icon": ChatOllamaComponent.icon,
+        "is_active": True,
+    }
+except ImportError:
+    pass
+
 # Expose only active providers ----------------------------------------------
 ACTIVE_MODEL_PROVIDERS_DICT: dict[str, ModelProvidersDict] = {
     name: prov for name, prov in MODEL_PROVIDERS_DICT.items() if prov.get("is_active", True)
@@ -302,10 +361,18 @@ MODEL_PROVIDERS: list[str] = list(ACTIVE_MODEL_PROVIDERS_DICT.keys())
 
 ALL_PROVIDER_FIELDS: list[str] = [field for prov in ACTIVE_MODEL_PROVIDERS_DICT.values() for field in prov["fields"]]
 
-MODEL_DYNAMIC_UPDATE_FIELDS = ["api_key", "model", "tool_model_enabled", "base_url", "model_name"]
+MODEL_DYNAMIC_UPDATE_FIELDS = [
+    "api_key",
+    "model",
+    "tool_model_enabled",
+    "base_url",
+    "model_name",
+    "watsonx_endpoint",
+    "url",
+]
 
 MODELS_METADATA = {name: {"icon": prov["icon"]} for name, prov in ACTIVE_MODEL_PROVIDERS_DICT.items()}
 
-MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "OpenAI"]
+MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "OpenAI", "IBM watsonx.ai", "Ollama"]
 
 MODEL_OPTIONS_METADATA = [MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA]

lfx/base/models/ollama_constants.py

@@ -47,3 +47,6 @@ URL_LIST = [
     "http://127.0.0.1:11434",
     "http://0.0.0.0:11434",
 ]
+
+
+DEFAULT_OLLAMA_API_URL = "https://ollama.com"

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/__init__.py

@@ -6,6 +6,7 @@ from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
     from lfx.components.agents.agent import AgentComponent
+    from lfx.components.agents.altk_agent import ALTKAgentComponent
     from lfx.components.agents.cuga_agent import CugaComponent
     from lfx.components.agents.mcp_component import MCPToolsComponent
 
@@ -13,9 +14,10 @@ _dynamic_imports = {
     "AgentComponent": "agent",
     "CugaComponent": "cuga_agent",
     "MCPToolsComponent": "mcp_component",
+    "ALTKAgentComponent": "altk_agent",
 }
 
-__all__ = ["AgentComponent", "CugaComponent", "MCPToolsComponent"]
+__all__ = ["ALTKAgentComponent", "AgentComponent", "CugaComponent", "MCPToolsComponent"]
 
 
 def __getattr__(attr_name: str) -> Any:

lfx/components/agents/agent.py

@@ -20,8 +20,8 @@ from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComp
 from lfx.custom.custom_component.component import get_component_toolkit
 from lfx.custom.utils import update_component_build_config
 from lfx.helpers.base_model import build_model_from_schema
-from lfx.inputs.inputs import BoolInput
-from lfx.io import DropdownInput, IntInput, MultilineInput, Output, TableInput
+from lfx.inputs.inputs import BoolInput, SecretStrInput, StrInput
+from lfx.io import DropdownInput, IntInput, MessageTextInput, MultilineInput, Output, TableInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dotdict import dotdict
@@ -77,6 +77,32 @@ class AgentComponent(ToolCallingAgentComponent):
                 },
             },
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="The API key to use for the model.",
+            required=True,
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Base URL",
+            info="The base URL of the API.",
+            required=True,
+            show=False,
+        ),
+        StrInput(
+            name="project_id",
+            display_name="Project ID",
+            info="The project ID of the model.",
+            required=True,
+            show=False,
+        ),
+        IntInput(
+            name="max_output_tokens",
+            display_name="Max Output Tokens",
+            info="The maximum number of tokens to generate.",
+            show=False,
+        ),
         *openai_inputs_filtered,
         MultilineInput(
             name="system_prompt",
@@ -85,6 +111,13 @@ class AgentComponent(ToolCallingAgentComponent):
             value="You are a helpful assistant that can use tools to answer questions and perform tasks.",
             advanced=False,
         ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
         IntInput(
             name="n_messages",
             display_name="Number of Chat History Messages",
@@ -154,7 +187,7 @@ class AgentComponent(ToolCallingAgentComponent):
                 },
             ],
         ),
-        *LCToolsAgentComponent._base_inputs,
+        *LCToolsAgentComponent.get_base_inputs(),
         # removed memory inputs from agent component
         # *memory_inputs,
         BoolInput(
@@ -188,10 +221,15 @@ class AgentComponent(ToolCallingAgentComponent):
             if not isinstance(self.tools, list):  # type: ignore[has-type]
                 self.tools = []
             current_date_tool = (await CurrentDateComponent(**self.get_base_args()).to_toolkit()).pop(0)
+
             if not isinstance(current_date_tool, StructuredTool):
                 msg = "CurrentDateComponent must be converted to a StructuredTool"
                 raise TypeError(msg)
             self.tools.append(current_date_tool)
+
+        # Set shared callbacks for tracing the tools used by the agent
+        self.set_tools_callbacks(self.tools, self._get_shared_callbacks())
+
         return llm_model, self.chat_history, self.tools
 
     async def message_response(self) -> Message:
@@ -408,6 +446,7 @@ class AgentComponent(ToolCallingAgentComponent):
             await MemoryComponent(**self.get_base_args())
             .set(
                 session_id=self.graph.session_id,
+                context_id=self.context_id,
                 order="Ascending",
                 n_messages=self.n_messages,
             )
@@ -463,7 +502,8 @@ class AgentComponent(ToolCallingAgentComponent):
     def delete_fields(self, build_config: dotdict, fields: dict | list[str]) -> None:
         """Delete specified fields from build_config."""
         for field in fields:
-            build_config.pop(field, None)
+            if build_config is not None and field in build_config:
+                build_config.pop(field, None)
 
     def update_input_types(self, build_config: dotdict) -> dotdict:
         """Update input types for all fields in build_config."""
@@ -591,11 +631,14 @@ class AgentComponent(ToolCallingAgentComponent):
         agent_description = self.get_tool_description()
         # TODO: Agent Description Depreciated Feature to be removed
         description = f"{agent_description}{tools_names}"
+
         tools = component_toolkit(component=self).get_tools(
             tool_name="Call_Agent",
             tool_description=description,
+            # here we do not use the shared callbacks as we are exposing the agent as a tool
             callbacks=self.get_langchain_callbacks(),
         )
         if hasattr(self, "tools_metadata"):
             tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)
+
         return tools