lfx-nightly 0.1.11.dev0__py3-none-any.whl

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,202 @@
+from collections import defaultdict
+from typing import Any
+
+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="OpenRouter API Key", required=True, info="Your OpenRouter API key"
+        ),
+        StrInput(
+            name="site_url",
+            display_name="Site URL",
+            info="Your site URL for OpenRouter rankings",
+            advanced=True,
+        ),
+        StrInput(
+            name="app_name",
+            display_name="App Name",
+            info="Your app name for OpenRouter rankings",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="provider",
+            display_name="Provider",
+            info="The AI model provider",
+            options=["Loading providers..."],
+            value="Loading providers...",
+            real_time_refresh=True,
+            required=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            info="The model to use for chat completion",
+            options=["Select a provider first"],
+            value="Select a provider first",
+            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),
+            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
+            advanced=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            info="Maximum number of tokens to generate",
+            advanced=True,
+        ),
+    ]
+
+    def fetch_models(self) -> dict[str, list]:
+        """Fetch available models from OpenRouter API and organize them by provider."""
+        url = "https://openrouter.ai/api/v1/models"
+
+        try:
+            with httpx.Client() as client:
+                response = client.get(url)
+                response.raise_for_status()
+
+                models_data = response.json().get("data", [])
+                provider_models = defaultdict(list)
+
+                for model in models_data:
+                    model_id = model.get("id", "")
+                    if "/" in model_id:
+                        provider = model_id.split("/")[0].title()
+                        provider_models[provider].append(
+                            {
+                                "id": model_id,
+                                "name": model.get("name", ""),
+                                "description": model.get("description", ""),
+                                "context_length": model.get("context_length", 0),
+                            }
+                        )
+
+                return dict(provider_models)
+
+        except httpx.HTTPError as e:
+            self.log(f"Error fetching models: {e!s}")
+            return {"Error": [{"id": "error", "name": f"Error fetching models: {e!s}"}]}
+
+    def build_model(self) -> LanguageModel:
+        """Build and return the OpenRouter language model."""
+        model_not_selected = "Please select a model"
+        api_key_required = "API key is required"
+
+        if not self.model_name or self.model_name == "Select a provider first":
+            raise ValueError(model_not_selected)
+
+        if not self.api_key:
+            raise ValueError(api_key_required)
+
+        api_key = SecretStr(self.api_key).get_secret_value()
+
+        # Build base configuration
+        kwargs: dict[str, Any] = {
+            "model": self.model_name,
+            "openai_api_key": api_key,
+            "openai_api_base": "https://openrouter.ai/api/v1",
+            "temperature": self.temperature if self.temperature is not None else 0.7,
+        }
+
+        # Add optional parameters
+        if self.max_tokens:
+            kwargs["max_tokens"] = 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
+
+        try:
+            return ChatOpenAI(**kwargs)
+        except (ValueError, httpx.HTTPError) as err:
+            error_msg = f"Failed to build model: {err!s}"
+            self.log(error_msg)
+            raise ValueError(error_msg) from err
+
+    def _get_exception_message(self, e: Exception) -> str | None:
+        """Get a message from an OpenRouter exception.
+
+        Args:
+            e (Exception): The exception to get the message from.
+
+        Returns:
+            str | None: The message from the exception, or None if no specific message can be extracted.
+        """
+        try:
+            from openai import BadRequestError
+
+            if isinstance(e, BadRequestError):
+                message = e.body.get("message")
+                if message:
+                    return message
+        except ImportError:
+            pass
+        return None
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
+        """Update build configuration based on field updates."""
+        try:
+            if field_name is None or field_name == "provider":
+                provider_models = self.fetch_models()
+                build_config["provider"]["options"] = sorted(provider_models.keys())
+                if build_config["provider"]["value"] not in provider_models:
+                    build_config["provider"]["value"] = build_config["provider"]["options"][0]
+
+            if field_name == "provider" and field_value in self.fetch_models():
+                provider_models = self.fetch_models()
+                models = provider_models[field_value]
+
+                build_config["model_name"]["options"] = [model["id"] for model in models]
+                if models:
+                    build_config["model_name"]["value"] = models[0]["id"]
+
+                tooltips = {
+                    model["id"]: (f"{model['name']}\nContext Length: {model['context_length']}\n{model['description']}")
+                    for model in models
+                }
+                build_config["model_name"]["tooltips"] = tooltips
+
+        except httpx.HTTPError as e:
+            self.log(f"Error updating build config: {e!s}")
+            build_config["provider"]["options"] = ["Error loading providers"]
+            build_config["provider"]["value"] = "Error loading providers"
+            build_config["model_name"]["options"] = ["Error loading models"]
+            build_config["model_name"]["value"] = "Error loading models"
+
+        return build_config

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__)