langflow-base-nightly 0.5.0.dev38__py3-none-any.whl → 0.5.1.dev0__py3-none-any.whl

langflow/components/datastax/__init__.py

@@ -8,9 +8,9 @@ if TYPE_CHECKING:
     from .astra_assistant_manager import AstraAssistantManager
     from .astra_db import AstraDBChatMemory
     from .astra_vectorize import AstraVectorizeComponent
+    from .astradb import AstraDBVectorStoreComponent
     from .astradb_cql import AstraDBCQLToolComponent
     from .astradb_tool import AstraDBToolComponent
-    from .cassandra import CassandraChatMemory
     from .create_assistant import AssistantsCreateAssistant
     from .create_thread import AssistantsCreateThread
     from .dotenv import Dotenv
@@ -29,8 +29,8 @@ _dynamic_imports = {
     "AstraDBCQLToolComponent": "astradb_cql",
     "AstraDBChatMemory": "astra_db",
     "AstraDBToolComponent": "astradb_tool",
+    "AstraDBVectorStoreComponent": "astradb",
     "AstraVectorizeComponent": "astra_vectorize",
-    "CassandraChatMemory": "cassandra",
     "Dotenv": "dotenv",
     "GetEnvVar": "getenvvar",
 }
@@ -45,8 +45,8 @@ __all__ = [
     "AstraDBCQLToolComponent",
     "AstraDBChatMemory",
     "AstraDBToolComponent",
+    "AstraDBVectorStoreComponent",
     "AstraVectorizeComponent",
-    "CassandraChatMemory",
     "Dotenv",
     "GetEnvVar",
 ]

langflow/components/docling/docling_inline.py

@@ -61,11 +61,11 @@ class DoclingInlineComponent(BaseFileComponent):
         ),
         DropdownInput(
             name="ocr_engine",
-            display_name="Ocr",
-            info="OCR engine to use",
-            options=["", "easyocr", "tesserocr", "rapidocr", "ocrmac"],
+            display_name="OCR Engine",
+            info="OCR engine to use. None will disable OCR.",
+            options=["None", "easyocr", "tesserocr", "rapidocr", "ocrmac"],
             real_time_refresh=False,
-            value="",
+            value="None",
         ),
         # TODO: expose more Docling options
     ]
@@ -130,6 +130,58 @@ class DoclingInlineComponent(BaseFileComponent):
                 self.log("Warning: Process still alive after SIGKILL")
 
     def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        try:
+            from docling.datamodel.base_models import InputFormat
+            from docling.datamodel.pipeline_options import (
+                OcrOptions,
+                PdfPipelineOptions,
+                VlmPipelineOptions,
+            )
+            from docling.document_converter import DocumentConverter, FormatOption, PdfFormatOption
+            from docling.models.factories import get_ocr_factory
+            from docling.pipeline.vlm_pipeline import VlmPipeline
+        except ImportError as e:
+            msg = (
+                "Docling is an optional dependency. Install with `uv pip install 'langflow[docling]'` or refer to the "
+                "documentation on how to install optional dependencies."
+            )
+            raise ImportError(msg) from e
+
+        # Configure the standard PDF pipeline
+        def _get_standard_opts() -> PdfPipelineOptions:
+            pipeline_options = PdfPipelineOptions()
+            pipeline_options.do_ocr = self.ocr_engine != "None"
+            if pipeline_options.do_ocr:
+                ocr_factory = get_ocr_factory(
+                    allow_external_plugins=False,
+                )
+
+                ocr_options: OcrOptions = ocr_factory.create_options(
+                    kind=self.ocr_engine,
+                )
+                pipeline_options.ocr_options = ocr_options
+            return pipeline_options
+
+        # Configure the VLM pipeline
+        def _get_vlm_opts() -> VlmPipelineOptions:
+            return VlmPipelineOptions()
+
+        # Configure the main format options and create the DocumentConverter()
+        def _get_converter() -> DocumentConverter:
+            if self.pipeline == "standard":
+                pdf_format_option = PdfFormatOption(
+                    pipeline_options=_get_standard_opts(),
+                )
+            elif self.pipeline == "vlm":
+                pdf_format_option = PdfFormatOption(pipeline_cls=VlmPipeline, pipeline_options=_get_vlm_opts())
+
+            format_options: dict[InputFormat, FormatOption] = {
+                InputFormat.PDF: pdf_format_option,
+                InputFormat.IMAGE: pdf_format_option,
+            }
+
+            return DocumentConverter(format_options=format_options)
+
         file_paths = [file.path for file in file_list if file.path]
 
         if not file_paths:

