lfx-nightly 0.1.13.dev7__py3-none-any.whl → 0.1.13.dev9__py3-none-any.whl

lfx/base/agents/agent.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, cast
 
 from langchain.agents import AgentExecutor, BaseMultiActionAgent, BaseSingleActionAgent
 from langchain.agents.agent import RunnableAgent
+from langchain.callbacks.base import BaseCallbackHandler
 from langchain_core.messages import HumanMessage
 from langchain_core.runnables import Runnable
 
@@ -75,6 +76,12 @@ class LCAgentComponent(Component):
         Output(display_name="Response", name="response", method="message_response"),
     ]
 
+    # Get shared callbacks for tracing and save them to self.shared_callbacks
+    def _get_shared_callbacks(self) -> list[BaseCallbackHandler]:
+        if not hasattr(self, "shared_callbacks"):
+            self.shared_callbacks = self.get_langchain_callbacks()
+        return self.shared_callbacks
+
     @abstractmethod
     def build_agent(self) -> AgentExecutor:
         """Create the agent."""
@@ -209,7 +216,8 @@ class LCAgentComponent(Component):
             result = await process_agent_events(
                 runnable.astream_events(
                     input_dict,
-                    config={"callbacks": [AgentAsyncHandler(self.log), *self.get_langchain_callbacks()]},
+                    # here we use the shared callbacks because the AgentExecutor uses the tools
+                    config={"callbacks": [AgentAsyncHandler(self.log), *self._get_shared_callbacks()]},
                     version="v2",
                 ),
                 agent_message,
@@ -285,15 +293,40 @@ class LCToolsAgentComponent(LCAgentComponent):
             tools_names = ", ".join([tool.name for tool in self.tools])
         return tools_names
 
+    # Set shared callbacks for tracing
+    def set_tools_callbacks(self, tools_list: list[Tool], callbacks_list: list[BaseCallbackHandler]):
+        """Set shared callbacks for tracing to the tools.
+
+        If we do not pass down the same callbacks to each tool
+        used by the agent, then each tool will instantiate a new callback.
+        For some tracing services, this will cause
+        the callback handler to lose the id of its parent run (Agent)
+        and thus throw an error in the tracing service client.
+
+        Args:
+            tools_list: list of tools to set the callbacks for
+            callbacks_list: list of callbacks to set for the tools
+        Returns:
+            None
+        """
+        for tool in tools_list or []:
+            if hasattr(tool, "callbacks"):
+                tool.callbacks = callbacks_list
+
     async def _get_tools(self) -> list[Tool]:
         component_toolkit = _get_component_toolkit()
         tools_names = self._build_tools_names()
         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=self.get_tool_name(), tool_description=description, callbacks=self.get_langchain_callbacks()
+            tool_name=self.get_tool_name(),
+            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

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/components/agents/agent.py

@@ -20,7 +20,7 @@ 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.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
@@ -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",
@@ -195,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:
@@ -471,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."""
@@ -599,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

lfx/components/agents/mcp_component.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import uuid
 from typing import Any
 
@@ -520,7 +521,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 = {}
@@ -535,11 +535,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:
@@ -547,6 +550,17 @@ 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)
+                # convert it to dict
+            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/ibm/watsonx.py

@@ -21,23 +21,24 @@ class WatsonxAIComponent(LCModelComponent):
     beta = False
 
     _default_models = ["ibm/granite-3-2b-instruct", "ibm/granite-3-8b-instruct", "ibm/granite-13b-instruct-v2"]
-
+    _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",
+    ]
     inputs = [
         *LCModelComponent.get_base_inputs(),
         DropdownInput(
-            name="url",
+            name="base_url",
             display_name="watsonx API Endpoint",
             info="The base URL of the API.",
-            value=None,
-            options=[
-                "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",
-            ],
+            value=[],
+            options=_urls,
             real_time_refresh=True,
+            required=True,
         ),
         StrInput(
             name="project_id",
@@ -56,8 +57,9 @@ class WatsonxAIComponent(LCModelComponent):
             display_name="Model Name",
             options=[],
             value=None,
-            dynamic=True,
+            real_time_refresh=True,
             required=True,
+            refresh_button=True,
         ),
         IntInput(
             name="max_tokens",
@@ -155,18 +157,20 @@ class WatsonxAIComponent(LCModelComponent):
 
     def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
         """Update model options when URL or API key changes."""
-        logger.info("Updating build config. Field name: %s, Field value: %s", field_name, field_value)
-
-        if field_name == "url" and field_value:
+        if field_name == "base_url" and field_value:
             try:
-                models = self.fetch_models(base_url=build_config.url.value)
-                build_config.model_name.options = models
-                if build_config.model_name.value:
-                    build_config.model_name.value = models[0]
-                info_message = f"Updated model options: {len(models)} models found in {build_config.url.value}"
+                models = self.fetch_models(base_url=field_value)
+                build_config["model_name"]["options"] = models
+                if build_config["model_name"]["value"]:
+                    build_config["model_name"]["value"] = 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 model options.")
+        if field_name == "model_name" and field_value and field_value in WatsonxAIComponent._urls:
+            build_config["model_name"]["options"] = self.fetch_models(base_url=field_value)
+            build_config["model_name"]["value"] = ""
+        return build_config
 
     def build_model(self) -> LanguageModel:
         # Parse logit_bias from JSON string if provided
@@ -195,7 +199,7 @@ class WatsonxAIComponent(LCModelComponent):
 
         return ChatWatsonx(
             apikey=SecretStr(self.api_key).get_secret_value(),
-            url=self.url,
+            url=self.base_url,
             project_id=self.project_id,
             model_id=self.model_name,
             params=chat_params,