lfx-nightly 0.1.12.dev14__py3-none-any.whl → 0.1.12.dev16__py3-none-any.whl

lfx/base/agents/events.py

@@ -34,7 +34,7 @@ class InputDict(TypedDict):
 
 def _build_agent_input_text_content(agent_input_dict: InputDict) -> str:
     final_input = agent_input_dict.get("input", "")
-    return f"**Input**: {final_input}"
+    return f"{final_input}"
 
 
 def _calculate_duration(start_time: float) -> int:
@@ -90,34 +90,45 @@ def _extract_output_text(output: str | list) -> str:
         return output
     if isinstance(output, list) and len(output) == 0:
         return ""
-    if not isinstance(output, list) or len(output) != 1:
-        msg = f"Output is not a string or list of dictionaries with 'text' key: {output}"
-        raise TypeError(msg)
-
-    item = output[0]
-    if isinstance(item, str):
-        return item
-    if isinstance(item, dict):
-        if "text" in item:
-            return item["text"]
-        # If the item's type is "tool_use", return an empty string.
-        # This likely indicates that "tool_use" outputs are not meant to be displayed as text.
-        if item.get("type") == "tool_use":
-            return ""
-    if isinstance(item, dict):
-        if "text" in item:
-            return item["text"]
-        # If the item's type is "tool_use", return an empty string.
-        # This likely indicates that "tool_use" outputs are not meant to be displayed as text.
-        if item.get("type") == "tool_use":
-            return ""
-        # This is a workaround to deal with function calling by Anthropic
-        # since the same data comes in the tool_output we don't need to stream it here
-        # although it would be nice to
-        if "partial_json" in item:
-            return ""
-    msg = f"Output is not a string or list of dictionaries with 'text' key: {output}"
-    raise TypeError(msg)
+
+    # Handle lists of various lengths and formats
+    if isinstance(output, list):
+        # Handle single item lists
+        if len(output) == 1:
+            item = output[0]
+            if isinstance(item, str):
+                return item
+            if isinstance(item, dict):
+                if "text" in item:
+                    return item["text"] or ""
+                # If the item's type is "tool_use", return an empty string.
+                if item.get("type") == "tool_use":
+                    return ""
+                # Handle items with only 'index' key (from ChatBedrockConverse)
+                if "index" in item and len(item) == 1:
+                    return ""
+                # This is a workaround to deal with function calling by Anthropic
+                if "partial_json" in item:
+                    return ""
+
+        # Handle multiple items - extract text from all text-type items
+        else:
+            text_parts = []
+            for item in output:
+                if isinstance(item, str):
+                    text_parts.append(item)
+                elif isinstance(item, dict):
+                    if "text" in item and item["text"] is not None:
+                        text_parts.append(item["text"])
+                    # Skip tool_use, index-only, and partial_json items
+                    elif (
+                        item.get("type") == "tool_use" or "partial_json" in item or ("index" in item and len(item) == 1)
+                    ):
+                        continue
+            return "".join(text_parts)
+
+    # If we get here, the format is unexpected but try to be graceful
+    return ""
 
 
 async def handle_on_chain_end(

lfx/base/constants.py

@@ -43,4 +43,4 @@ FIELD_FORMAT_ATTRIBUTES = [
 ]
 SKIPPED_FIELD_ATTRIBUTES = ["advanced"]
 ORJSON_OPTIONS = orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS | orjson.OPT_OMIT_MICROSECONDS
-SKIPPED_COMPONENTS = {"LanguageModelComponent", "File", "FileComponent"}
+SKIPPED_COMPONENTS = {"LanguageModelComponent"}

lfx/base/data/docling_utils.py

@@ -16,6 +16,15 @@ if TYPE_CHECKING:
     from langchain_core.language_models.chat_models import BaseChatModel
 
 
+class DoclingDependencyError(Exception):
+    """Custom exception for missing Docling dependencies."""
+
+    def __init__(self, dependency_name: str, install_command: str):
+        self.dependency_name = dependency_name
+        self.install_command = install_command
+        super().__init__(f"{dependency_name} is not correctly installed. {install_command}")
+
+
 def extract_docling_documents(data_inputs: Data | list[Data] | DataFrame, doc_key: str) -> list[DoclingDocument]:
     documents: list[DoclingDocument] = []
     if isinstance(data_inputs, DataFrame):
@@ -249,22 +258,48 @@ def docling_worker(
             logger.debug(f"Processing file {i + 1}/{len(file_paths)}: {file_path}")
 
             try:
-                # Process single file (we can't easily interrupt convert_all)
                 single_result = converter.convert_all([file_path])
                 results.extend(single_result)
-
-                # Check for shutdown after each file
                 check_shutdown()
 
-            except (OSError, ValueError, RuntimeError, ImportError) as file_error:
-                # Handle specific file processing errors
+            except ImportError as import_error:
+                # Simply pass ImportError to main process for handling
+                queue.put(
+                    {"error": str(import_error), "error_type": "import_error", "original_exception": "ImportError"}
+                )
+                return
+
+            except (OSError, ValueError, RuntimeError) as file_error:
+                error_msg = str(file_error)
+
+                # Check for specific dependency errors and identify the dependency name
+                dependency_name = None
+                if "ocrmac is not correctly installed" in error_msg:
+                    dependency_name = "ocrmac"
+                elif "easyocr" in error_msg and "not installed" in error_msg:
+                    dependency_name = "easyocr"
+                elif "tesserocr" in error_msg and "not installed" in error_msg:
+                    dependency_name = "tesserocr"
+                elif "rapidocr" in error_msg and "not installed" in error_msg:
+                    dependency_name = "rapidocr"
+
+                if dependency_name:
+                    queue.put(
+                        {
+                            "error": error_msg,
+                            "error_type": "dependency_error",
+                            "dependency_name": dependency_name,
+                            "original_exception": type(file_error).__name__,
+                        }
+                    )
+                    return
+
+                # If not a dependency error, log and continue with other files
                 logger.error(f"Error processing file {file_path}: {file_error}")
-                # Continue with other files, but check for shutdown
                 check_shutdown()
+
             except Exception as file_error:  # noqa: BLE001
-                # Catch any other unexpected errors to prevent worker crash
                 logger.error(f"Unexpected error processing file {file_path}: {file_error}")
-                # Continue with other files, but check for shutdown
                 check_shutdown()
 
         # Final shutdown check before sending results

lfx/base/data/utils.py

@@ -13,17 +13,17 @@ from lfx.schema.data import Data
 # Types of files that can be read simply by file.read()
 # and have 100% to be completely readable
 TEXT_FILE_TYPES = [
+    "csv",
+    "json",
+    "pdf",
     "txt",
     "md",
     "mdx",
-    "csv",
-    "json",
     "yaml",
     "yml",
     "xml",
     "html",
     "htm",
-    "pdf",
     "docx",
     "py",
     "sh",

lfx/base/knowledge_bases/__init__.py

@@ -0,0 +1,3 @@
+from .knowledge_base_utils import compute_bm25, compute_tfidf, get_knowledge_bases
+
+__all__ = ["compute_bm25", "compute_tfidf", "get_knowledge_bases"]

lfx/base/knowledge_bases/knowledge_base_utils.py

@@ -0,0 +1,137 @@
+import math
+from collections import Counter
+from pathlib import Path
+from uuid import UUID
+
+from langflow.services.database.models.user.crud import get_user_by_id
+from langflow.services.deps import session_scope
+
+
+def compute_tfidf(documents: list[str], query_terms: list[str]) -> list[float]:
+    """Compute TF-IDF scores for query terms across a collection of documents.
+
+    Args:
+        documents: List of document strings
+        query_terms: List of query terms to score
+
+    Returns:
+        List of TF-IDF scores for each document
+    """
+    # Tokenize documents (simple whitespace splitting)
+    tokenized_docs = [doc.lower().split() for doc in documents]
+    n_docs = len(documents)
+
+    # Calculate document frequency for each term
+    document_frequencies = {}
+    for term in query_terms:
+        document_frequencies[term] = sum(1 for doc in tokenized_docs if term.lower() in doc)
+
+    scores = []
+
+    for doc_tokens in tokenized_docs:
+        doc_score = 0.0
+        doc_length = len(doc_tokens)
+        term_counts = Counter(doc_tokens)
+
+        for term in query_terms:
+            term_lower = term.lower()
+
+            # Term frequency (TF)
+            tf = term_counts[term_lower] / doc_length if doc_length > 0 else 0
+
+            # Inverse document frequency (IDF)
+            idf = math.log(n_docs / document_frequencies[term]) if document_frequencies[term] > 0 else 0
+
+            # TF-IDF score
+            doc_score += tf * idf
+
+        scores.append(doc_score)
+
+    return scores
+
+
+def compute_bm25(documents: list[str], query_terms: list[str], k1: float = 1.2, b: float = 0.75) -> list[float]:
+    """Compute BM25 scores for query terms across a collection of documents.
+
+    Args:
+        documents: List of document strings
+        query_terms: List of query terms to score
+        k1: Controls term frequency scaling (default: 1.2)
+        b: Controls document length normalization (default: 0.75)
+
+    Returns:
+        List of BM25 scores for each document
+    """
+    # Tokenize documents
+    tokenized_docs = [doc.lower().split() for doc in documents]
+    n_docs = len(documents)
+
+    # Calculate average document length
+    avg_doc_length = sum(len(doc) for doc in tokenized_docs) / n_docs if n_docs > 0 else 0
+
+    # Handle edge case where all documents are empty
+    if avg_doc_length == 0:
+        return [0.0] * n_docs
+
+    # Calculate document frequency for each term
+    document_frequencies = {}
+    for term in query_terms:
+        document_frequencies[term] = sum(1 for doc in tokenized_docs if term.lower() in doc)
+
+    scores = []
+
+    for doc_tokens in tokenized_docs:
+        doc_score = 0.0
+        doc_length = len(doc_tokens)
+        term_counts = Counter(doc_tokens)
+
+        for term in query_terms:
+            term_lower = term.lower()
+
+            # Term frequency in document
+            tf = term_counts[term_lower]
+
+            # Inverse document frequency (IDF)
+            # Use standard BM25 IDF formula that ensures non-negative values
+            idf = math.log(n_docs / document_frequencies[term]) if document_frequencies[term] > 0 else 0
+
+            # BM25 score calculation
+            numerator = tf * (k1 + 1)
+            denominator = tf + k1 * (1 - b + b * (doc_length / avg_doc_length))
+
+            # Handle division by zero when tf=0 and k1=0
+            term_score = 0 if denominator == 0 else idf * (numerator / denominator)
+
+            doc_score += term_score
+
+        scores.append(doc_score)
+
+    return scores
+
+
+async def get_knowledge_bases(kb_root: Path, user_id: UUID | str) -> list[str]:
+    """Retrieve a list of available knowledge bases.
+
+    Returns:
+        A list of knowledge base names.
+    """
+    if not kb_root.exists():
+        return []
+
+    # Get the current user
+    async with session_scope() as db:
+        if not user_id:
+            msg = "User ID is required for fetching knowledge bases."
+            raise ValueError(msg)
+        user_id = UUID(user_id) if isinstance(user_id, str) else user_id
+        current_user = await get_user_by_id(db, user_id)
+        if not current_user:
+            msg = f"User with ID {user_id} not found."
+            raise ValueError(msg)
+        kb_user = current_user.username
+    kb_path = kb_root / kb_user
+
+    if not kb_path.exists():
+        return []
+
+    return [str(d.name) for d in kb_path.iterdir() if not d.name.startswith(".") and d.is_dir()]

lfx/base/models/anthropic_constants.py

@@ -8,7 +8,9 @@ ANTHROPIC_MODELS_DETAILED = [
     create_model_metadata(provider="Anthropic", name="claude-3-5-sonnet-latest", icon="Anthropic", tool_calling=True),
     create_model_metadata(provider="Anthropic", name="claude-3-5-haiku-latest", icon="Anthropic", tool_calling=True),
     create_model_metadata(provider="Anthropic", name="claude-3-opus-latest", icon="Anthropic", tool_calling=True),
-    create_model_metadata(provider="Anthropic", name="claude-3-sonnet-20240229", icon="Anthropic", tool_calling=True),
+    create_model_metadata(
+        provider="Anthropic", name="claude-3-sonnet-20240229", icon="Anthropic", tool_calling=True, deprecated=True
+    ),
     # Tool calling unsupported models
     create_model_metadata(provider="Anthropic", name="claude-2.1", icon="Anthropic", tool_calling=False),
     create_model_metadata(provider="Anthropic", name="claude-2.0", icon="Anthropic", tool_calling=False),

lfx/base/models/model_input_constants.py

@@ -213,7 +213,7 @@ try:
         "prefix": "",
         "component_class": GroqModel(),
         "icon": GroqModel.icon,
-        "is_active": True,
+        "is_active": False,
     }
 except ImportError:
     pass

lfx/base/vectorstores/vector_store_connection_decorator.py

@@ -31,7 +31,7 @@ def vector_store_connection(cls):
                 [
                     Output(
                         display_name="Vector Store Connection",
-                        hidden=True,
+                        hidden=False,
                         name="vectorstoreconnection",
                         method="as_vector_store",
                         group_outputs=False,

lfx/components/agentql/agentql_api.py

@@ -17,7 +17,7 @@ class AgentQL(Component):
     inputs = [
         SecretStrInput(
             name="api_key",
-            display_name="API Key",
+            display_name="AgentQL API Key",
             required=True,
             password=True,
             info="Your AgentQL API key from dev.agentql.com",

lfx/components/agents/agent.py

@@ -9,7 +9,6 @@ from lfx.base.agents.events import ExceptionWithMessageError
 from lfx.base.models.model_input_constants import (
     ALL_PROVIDER_FIELDS,
     MODEL_DYNAMIC_UPDATE_FIELDS,
-    MODEL_PROVIDERS,
     MODEL_PROVIDERS_DICT,
     MODELS_METADATA,
 )
@@ -20,8 +19,8 @@ from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComp
 from lfx.custom.custom_component.component import get_component_toolkit
 from lfx.custom.utils import update_component_build_config
 from lfx.helpers.base_model import build_model_from_schema
-from lfx.inputs.inputs import TableInput
-from lfx.io import BoolInput, DropdownInput, IntInput, MultilineInput, Output
+from lfx.inputs.inputs import BoolInput
+from lfx.io import DropdownInput, IntInput, MultilineInput, Output, TableInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dotdict import dotdict
@@ -34,7 +33,7 @@ def set_advanced_true(component_input):
     return component_input
 
 
-MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "Groq", "OpenAI"]
+MODEL_PROVIDERS_LIST = ["Anthropic", "Google Generative AI", "OpenAI"]
 
 
 class AgentComponent(ToolCallingAgentComponent):
@@ -62,12 +61,24 @@ class AgentComponent(ToolCallingAgentComponent):
             name="agent_llm",
             display_name="Model Provider",
             info="The provider of the language model that the agent will use to generate responses.",
-            options=[*MODEL_PROVIDERS_LIST, "Custom"],
+            options=[*MODEL_PROVIDERS_LIST],
             value="OpenAI",
             real_time_refresh=True,
+            refresh_button=False,
             input_types=[],
             options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA]
             + [{"icon": "brain"}],
+            external_options={
+                "fields": {
+                    "data": {
+                        "node": {
+                            "name": "connect_other_models",
+                            "display_name": "Connect other models",
+                            "icon": "CornerDownLeft",
+                        }
+                    }
+                },
+            },
         ),
         *openai_inputs_filtered,
         MultilineInput(
@@ -159,7 +170,6 @@ class AgentComponent(ToolCallingAgentComponent):
     ]
     outputs = [
         Output(name="response", display_name="Response", method="message_response"),
-        Output(name="structured_response", display_name="Structured Response", method="json_response", tool_mode=False),
     ]
 
     async def get_agent_requirements(self):
@@ -228,7 +238,13 @@ class AgentComponent(ToolCallingAgentComponent):
             }
             # Ensure multiple is handled correctly
             if isinstance(processed_field["multiple"], str):
-                processed_field["multiple"] = processed_field["multiple"].lower() in ["true", "1", "t", "y", "yes"]
+                processed_field["multiple"] = processed_field["multiple"].lower() in [
+                    "true",
+                    "1",
+                    "t",
+                    "y",
+                    "yes",
+                ]
             processed_schema.append(processed_field)
         return processed_schema
 
@@ -343,7 +359,12 @@ class AgentComponent(ToolCallingAgentComponent):
                 raise
             try:
                 result = await self.run_agent(structured_agent)
-            except (ExceptionWithMessageError, ValueError, TypeError, RuntimeError) as e:
+            except (
+                ExceptionWithMessageError,
+                ValueError,
+                TypeError,
+                RuntimeError,
+            ) as e:
                 await logger.aerror(f"Error with structured agent result: {e}")
                 raise
             # Extract content from structured agent result
@@ -354,7 +375,13 @@ class AgentComponent(ToolCallingAgentComponent):
             else:
                 content = str(result)
 
-        except (ExceptionWithMessageError, ValueError, TypeError, NotImplementedError, AttributeError) as e:
+        except (
+            ExceptionWithMessageError,
+            ValueError,
+            TypeError,
+            NotImplementedError,
+            AttributeError,
+        ) as e:
             await logger.aerror(f"Error with structured chat agent: {e}")
             # Fallback to regular agent
             content_str = "No content returned from agent"
@@ -381,7 +408,11 @@ class AgentComponent(ToolCallingAgentComponent):
         # TODO: This is a temporary fix to avoid message duplication. We should develop a function for this.
         messages = (
             await MemoryComponent(**self.get_base_args())
-            .set(session_id=self.graph.session_id, order="Ascending", n_messages=self.n_messages)
+            .set(
+                session_id=self.graph.session_id,
+                order="Ascending",
+                n_messages=self.n_messages,
+            )
             .retrieve_messages()
         )
         return [
@@ -488,19 +519,31 @@ class AgentComponent(ToolCallingAgentComponent):
                 # Reset input types for agent_llm
                 build_config["agent_llm"]["input_types"] = []
                 build_config["agent_llm"]["display_name"] = "Model Provider"
-            elif field_value == "Custom":
+            elif field_value == "connect_other_models":
                 # Delete all provider fields
                 self.delete_fields(build_config, ALL_PROVIDER_FIELDS)
-                # Update with custom component
+                # # Update with custom component
                 custom_component = DropdownInput(
                     name="agent_llm",
                     display_name="Language Model",
-                    options=[*sorted(MODEL_PROVIDERS), "Custom"],
-                    value="Custom",
+                    info="The provider of the language model that the agent will use to generate responses.",
+                    options=[*MODEL_PROVIDERS_LIST],
                     real_time_refresh=True,
+                    refresh_button=False,
                     input_types=["LanguageModel"],
-                    options_metadata=[MODELS_METADATA[key] for key in sorted(MODELS_METADATA.keys())]
-                    + [{"icon": "brain"}],
+                    placeholder="Awaiting model input.",
+                    options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA],
+                    external_options={
+                        "fields": {
+                            "data": {
+                                "node": {
+                                    "name": "connect_other_models",
+                                    "display_name": "Connect other models",
+                                    "icon": "CornerDownLeft",
+                                },
+                            }
+                        },
+                    },
                 )
                 build_config.update({"agent_llm": custom_component.to_dict()})
             # Update input types for all fields
@@ -551,7 +594,9 @@ class AgentComponent(ToolCallingAgentComponent):
         # TODO: Agent Description Depreciated Feature to be removed
         description = f"{agent_description}{tools_names}"
         tools = component_toolkit(component=self).get_tools(
-            tool_name="Call_Agent", tool_description=description, callbacks=self.get_langchain_callbacks()
+            tool_name="Call_Agent",
+            tool_description=description,
+            callbacks=self.get_langchain_callbacks(),
         )
         if hasattr(self, "tools_metadata"):
             tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)

lfx/components/agents/mcp_component.py

@@ -275,7 +275,17 @@ class MCPToolsComponent(ComponentWithCache):
 
                 # To avoid unnecessary updates, only proceed if the server has actually changed
                 if (_last_selected_server in (current_server_name, "")) and build_config["tool"]["show"]:
-                    return build_config
+                    if current_server_name:
+                        servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                        if isinstance(servers_cache, dict):
+                            cached = servers_cache.get(current_server_name)
+                            if cached is not None and cached.get("tool_names"):
+                                cached_tools = cached["tool_names"]
+                                current_tools = build_config["tool"]["options"]
+                                if current_tools == cached_tools:
+                                    return build_config
+                    else:
+                        return build_config
 
                 # Determine if "Tool Mode" is active by checking if the tool dropdown is hidden.
                 is_in_tool_mode = build_config["tools_metadata"]["show"]

lfx/components/aiml/aiml.py

@@ -56,7 +56,10 @@ class AIMLModelComponent(LCModelComponent):
             required=True,
         ),
         SliderInput(
-            name="temperature", display_name="Temperature", value=0.1, range_spec=RangeSpec(min=0, max=2, step=0.01)
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
         ),
     ]