lfx-nightly 0.2.0.dev41__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

lfx/components/models_and_agents/prompt.py

@@ -1,22 +1,36 @@
+from typing import Any
+
 from lfx.base.prompts.api_utils import process_prompt_template
 from lfx.custom.custom_component.component import Component
+from lfx.inputs.input_mixin import FieldTypes
 from lfx.inputs.inputs import DefaultPromptField
-from lfx.io import MessageTextInput, Output, PromptInput
+from lfx.io import BoolInput, MessageTextInput, Output, PromptInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
 from lfx.schema.message import Message
 from lfx.template.utils import update_template_values
+from lfx.utils.mustache_security import validate_mustache_template
 
 
 class PromptComponent(Component):
     display_name: str = "Prompt Template"
     description: str = "Create a prompt template with dynamic variables."
     documentation: str = "https://docs.langflow.org/components-prompts"
-    icon = "braces"
+    icon = "prompts"
     trace_type = "prompt"
     name = "Prompt Template"
     priority = 0  # Set priority to 0 to make it appear first
 
     inputs = [
         PromptInput(name="template", display_name="Template"),
+        BoolInput(
+            name="use_double_brackets",
+            display_name="Use Double Brackets",
+            value=False,
+            advanced=True,
+            info="Use {{variable}} syntax instead of {variable}.",
+            real_time_refresh=True,
+        ),
         MessageTextInput(
             name="tool_placeholder",
             display_name="Tool Placeholder",
@@ -30,34 +44,107 @@ class PromptComponent(Component):
         Output(display_name="Prompt", name="prompt", method="build_prompt"),
     ]
 
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        """Update the template field type based on the selected mode."""
+        if field_name == "use_double_brackets":
+            # Change the template field type based on mode
+            is_mustache = field_value is True
+            if is_mustache:
+                build_config["template"]["type"] = FieldTypes.MUSTACHE_PROMPT.value
+            else:
+                build_config["template"]["type"] = FieldTypes.PROMPT.value
+
+            # Re-process the template to update variables when mode changes
+            template_value = build_config.get("template", {}).get("value", "")
+            if template_value:
+                # Ensure custom_fields is properly initialized
+                if "custom_fields" not in build_config:
+                    build_config["custom_fields"] = {}
+
+                # Clean up fields from the OLD mode before processing with NEW mode
+                # This ensures we don't keep fields with wrong syntax even if validation fails
+                old_custom_fields = build_config["custom_fields"].get("template", [])
+                for old_field in list(old_custom_fields):
+                    # Remove the field from custom_fields and template
+                    if old_field in old_custom_fields:
+                        old_custom_fields.remove(old_field)
+                    build_config.pop(old_field, None)
+
+                # Try to process template with new mode to add new variables
+                # If validation fails, at least we cleaned up old fields
+                try:
+                    # Validate mustache templates for security
+                    if is_mustache:
+                        validate_mustache_template(template_value)
+
+                    # Re-process template with new mode to add new variables
+                    _ = process_prompt_template(
+                        template=template_value,
+                        name="template",
+                        custom_fields=build_config["custom_fields"],
+                        frontend_node_template=build_config,
+                        is_mustache=is_mustache,
+                    )
+                except ValueError as e:
+                    # If validation fails, we still updated the mode and cleaned old fields
+                    # User will see error when they try to save
+                    logger.debug(f"Template validation failed during mode switch: {e}")
+        return build_config
+
     async def build_prompt(self) -> Message:
-        prompt = Message.from_template(**self._attributes)
+        use_double_brackets = self.use_double_brackets if hasattr(self, "use_double_brackets") else False
+        template_format = "mustache" if use_double_brackets else "f-string"
+        prompt = await Message.from_template_and_variables(template_format=template_format, **self._attributes)
         self.status = prompt.text
         return prompt
 
     def _update_template(self, frontend_node: dict):
         prompt_template = frontend_node["template"]["template"]["value"]
-        custom_fields = frontend_node["custom_fields"]
-        frontend_node_template = frontend_node["template"]
-        _ = process_prompt_template(
-            template=prompt_template,
-            name="template",
-            custom_fields=custom_fields,
-            frontend_node_template=frontend_node_template,
-        )
+        use_double_brackets = frontend_node["template"].get("use_double_brackets", {}).get("value", False)
+        is_mustache = use_double_brackets is True
+
+        try:
+            # Validate mustache templates for security
+            if is_mustache:
+                validate_mustache_template(prompt_template)
+
+            custom_fields = frontend_node["custom_fields"]
+            frontend_node_template = frontend_node["template"]
+            _ = process_prompt_template(
+                template=prompt_template,
+                name="template",
+                custom_fields=custom_fields,
+                frontend_node_template=frontend_node_template,
+                is_mustache=is_mustache,
+            )
+        except ValueError as e:
+            # If validation fails, don't add variables but allow component to be created
+            logger.debug(f"Template validation failed in _update_template: {e}")
         return frontend_node
 
     async def update_frontend_node(self, new_frontend_node: dict, current_frontend_node: dict):
         """This function is called after the code validation is done."""
         frontend_node = await super().update_frontend_node(new_frontend_node, current_frontend_node)
         template = frontend_node["template"]["template"]["value"]
-        # Kept it duplicated for backwards compatibility
-        _ = process_prompt_template(
-            template=template,
-            name="template",
-            custom_fields=frontend_node["custom_fields"],
-            frontend_node_template=frontend_node["template"],
-        )
+        use_double_brackets = frontend_node["template"].get("use_double_brackets", {}).get("value", False)
+        is_mustache = use_double_brackets is True
+
+        try:
+            # Validate mustache templates for security
+            if is_mustache:
+                validate_mustache_template(template)
+
+            # Kept it duplicated for backwards compatibility
+            _ = process_prompt_template(
+                template=template,
+                name="template",
+                custom_fields=frontend_node["custom_fields"],
+                frontend_node_template=frontend_node["template"],
+                is_mustache=is_mustache,
+            )
+        except ValueError as e:
+            # If validation fails, don't add variables but allow component to be updated
+            logger.debug(f"Template validation failed in update_frontend_node: {e}")
         # Now that template is updated, we need to grab any values that were set in the current_frontend_node
         # and update the frontend_node with those values
         update_template_values(new_template=frontend_node, previous_template=current_frontend_node["template"])

lfx/components/ollama/ollama_embeddings.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import Any
 from urllib.parse import urljoin
 
@@ -5,9 +6,9 @@ import httpx
 from langchain_ollama import OllamaEmbeddings
 
 from lfx.base.models.model import LCModelComponent
-from lfx.base.models.ollama_constants import OLLAMA_EMBEDDING_MODELS
 from lfx.field_typing import Embeddings
-from lfx.io import DropdownInput, MessageTextInput, Output
+from lfx.io import DropdownInput, MessageTextInput, Output, SecretStrInput
+from lfx.log.logger import logger
 from lfx.utils.util import transform_localhost_url
 
 HTTP_STATUS_OK = 200
@@ -20,6 +21,12 @@ class OllamaEmbeddingsComponent(LCModelComponent):
     icon = "Ollama"
     name = "OllamaEmbeddings"
 
+    # Define constants for JSON keys
+    JSON_MODELS_KEY = "models"
+    JSON_NAME_KEY = "name"
+    JSON_CAPABILITIES_KEY = "capabilities"
+    EMBEDDING_CAPABILITY = "embedding"
+
     inputs = [
         DropdownInput(
             name="model_name",
@@ -34,8 +41,19 @@ class OllamaEmbeddingsComponent(LCModelComponent):
         MessageTextInput(
             name="base_url",
             display_name="Ollama Base URL",
-            value="",
+            info="Endpoint of the Ollama API. Defaults to http://localhost:11434.",
+            value="http://localhost:11434",
             required=True,
+            real_time_refresh=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Ollama API Key",
+            info="Your Ollama API key.",
+            value=None,
+            required=False,
+            real_time_refresh=True,
+            advanced=True,
         ),
     ]
 
@@ -43,25 +61,58 @@ class OllamaEmbeddingsComponent(LCModelComponent):
         Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
     ]
 
+    @property
+    def headers(self) -> dict[str, str] | None:
+        """Get the headers for the Ollama API."""
+        if self.api_key and self.api_key.strip():
+            return {"Authorization": f"Bearer {self.api_key}"}
+        return None
+
     def build_embeddings(self) -> Embeddings:
         transformed_base_url = transform_localhost_url(self.base_url)
+
+        # Strip /v1 suffix if present
+        if transformed_base_url and transformed_base_url.rstrip("/").endswith("/v1"):
+            transformed_base_url = transformed_base_url.rstrip("/").removesuffix("/v1")
+            logger.warning(
+                "Detected '/v1' suffix in base URL. The Ollama component uses the native Ollama API, "
+                "not the OpenAI-compatible API. The '/v1' suffix has been automatically removed. "
+                "If you want to use the OpenAI-compatible API, please use the OpenAI component instead. "
+                "Learn more at https://docs.ollama.com/openai#openai-compatibility"
+            )
+
+        llm_params = {
+            "model": self.model_name,
+            "base_url": transformed_base_url,
+        }
+
+        if self.headers:
+            llm_params["client_kwargs"] = {"headers": self.headers}
+
         try:
-            output = OllamaEmbeddings(model=self.model_name, base_url=transformed_base_url)
+            output = OllamaEmbeddings(**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.",
+                "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):
+    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(self.base_url):
             msg = "Ollama is not running on the provided base URL. Please start Ollama and try again."
             raise ValueError(msg)
-        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)
+        if field_name in {"model_name", "base_url"}:
+            # Use field_value if base_url is being updated, otherwise use self.base_url
+            base_url_to_check = field_value if field_name == "base_url" else self.base_url
+            # Fallback to self.base_url if field_value is None or empty
+            if not base_url_to_check and field_name == "base_url":
+                base_url_to_check = self.base_url
+            logger.warning(f"Fetching Ollama models from updated URL: {base_url_to_check}")
+
+            if base_url_to_check and await self.is_valid_ollama_url(base_url_to_check):
+                build_config["model_name"]["options"] = await self.get_model(base_url_to_check)
             else:
                 build_config["model_name"]["options"] = []
 
@@ -69,26 +120,49 @@ class OllamaEmbeddingsComponent(LCModelComponent):
 
     async def get_model(self, base_url_value: str) -> list[str]:
         """Get the model names from Ollama."""
-        model_ids = []
         try:
-            base_url_value = transform_localhost_url(base_url_value)
-            url = urljoin(base_url_value, "/api/tags")
+            # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+            base_url = base_url_value.rstrip("/").removesuffix("/v1")
+            if not base_url.endswith("/"):
+                base_url = base_url + "/"
+            base_url = transform_localhost_url(base_url)
+
+            # 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:
-                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:
+                headers = self.headers
+                # Fetch available models
+                tags_response = await client.get(url=tags_url, headers=headers)
+                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 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(url=show_url, json=payload, headers=headers)
+                    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.EMBEDDING_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
 
@@ -98,6 +172,14 @@ class OllamaEmbeddingsComponent(LCModelComponent):
         try:
             async with httpx.AsyncClient() as client:
                 url = transform_localhost_url(url)
-                return (await client.get(f"{url}/api/tags")).status_code == HTTP_STATUS_OK
+                if not url:
+                    return False
+                # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+                url = url.rstrip("/").removesuffix("/v1")
+                if not url.endswith("/"):
+                    url = url + "/"
+                return (
+                    await client.get(url=urljoin(url, "api/tags"), headers=self.headers)
+                ).status_code == HTTP_STATUS_OK
         except httpx.RequestError:
             return False

lfx/components/openai/openai_chat_model.py

@@ -98,7 +98,7 @@ class OpenAIModelComponent(LCModelComponent):
         # 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}")
+            logger.debug(f"API key type: {type(self.api_key)}, value: {'***' if self.api_key else None}")
             if isinstance(self.api_key, SecretStr):
                 api_key_value = self.api_key.get_secret_value()
             else: