langflow-base-nightly 0.5.0.dev37__py3-none-any.whl → 0.5.0.dev39__py3-none-any.whl

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/serpapi/serp.py

@@ -2,12 +2,12 @@ from typing import Any
 
 from langchain_community.utilities.serpapi import SerpAPIWrapper
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

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/tavily/tavily_extract.py

@@ -1,8 +1,8 @@
 import httpx
-from loguru import logger
 
 from langflow.custom import Component
 from langflow.io import BoolInput, DropdownInput, MessageTextInput, Output, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema import Data
 from langflow.schema.dataframe import DataFrame
 

langflow/components/tavily/tavily_search.py

@@ -1,8 +1,8 @@
 import httpx
-from loguru import logger
 
 from langflow.custom.custom_component.component import Component
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 from langflow.template.field.base import Output

langflow/components/tools/calculator.py

@@ -3,12 +3,12 @@ import operator
 
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import MessageTextInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -87,7 +87,7 @@ class CalculatorToolComponent(LCToolComponent):
             self.status = error_message
             return [Data(data={"error": error_message, "input": expression})]
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error evaluating expression")
+            logger.debug("Error evaluating expression", exc_info=True)
             error_message = f"Error: {e}"
             self.status = error_message
             return [Data(data={"error": error_message, "input": expression})]

langflow/components/tools/python_code_structured_tool.py

@@ -4,21 +4,14 @@ from typing import Any
 
 from langchain.agents import Tool
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from pydantic.v1 import Field, create_model
 from pydantic.v1.fields import Undefined
 from typing_extensions import override
 
 from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.inputs.inputs import (
-    BoolInput,
-    DropdownInput,
-    FieldTypes,
-    HandleInput,
-    MessageTextInput,
-    MultilineInput,
-)
+from langflow.inputs.inputs import BoolInput, DropdownInput, FieldTypes, HandleInput, MessageTextInput, MultilineInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict
 
@@ -139,7 +132,7 @@ class PythonCodeStructuredTool(LCToolComponent):
             build_config["tool_function"]["options"] = names
         except Exception as e:  # noqa: BLE001
             self.status = f"Failed to extract names: {e}"
-            logger.opt(exception=True).debug(self.status)
+            logger.debug(self.status, exc_info=True)
             build_config["tool_function"]["options"] = ["Failed to parse", str(e)]
         return build_config
 

langflow/components/tools/python_repl.py

@@ -3,12 +3,12 @@ import importlib
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
 from langchain_experimental.utilities import PythonREPL
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import StrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -78,7 +78,7 @@ class PythonREPLToolComponent(LCToolComponent):
             try:
                 return python_repl.run(code)
             except Exception as e:
