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

lfx/components/openai/openai.py

@@ -0,0 +1,100 @@
+from langchain_openai import OpenAIEmbeddings
+
+from lfx.base.embeddings.model import LCEmbeddingsModel
+from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
+from lfx.field_typing import Embeddings
+from lfx.io import BoolInput, DictInput, DropdownInput, FloatInput, IntInput, MessageTextInput, SecretStrInput
+
+
+class OpenAIEmbeddingsComponent(LCEmbeddingsModel):
+    display_name = "OpenAI Embeddings"
+    description = "Generate embeddings using OpenAI models."
+    icon = "OpenAI"
+    name = "OpenAIEmbeddings"
+
+    inputs = [
+        DictInput(
+            name="default_headers",
+            display_name="Default Headers",
+            advanced=True,
+            info="Default headers to use for the API request.",
+        ),
+        DictInput(
+            name="default_query",
+            display_name="Default Query",
+            advanced=True,
+            info="Default query parameters to use for the API request.",
+        ),
+        IntInput(name="chunk_size", display_name="Chunk Size", advanced=True, value=1000),
+        MessageTextInput(name="client", display_name="Client", advanced=True),
+        MessageTextInput(name="deployment", display_name="Deployment", advanced=True),
+        IntInput(name="embedding_ctx_length", display_name="Embedding Context Length", advanced=True, value=1536),
+        IntInput(name="max_retries", display_name="Max Retries", value=3, advanced=True),
+        DropdownInput(
+            name="model",
+            display_name="Model",
+            advanced=False,
+            options=OPENAI_EMBEDDING_MODEL_NAMES,
+            value="text-embedding-3-small",
+        ),
+        DictInput(name="model_kwargs", display_name="Model Kwargs", advanced=True),
+        SecretStrInput(name="openai_api_key", display_name="OpenAI API Key", value="OPENAI_API_KEY", required=True),
+        MessageTextInput(name="openai_api_base", display_name="OpenAI API Base", advanced=True),
+        MessageTextInput(name="openai_api_type", display_name="OpenAI API Type", advanced=True),
+        MessageTextInput(name="openai_api_version", display_name="OpenAI API Version", advanced=True),
+        MessageTextInput(
+            name="openai_organization",
+            display_name="OpenAI Organization",
+            advanced=True,
+        ),
+        MessageTextInput(name="openai_proxy", display_name="OpenAI Proxy", advanced=True),
+        FloatInput(name="request_timeout", display_name="Request Timeout", advanced=True),
+        BoolInput(name="show_progress_bar", display_name="Show Progress Bar", advanced=True),
+        BoolInput(name="skip_empty", display_name="Skip Empty", advanced=True),
+        MessageTextInput(
+            name="tiktoken_model_name",
+            display_name="TikToken Model Name",
+            advanced=True,
+        ),
+        BoolInput(
+            name="tiktoken_enable",
+            display_name="TikToken Enable",
+            advanced=True,
+            value=True,
+            info="If False, you must have transformers installed.",
+        ),
+        IntInput(
+            name="dimensions",
+            display_name="Dimensions",
+            info="The number of dimensions the resulting output embeddings should have. "
+            "Only supported by certain models.",
+            advanced=True,
+        ),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        return OpenAIEmbeddings(
+            client=self.client or None,
+            model=self.model,
+            dimensions=self.dimensions or None,
+            deployment=self.deployment or None,
+            api_version=self.openai_api_version or None,
+            base_url=self.openai_api_base or None,
+            openai_api_type=self.openai_api_type or None,
+            openai_proxy=self.openai_proxy or None,
+            embedding_ctx_length=self.embedding_ctx_length,
+            api_key=self.openai_api_key or None,
+            organization=self.openai_organization or None,
+            allowed_special="all",
+            disallowed_special="all",
+            chunk_size=self.chunk_size,
+            max_retries=self.max_retries,
+            timeout=self.request_timeout or None,
+            tiktoken_enabled=self.tiktoken_enable,
+            tiktoken_model_name=self.tiktoken_model_name or None,
+            show_progress_bar=self.show_progress_bar,
+            model_kwargs=self.model_kwargs,
+            skip_empty=self.skip_empty,
+            default_headers=self.default_headers or None,
+            default_query=self.default_query or None,
+        )

lfx/components/openai/openai_chat_model.py

@@ -0,0 +1,176 @@
+from typing import Any
+
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+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, DictInput, DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
+from lfx.log.logger import logger
+
+
+class OpenAIModelComponent(LCModelComponent):
+    display_name = "OpenAI"
+    description = "Generates text using OpenAI LLMs."
+    icon = "OpenAI"
+    name = "OpenAIModel"
+
+    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,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
+            value=OPENAI_CHAT_MODEL_NAMES[0],
+            combobox=True,
+            real_time_refresh=True,
+        ),
+        StrInput(
+            name="openai_api_base",
+            display_name="OpenAI API Base",
+            advanced=True,
+            info="The base URL of the OpenAI API. "
+            "Defaults to https://api.openai.com/v1. "
+            "You can change this to use other APIs like JinaChat, LocalAI and Prem.",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="OpenAI API Key",
+            info="The OpenAI API Key to use for the OpenAI model.",
+            advanced=False,
+            value="OPENAI_API_KEY",
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            show=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+        IntInput(
+            name="max_retries",
+            display_name="Max Retries",
+            info="The maximum number of retries to make when generating.",
+            advanced=True,
+            value=5,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="The timeout for requests to OpenAI completion API.",
+            advanced=True,
+            value=700,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        logger.debug(f"Executing request with model: {self.model_name}")
+        # Handle api_key - it can be string or SecretStr
+        api_key_value = None
+        if self.api_key:
+            logger.debug(f"API key type: {type(self.api_key)}, value: {self.api_key!r}")
+            if isinstance(self.api_key, SecretStr):
+                api_key_value = self.api_key.get_secret_value()
+            else:
+                api_key_value = str(self.api_key)
+        logger.debug(f"Final api_key_value type: {type(api_key_value)}, value: {'***' if api_key_value else None}")
+
+        # Handle model_kwargs and ensure api_key doesn't conflict
+        model_kwargs = self.model_kwargs or {}
+        # Remove api_key from model_kwargs if it exists to prevent conflicts
+        if "api_key" in model_kwargs:
+            logger.warning("api_key found in model_kwargs, removing to prevent conflicts")
+            model_kwargs = dict(model_kwargs)  # Make a copy
+            del model_kwargs["api_key"]
+
+        parameters = {
+            "api_key": api_key_value,
+            "model_name": self.model_name,
+            "max_tokens": self.max_tokens or None,
+            "model_kwargs": model_kwargs,
+            "base_url": self.openai_api_base or "https://api.openai.com/v1",
+            "max_retries": self.max_retries,
+            "timeout": self.timeout,
+        }
+
+        # TODO: Revisit if/once parameters are supported for reasoning models
+        unsupported_params_for_reasoning_models = ["temperature", "seed"]
+
+        if self.model_name not in OPENAI_REASONING_MODEL_NAMES:
+            parameters["temperature"] = self.temperature if self.temperature is not None else 0.1
+            parameters["seed"] = self.seed
+        else:
+            params_str = ", ".join(unsupported_params_for_reasoning_models)
+            logger.debug(f"{self.model_name} is a reasoning model, {params_str} are not configurable. Ignoring.")
+
+        # Ensure all parameter values are the correct types
+        if isinstance(parameters.get("api_key"), SecretStr):
+            parameters["api_key"] = parameters["api_key"].get_secret_value()
+        output = ChatOpenAI(**parameters)
+        if self.json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output
+
+    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 import BadRequestError
+        except ImportError:
+            return None
+        if isinstance(e, BadRequestError):
+            message = e.body.get("message")
+            if message:
+                return message
+        return None
+
+    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
+        if field_name in {"base_url", "model_name", "api_key"} and field_value in OPENAI_REASONING_MODEL_NAMES:
+            build_config["temperature"]["show"] = False
+            build_config["seed"]["show"] = False
+            # Hide system_message for o1 models - currently unsupported
+            if field_value.startswith("o1") and "system_message" in build_config:
+                build_config["system_message"]["show"] = False
+        if field_name in {"base_url", "model_name", "api_key"} and field_value in OPENAI_CHAT_MODEL_NAMES:
+            build_config["temperature"]["show"] = True
+            build_config["seed"]["show"] = True
+            if "system_message" in build_config:
+                build_config["system_message"]["show"] = True
+        return build_config

lfx/components/openrouter/__init__.py

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

@@ -0,0 +1,104 @@
+import httpx
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+
+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 DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
+
+
+class OpenRouterComponent(LCModelComponent):
+    """OpenRouter API component for language models."""
+
+    display_name = "OpenRouter"
+    description = (
+        "OpenRouter provides unified access to multiple AI models from different providers through a single API."
+    )
+    icon = "OpenRouter"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        SecretStrInput(name="api_key", display_name="API Key", required=True),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            options=[],
+            value="",
+            refresh_button=True,
+            real_time_refresh=True,
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.7,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            advanced=True,
+        ),
+        IntInput(name="max_tokens", display_name="Max Tokens", advanced=True),
+        StrInput(name="site_url", display_name="Site URL", advanced=True),
+        StrInput(name="app_name", display_name="App Name", advanced=True),
+    ]
+
+    def fetch_models(self) -> list[dict]:
+        """Fetch available models from OpenRouter."""
+        try:
+            response = httpx.get("https://openrouter.ai/api/v1/models", timeout=10.0)
+            response.raise_for_status()
+            models = response.json().get("data", [])
+            return sorted(
+                [
+                    {
+                        "id": m["id"],
+                        "name": m.get("name", m["id"]),
+                        "context": m.get("context_length", 0),
+                    }
+                    for m in models
+                    if m.get("id")
+                ],
+                key=lambda x: x["name"],
+            )
+        except (httpx.RequestError, httpx.HTTPStatusError) as e:
+            self.log(f"Error fetching models: {e}")
+            return []
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:  # noqa: ARG002
+        """Update model options."""
+        models = self.fetch_models()
+        if models:
+            build_config["model_name"]["options"] = [m["id"] for m in models]
+            build_config["model_name"]["tooltips"] = {m["id"]: f"{m['name']} ({m['context']:,} tokens)" for m in models}
+        else:
+            build_config["model_name"]["options"] = ["Failed to load models"]
+            build_config["model_name"]["value"] = "Failed to load models"
+        return build_config
+
+    def build_model(self) -> LanguageModel:
+        """Build the OpenRouter model."""
+        if not self.api_key:
+            msg = "API key is required"
+            raise ValueError(msg)
+        if not self.model_name or self.model_name == "Loading...":
+            msg = "Please select a model"
+            raise ValueError(msg)
+
+        kwargs = {
+            "model": self.model_name,
+            "openai_api_key": SecretStr(self.api_key).get_secret_value(),
+            "openai_api_base": "https://openrouter.ai/api/v1",
+            "temperature": self.temperature if self.temperature is not None else 0.7,
+        }
+
+        if self.max_tokens:
+            kwargs["max_tokens"] = int(self.max_tokens)
+
+        headers = {}
+        if self.site_url:
+            headers["HTTP-Referer"] = self.site_url
+        if self.app_name:
+            headers["X-Title"] = self.app_name
+        if headers:
+            kwargs["default_headers"] = headers
+
+        return ChatOpenAI(**kwargs)

