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

lfx/components/ollama/ollama.py

@@ -0,0 +1,330 @@
+import asyncio
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+from langchain_ollama import ChatOllama
+
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.ollama_constants import URL_LIST
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.io import BoolInput, DictInput, DropdownInput, FloatInput, IntInput, MessageTextInput, SliderInput
+from lfx.log.logger import logger
+
+HTTP_STATUS_OK = 200
+
+
+class ChatOllamaComponent(LCModelComponent):
+    display_name = "Ollama"
+    description = "Generate text using Ollama Local LLMs."
+    icon = "Ollama"
+    name = "OllamaModel"
+
+    # Define constants for JSON keys
+    JSON_MODELS_KEY = "models"
+    JSON_NAME_KEY = "name"
+    JSON_CAPABILITIES_KEY = "capabilities"
+    DESIRED_CAPABILITY = "completion"
+    TOOL_CALLING_CAPABILITY = "tools"
+
+    inputs = [
+        MessageTextInput(
+            name="base_url",
+            display_name="Base URL",
+            info="Endpoint of the Ollama API.",
+            value="",
+            real_time_refresh=True,
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            options=[],
+            info="Refer to https://ollama.com/library for more models.",
+            refresh_button=True,
+            real_time_refresh=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="format", display_name="Format", info="Specify the format of the output (e.g., json).", advanced=True
+        ),
+        DictInput(name="metadata", display_name="Metadata", info="Metadata to add to the run trace.", advanced=True),
+        DropdownInput(
+            name="mirostat",
+            display_name="Mirostat",
+            options=["Disabled", "Mirostat", "Mirostat 2.0"],
+            info="Enable/disable Mirostat sampling for controlling perplexity.",
+            value="Disabled",
+            advanced=True,
+            real_time_refresh=True,
+        ),
+        FloatInput(
+            name="mirostat_eta",
+            display_name="Mirostat Eta",
+            info="Learning rate for Mirostat algorithm. (Default: 0.1)",
+            advanced=True,
+        ),
+        FloatInput(
+            name="mirostat_tau",
+            display_name="Mirostat Tau",
+            info="Controls the balance between coherence and diversity of the output. (Default: 5.0)",
+            advanced=True,
+        ),
+        IntInput(
+            name="num_ctx",
+            display_name="Context Window Size",
+            info="Size of the context window for generating tokens. (Default: 2048)",
+            advanced=True,
+        ),
+        IntInput(
+            name="num_gpu",
+            display_name="Number of GPUs",
+            info="Number of GPUs to use for computation. (Default: 1 on macOS, 0 to disable)",
+            advanced=True,
+        ),
+        IntInput(
+            name="num_thread",
+            display_name="Number of Threads",
+            info="Number of threads to use during computation. (Default: detected for optimal performance)",
+            advanced=True,
+        ),
+        IntInput(
+            name="repeat_last_n",
+            display_name="Repeat Last N",
+            info="How far back the model looks to prevent repetition. (Default: 64, 0 = disabled, -1 = num_ctx)",
+            advanced=True,
+        ),
+        FloatInput(
+            name="repeat_penalty",
+            display_name="Repeat Penalty",
+            info="Penalty for repetitions in generated text. (Default: 1.1)",
+            advanced=True,
+        ),
+        FloatInput(name="tfs_z", display_name="TFS Z", info="Tail free sampling value. (Default: 1)", advanced=True),
+        IntInput(name="timeout", display_name="Timeout", info="Timeout for the request stream.", advanced=True),
+        IntInput(
+            name="top_k", display_name="Top K", info="Limits token selection to top K. (Default: 40)", advanced=True
+        ),
+        FloatInput(name="top_p", display_name="Top P", info="Works together with top-k. (Default: 0.9)", advanced=True),
+        BoolInput(name="verbose", display_name="Verbose", info="Whether to print out response text.", advanced=True),
+        MessageTextInput(
+            name="tags",
+            display_name="Tags",
+            info="Comma-separated list of tags to add to the run trace.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="stop_tokens",
+            display_name="Stop Tokens",
+            info="Comma-separated list of tokens to signal the model to stop generating text.",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="system", display_name="System", info="System to use for generating text.", advanced=True
+        ),
+        BoolInput(
+            name="tool_model_enabled",
+            display_name="Tool Model Enabled",
+            info="Whether to enable tool calling in the model.",
+            value=True,
+            real_time_refresh=True,
+        ),
+        MessageTextInput(
+            name="template", display_name="Template", info="Template to use for generating text.", advanced=True
+        ),
+        *LCModelComponent.get_base_inputs(),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        # Mapping mirostat settings to their corresponding values
+        mirostat_options = {"Mirostat": 1, "Mirostat 2.0": 2}
+
+        # Default to 0 for 'Disabled'
+        mirostat_value = mirostat_options.get(self.mirostat, 0)
+
+        # Set mirostat_eta and mirostat_tau to None if mirostat is disabled
+        if mirostat_value == 0:
+            mirostat_eta = None
+            mirostat_tau = None
+        else:
+            mirostat_eta = self.mirostat_eta
+            mirostat_tau = self.mirostat_tau
+
+        # Mapping system settings to their corresponding values
+        llm_params = {
+            "base_url": self.base_url,
+            "model": self.model_name,
+            "mirostat": mirostat_value,
+            "format": self.format,
+            "metadata": self.metadata,
+            "tags": self.tags.split(",") if self.tags else None,
+            "mirostat_eta": mirostat_eta,
+            "mirostat_tau": mirostat_tau,
+            "num_ctx": self.num_ctx or None,
+            "num_gpu": self.num_gpu or None,
+            "num_thread": self.num_thread or None,
+            "repeat_last_n": self.repeat_last_n or None,
+            "repeat_penalty": self.repeat_penalty or None,
+            "temperature": self.temperature or None,
+            "stop": self.stop_tokens.split(",") if self.stop_tokens else None,
+            "system": self.system,
+            "tfs_z": self.tfs_z or None,
+            "timeout": self.timeout or None,
+            "top_k": self.top_k or None,
+            "top_p": self.top_p or None,
+            "verbose": self.verbose,
+            "template": self.template,
+        }
+
+        # Remove parameters with None values
+        llm_params = {k: v for k, v in llm_params.items() if v is not None}
+
+        try:
+            output = ChatOllama(**llm_params)
+        except Exception as e:
+            msg = (
+                "Unable to connect to the Ollama API. ",
+                "Please verify the base URL, ensure the relevant Ollama model is pulled, and try again.",
+            )
+            raise ValueError(msg) from e
+
+        return output
+
+    async def is_valid_ollama_url(self, url: str) -> bool:
+        try:
+            async with httpx.AsyncClient() as client:
+                return (await client.get(urljoin(url, "api/tags"))).status_code == HTTP_STATUS_OK
+        except httpx.RequestError:
+            return False
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):
+        if field_name == "mirostat":
+            if field_value == "Disabled":
+                build_config["mirostat_eta"]["advanced"] = True
+                build_config["mirostat_tau"]["advanced"] = True
+                build_config["mirostat_eta"]["value"] = None
+                build_config["mirostat_tau"]["value"] = None
+
+            else:
+                build_config["mirostat_eta"]["advanced"] = False
+                build_config["mirostat_tau"]["advanced"] = False
+
+                if field_value == "Mirostat 2.0":
+                    build_config["mirostat_eta"]["value"] = 0.2
+                    build_config["mirostat_tau"]["value"] = 10
+                else:
+                    build_config["mirostat_eta"]["value"] = 0.1
+                    build_config["mirostat_tau"]["value"] = 5
+
+        if field_name in {"base_url", "model_name"}:
+            if build_config["base_url"].get("load_from_db", False):
+                base_url_value = await self.get_variables(build_config["base_url"].get("value", ""), "base_url")
+            else:
+                base_url_value = build_config["base_url"].get("value", "")
+
+            if not await self.is_valid_ollama_url(base_url_value):
+                # Check if any URL in the list is valid
+                valid_url = ""
+                check_urls = URL_LIST
+                if self.base_url:
+                    check_urls = [self.base_url, *URL_LIST]
+                for url in check_urls:
+                    if await self.is_valid_ollama_url(url):
+                        valid_url = url
+                        break
+                if valid_url != "":
+                    build_config["base_url"]["value"] = valid_url
+                else:
+                    msg = "No valid Ollama URL found."
+                    raise ValueError(msg)
+        if field_name in {"model_name", "base_url", "tool_model_enabled"}:
+            if await self.is_valid_ollama_url(self.base_url):
+                tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
+                build_config["model_name"]["options"] = await self.get_models(
+                    self.base_url, tool_model_enabled=tool_model_enabled
+                )
+            elif await self.is_valid_ollama_url(build_config["base_url"].get("value", "")):
+                tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
+                build_config["model_name"]["options"] = await self.get_models(
+                    build_config["base_url"].get("value", ""), tool_model_enabled=tool_model_enabled
+                )
+            else:
+                build_config["model_name"]["options"] = []
+        if field_name == "keep_alive_flag":
+            if field_value == "Keep":
+                build_config["keep_alive"]["value"] = "-1"
+                build_config["keep_alive"]["advanced"] = True
+            elif field_value == "Immediately":
+                build_config["keep_alive"]["value"] = "0"
+                build_config["keep_alive"]["advanced"] = True
+            else:
+                build_config["keep_alive"]["advanced"] = False
+
+        return build_config
+
+    async def get_models(self, base_url_value: str, *, tool_model_enabled: bool | None = None) -> list[str]:
+        """Fetches a list of models from the Ollama API that do not have the "embedding" capability.
+
+        Args:
+            base_url_value (str): The base URL of the Ollama API.
+            tool_model_enabled (bool | None, optional): If True, filters the models further to include
+                only those that support tool calling. Defaults to None.
+
+        Returns:
+            list[str]: A list of model names that do not have the "embedding" capability. If
+                `tool_model_enabled` is True, only models supporting tool calling are included.
+
+        Raises:
+            ValueError: If there is an issue with the API request or response, or if the model
+                names cannot be retrieved.
+        """
+        try:
+            # Normalize the base URL to avoid the repeated "/" at the end
+            base_url = base_url_value.rstrip("/") + "/"
+
+            # Ollama REST API to return models
+            tags_url = urljoin(base_url, "api/tags")
+
+            # Ollama REST API to return model capabilities
+            show_url = urljoin(base_url, "api/show")
+
+            async with httpx.AsyncClient() as client:
+                # Fetch available models
+                tags_response = await client.get(tags_url)
+                tags_response.raise_for_status()
+                models = tags_response.json()
+                if asyncio.iscoroutine(models):
+                    models = await models
+                await logger.adebug(f"Available models: {models}")
+
+                # Filter models that are NOT embedding models
+                model_ids = []
+                for model in models[self.JSON_MODELS_KEY]:
+                    model_name = model[self.JSON_NAME_KEY]
+                    await logger.adebug(f"Checking model: {model_name}")
+
+                    payload = {"model": model_name}
+                    show_response = await client.post(show_url, json=payload)
+                    show_response.raise_for_status()
+                    json_data = show_response.json()
+                    if asyncio.iscoroutine(json_data):
+                        json_data = await json_data
+                    capabilities = json_data.get(self.JSON_CAPABILITIES_KEY, [])
+                    await logger.adebug(f"Model: {model_name}, Capabilities: {capabilities}")
+
+                    if self.DESIRED_CAPABILITY in capabilities and (
+                        not tool_model_enabled or self.TOOL_CALLING_CAPABILITY in capabilities
+                    ):
+                        model_ids.append(model_name)
+
+        except (httpx.RequestError, ValueError) as e:
+            msg = "Could not get model names from Ollama."
+            raise ValueError(msg) from e
+
+        return model_ids

