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

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

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

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