lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/aiml/aiml.py

@@ -0,0 +1,115 @@
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+from typing_extensions import override
+
+from lfx.base.models.aiml_constants import AimlModels
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import (
+    DictInput,
+    DropdownInput,
+    IntInput,
+    SecretStrInput,
+    SliderInput,
+    StrInput,
+)
+
+
+class AIMLModelComponent(LCModelComponent):
+    display_name = "AI/ML API"
+    description = "Generates text using AI/ML API LLMs."
+    icon = "AIML"
+    name = "AIMLModel"
+    documentation = "https://docs.aimlapi.com/api-reference"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(name="model_kwargs", display_name="Model Kwargs", advanced=True),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=[],
+            refresh_button=True,
+        ),
+        StrInput(
+            name="aiml_api_base",
+            display_name="AI/ML API Base",
+            advanced=True,
+            info="The base URL of the API. Defaults to https://api.aimlapi.com . "
+            "You can change this to use other APIs like JinaChat, LocalAI and Prem.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="AI/ML API Key",
+            info="The AI/ML API Key to use for the OpenAI model.",
+            advanced=False,
+            value="AIML_API_KEY",
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+        ),
+    ]
+
+    @override
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        if field_name in {"api_key", "aiml_api_base", "model_name"}:
+            aiml = AimlModels()
+            aiml.get_aiml_models()
+            build_config["model_name"]["options"] = aiml.chat_models
+        return build_config
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        aiml_api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+        model_kwargs = self.model_kwargs or {}
+        aiml_api_base = self.aiml_api_base or "https://api.aimlapi.com/v2"
+
+        openai_api_key = aiml_api_key.get_secret_value() if isinstance(aiml_api_key, SecretStr) else aiml_api_key
+
+        # TODO: Once OpenAI fixes their o1 models, this part will need to be removed
+        # to work correctly with o1 temperature settings.
+        if "o1" in model_name:
+            temperature = 1
+
+        return ChatOpenAI(
+            model=model_name,
+            temperature=temperature,
+            api_key=openai_api_key,
+            base_url=aiml_api_base,
+            max_tokens=max_tokens or None,
+            **model_kwargs,
+        )
+
+    def _get_exception_message(self, e: Exception):
+        """Get a message from an OpenAI exception.
+
+        Args:
+            e (Exception): The exception to get the message from.
+
+        Returns:
+            str: The message from the exception.
+        """
+        try:
+            from openai.error import BadRequestError
+        except ImportError:
+            return None
+        if isinstance(e, BadRequestError):
+            message = e.json_body.get("error", {}).get("message", "")
+            if message:
+                return message
+        return None

lfx/components/aiml/aiml_embeddings.py