-                logger.opt(exception=True).debug("Error running Python code")
+                logger.debug("Error running Python code", exc_info=True)
                 raise ToolException(str(e)) from e
 
         tool = StructuredTool.from_function(

langflow/components/tools/searxng.py

@@ -5,12 +5,12 @@ from typing import Any
 import requests
 from langchain.agents import Tool
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from pydantic.v1 import Field, create_model
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput, MultiselectInput
 from langflow.io import Output
+from langflow.logging.logger import logger
 from langflow.schema.dotdict import dotdict
 
 
@@ -76,7 +76,7 @@ class SearXNGToolComponent(LCToolComponent):
             build_config["language"]["options"] = languages.copy()
         except Exception as e:  # noqa: BLE001
             self.status = f"Failed to extract names: {e}"
-            logger.opt(exception=True).debug(self.status)
+            logger.debug(self.status, exc_info=True)
             build_config["categories"]["options"] = ["Failed to parse", str(e)]
         return build_config
 
@@ -112,7 +112,7 @@ class SearXNGToolComponent(LCToolComponent):
                     num_results = min(SearxSearch._max_results, len(response["results"]))
                     return [response["results"][i] for i in range(num_results)]
                 except Exception as e:  # noqa: BLE001
-                    logger.opt(exception=True).debug("Error running SearXNG Search")
+                    logger.debug("Error running SearXNG Search", exc_info=True)
                     return [f"Failed to search: {e}"]
 
         SearxSearch._url = self.url

langflow/components/tools/serp_api.py

@@ -3,12 +3,12 @@ from typing import Any
 from langchain.tools import StructuredTool
 from langchain_community.utilities.serpapi import SerpAPIWrapper
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import DictInput, IntInput, MultilineInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 
@@ -111,7 +111,7 @@ class SerpAPIComponent(LCToolComponent):
             data_list = [Data(data=result, text=result.get("snippet", "")) for result in results]
 
         except Exception as e:  # noqa: BLE001
-            logger.opt(exception=True).debug("Error running SerpAPI")
+            logger.debug("Error running SerpAPI", exc_info=True)
             self.status = f"Error: {e}"
             return [Data(data={"error": str(e)}, text=str(e))]
 

langflow/components/tools/tavily_search_tool.py

@@ -3,12 +3,12 @@ from enum import Enum
 import httpx
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 # Add at the top with other constants
@@ -338,7 +338,7 @@ Note: Check 'Advanced' for all options.
             raise ToolException(error_message) from e
         except Exception as e:
             error_message = f"Unexpected error: {e}"
-            logger.opt(exception=True).debug("Error running Tavily Search")
+            logger.debug("Error running Tavily Search", exc_info=True)
             self.status = error_message
             raise ToolException(error_message) from e
         return data_results

langflow/components/tools/yahoo_finance.py

@@ -5,12 +5,12 @@ from enum import Enum
 import yfinance as yf
 from langchain.tools import StructuredTool
 from langchain_core.tools import ToolException
-from loguru import logger
 from pydantic import BaseModel, Field
 
 from langflow.base.langchain_utilities.model import LCToolComponent
 from langflow.field_typing import Tool
 from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 

langflow/components/twelvelabs/video_embeddings.py

@@ -29,9 +29,9 @@ class TwelveLabsVideoEmbeddings(Embeddings):
 
             # First try to use video embedding, then fall back to clip embedding if available
             if result["video_embedding"] is not None:
-                embeddings.append(cast(list[float], result["video_embedding"]))
+                embeddings.append(cast("list[float]", result["video_embedding"]))
             elif result["clip_embeddings"] and len(result["clip_embeddings"]) > 0:
-                embeddings.append(cast(list[float], result["clip_embeddings"][0]))
+                embeddings.append(cast("list[float]", result["clip_embeddings"][0]))
             else:
                 # If neither is available, raise an error
                 error_msg = "No embeddings were generated for the video"
@@ -45,9 +45,9 @@ class TwelveLabsVideoEmbeddings(Embeddings):
 
         # First try to use video embedding, then fall back to clip embedding if available
         if result["video_embedding"] is not None:
-            return cast(list[float], result["video_embedding"])
+            return cast("list[float]", result["video_embedding"])
         if result["clip_embeddings"] and len(result["clip_embeddings"]) > 0:
-            return cast(list[float], result["clip_embeddings"][0])
+            return cast("list[float]", result["clip_embeddings"][0])
         # If neither is available, raise an error
         error_msg = "No embeddings were generated for the video"
         raise ValueError(error_msg)

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

langflow/components/vectara/__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 .vectara import VectaraVectorStoreComponent
+    from .vectara_rag import VectaraRagComponent
+
+_dynamic_imports = {
+    "VectaraVectorStoreComponent": "vectara",
+    "VectaraRagComponent": "vectara_rag",
+}
+
+__all__ = [
+    "VectaraRagComponent",
+    "VectaraVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Vectara 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/vectorstores/__init__.py

@@ -5,83 +5,14 @@ from typing import TYPE_CHECKING, Any
 from langflow.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from .astradb import AstraDBVectorStoreComponent
-    from .astradb_graph import AstraDBGraphVectorStoreComponent
-    from .cassandra import CassandraVectorStoreComponent
-    from .cassandra_graph import CassandraGraphVectorStoreComponent
-    from .chroma import ChromaVectorStoreComponent
-    from .clickhouse import ClickhouseVectorStoreComponent
-    from .couchbase import CouchbaseVectorStoreComponent
-    from .elasticsearch import ElasticsearchVectorStoreComponent
-    from .faiss import FaissVectorStoreComponent
-    from .graph_rag import GraphRAGComponent
-    from .hcd import HCDVectorStoreComponent
     from .local_db import LocalDBComponent
-    from .milvus import MilvusVectorStoreComponent
-    from .mongodb_atlas import MongoVectorStoreComponent
-    from .opensearch import OpenSearchVectorStoreComponent
-    from .pgvector import PGVectorStoreComponent
-    from .pinecone import PineconeVectorStoreComponent
-    from .qdrant import QdrantVectorStoreComponent
-    from .redis import RedisVectorStoreComponent
-    from .supabase import SupabaseVectorStoreComponent
-    from .upstash import UpstashVectorStoreComponent
-    from .vectara import VectaraVectorStoreComponent
-    from .vectara_rag import VectaraRagComponent
-    from .weaviate import WeaviateVectorStoreComponent
 
 _dynamic_imports = {
-    "AstraDBVectorStoreComponent": "astradb",
-    "AstraDBGraphVectorStoreComponent": "astradb_graph",
-    "CassandraVectorStoreComponent": "cassandra",
-    "CassandraGraphVectorStoreComponent": "cassandra_graph",
-    "ChromaVectorStoreComponent": "chroma",
-    "ClickhouseVectorStoreComponent": "clickhouse",
-    "CouchbaseVectorStoreComponent": "couchbase",
-    "ElasticsearchVectorStoreComponent": "elasticsearch",
-    "FaissVectorStoreComponent": "faiss",
-    "GraphRAGComponent": "graph_rag",
-    "HCDVectorStoreComponent": "hcd",
     "LocalDBComponent": "local_db",
-    "MilvusVectorStoreComponent": "milvus",
-    "MongoVectorStoreComponent": "mongodb_atlas",
-    "OpenSearchVectorStoreComponent": "opensearch",
-    "PGVectorStoreComponent": "pgvector",
-    "PineconeVectorStoreComponent": "pinecone",
-    "QdrantVectorStoreComponent": "qdrant",
-    "RedisVectorStoreComponent": "redis",
-    "SupabaseVectorStoreComponent": "supabase",
-    "UpstashVectorStoreComponent": "upstash",
-    "VectaraVectorStoreComponent": "vectara",
-    "VectaraRagComponent": "vectara_rag",
-    "WeaviateVectorStoreComponent": "weaviate",
 }
 
 __all__ = [
-    "AstraDBGraphVectorStoreComponent",
-    "AstraDBVectorStoreComponent",
-    "CassandraGraphVectorStoreComponent",
-    "CassandraVectorStoreComponent",
-    "ChromaVectorStoreComponent",
-    "ClickhouseVectorStoreComponent",
-    "CouchbaseVectorStoreComponent",
-    "ElasticsearchVectorStoreComponent",
-    "FaissVectorStoreComponent",
-    "GraphRAGComponent",
-    "HCDVectorStoreComponent",
     "LocalDBComponent",
-    "MilvusVectorStoreComponent",
-    "MongoVectorStoreComponent",
-    "OpenSearchVectorStoreComponent",
-    "PGVectorStoreComponent",
-    "PineconeVectorStoreComponent",
-    "QdrantVectorStoreComponent",
-    "RedisVectorStoreComponent",
-    "SupabaseVectorStoreComponent",
-    "UpstashVectorStoreComponent",
-    "VectaraRagComponent",
-    "VectaraVectorStoreComponent",
-    "WeaviateVectorStoreComponent",
 ]
 
 

langflow/components/vectorstores/local_db.py

@@ -2,13 +2,13 @@ from copy import deepcopy
 from pathlib import Path
 
 from langchain_chroma import Chroma
-from loguru import logger
 from typing_extensions import override
 
 from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
 from langflow.base.vectorstores.utils import chroma_collection_to_data
 from langflow.inputs.inputs import MultilineInput
 from langflow.io import BoolInput, DropdownInput, HandleInput, IntInput, MessageTextInput, TabInput
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
 from langflow.template.field.base import Output
@@ -21,6 +21,7 @@ class LocalDBComponent(LCVectorStoreComponent):
     description: str = "Local Vector Store with search capabilities"
     name = "LocalDB"
     icon = "database"
+    legacy = True
 
     inputs = [
         TabInput(

langflow/components/weaviate/__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 .weaviate import WeaviateVectorStoreComponent
+
+_dynamic_imports = {
+    "WeaviateVectorStoreComponent": "weaviate",
+}
+
+__all__ = [
+    "WeaviateVectorStoreComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import Weaviate 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__)