lfx/components/ollama/ollama_embeddings.py

@@ -0,0 +1,106 @@
+from typing import Any
+from urllib.parse import urljoin
+
+import httpx
+from langchain_ollama import OllamaEmbeddings
+
+from lfx.base.models.model import LCModelComponent
+from lfx.base.models.ollama_constants import OLLAMA_EMBEDDING_MODELS, URL_LIST
+from lfx.field_typing import Embeddings
+from lfx.io import DropdownInput, MessageTextInput, Output
+
+HTTP_STATUS_OK = 200
+
+
+class OllamaEmbeddingsComponent(LCModelComponent):
+    display_name: str = "Ollama Embeddings"
+    description: str = "Generate embeddings using Ollama models."
+    documentation = "https://python.langchain.com/docs/integrations/text_embedding/ollama"
+    icon = "Ollama"
+    name = "OllamaEmbeddings"
+
+    inputs = [
+        DropdownInput(
+            name="model_name",
+            display_name="Ollama Model",
+            value="",
+            options=[],
+            real_time_refresh=True,
+            refresh_button=True,
+            combobox=True,
+            required=True,
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="Ollama Base URL",
+            value="",
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        try:
+            output = OllamaEmbeddings(model=self.model_name, base_url=self.base_url)
+        except Exception as e:
+            msg = (
+                "Unable to connect to the Ollama API. ",
+                "Please verify the base URL, ensure the relevant Ollama model is pulled, and try again.",
+            )
+            raise ValueError(msg) from e
+        return output
+
+    async def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None):
+        if field_name in {"base_url", "model_name"} and not await self.is_valid_ollama_url(field_value):
+            # Check if any URL in the list is valid
+            valid_url = ""
+            for url in URL_LIST:
+                if await self.is_valid_ollama_url(url):
+                    valid_url = url
+                    break
+            build_config["base_url"]["value"] = valid_url
+        if field_name in {"model_name", "base_url", "tool_model_enabled"}:
+            if await self.is_valid_ollama_url(self.base_url):
+                build_config["model_name"]["options"] = await self.get_model(self.base_url)
+            elif await self.is_valid_ollama_url(build_config["base_url"].get("value", "")):
+                build_config["model_name"]["options"] = await self.get_model(build_config["base_url"].get("value", ""))
+            else:
+                build_config["model_name"]["options"] = []
+
+        return build_config
+
+    async def get_model(self, base_url_value: str) -> list[str]:
+        """Get the model names from Ollama."""
+        model_ids = []
+        try:
+            url = urljoin(base_url_value, "/api/tags")
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                response.raise_for_status()
+                data = response.json()
+
+            model_ids = [model["name"] for model in data.get("models", [])]
+            # this to ensure that not embedding models are included.
+            # not even the base models since models can have 1b 2b etc
+            # handles cases when embeddings models have tags like :latest - etc.
+            model_ids = [
+                model
+                for model in model_ids
+                if any(model.startswith(f"{embedding_model}") for embedding_model in OLLAMA_EMBEDDING_MODELS)
+            ]
+
+        except (ImportError, ValueError, httpx.RequestError) as e:
+            msg = "Could not get model names from Ollama."
+            raise ValueError(msg) from e
+
+        return model_ids
+
+    async def is_valid_ollama_url(self, url: str) -> bool:
+        try:
+            async with httpx.AsyncClient() as client:
+                return (await client.get(f"{url}/api/tags")).status_code == HTTP_STATUS_OK
+        except httpx.RequestError:
+            return False

lfx/components/openai/__init__.py

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