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

lfx/components/models_and_agents/__init__.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.models_and_agents.agent import AgentComponent
+    from lfx.components.models_and_agents.embedding_model import EmbeddingModelComponent
+    from lfx.components.models_and_agents.language_model import LanguageModelComponent
+    from lfx.components.models_and_agents.mcp_component import MCPToolsComponent
+    from lfx.components.models_and_agents.memory import MemoryComponent
+    from lfx.components.models_and_agents.prompt import PromptComponent
+
+_dynamic_imports = {
+    "AgentComponent": "agent",
+    "EmbeddingModelComponent": "embedding_model",
+    "LanguageModelComponent": "language_model",
+    "MCPToolsComponent": "mcp_component",
+    "MemoryComponent": "memory",
+    "PromptComponent": "prompt",
+}
+
+__all__ = [
+    "AgentComponent",
+    "EmbeddingModelComponent",
+    "LanguageModelComponent",
+    "MCPToolsComponent",
+    "MemoryComponent",
+    "PromptComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import model and agent components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

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

@@ -14,9 +14,9 @@ from lfx.base.models.model_input_constants import (
     MODELS_METADATA,
 )
 from lfx.base.models.model_utils import get_model_name
-from lfx.components.helpers.current_date import CurrentDateComponent
-from lfx.components.helpers.memory import MemoryComponent
+from lfx.components.helpers import CurrentDateComponent
 from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComponent
+from lfx.components.models_and_agents.memory import MemoryComponent
 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
@@ -619,9 +619,11 @@ class AgentComponent(ToolCallingAgentComponent):
                     # Call each component class's update_build_config method
                     # remove the prefix from the field_name
                     if isinstance(field_name, str) and isinstance(prefix, str):
-                        field_name = field_name.replace(prefix, "")
+                        field_name_without_prefix = field_name.replace(prefix, "")
+                    else:
+                        field_name_without_prefix = field_name
                     build_config = await update_component_build_config(
-                        component_class, build_config, field_value, "model_name"
+                        component_class, build_config, field_value, field_name_without_prefix
                     )
         return dotdict({k: v.to_dict() if hasattr(v, "to_dict") else v for k, v in build_config.items()})
 

lfx/components/models_and_agents/embedding_model.py

@@ -0,0 +1,353 @@
+from typing import Any
+
+import requests
+from ibm_watsonx_ai.metanames import EmbedTextParamsMetaNames
+from langchain_openai import OpenAIEmbeddings
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.base.models.model_utils import get_ollama_models, is_valid_ollama_url
+from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.base.models.watsonx_constants import (
+    IBM_WATSONX_URLS,
+    WATSONX_EMBEDDING_MODEL_NAMES,
+)
+from lfx.field_typing import Embeddings
+from lfx.io import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    FloatInput,
+    IntInput,
+    MessageTextInput,
+    SecretStrInput,
+)
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+from lfx.utils.util import transform_localhost_url
+
+# Ollama API constants
+HTTP_STATUS_OK = 200
+JSON_MODELS_KEY = "models"
+JSON_NAME_KEY = "name"
+JSON_CAPABILITIES_KEY = "capabilities"
+DESIRED_CAPABILITY = "embedding"
+DEFAULT_OLLAMA_URL = "http://localhost:11434"
+
+
+class EmbeddingModelComponent(LCEmbeddingsModel):
+    display_name = "Embedding Model"
+    description = "Generate embeddings using a specified provider."
+    documentation: str = "https://docs.langflow.org/components-embedding-models"
+    icon = "binary"
+    name = "EmbeddingModel"
+    category = "models"
+
+    inputs = [
+        DropdownInput(
+            name="provider",
+            display_name="Model Provider",
+            options=["OpenAI", "Ollama", "IBM watsonx.ai"],
+            value="OpenAI",
+            info="Select the embedding model provider",
+            real_time_refresh=True,
+            options_metadata=[{"icon": "OpenAI"}, {"icon": "Ollama"}, {"icon": "WatsonxAI"}],
+        ),
+        MessageTextInput(
+            name="api_base",
+            display_name="API Base URL",
+            info="Base URL for the API. Leave empty for default.",
+            advanced=True,
+        ),
+        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,
+        ),
+        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,
+        ),
+        DropdownInput(
+            name="model",
+            display_name="Model Name",
+            options=OPENAI_EMBEDDING_MODEL_NAMES,
+            value=OPENAI_EMBEDDING_MODEL_NAMES[0],
+            info="Select the embedding 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=True,
+            show=True,
+            real_time_refresh=True,
+        ),
+        # Watson-specific inputs
+        MessageTextInput(
+            name="project_id",
+            display_name="Project ID",
+            info="IBM watsonx.ai Project ID (required for IBM watsonx.ai)",
+            show=False,
+        ),
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have. "
+            "Only supported by certain models.",
+            advanced=True,
+        ),
+        IntInput(name="chunk_size", display_name="Chunk Size", advanced=True, value=1000),
+        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
+        IntInput(name="max_retries", display_name="Max Retries", advanced=True, value=3),
+        BoolInput(name="show_progress_bar", display_name="Show Progress Bar", advanced=True),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        IntInput(
+            name="truncate_input_tokens",
+            display_name="Truncate Input Tokens",
+            advanced=True,
+            value=200,
+            show=False,
+        ),
+        BoolInput(
+            name="input_text",
+            display_name="Include the original text in the output",
+            value=True,
+            advanced=True,
+            show=False,
+        ),
+    ]
+
+    @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_embedding,!lifecycle_withdrawn:and",
+            }
+            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 models")
+            return WATSONX_EMBEDDING_MODEL_NAMES
+
+    def build_embeddings(self) -> Embeddings:
+        provider = self.provider
+        model = self.model
+        api_key = self.api_key
+        api_base = self.api_base
+        base_url_ibm_watsonx = self.base_url_ibm_watsonx
+        ollama_base_url = self.ollama_base_url
+        dimensions = self.dimensions
+        chunk_size = self.chunk_size
+        request_timeout = self.request_timeout
+        max_retries = self.max_retries
+        show_progress_bar = self.show_progress_bar
+        model_kwargs = self.model_kwargs or {}
+
+        if provider == "OpenAI":
+            if not api_key:
+                msg = "OpenAI API key is required when using OpenAI provider"
+                raise ValueError(msg)
+            return OpenAIEmbeddings(
+                model=model,
+                dimensions=dimensions or None,
+                base_url=api_base or None,
+                api_key=api_key,
+                chunk_size=chunk_size,
+                max_retries=max_retries,
+                timeout=request_timeout or None,
+                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
+
+            transformed_base_url = transform_localhost_url(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 OllamaEmbeddings(
+                model=model,
+                base_url=transformed_base_url or "http://localhost:11434",
+                **model_kwargs,
+            )
+
+        if provider == "IBM watsonx.ai":
+            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 = "IBM watsonx.ai API key is required when using IBM watsonx.ai provider"
+                raise ValueError(msg)
+
+            project_id = self.project_id
+
+            if not project_id:
+                msg = "Project ID is required for IBM watsonx.ai provider"
+                raise ValueError(msg)
+
+            from ibm_watsonx_ai import APIClient, Credentials
+
+            credentials = Credentials(
+                api_key=self.api_key,
+                url=base_url_ibm_watsonx or "https://us-south.ml.cloud.ibm.com",
+            )
+
+            api_client = APIClient(credentials)
+
+            params = {
+                EmbedTextParamsMetaNames.TRUNCATE_INPUT_TOKENS: self.truncate_input_tokens,
+                EmbedTextParamsMetaNames.RETURN_OPTIONS: {"input_text": self.input_text},
+            }
+
+            return WatsonxEmbeddings(
+                model_id=model,
+                params=params,
+                watsonx_client=api_client,
+                project_id=project_id,
+            )
+
+        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"]["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["api_base"]["advanced"] = True
+                build_config["api_base"]["show"] = True
+                build_config["ollama_base_url"]["show"] = False
+                build_config["project_id"]["show"] = False
+                build_config["base_url_ibm_watsonx"]["show"] = False
+                build_config["truncate_input_tokens"]["show"] = False
+                build_config["input_text"]["show"] = False
+            elif field_value == "Ollama":
+                build_config["ollama_base_url"]["show"] = True
+
+                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"]["options"] = models
+                        build_config["model"]["value"] = models[0] if models else ""
+                    except ValueError:
+                        build_config["model"]["options"] = []
+                        build_config["model"]["value"] = ""
+                else:
+                    build_config["model"]["options"] = []
+                    build_config["model"]["value"] = ""
+                build_config["truncate_input_tokens"]["show"] = False
+                build_config["input_text"]["show"] = False
+                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"]["show"] = False
+                build_config["project_id"]["show"] = False
+                build_config["base_url_ibm_watsonx"]["show"] = False
+
+            elif field_value == "IBM watsonx.ai":
+                build_config["model"]["options"] = self.fetch_ibm_models(base_url=self.base_url_ibm_watsonx)
+                build_config["model"]["value"] = self.fetch_ibm_models(base_url=self.base_url_ibm_watsonx)[0]
+                build_config["api_key"]["display_name"] = "IBM watsonx.ai API Key"
+                build_config["api_key"]["required"] = True
+                build_config["api_key"]["show"] = True
+                build_config["api_base"]["show"] = False
+                build_config["ollama_base_url"]["show"] = False
+                build_config["base_url_ibm_watsonx"]["show"] = True
+                build_config["project_id"]["show"] = True
+                build_config["truncate_input_tokens"]["show"] = True
+                build_config["input_text"]["show"] = True
+        elif field_name == "base_url_ibm_watsonx":
+            build_config["model"]["options"] = self.fetch_ibm_models(base_url=field_value)
+            build_config["model"]["value"] = self.fetch_ibm_models(base_url=field_value)[0]
+        elif field_name == "ollama_base_url":
+            # # Refresh Ollama models when base URL changes
+            # if hasattr(self, "provider") and self.provider == "Ollama":
+            # Use field_value if provided, otherwise fall back to instance attribute
+            ollama_url = self.ollama_base_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"]["options"] = models
+                    build_config["model"]["value"] = models[0] if models else ""
+                except ValueError:
+                    await logger.awarning("Failed to fetch Ollama embedding models.")
+                    build_config["model"]["options"] = []
+                    build_config["model"]["value"] = ""
+
+        elif field_name == "model" and self.provider == "Ollama":
+            ollama_url = self.ollama_base_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"]["options"] = models
+                except ValueError:
+                    await logger.awarning("Failed to refresh Ollama embedding models.")
+                    build_config["model"]["options"] = []
+
+        return build_config