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

lfx/components/models_and_agents/language_model.py

@@ -0,0 +1,398 @@
+from typing import Any
+
+import requests
+from langchain_anthropic import ChatAnthropic
+from langchain_ibm import ChatWatsonx
+from langchain_ollama import ChatOllama
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.anthropic_constants import ANTHROPIC_MODELS
+from lfx.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
+from lfx.base.models.google_generative_ai_model import ChatGoogleGenerativeAIFixed
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.model_utils import get_ollama_models, is_valid_ollama_url
+from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, MessageTextInput, StrInput
+from lfx.io import DropdownInput, MessageInput, MultilineInput, SecretStrInput, SliderInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+from lfx.utils.util import transform_localhost_url
+
+# IBM watsonx.ai constants
+IBM_WATSONX_DEFAULT_MODELS = ["ibm/granite-3-2b-instruct", "ibm/granite-3-8b-instruct", "ibm/granite-13b-instruct-v2"]
+IBM_WATSONX_URLS = [
+    "https://us-south.ml.cloud.ibm.com",
+    "https://eu-de.ml.cloud.ibm.com",
+    "https://eu-gb.ml.cloud.ibm.com",
+    "https://au-syd.ml.cloud.ibm.com",
+    "https://jp-tok.ml.cloud.ibm.com",
+    "https://ca-tor.ml.cloud.ibm.com",
+]
+
+# Ollama API constants
+HTTP_STATUS_OK = 200
+JSON_MODELS_KEY = "models"
+JSON_NAME_KEY = "name"
+JSON_CAPABILITIES_KEY = "capabilities"
+DESIRED_CAPABILITY = "completion"
+DEFAULT_OLLAMA_URL = "http://localhost:11434"
+
+
+class LanguageModelComponent(LCModelComponent):
+    display_name = "Language Model"
+    description = "Runs a language model given a specified provider."
+    documentation: str = "https://docs.langflow.org/components-models"
+    icon = "brain-circuit"
+    category = "models"
+    priority = 0  # Set priority to 0 to make it appear first
+
+    @staticmethod
+    def fetch_ibm_models(base_url: str) -> list[str]:
+        """Fetch available models from the watsonx.ai API."""
+        try:
+            endpoint = f"{base_url}/ml/v1/foundation_model_specs"
+            params = {"version": "2024-09-16", "filters": "function_text_chat,!lifecycle_withdrawn"}
+            response = requests.get(endpoint, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            models = [model["model_id"] for model in data.get("resources", [])]
+            return sorted(models)
+        except Exception:  # noqa: BLE001
+            logger.exception("Error fetching IBM watsonx models. Using default models.")
+            return IBM_WATSONX_DEFAULT_MODELS
+
+    inputs = [
+        DropdownInput(
+            name="provider",
+            display_name="Model Provider",
+            options=["OpenAI", "Anthropic", "Google", "IBM watsonx.ai", "Ollama"],
+            value="OpenAI",
+            info="Select the model provider",
+            real_time_refresh=True,
+            options_metadata=[
+                {"icon": "OpenAI"},
+                {"icon": "Anthropic"},
+                {"icon": "GoogleGenerativeAI"},
+                {"icon": "WatsonxAI"},
+                {"icon": "Ollama"},
+            ],
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
+            value=OPENAI_CHAT_MODEL_NAMES[0],
+            info="Select the model to use",
+            real_time_refresh=True,
+            refresh_button=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="OpenAI API Key",
+            info="Model Provider API key",
+            required=False,
+            show=True,
+            real_time_refresh=True,
+        ),
+        DropdownInput(
+            name="base_url_ibm_watsonx",
+            display_name="watsonx API Endpoint",
+            info="The base URL of the API (IBM watsonx.ai only)",
+            options=IBM_WATSONX_URLS,
+            value=IBM_WATSONX_URLS[0],
+            show=False,
+            real_time_refresh=True,
+        ),
+        StrInput(
+            name="project_id",
+            display_name="watsonx Project ID",
+            info="The project ID associated with the foundation model (IBM watsonx.ai only)",
+            show=False,
+            required=False,
+        ),
+        MessageTextInput(
+            name="ollama_base_url",
+            display_name="Ollama API URL",
+            info=f"Endpoint of the Ollama API (Ollama only). Defaults to {DEFAULT_OLLAMA_URL}",
+            value=DEFAULT_OLLAMA_URL,
+            show=False,
+            real_time_refresh=True,
+            load_from_db=True,
+        ),
+        MessageInput(
+            name="input_value",
+            display_name="Input",
+            info="The input text to send to the model",
+        ),
+        MultilineInput(
+            name="system_message",
+            display_name="System Message",
+            info="A system message that helps set the behavior of the assistant",
+            advanced=False,
+        ),
+        BoolInput(
+            name="stream",
+            display_name="Stream",
+            info="Whether to stream the response",
+            value=False,
+            advanced=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            info="Controls randomness in responses",
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:
+        provider = self.provider
+        model_name = self.model_name
+        temperature = self.temperature
+        stream = self.stream
+
+        if provider == "OpenAI":
+            if not self.api_key:
+                msg = "OpenAI API key is required when using OpenAI provider"
+                raise ValueError(msg)
+
+            if model_name in OPENAI_REASONING_MODEL_NAMES:
+                # reasoning models do not support temperature (yet)
+                temperature = None
+
+            return ChatOpenAI(
+                model_name=model_name,
+                temperature=temperature,
+                streaming=stream,
+                openai_api_key=self.api_key,
+            )
+        if provider == "Anthropic":
+            if not self.api_key:
+                msg = "Anthropic API key is required when using Anthropic provider"
+                raise ValueError(msg)
+            return ChatAnthropic(
+                model=model_name,
+                temperature=temperature,
+                streaming=stream,
+                anthropic_api_key=self.api_key,
+            )
+        if provider == "Google":
+            if not self.api_key:
+                msg = "Google API key is required when using Google provider"
+                raise ValueError(msg)
+            return ChatGoogleGenerativeAIFixed(
+                model=model_name,
+                temperature=temperature,
+                streaming=stream,
+                google_api_key=self.api_key,
+            )
+        if provider == "IBM watsonx.ai":
+            if not self.api_key:
+                msg = "IBM API key is required when using IBM watsonx.ai provider"
+                raise ValueError(msg)
+            if not self.base_url_ibm_watsonx:
+                msg = "IBM watsonx API Endpoint is required when using IBM watsonx.ai provider"
+                raise ValueError(msg)
+            if not self.project_id:
+                msg = "IBM watsonx Project ID is required when using IBM watsonx.ai provider"
+                raise ValueError(msg)
+            return ChatWatsonx(
+                apikey=SecretStr(self.api_key).get_secret_value(),
+                url=self.base_url_ibm_watsonx,
+                project_id=self.project_id,
+                model_id=model_name,
+                params={
+                    "temperature": temperature,
+                },
+                streaming=stream,
+            )
+        if provider == "Ollama":
+            if not self.ollama_base_url:
+                msg = "Ollama API URL is required when using Ollama provider"
+                raise ValueError(msg)
+            if not model_name:
+                msg = "Model name is required when using Ollama provider"
+                raise ValueError(msg)
+
+            transformed_base_url = transform_localhost_url(self.ollama_base_url)
+
+            # Check if URL contains /v1 suffix (OpenAI-compatible mode)
+            if transformed_base_url and transformed_base_url.rstrip("/").endswith("/v1"):
+                # Strip /v1 suffix and log warning
+                transformed_base_url = transformed_base_url.rstrip("/").removesuffix("/v1")
+                logger.warning(
+                    "Detected '/v1' suffix in base URL. The Ollama component uses the native Ollama API, "
+                    "not the OpenAI-compatible API. The '/v1' suffix has been automatically removed. "
+                    "If you want to use the OpenAI-compatible API, please use the OpenAI component instead. "
+                    "Learn more at https://docs.ollama.com/openai#openai-compatibility"
+                )
+
+            return ChatOllama(
+                base_url=transformed_base_url,
+                model=model_name,
+                temperature=temperature,
+            )
+        msg = f"Unknown provider: {provider}"
+        raise ValueError(msg)
+
+    async def update_build_config(
+        self, build_config: dotdict, field_value: Any, field_name: str | None = None
+    ) -> dotdict:
+        if field_name == "provider":
+            if field_value == "OpenAI":
+                build_config["model_name"]["options"] = OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES
+                build_config["model_name"]["value"] = OPENAI_CHAT_MODEL_NAMES[0]
+                build_config["api_key"]["display_name"] = "OpenAI API Key"
+                build_config["api_key"]["show"] = True
+                build_config["base_url_ibm_watsonx"]["show"] = False
+                build_config["project_id"]["show"] = False
+                build_config["ollama_base_url"]["show"] = False
+            elif field_value == "Anthropic":
+                build_config["model_name"]["options"] = ANTHROPIC_MODELS
+                build_config["model_name"]["value"] = ANTHROPIC_MODELS[0]
+                build_config["api_key"]["display_name"] = "Anthropic API Key"
+                build_config["api_key"]["show"] = True
+                build_config["base_url_ibm_watsonx"]["show"] = False
+                build_config["project_id"]["show"] = False
+                build_config["ollama_base_url"]["show"] = False
+            elif field_value == "Google":
+                build_config["model_name"]["options"] = GOOGLE_GENERATIVE_AI_MODELS
+                build_config["model_name"]["value"] = GOOGLE_GENERATIVE_AI_MODELS[0]
+                build_config["api_key"]["display_name"] = "Google API Key"
+                build_config["api_key"]["show"] = True
+                build_config["base_url_ibm_watsonx"]["show"] = False
+                build_config["project_id"]["show"] = False
+                build_config["ollama_base_url"]["show"] = False
+            elif field_value == "IBM watsonx.ai":
+                build_config["model_name"]["options"] = IBM_WATSONX_DEFAULT_MODELS
+                build_config["model_name"]["value"] = IBM_WATSONX_DEFAULT_MODELS[0]
+                build_config["api_key"]["display_name"] = "IBM API Key"
+                build_config["api_key"]["show"] = True
+                build_config["base_url_ibm_watsonx"]["show"] = True
+                build_config["project_id"]["show"] = True
+                build_config["ollama_base_url"]["show"] = False
+            elif field_value == "Ollama":
+                # Fetch Ollama models from the API
+                build_config["api_key"]["show"] = False
+                build_config["base_url_ibm_watsonx"]["show"] = False
+                build_config["project_id"]["show"] = False
+                build_config["ollama_base_url"]["show"] = True
+
+                # Try multiple sources to get the URL (in order of preference):
+                # 1. Instance attribute (already resolved from global/db)
+                # 2. Build config value (may be a global variable reference)
+                # 3. Default value
+                ollama_url = getattr(self, "ollama_base_url", None)
+                if not ollama_url:
+                    config_value = build_config["ollama_base_url"].get("value", DEFAULT_OLLAMA_URL)
+                    # If config_value looks like a variable name (all caps with underscores), use default
+                    is_variable_ref = (
+                        config_value
+                        and isinstance(config_value, str)
+                        and config_value.isupper()
+                        and "_" in config_value
+                    )
+                    if is_variable_ref:
+                        await logger.adebug(
+                            f"Config value appears to be a variable reference: {config_value}, using default"
+                        )
+                        ollama_url = DEFAULT_OLLAMA_URL
+                    else:
+                        ollama_url = config_value
+
+                await logger.adebug(f"Fetching Ollama models for provider switch. URL: {ollama_url}")
+                if await is_valid_ollama_url(url=ollama_url):
+                    try:
+                        models = await get_ollama_models(
+                            base_url_value=ollama_url,
+                            desired_capability=DESIRED_CAPABILITY,
+                            json_models_key=JSON_MODELS_KEY,
+                            json_name_key=JSON_NAME_KEY,
+                            json_capabilities_key=JSON_CAPABILITIES_KEY,
+                        )
+                        build_config["model_name"]["options"] = models
+                        build_config["model_name"]["value"] = models[0] if models else ""
+                    except ValueError:
+                        await logger.awarning("Failed to fetch Ollama models. Setting empty options.")
+                        build_config["model_name"]["options"] = []
+                        build_config["model_name"]["value"] = ""
+                else:
+                    await logger.awarning(f"Invalid Ollama URL: {ollama_url}")
+                    build_config["model_name"]["options"] = []
+                    build_config["model_name"]["value"] = ""
+        elif (
+            field_name == "base_url_ibm_watsonx"
+            and field_value
+            and hasattr(self, "provider")
+            and self.provider == "IBM watsonx.ai"
+        ):
+            # Fetch IBM models when base_url changes
+            try:
+                models = self.fetch_ibm_models(base_url=field_value)
+                build_config["model_name"]["options"] = models
+                build_config["model_name"]["value"] = models[0] if models else IBM_WATSONX_DEFAULT_MODELS[0]
+                info_message = f"Updated model options: {len(models)} models found in {field_value}"
+                logger.info(info_message)
+            except Exception:  # noqa: BLE001
+                logger.exception("Error updating IBM model options.")
+        elif field_name == "ollama_base_url":
+            # Fetch Ollama models when ollama_base_url changes
+            # Use the field_value directly since this is triggered when the field changes
+            logger.debug(
+                f"Fetching Ollama models from updated URL: {build_config['ollama_base_url']} \
+                and value {self.ollama_base_url}",
+            )
+            await logger.adebug(f"Fetching Ollama models from updated URL: {self.ollama_base_url}")
+            if await is_valid_ollama_url(url=self.ollama_base_url):
+                try:
+                    models = await get_ollama_models(
+                        base_url_value=self.ollama_base_url,
+                        desired_capability=DESIRED_CAPABILITY,
+                        json_models_key=JSON_MODELS_KEY,
+                        json_name_key=JSON_NAME_KEY,
+                        json_capabilities_key=JSON_CAPABILITIES_KEY,
+                    )
+                    build_config["model_name"]["options"] = models
+                    build_config["model_name"]["value"] = models[0] if models else ""
+                    info_message = f"Updated model options: {len(models)} models found in {self.ollama_base_url}"
+                    await logger.ainfo(info_message)
+                except ValueError:
+                    await logger.awarning("Error updating Ollama model options.")
+                    build_config["model_name"]["options"] = []
+                    build_config["model_name"]["value"] = ""
+            else:
+                await logger.awarning(f"Invalid Ollama URL: {self.ollama_base_url}")
+                build_config["model_name"]["options"] = []
+                build_config["model_name"]["value"] = ""
+        elif field_name == "model_name":
+            # Refresh Ollama models when model_name field is accessed
+            if hasattr(self, "provider") and self.provider == "Ollama":
+                ollama_url = getattr(self, "ollama_base_url", DEFAULT_OLLAMA_URL)
+                if await is_valid_ollama_url(url=ollama_url):
+                    try:
+                        models = await get_ollama_models(
+                            base_url_value=ollama_url,
+                            desired_capability=DESIRED_CAPABILITY,
+                            json_models_key=JSON_MODELS_KEY,
+                            json_name_key=JSON_NAME_KEY,
+                            json_capabilities_key=JSON_CAPABILITIES_KEY,
+                        )
+                        build_config["model_name"]["options"] = models
+                    except ValueError:
+                        await logger.awarning("Failed to refresh Ollama models.")
+                        build_config["model_name"]["options"] = []
+                else:
+                    build_config["model_name"]["options"] = []
+
+            # Hide system_message for o1 models - currently unsupported
+            if field_value and field_value.startswith("o1") and hasattr(self, "provider") and self.provider == "OpenAI":
+                if "system_message" in build_config:
+                    build_config["system_message"]["show"] = False
+            elif "system_message" in build_config:
+                build_config["system_message"]["show"] = True
+        return build_config

lfx/components/{agents → models_and_agents}/mcp_component.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import uuid
-from typing import Any
 
 from langchain_core.tools import StructuredTool  # noqa: TC002
 
@@ -61,11 +61,12 @@ class MCPToolsComponent(ComponentWithCache):
         "mcp_server",
         "tool",
         "use_cache",
+        "verify_ssl",
     ]
 
     display_name = "MCP Tools"
     description = "Connect to an MCP server to use its tools."
-    documentation: str = "https://docs.langflow.org/mcp-client"
+    documentation: str = "https://docs.langflow.org/mcp-tools"
     icon = "Mcp"
     name = "MCPTools"
 
@@ -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,
@@ -308,9 +324,29 @@ class MCPToolsComponent(ComponentWithCache):
 
                 current_server_name = field_value.get("name") if isinstance(field_value, dict) else field_value
                 _last_selected_server = safe_cache_get(self._shared_component_cache, "last_selected_server", "")
+                server_changed = current_server_name != _last_selected_server
+
+                # Determine if "Tool Mode" is active by checking if the tool dropdown is hidden.
+                is_in_tool_mode = build_config["tools_metadata"]["show"]
+
+                # Get use_cache setting to determine if we should use cached data
+                use_cache = getattr(self, "use_cache", False)
+
+                # Fast path: if server didn't change and we already have options, keep them as-is
+                # BUT only if caching is enabled or we're in tool mode
+                existing_options = build_config.get("tool", {}).get("options") or []
+                if not server_changed and existing_options:
+                    # In non-tool mode with cache disabled, skip the fast path to force refresh
+                    if not is_in_tool_mode and not use_cache:
+                        pass  # Continue to refresh logic below
+                    else:
+                        if not is_in_tool_mode:
+                            build_config["tool"]["show"] = True
+                        return build_config
 
                 # To avoid unnecessary updates, only proceed if the server has actually changed
-                if (_last_selected_server in (current_server_name, "")) and build_config["tool"]["show"]:
+                # OR if caching is disabled (to force refresh in non-tool mode)
+                if (_last_selected_server in (current_server_name, "")) and build_config["tool"]["show"] and use_cache:
                     if current_server_name:
                         servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
                         if isinstance(servers_cache, dict):
@@ -322,36 +358,35 @@ class MCPToolsComponent(ComponentWithCache):
                                     return build_config
                     else:
                         return build_config
-
-                # Determine if "Tool Mode" is active by checking if the tool dropdown is hidden.
-                is_in_tool_mode = build_config["tools_metadata"]["show"]
                 safe_cache_set(self._shared_component_cache, "last_selected_server", current_server_name)
 
                 # Check if tools are already cached for this server before clearing
                 cached_tools = None
-                if current_server_name:
-                    use_cache = getattr(self, "use_cache", True)
-                    if use_cache:
-                        servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
-                        if isinstance(servers_cache, dict):
-                            cached = servers_cache.get(current_server_name)
-                            if cached is not None:
-                                try:
-                                    cached_tools = cached["tools"]
-                                    self.tools = cached_tools
-                                    self.tool_names = cached["tool_names"]
-                                    self._tool_cache = cached["tool_cache"]
-                                except (TypeError, KeyError, AttributeError) as e:
-                                    # Handle corrupted cache data by ignoring it
-                                    msg = f"Unable to use cached data for MCP Server,{current_server_name}: {e}"
-                                    await logger.awarning(msg)
-                                    cached_tools = None
+                if current_server_name and use_cache:
+                    servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                    if isinstance(servers_cache, dict):
+                        cached = servers_cache.get(current_server_name)
+                        if cached is not None:
+                            try:
+                                cached_tools = cached["tools"]
+                                self.tools = cached_tools
+                                self.tool_names = cached["tool_names"]
+                                self._tool_cache = cached["tool_cache"]
+                            except (TypeError, KeyError, AttributeError) as e:
+                                # Handle corrupted cache data by ignoring it
+                                msg = f"Unable to use cached data for MCP Server,{current_server_name}: {e}"
+                                await logger.awarning(msg)
+                                cached_tools = None
 
                 # Only clear tools if we don't have cached tools for the current server
                 if not cached_tools:
                     self.tools = []  # Clear previous tools only if no cache
 
-                self.remove_non_default_keys(build_config)  # Clear previous tool inputs
+                # Clear previous tool inputs if:
+                # 1. Server actually changed
+                # 2. Cache is disabled (meaning tool list will be refreshed)
+                if server_changed or not use_cache:
+                    self.remove_non_default_keys(build_config)
 
                 # Only show the tool dropdown if not in tool_mode
                 if not is_in_tool_mode:
@@ -364,7 +399,12 @@ class MCPToolsComponent(ComponentWithCache):
                         # Show loading state only when we need to fetch tools
                         build_config["tool"]["placeholder"] = "Loading tools..."
                         build_config["tool"]["options"] = []
-                    build_config["tool"]["value"] = uuid.uuid4()
+                    # Force a value refresh when:
+                    # 1. Server changed
+                    # 2. We don't have cached tools
+                    # 3. Cache is disabled (to force refresh on config changes)
+                    if server_changed or not cached_tools or not use_cache:
+                        build_config["tool"]["value"] = uuid.uuid4()
                 else:
                     # Keep the tool dropdown hidden if in tool_mode
                     self._not_load_actions = True
@@ -409,18 +449,6 @@ class MCPToolsComponent(ComponentWithCache):
                 continue
         return inputs
 
-    def remove_input_schema_from_build_config(
-        self, build_config: dict, tool_name: str, input_schema: dict[list[InputTypes], Any]
-    ):
-        """Remove the input schema for the tool from the build config."""
-        # Keep only schemas that don't belong to the current tool
-        input_schema = {k: v for k, v in input_schema.items() if k != tool_name}
-        # Remove all inputs from other tools
-        for value in input_schema.values():
-            for _input in value:
-                if _input.name in build_config:
-                    build_config.pop(_input.name)
-
     def remove_non_default_keys(self, build_config: dict) -> None:
         """Remove non-default keys from the build config."""
         for key in list(build_config.keys()):
@@ -444,24 +472,23 @@ class MCPToolsComponent(ComponentWithCache):
             return
 
         try:
-            # Store current values before removing inputs
+            # Store current values before removing inputs (only for the current tool)
             current_values = {}
             for key, value in build_config.items():
                 if key not in self.default_keys and isinstance(value, dict) and "value" in value:
                     current_values[key] = value["value"]
 
-            # Get all tool inputs and remove old ones
-            input_schema_for_all_tools = self.get_inputs_for_all_tools(self.tools)
-            self.remove_input_schema_from_build_config(build_config, tool_name, input_schema_for_all_tools)
+            # Remove ALL non-default keys (all previous tool inputs)
+            self.remove_non_default_keys(build_config)
 
-            # Get and validate new inputs
+            # Get and validate new inputs for the selected tool
             self.schema_inputs = await self._validate_schema_inputs(tool_obj)
             if not self.schema_inputs:
                 msg = f"No input parameters to configure for tool '{tool_name}'"
                 await logger.ainfo(msg)
                 return
 
-            # Add new inputs to build config
+            # Add new inputs to build config for the selected tool only
             for schema_input in self.schema_inputs:
                 if not schema_input or not hasattr(schema_input, "name"):
                     msg = "Invalid schema input detected, skipping"
@@ -504,7 +531,6 @@ class MCPToolsComponent(ComponentWithCache):
                 if session_context:
                     self.stdio_client.set_session_context(session_context)
                     self.streamable_http_client.set_session_context(session_context)
-
                 exec_tool = self._tool_cache[self.tool]
                 tool_args = self.get_inputs_for_all_tools(self.tools)[self.tool]
                 kwargs = {}
@@ -519,11 +545,14 @@ class MCPToolsComponent(ComponentWithCache):
                 unflattened_kwargs = maybe_unflatten_dict(kwargs)
 
                 output = await exec_tool.coroutine(**unflattened_kwargs)
-
                 tool_content = []
                 for item in output.content:
                     item_dict = item.model_dump()
+                    item_dict = self.process_output_item(item_dict)
                     tool_content.append(item_dict)
+
+                if isinstance(tool_content, list) and all(isinstance(x, dict) for x in tool_content):
+                    return DataFrame(tool_content)
                 return DataFrame(data=tool_content)
             return DataFrame(data=[{"error": "You must select a tool"}])
         except Exception as e:
@@ -531,6 +560,16 @@ class MCPToolsComponent(ComponentWithCache):
             await logger.aexception(msg)
             raise ValueError(msg) from e
 
+    def process_output_item(self, item_dict):
+        """Process the output of a tool."""
+        if item_dict.get("type") == "text":
+            text = item_dict.get("text")
+            try:
+                return json.loads(text)
+            except json.JSONDecodeError:
+                return item_dict
+        return item_dict
+
     def _get_session_context(self) -> str | None:
         """Get the Langflow session ID for MCP session caching."""
         # Try to get session ID from the component's execution context

lfx/components/{helpers → models_and_agents}/memory.py

@@ -16,7 +16,7 @@ from lfx.utils.constants import MESSAGE_SENDER_AI, MESSAGE_SENDER_NAME_AI, MESSA
 class MemoryComponent(Component):
     display_name = "Message History"
     description = "Stores or retrieves stored chat messages from Langflow tables or an external memory."
-    documentation: str = "https://docs.langflow.org/components-helpers#message-history"
+    documentation: str = "https://docs.langflow.org/message-history"
     icon = "message-square-more"
     name = "Memory"
     default_keys = ["mode", "memory", "session_id", "context_id"]

lfx/components/nvidia/system_assist.py

@@ -15,7 +15,7 @@ class NvidiaSystemAssistComponent(ComponentWithCache):
         "The user may query GPU specifications, state, and ask the NV-API to perform "
         "several GPU-editing acations. The prompt must be human-readable language."
     )
-    documentation = "https://docs.langflow.org/integrations-nvidia-g-assist"
+    documentation = "https://docs.langflow.org/bundles-nvidia"
     icon = "NVIDIA"
     rise_initialized = False
 

lfx/components/olivya/olivya.py

@@ -11,7 +11,7 @@ from lfx.schema.data import Data
 class OlivyaComponent(Component):
     display_name = "Place Call"
     description = "A component to create an outbound call request from Olivya's platform."
-    documentation: str = "http://docs.langflow.org/components/olivya"
+    documentation: str = "https://docs.olivya.io"
     icon = "Olivya"
     name = "OlivyaComponent"