langflow/components/elastic/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .elasticsearch import ElasticsearchVectorStoreComponent
+    from .opensearch import OpenSearchVectorStoreComponent
+
+_dynamic_imports = {
+    "ElasticsearchVectorStoreComponent": "elasticsearch",
+    "OpenSearchVectorStoreComponent": "opensearch",
+}
+
+__all__ = [
+    "ElasticsearchVectorStoreComponent",
+    "OpenSearchVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Elastic 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__)

langflow/components/milvus/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .milvus import MilvusVectorStoreComponent
+
+_dynamic_imports = {
+    "MilvusVectorStoreComponent": "milvus",
+}
+
+__all__ = [
+    "MilvusVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Milvus 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__)

langflow/components/mongodb/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .mongodb_atlas import MongoVectorStoreComponent
+
+_dynamic_imports = {
+    "MongoVectorStoreComponent": "mongodb_atlas",
+}
+
+__all__ = [
+    "MongoVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import MongoDB 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__)

langflow/components/nvidia/nvidia_ingest.py

@@ -21,8 +21,9 @@ class NvidiaIngestComponent(BaseFileComponent):
         VALID_EXTENSIONS = ["pdf", "docx", "pptx", "jpeg", "png", "svg", "tiff", "txt"]
     except ImportError:
         msg = (
-            "NVIDIA Retriever Extraction (nv-ingest) dependencies missing. "
-            "Please install them using your package manager. (e.g. uv pip install langflow[nv-ingest])"
+            "NVIDIA Retriever Extraction (nv-ingest) is an optional dependency. "
+            "Install with `uv pip install 'langflow[nv-ingest]'` "
+            "(requires Python 3.12>=)"
         )
         VALID_EXTENSIONS = [msg]
 

langflow/components/ollama/ollama.py

@@ -34,6 +34,7 @@ class ChatOllamaComponent(LCModelComponent):
             display_name="Base URL",
             info="Endpoint of the Ollama API.",
             value="",
+            real_time_refresh=True,
         ),
         DropdownInput(
             name="model_name",

langflow/components/perplexity/perplexity.py

@@ -31,9 +31,7 @@ class PerplexityComponent(LCModelComponent):
             ],
             value="llama-3.1-sonar-small-128k-online",
         ),
-        IntInput(
-            name="max_output_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."
-        ),
+        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",
@@ -57,20 +55,13 @@ class PerplexityComponent(LCModelComponent):
             "Note that the API may not return the full n completions if duplicates are generated.",
             advanced=True,
         ),
-        IntInput(
-            name="top_k",
-            display_name="Top K",
-            info="Decode using top-k sampling: consider the set of top_k most probable tokens. Must be positive.",
-            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_output_tokens = self.max_output_tokens
-        top_k = self.top_k
+        max_tokens = self.max_tokens
         top_p = self.top_p
         n = self.n
 
@@ -78,8 +69,7 @@ class PerplexityComponent(LCModelComponent):
             model=model,
             temperature=temperature or 0.75,
             pplx_api_key=api_key,
-            top_k=top_k or None,
             top_p=top_p or None,
             n=n or 1,
-            max_output_tokens=max_output_tokens,
+            max_tokens=max_tokens,
         )

langflow/components/pgvector/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.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__)

langflow/components/pinecone/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.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__)

langflow/components/qdrant/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .qdrant import QdrantVectorStoreComponent
+
+_dynamic_imports = {
+    "QdrantVectorStoreComponent": "qdrant",
+}
+
+__all__ = [
+    "QdrantVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Qdrant 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__)

langflow/components/redis/__init__.py

@@ -1,3 +1,37 @@
-from .redis import RedisIndexChatMemory
+from __future__ import annotations
 
-__all__ = ["RedisIndexChatMemory"]
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .redis import RedisVectorStoreComponent
+    from .redis_chat import RedisIndexChatMemory
+
+_dynamic_imports = {
+    "RedisVectorStoreComponent": "redis",
+    "RedisIndexChatMemory": "redis_chat",
+}
+
+__all__ = [
+    "RedisIndexChatMemory",
+    "RedisVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Redis 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__)

langflow/components/redis/redis.py

@@ -1,43 +1,89 @@
-from urllib import parse
+from pathlib import Path
 
-from langchain_community.chat_message_histories.redis import RedisChatMessageHistory
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.vectorstores.redis import Redis
 
-from langflow.base.memory.model import LCChatMemoryComponent
-from langflow.field_typing.constants import Memory
-from langflow.inputs.inputs import IntInput, MessageTextInput, SecretStrInput, StrInput
+from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
+from langflow.helpers.data import docs_to_data
+from langflow.io import HandleInput, IntInput, SecretStrInput, StrInput
+from langflow.schema.data import Data
 
 
-class RedisIndexChatMemory(LCChatMemoryComponent):
-    display_name = "Redis Chat Memory"
-    description = "Retrieves and store chat messages from Redis."
-    name = "RedisChatMemory"
+class RedisVectorStoreComponent(LCVectorStoreComponent):
+    """A custom component for implementing a Vector Store using Redis."""
+
+    display_name: str = "Redis"
+    description: str = "Implementation of Vector Store using Redis"
+    name = "Redis"
     icon = "Redis"
 
     inputs = [
+        SecretStrInput(name="redis_server_url", display_name="Redis Server Connection String", required=True),
         StrInput(
-            name="host", display_name="hostname", required=True, value="localhost", info="IP address or hostname."
-        ),
-        IntInput(name="port", display_name="port", required=True, value=6379, info="Redis Port Number."),
-        StrInput(name="database", display_name="database", required=True, value="0", info="Redis database."),
-        MessageTextInput(
-            name="username", display_name="Username", value="", info="The Redis user name.", advanced=True
+            name="redis_index_name",
+            display_name="Redis Index",
         ),
-        SecretStrInput(
-            name="password", display_name="Password", value="", info="The password for username.", advanced=True
+        StrInput(name="code", display_name="Code", advanced=True),
+        StrInput(
+            name="schema",
+            display_name="Schema",
         ),
-        StrInput(name="key_prefix", display_name="Key prefix", info="Key prefix.", advanced=True),
-        MessageTextInput(
-            name="session_id", display_name="Session ID", info="Session ID for the message.", advanced=True
+        *LCVectorStoreComponent.inputs,
+        IntInput(
+            name="number_of_results",
+            display_name="Number of Results",
+            info="Number of results to return.",
+            value=4,
+            advanced=True,
         ),
+        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
     ]
 
-    def build_message_history(self) -> Memory:
-        kwargs = {}
-        password: str | None = self.password
-        if self.key_prefix:
-            kwargs["key_prefix"] = self.key_prefix
-        if password:
-            password = parse.quote_plus(password)
+    @check_cached_vector_store
+    def build_vector_store(self) -> Redis:
+        # 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)
+        Path("docuemnts.txt").write_text(str(documents), encoding="utf-8")
+
+        if not documents:
+            if self.schema is None:
+                msg = "If no documents are provided, a schema must be provided."
+                raise ValueError(msg)
+            redis_vs = Redis.from_existing_index(
+                embedding=self.embedding,
+                index_name=self.redis_index_name,
+                schema=self.schema,
+                key_prefix=None,
+                redis_url=self.redis_server_url,
+            )
+        else:
+            text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+            docs = text_splitter.split_documents(documents)
+            redis_vs = Redis.from_documents(
+                documents=docs,
+                embedding=self.embedding,
+                redis_url=self.redis_server_url,
+                index_name=self.redis_index_name,
+            )
+        return redis_vs
+
+    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,
+            )
 
-        url = f"redis://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
-        return RedisChatMessageHistory(session_id=self.session_id, url=url, **kwargs)
+            data = docs_to_data(docs)
+            self.status = data
+            return data
+        return []

langflow/components/redis/redis_chat.py

@@ -0,0 +1,43 @@
+from urllib import parse
+
+from langchain_community.chat_message_histories.redis import RedisChatMessageHistory
+
+from langflow.base.memory.model import LCChatMemoryComponent
+from langflow.field_typing.constants import Memory
+from langflow.inputs.inputs import IntInput, MessageTextInput, SecretStrInput, StrInput
+
+
+class RedisIndexChatMemory(LCChatMemoryComponent):
+    display_name = "Redis Chat Memory"
+    description = "Retrieves and store chat messages from Redis."
+    name = "RedisChatMemory"
+    icon = "Redis"
+
+    inputs = [
+        StrInput(
+            name="host", display_name="hostname", required=True, value="localhost", info="IP address or hostname."
+        ),
+        IntInput(name="port", display_name="port", required=True, value=6379, info="Redis Port Number."),
+        StrInput(name="database", display_name="database", required=True, value="0", info="Redis database."),
+        MessageTextInput(
+            name="username", display_name="Username", value="", info="The Redis user name.", advanced=True
+        ),
+        SecretStrInput(
+            name="password", display_name="Password", value="", info="The password for username.", advanced=True
+        ),
+        StrInput(name="key_prefix", display_name="Key prefix", info="Key prefix.", advanced=True),
+        MessageTextInput(
+            name="session_id", display_name="Session ID", info="Session ID for the message.", advanced=True
+        ),
+    ]
+
+    def build_message_history(self) -> Memory:
+        kwargs = {}
+        password: str | None = self.password
+        if self.key_prefix:
+            kwargs["key_prefix"] = self.key_prefix
+        if password:
+            password = parse.quote_plus(password)
+
+        url = f"redis://{self.username}:{self.password}@{self.host}:{self.port}/{self.database}"
+        return RedisChatMessageHistory(session_id=self.session_id, url=url, **kwargs)

langflow/components/supabase/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .supabase import SupabaseVectorStoreComponent
+    from .supabase_composio import SupabaseComposioComponent
+
+_dynamic_imports = {
+    "SupabaseVectorStoreComponent": "supabase",
+    "SupabaseComposioComponent": "supabase_composio",
+}
+
+__all__ = [
+    "SupabaseComposioComponent",
+    "SupabaseVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Supabase 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__)

langflow/components/upstash/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .upstash import UpstashVectorStoreComponent
+
+_dynamic_imports = {
+    "UpstashVectorStoreComponent": "upstash",
+}
+
+__all__ = [
+    "UpstashVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Upstash 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__)