lfx/components/output_parsers/__init__.py

@@ -0,0 +1,3 @@
+"""LangFlow output parsers components."""
+
+__all__: list[str] = []

lfx/components/perplexity/__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 .perplexity import PerplexityComponent
+
+_dynamic_imports = {
+    "PerplexityComponent": "perplexity",
+}
+
+__all__ = [
+    "PerplexityComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import perplexity 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/perplexity/perplexity.py

@@ -0,0 +1,75 @@
+from langchain_community.chat_models import ChatPerplexity
+from pydantic.v1 import SecretStr
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import DropdownInput, FloatInput, IntInput, SecretStrInput, SliderInput
+
+
+class PerplexityComponent(LCModelComponent):
+    display_name = "Perplexity"
+    description = "Generate text using Perplexity LLMs."
+    documentation = "https://python.langchain.com/v0.2/docs/integrations/chat/perplexity/"
+    icon = "Perplexity"
+    name = "PerplexityModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=[
+                "llama-3.1-sonar-small-128k-online",
+                "llama-3.1-sonar-large-128k-online",
+                "llama-3.1-sonar-huge-128k-online",
+                "llama-3.1-sonar-small-128k-chat",
+                "llama-3.1-sonar-large-128k-chat",
+                "llama-3.1-8b-instruct",
+                "llama-3.1-70b-instruct",
+            ],
+            value="llama-3.1-sonar-small-128k-online",
+        ),
+        IntInput(name="max_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."),
+        SecretStrInput(
+            name="api_key",
+            display_name="Perplexity API Key",
+            info="The Perplexity API Key to use for the Perplexity model.",
+            advanced=False,
+            required=True,
+        ),
+        SliderInput(
+            name="temperature", display_name="Temperature", value=0.75, range_spec=RangeSpec(min=0, max=2, step=0.05)
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top P",
+            info="The maximum cumulative probability of tokens to consider when sampling.",
+            advanced=True,
+        ),
+        IntInput(
+            name="n",
+            display_name="N",
+            info="Number of chat completions to generate for each prompt. "
+            "Note that the API may not return the full n completions if duplicates are generated.",
+            advanced=True,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        api_key = SecretStr(self.api_key).get_secret_value()
+        temperature = self.temperature
+        model = self.model_name
+        max_tokens = self.max_tokens
+        top_p = self.top_p
+        n = self.n
+
+        return ChatPerplexity(
+            model=model,
+            temperature=temperature or 0.75,
+            pplx_api_key=api_key,
+            top_p=top_p or None,
+            n=n or 1,
+            max_tokens=max_tokens,
+        )

lfx/components/pgvector/__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 .pgvector import PGVectorStoreComponent
+
+_dynamic_imports = {
+    "PGVectorStoreComponent": "pgvector",
+}
+
+__all__ = [
+    "PGVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import pgvector 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/pgvector/pgvector.py

@@ -0,0 +1,72 @@
+from langchain_community.vectorstores import PGVector
+
+from lfx.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from lfx.helpers.data import docs_to_data
+from lfx.io import HandleInput, IntInput, SecretStrInput, StrInput
+from lfx.schema.data import Data
+from lfx.utils.connection_string_parser import transform_connection_string
+
+
+class PGVectorStoreComponent(LCVectorStoreComponent):
+    display_name = "PGVector"
+    description = "PGVector Vector Store with search capabilities"
+    name = "pgvector"
+    icon = "cpu"
+
+    inputs = [
+        SecretStrInput(name="pg_server_url", display_name="PostgreSQL Server Connection String", required=True),
+        StrInput(name="collection_name", display_name="Table", required=True),
+        *LCVectorStoreComponent.inputs,
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"], required=True),
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
+        ),
+    ]
+
+    @check_cached_vector_store
+    def build_vector_store(self) -> PGVector:
+        # Convert DataFrame to Data if needed using parent's method
+        self.ingest_data = self._prepare_ingest_data()
+
+        documents = []
+        for _input in self.ingest_data or []:
+            if isinstance(_input, Data):
+                documents.append(_input.to_lc_document())
+            else:
+                documents.append(_input)
+
+        connection_string_parsed = transform_connection_string(self.pg_server_url)
+
+        if documents:
+            pgvector = PGVector.from_documents(
+                embedding=self.embedding,
+                documents=documents,
+                collection_name=self.collection_name,
+                connection_string=connection_string_parsed,
+            )
+        else:
+            pgvector = PGVector.from_existing_index(
+                embedding=self.embedding,
+                collection_name=self.collection_name,
+                connection_string=connection_string_parsed,
+            )
+
+        return pgvector
+
+    def search_documents(self) -> list[Data]:
+        vector_store = self.build_vector_store()
+
+        if self.search_query and isinstance(self.search_query, str) and self.search_query.strip():
+            docs = vector_store.similarity_search(
+                query=self.search_query,
+                k=self.number_of_results,
+            )
+
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

lfx/components/pinecone/__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 .pinecone import PineconeVectorStoreComponent
+
+_dynamic_imports = {
+    "PineconeVectorStoreComponent": "pinecone",
+}
+
+__all__ = [
+    "PineconeVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Pinecone 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__)