@@ -0,0 +1,37 @@
+from lfx.base.embeddings.aiml_embeddings import AIMLEmbeddingsImpl
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.field_typing import Embeddings
+from lfx.inputs.inputs import DropdownInput
+from lfx.io import SecretStrInput
+
+
+class AIMLEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "AI/ML API Embeddings"
+    description = "Generate embeddings using the AI/ML API."
+    icon = "AIML"
+    name = "AIMLEmbeddings"
+
+    inputs = [
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=[
+                "text-embedding-3-small",
+                "text-embedding-3-large",
+                "text-embedding-ada-002",
+            ],
+            required=True,
+        ),
+        SecretStrInput(
+            name="aiml_api_key",
+            display_name="AI/ML API Key",
+            value="AIML_API_KEY",
+            required=True,
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        return AIMLEmbeddingsImpl(
+            api_key=self.aiml_api_key,
+            model=self.model_name,
+        )

lfx/components/altk/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .altk_agent import ALTKAgentComponent
+
+_dynamic_imports = {
+    "ALTKAgentComponent": "altk_agent",
+}
+
+__all__ = [
+    "ALTKAgentComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import altk 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/altk/altk_agent.py

@@ -0,0 +1,193 @@
+"""ALTK Agent Component that combines pre-tool validation and post-tool processing capabilities."""
+
+from lfx.base.agents.altk_base_agent import ALTKBaseAgentComponent
+from lfx.base.agents.altk_tool_wrappers import (
+    PostToolProcessingWrapper,
+    PreToolValidationWrapper,
+)
+from lfx.base.models.model_input_constants import MODEL_PROVIDERS_DICT, MODELS_METADATA
+from lfx.components.models_and_agents.memory import MemoryComponent
+from lfx.inputs.inputs import BoolInput
+from lfx.io import DropdownInput, IntInput, Output
+from lfx.log.logger import logger
+
+
+def set_advanced_true(component_input):
+    """Set the advanced flag to True for a component input."""
+    component_input.advanced = True
+    return component_input
+
+
+MODEL_PROVIDERS_LIST = ["Anthropic", "OpenAI"]
+INPUT_NAMES_TO_BE_OVERRIDDEN = ["agent_llm"]
+
+
+def get_parent_agent_inputs():
+    return [
+        input_field
+        for input_field in ALTKBaseAgentComponent.inputs
+        if input_field.name not in INPUT_NAMES_TO_BE_OVERRIDDEN
+    ]
+
+
+# === Combined ALTK Agent Component ===
+
+
+class ALTKAgentComponent(ALTKBaseAgentComponent):
+    """ALTK Agent with both pre-tool validation and post-tool processing capabilities.
+
+    This agent combines the functionality of both ALTKAgent and AgentReflection components,
+    implementing a modular pipeline for tool processing that can be extended with
+    additional capabilities in the future.
+    """
+
+    display_name: str = "ALTK Agent"
+    description: str = "Advanced agent with both pre-tool validation and post-tool processing capabilities."
+    documentation: str = "https://docs.langflow.org/bundles-altk"
+    icon = "zap"
+    beta = True
+    name = "ALTK Agent"
+
+    memory_inputs = [set_advanced_true(component_input) for component_input in MemoryComponent().inputs]
+
+    # Filter out json_mode from OpenAI inputs since we handle structured output differently
+    if "OpenAI" in MODEL_PROVIDERS_DICT:
+        openai_inputs_filtered = [
+            input_field
+            for input_field in MODEL_PROVIDERS_DICT["OpenAI"]["inputs"]
+            if not (hasattr(input_field, "name") and input_field.name == "json_mode")
+        ]
+    else:
+        openai_inputs_filtered = []
+
+    inputs = [
+        DropdownInput(
+            name="agent_llm",
+            display_name="Model Provider",
+            info="The provider of the language model that the agent will use to generate responses.",
+            options=[*MODEL_PROVIDERS_LIST],
+            value="OpenAI",
+            real_time_refresh=True,
+            refresh_button=False,
+            input_types=[],
+            options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA],
+        ),
+        *get_parent_agent_inputs(),
+        BoolInput(
+            name="enable_tool_validation",
+            display_name="Tool Validation",
+            info="Validates tool calls using SPARC before execution.",
+            value=True,
+        ),
+        BoolInput(
+            name="enable_post_tool_reflection",
+            display_name="Post Tool JSON Processing",
+            info="Processes tool output through JSON analysis.",
+            value=True,
+        ),
+        IntInput(
+            name="response_processing_size_threshold",
+            display_name="Response Processing Size Threshold",
+            value=100,
+            info="Tool output is post-processed only if response exceeds this character threshold.",
+            advanced=True,
+        ),
+    ]
+    outputs = [
+        Output(name="response", display_name="Response", method="message_response"),
+    ]
+
+    def configure_tool_pipeline(self) -> None:
+        """Configure the tool pipeline with wrappers based on enabled features."""
+        wrappers = []
+
+        # Add post-tool processing first (innermost wrapper)
+        if self.enable_post_tool_reflection:
+            logger.info("Enabling Post-Tool Processing Wrapper!")
+            post_processor = PostToolProcessingWrapper(
+                response_processing_size_threshold=self.response_processing_size_threshold
+            )
+            wrappers.append(post_processor)
+
+        # Add pre-tool validation last (outermost wrapper)
+        if self.enable_tool_validation:
+            logger.info("Enabling Pre-Tool Validation Wrapper!")
+            pre_validator = PreToolValidationWrapper()
+            wrappers.append(pre_validator)
+
+        self.pipeline_manager.configure_wrappers(wrappers)
+
+    def update_runnable_instance(self, agent, runnable, tools):
+        """Override to add tool specs update for validation wrappers."""
+        # Get context info (copied from parent)
+        user_query = self.get_user_query()
+        conversation_context = self.build_conversation_context()
+
+        # Initialize pipeline (this ensures configure_tool_pipeline is called)
+        self._initialize_tool_pipeline()
+
+        # Update tool specs for validation wrappers BEFORE processing
+        for wrapper in self.pipeline_manager.wrappers:
+            if isinstance(wrapper, PreToolValidationWrapper) and tools:
+                wrapper.tool_specs = wrapper.convert_langchain_tools_to_sparc_tool_specs_format(tools)
+
+        # Process tools with updated specs
+        processed_tools = self.pipeline_manager.process_tools(
+            list(tools or []),
+            agent=agent,
+            user_query=user_query,
+            conversation_context=conversation_context,
+        )
+
+        runnable.tools = processed_tools
+        return runnable
+
+    def __init__(self, **kwargs):
+        """Initialize ALTK agent with input normalization for Data.to_lc_message() inconsistencies."""
+        super().__init__(**kwargs)
+
+        # If input_value uses Data.to_lc_message(), wrap it to provide consistent content
+        if hasattr(self.input_value, "to_lc_message") and callable(self.input_value.to_lc_message):
+            self.input_value = self._create_normalized_input_proxy(self.input_value)
+
+    def _create_normalized_input_proxy(self, original_input):
+        """Create a proxy that normalizes to_lc_message() content format."""
+
+        class NormalizedInputProxy:
+            def __init__(self, original):
+                self._original = original
+
+            def __getattr__(self, name):
+                if name == "to_lc_message":
+                    return self._normalized_to_lc_message
+                return getattr(self._original, name)
+
+            def _normalized_to_lc_message(self):
+                """Return a message with normalized string content."""
+                original_msg = self._original.to_lc_message()
+
+                # If content is in list format, normalize it to string
+                if hasattr(original_msg, "content") and isinstance(original_msg.content, list):
+                    from langchain_core.messages import AIMessage, HumanMessage
+
+                    from lfx.base.agents.altk_base_agent import (
+                        normalize_message_content,
+                    )
+
+                    normalized_content = normalize_message_content(original_msg)
+
+                    # Create new message with string content
+                    if isinstance(original_msg, HumanMessage):
+                        return HumanMessage(content=normalized_content)
+                    return AIMessage(content=normalized_content)
+
+                # Return original if already string format
+                return original_msg
+
+            def __str__(self):
+                return str(self._original)
+
+            def __repr__(self):
+                return f"NormalizedInputProxy({self._original!r})"
+
+        return NormalizedInputProxy(original_input)

lfx/components/amazon/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.amazon.amazon_bedrock_embedding import AmazonBedrockEmbeddingsComponent
+    from lfx.components.amazon.amazon_bedrock_model import AmazonBedrockComponent
+    from lfx.components.amazon.s3_bucket_uploader import S3BucketUploaderComponent
+
+_dynamic_imports = {
+    "AmazonBedrockEmbeddingsComponent": "amazon_bedrock_embedding",
+    "AmazonBedrockComponent": "amazon_bedrock_model",
+    "S3BucketUploaderComponent": "s3_bucket_uploader",
+}
+
+__all__ = ["AmazonBedrockComponent", "AmazonBedrockEmbeddingsComponent", "S3BucketUploaderComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import amazon 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/amazon/amazon_bedrock_converse.py

@@ -0,0 +1,195 @@
+from langflow.field_typing import LanguageModel
+from langflow.inputs.inputs import BoolInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.io import DictInput, DropdownInput
+
+from lfx.base.models.aws_constants import AWS_REGIONS, AWS_MODEL_IDs
+from lfx.base.models.model import LCModelComponent
+
+
+class AmazonBedrockConverseComponent(LCModelComponent):
+    display_name: str = "Amazon Bedrock Converse"
+    description: str = (
+        "Generate text using Amazon Bedrock LLMs with the modern Converse API for improved conversation handling."
+    )
+    icon = "Amazon"
+    name = "AmazonBedrockConverseModel"
+    beta = True
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        DropdownInput(
+            name="model_id",
+            display_name="Model ID",
+            options=AWS_MODEL_IDs,
+            value="anthropic.claude-3-5-sonnet-20241022-v2:0",
+            info="List of available model IDs to choose from.",
+        ),
+        SecretStrInput(
+            name="aws_access_key_id",
+            display_name="AWS Access Key ID",
+            info="The access key for your AWS account. "
+            "Usually set in Python code as the environment variable 'AWS_ACCESS_KEY_ID'.",
+            value="AWS_ACCESS_KEY_ID",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_secret_access_key",
+            display_name="AWS Secret Access Key",
+            info="The secret key for your AWS account. "
+            "Usually set in Python code as the environment variable 'AWS_SECRET_ACCESS_KEY'.",
+            value="AWS_SECRET_ACCESS_KEY",
+            required=True,
+        ),
+        SecretStrInput(
+            name="aws_session_token",
+            display_name="AWS Session Token",
+            advanced=True,
+            info="The session key for your AWS account. "
+            "Only needed for temporary credentials. "
+            "Usually set in Python code as the environment variable 'AWS_SESSION_TOKEN'.",
+            load_from_db=False,
+        ),
+        SecretStrInput(
+            name="credentials_profile_name",
+            display_name="Credentials Profile Name",
+            advanced=True,
+            info="The name of the profile to use from your "
+            "~/.aws/credentials file. "
+            "If not provided, the default profile will be used.",
+            load_from_db=False,
+        ),
+        DropdownInput(
+            name="region_name",
+            display_name="Region Name",
+            value="us-east-1",
+            options=AWS_REGIONS,
+            info="The AWS region where your Bedrock resources are located.",
+        ),
+        MessageTextInput(
+            name="endpoint_url",
+            display_name="Endpoint URL",
+            advanced=True,
+            info="The URL of the Bedrock endpoint to use.",
+        ),
+        # Model-specific parameters for fine control
+        FloatInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.7,
+            info="Controls randomness in output. Higher values make output more random.",
+            advanced=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            value=4096,
+            info="Maximum number of tokens to generate.",
+            advanced=True,
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top P",
+            value=0.9,
+            info="Nucleus sampling parameter. Controls diversity of output.",
+            advanced=True,
+        ),
+        IntInput(
+            name="top_k",
+            display_name="Top K",
+            value=250,
+            info="Limits the number of highest probability vocabulary tokens to consider. "
+            "Note: Not all models support top_k. Use 'Additional Model Fields' for manual configuration if needed.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="disable_streaming",
+            display_name="Disable Streaming",
+            value=False,
+            info="If True, disables streaming responses. Useful for batch processing.",
+            advanced=True,
+        ),
+        DictInput(
+            name="additional_model_fields",
+            display_name="Additional Model Fields",
+            advanced=True,
+            is_list=True,
+            info="Additional model-specific parameters for fine-tuning behavior.",
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        try:
+            from langchain_aws.chat_models.bedrock_converse import ChatBedrockConverse
+        except ImportError as e:
+            msg = "langchain_aws is not installed. Please install it with `pip install langchain_aws`."
+            raise ImportError(msg) from e
+
+        # Prepare initialization parameters
+        init_params = {
+            "model": self.model_id,
+            "region_name": self.region_name,
+        }
+
+        # Add AWS credentials if provided
+        if self.aws_access_key_id:
+            init_params["aws_access_key_id"] = self.aws_access_key_id
+        if self.aws_secret_access_key:
+            init_params["aws_secret_access_key"] = self.aws_secret_access_key
+        if self.aws_session_token:
+            init_params["aws_session_token"] = self.aws_session_token
+        if self.credentials_profile_name:
+            init_params["credentials_profile_name"] = self.credentials_profile_name
+        if self.endpoint_url:
+            init_params["endpoint_url"] = self.endpoint_url
+
+        # Add model parameters directly as supported by ChatBedrockConverse
+        if hasattr(self, "temperature") and self.temperature is not None:
+            init_params["temperature"] = self.temperature
+        if hasattr(self, "max_tokens") and self.max_tokens is not None:
+            init_params["max_tokens"] = self.max_tokens
+        if hasattr(self, "top_p") and self.top_p is not None:
+            init_params["top_p"] = self.top_p
+
+        # Handle streaming - only disable if explicitly requested
+        if hasattr(self, "disable_streaming") and self.disable_streaming:
+            init_params["disable_streaming"] = True
+
+        # Handle additional model request fields carefully
+        # Based on the error, inferenceConfig should not be passed as additional fields for some models
+        additional_model_request_fields = {}
+
+        # Only add top_k if user explicitly provided additional fields or if needed for specific models
+        if hasattr(self, "additional_model_fields") and self.additional_model_fields:
+            for field in self.additional_model_fields:
+                if isinstance(field, dict):
+                    additional_model_request_fields.update(field)
+
+        # For now, don't automatically add inferenceConfig for top_k to avoid validation errors
+        # Users can manually add it via additional_model_fields if their model supports it
+
+        # Only add if we have actual additional fields
+        if additional_model_request_fields:
+            init_params["additional_model_request_fields"] = additional_model_request_fields
+
+        try:
+            output = ChatBedrockConverse(**init_params)
+        except Exception as e:
+            # Provide helpful error message with fallback suggestions
+            error_details = str(e)
+            if "validation error" in error_details.lower():
+                msg = (
+                    f"ChatBedrockConverse validation error: {error_details}. "
+                    f"This may be due to incompatible parameters for model '{self.model_id}'. "
+                    f"Consider adjusting the model parameters or trying the legacy Amazon Bedrock component."
+                )
+            elif "converse api" in error_details.lower():
+                msg = (
+                    f"Converse API error: {error_details}. "
+                    f"The model '{self.model_id}' may not support the Converse API. "
+                    f"Try using the legacy Amazon Bedrock component instead."
+                )
+            else:
+                msg = f"Could not initialize ChatBedrockConverse: {error_details}"
+            raise ValueError(msg) from e
+
+        return output