langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/vectorstores/local_db.py

@@ -1,261 +0,0 @@
-from copy import deepcopy
-from pathlib import Path
-
-from langchain_chroma import Chroma
-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
-
-
-class LocalDBComponent(LCVectorStoreComponent):
-    """Chroma Vector Store with search capabilities."""
-
-    display_name: str = "Local DB"
-    description: str = "Local Vector Store with search capabilities"
-    name = "LocalDB"
-    icon = "database"
-    legacy = True
-
-    inputs = [
-        TabInput(
-            name="mode",
-            display_name="Mode",
-            options=["Ingest", "Retrieve"],
-            info="Select the operation mode",
-            value="Ingest",
-            real_time_refresh=True,
-            show=True,
-        ),
-        MessageTextInput(
-            name="collection_name",
-            display_name="Collection Name",
-            value="langflow",
-            required=True,
-        ),
-        MessageTextInput(
-            name="persist_directory",
-            display_name="Persist Directory",
-            info=(
-                "Custom base directory to save the vector store. "
-                "Collections will be stored under '{directory}/vector_stores/{collection_name}'. "
-                "If not specified, it will use your system's cache folder."
-            ),
-            advanced=True,
-        ),
-        DropdownInput(
-            name="existing_collections",
-            display_name="Existing Collections",
-            options=[],  # Will be populated dynamically
-            info="Select a previously created collection to search through its stored data.",
-            show=False,
-            combobox=True,
-        ),
-        HandleInput(name="embedding", display_name="Embedding", required=True, input_types=["Embeddings"]),
-        BoolInput(
-            name="allow_duplicates",
-            display_name="Allow Duplicates",
-            advanced=True,
-            info="If false, will not add documents that are already in the Vector Store.",
-        ),
-        DropdownInput(
-            name="search_type",
-            display_name="Search Type",
-            options=["Similarity", "MMR"],
-            value="Similarity",
-            advanced=True,
-        ),
-        HandleInput(
-            name="ingest_data",
-            display_name="Ingest Data",
-            input_types=["Data", "DataFrame"],
-            is_list=True,
-            info="Data to store. It will be embedded and indexed for semantic search.",
-            show=True,
-        ),
-        MultilineInput(
-            name="search_query",
-            display_name="Search Query",
-            tool_mode=True,
-            info="Enter text to search for similar content in the selected collection.",
-            show=False,
-        ),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            advanced=True,
-            value=10,
-        ),
-        IntInput(
-            name="limit",
-            display_name="Limit",
-            advanced=True,
-            info="Limit the number of records to compare when Allow Duplicates is False.",
-        ),
-    ]
-    outputs = [
-        Output(display_name="DataFrame", name="dataframe", method="perform_search"),
-    ]
-
-    def get_vector_store_directory(self, base_dir: str | Path) -> Path:
-        """Get the full directory path for a collection."""
-        # Ensure base_dir is a Path object
-        base_dir = Path(base_dir)
-        # Create the full path: base_dir/vector_stores/collection_name
-        full_path = base_dir / "vector_stores" / self.collection_name
-        # Create the directory if it doesn't exist
-        full_path.mkdir(parents=True, exist_ok=True)
-        return full_path
-
-    def get_default_persist_dir(self) -> str:
-        """Get the default persist directory from cache."""
-        from langflow.services.cache.utils import CACHE_DIR
-
-        return str(self.get_vector_store_directory(CACHE_DIR))
-
-    def list_existing_collections(self) -> list[str]:
-        """List existing vector store collections from the persist directory."""
-        from langflow.services.cache.utils import CACHE_DIR
-
-        # Get the base directory (either custom or cache)
-        base_dir = Path(self.persist_directory) if self.persist_directory else Path(CACHE_DIR)
-        # Get the vector_stores subdirectory
-        vector_stores_dir = base_dir / "vector_stores"
-        if not vector_stores_dir.exists():
-            return []
-
-        return [d.name for d in vector_stores_dir.iterdir() if d.is_dir()]
-
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
-        """Update the build configuration when the mode changes."""
-        if field_name == "mode":
-            # Hide all dynamic fields by default
-            dynamic_fields = [
-                "ingest_data",
-                "search_query",
-                "search_type",
-                "number_of_results",
-                "existing_collections",
-                "collection_name",
-                "embedding",
-                "allow_duplicates",
-                "limit",
-            ]
-            for field in dynamic_fields:
-                if field in build_config:
-                    build_config[field]["show"] = False
-
-            # Show/hide fields based on selected mode
-            if field_value == "Ingest":
-                if "ingest_data" in build_config:
-                    build_config["ingest_data"]["show"] = True
-                if "collection_name" in build_config:
-                    build_config["collection_name"]["show"] = True
-                    build_config["collection_name"]["display_name"] = "Name Your Collection"
-                if "persist" in build_config:
-                    build_config["persist"]["show"] = True
-                if "persist_directory" in build_config:
-                    build_config["persist_directory"]["show"] = True
-                if "embedding" in build_config:
-                    build_config["embedding"]["show"] = True
-                if "allow_duplicates" in build_config:
-                    build_config["allow_duplicates"]["show"] = True
-                if "limit" in build_config:
-                    build_config["limit"]["show"] = True
-            elif field_value == "Retrieve":
-                if "persist" in build_config:
-                    build_config["persist"]["show"] = False
-                build_config["search_query"]["show"] = True
-                build_config["search_type"]["show"] = True
-                build_config["number_of_results"]["show"] = True
-                build_config["embedding"]["show"] = True
-                build_config["collection_name"]["show"] = False
-                # Show existing collections dropdown and update its options
-                if "existing_collections" in build_config:
-                    build_config["existing_collections"]["show"] = True
-                    build_config["existing_collections"]["options"] = self.list_existing_collections()
-                # Hide collection_name in Retrieve mode since we use existing_collections
-        elif field_name == "existing_collections":
-            # Update collection_name when an existing collection is selected
-            if "collection_name" in build_config:
-                build_config["collection_name"]["value"] = field_value
-
-        return build_config
-
-    @override
-    @check_cached_vector_store
-    def build_vector_store(self) -> Chroma:
-        """Builds the Chroma object."""
-        try:
-            from langchain_chroma import Chroma
-        except ImportError as e:
-            msg = "Could not import Chroma integration package. Please install it with `pip install langchain-chroma`."
-            raise ImportError(msg) from e
-        # Chroma settings
-        # chroma_settings = None
-        if self.existing_collections:
-            self.collection_name = self.existing_collections
-
-        # Use user-provided directory or default cache directory
-        if self.persist_directory:
-            base_dir = self.resolve_path(self.persist_directory)
-            persist_directory = str(self.get_vector_store_directory(base_dir))
-            logger.debug(f"Using custom persist directory: {persist_directory}")
-        else:
-            persist_directory = self.get_default_persist_dir()
-            logger.debug(f"Using default persist directory: {persist_directory}")
-
-        chroma = Chroma(
-            persist_directory=persist_directory,
-            client=None,
-            embedding_function=self.embedding,
-            collection_name=self.collection_name,
-        )
-
-        self._add_documents_to_vector_store(chroma)
-        self.status = chroma_collection_to_data(chroma.get(limit=self.limit))
-        return chroma
-
-    def _add_documents_to_vector_store(self, vector_store: "Chroma") -> None:
-        """Adds documents to the Vector Store."""
-        ingest_data: list | Data | DataFrame = self.ingest_data
-        if not ingest_data:
-            self.status = ""
-            return
-
-        # Convert DataFrame to Data if needed using parent's method
-        ingest_data = self._prepare_ingest_data()
-
-        stored_documents_without_id = []
-        if self.allow_duplicates:
-            stored_data = []
-        else:
-            stored_data = chroma_collection_to_data(vector_store.get(limit=self.limit))
-            for value in deepcopy(stored_data):
-                del value.id
-                stored_documents_without_id.append(value)
-
-        documents = []
-        for _input in ingest_data or []:
-            if isinstance(_input, Data):
-                if _input not in stored_documents_without_id:
-                    documents.append(_input.to_lc_document())
-            else:
-                msg = "Vector Store Inputs must be Data objects."
-                raise TypeError(msg)
-
-        if documents and self.embedding is not None:
-            self.log(f"Adding {len(documents)} documents to the Vector Store.")
-            vector_store.add_documents(documents)
-        else:
-            self.log("No documents to add to the Vector Store.")
-
-    def perform_search(self) -> DataFrame:
-        return DataFrame(self.search_documents())

langflow/components/vertexai/__init__.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from .vertexai import ChatVertexAIComponent
-    from .vertexai_embeddings import VertexAIEmbeddingsComponent
-
-_dynamic_imports = {
-    "ChatVertexAIComponent": "vertexai",
-    "VertexAIEmbeddingsComponent": "vertexai_embeddings",
-}
-
-__all__ = [
-    "ChatVertexAIComponent",
-    "VertexAIEmbeddingsComponent",
-]
-
-
-def __getattr__(attr_name: str) -> Any:
-    """Lazily import vertexai 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/vertexai/vertexai.py

@@ -1,71 +0,0 @@
-from typing import cast
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.inputs.inputs import MessageTextInput
-from langflow.io import BoolInput, FileInput, FloatInput, IntInput, StrInput
-
-
-class ChatVertexAIComponent(LCModelComponent):
-    display_name = "Vertex AI"
-    description = "Generate text using Vertex AI LLMs."
-    icon = "VertexAI"
-    name = "VertexAiModel"
-
-    inputs = [
-        *LCModelComponent._base_inputs,
-        FileInput(
-            name="credentials",
-            display_name="Credentials",
-            info="JSON credentials file. Leave empty to fallback to environment variables",
-            file_types=["json"],
-        ),
-        MessageTextInput(name="model_name", display_name="Model Name", value="gemini-1.5-pro"),
-        StrInput(name="project", display_name="Project", info="The project ID.", advanced=True),
-        StrInput(name="location", display_name="Location", value="us-central1", advanced=True),
-        IntInput(name="max_output_tokens", display_name="Max Output Tokens", advanced=True),
-        IntInput(name="max_retries", display_name="Max Retries", value=1, advanced=True),
-        FloatInput(name="temperature", value=0.0, display_name="Temperature"),
-        IntInput(name="top_k", display_name="Top K", advanced=True),
-        FloatInput(name="top_p", display_name="Top P", value=0.95, advanced=True),
-        BoolInput(name="verbose", display_name="Verbose", value=False, advanced=True),
-    ]
-
-    def build_model(self) -> LanguageModel:
-        try:
-            from langchain_google_vertexai import ChatVertexAI
-        except ImportError as e:
-            msg = "Please install the langchain-google-vertexai package to use the VertexAIEmbeddings component."
-            raise ImportError(msg) from e
-        location = self.location or None
-        if self.credentials:
-            from google.cloud import aiplatform
-            from google.oauth2 import service_account
-
-            credentials = service_account.Credentials.from_service_account_file(self.credentials)
-            project = self.project or credentials.project_id
-            # ChatVertexAI sometimes skip manual credentials initialization
-            aiplatform.init(
-                project=project,
-                location=location,
-                credentials=credentials,
-            )
-        else:
-            project = self.project or None
-            credentials = None
-
-        return cast(
-            "LanguageModel",
-            ChatVertexAI(
-                credentials=credentials,
-                location=location,
-                project=project,
-                max_output_tokens=self.max_output_tokens or None,
-                max_retries=self.max_retries,
-                model_name=self.model_name,
-                temperature=self.temperature,
-                top_k=self.top_k or None,
-                top_p=self.top_p,
-                verbose=self.verbose,
-            ),
-        )

langflow/components/vertexai/vertexai_embeddings.py

@@ -1,67 +0,0 @@
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import Embeddings
-from langflow.io import BoolInput, FileInput, FloatInput, IntInput, MessageTextInput, Output
-
-
-class VertexAIEmbeddingsComponent(LCModelComponent):
-    display_name = "Vertex AI Embeddings"
-    description = "Generate embeddings using Google Cloud Vertex AI models."
-    icon = "VertexAI"
-    name = "VertexAIEmbeddings"
-
-    inputs = [
-        FileInput(
-            name="credentials",
-            display_name="Credentials",
-            info="JSON credentials file. Leave empty to fallback to environment variables",
-            value="",
-            file_types=["json"],
-            required=True,
-        ),
-        MessageTextInput(name="location", display_name="Location", value="us-central1", advanced=True),
-        MessageTextInput(name="project", display_name="Project", info="The project ID.", advanced=True),
-        IntInput(name="max_output_tokens", display_name="Max Output Tokens", advanced=True),
-        IntInput(name="max_retries", display_name="Max Retries", value=1, advanced=True),
-        MessageTextInput(name="model_name", display_name="Model Name", value="textembedding-gecko", required=True),
-        IntInput(name="n", display_name="N", value=1, advanced=True),
-        IntInput(name="request_parallelism", value=5, display_name="Request Parallelism", advanced=True),
-        MessageTextInput(name="stop_sequences", display_name="Stop", advanced=True, is_list=True),
-        BoolInput(name="streaming", display_name="Streaming", value=False, advanced=True),
-        FloatInput(name="temperature", value=0.0, display_name="Temperature"),
-        IntInput(name="top_k", display_name="Top K", advanced=True),
-        FloatInput(name="top_p", display_name="Top P", value=0.95, advanced=True),
-    ]
-
-    outputs = [
-        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
-    ]
-
-    def build_embeddings(self) -> Embeddings:
-        try:
-            from langchain_google_vertexai import VertexAIEmbeddings
-        except ImportError as e:
-            msg = "Please install the langchain-google-vertexai package to use the VertexAIEmbeddings component."
-            raise ImportError(msg) from e
-
-        from google.oauth2 import service_account
-
-        if self.credentials:
-            gcloud_credentials = service_account.Credentials.from_service_account_file(self.credentials)
-        else:
-            # will fallback to environment variable or inferred from gcloud CLI
-            gcloud_credentials = None
-        return VertexAIEmbeddings(
-            credentials=gcloud_credentials,
-            location=self.location,
-            max_output_tokens=self.max_output_tokens or None,
-            max_retries=self.max_retries,
-            model_name=self.model_name,
-            n=self.n,
-            project=self.project,
-            request_parallelism=self.request_parallelism,
-            stop=self.stop_sequences or None,
-            streaming=self.streaming,
-            temperature=self.temperature,
-            top_k=self.top_k or None,
-            top_p=self.top_p,
-        )

langflow/components/weaviate/__init__.py

@@ -1,34 +0,0 @@
-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__)

langflow/components/weaviate/weaviate.py

@@ -1,89 +0,0 @@
-import weaviate
-from langchain_community.vectorstores import Weaviate
-
-from langflow.base.vectorstores.model import LCVectorStoreComponent, check_cached_vector_store
-from langflow.helpers.data import docs_to_data
-from langflow.io import BoolInput, HandleInput, IntInput, SecretStrInput, StrInput
-from langflow.schema.data import Data
-
-
-class WeaviateVectorStoreComponent(LCVectorStoreComponent):
-    display_name = "Weaviate"
-    description = "Weaviate Vector Store with search capabilities"
-    name = "Weaviate"
-    icon = "Weaviate"
-
-    inputs = [
-        StrInput(name="url", display_name="Weaviate URL", value="http://localhost:8080", required=True),
-        SecretStrInput(name="api_key", display_name="API Key", required=False),
-        StrInput(
-            name="index_name",
-            display_name="Index Name",
-            required=True,
-            info="Requires capitalized index name.",
-        ),
-        StrInput(name="text_key", display_name="Text Key", value="text", advanced=True),
-        *LCVectorStoreComponent.inputs,
-        HandleInput(name="embedding", display_name="Embedding", input_types=["Embeddings"]),
-        IntInput(
-            name="number_of_results",
-            display_name="Number of Results",
-            info="Number of results to return.",
-            value=4,
-            advanced=True,
-        ),
-        BoolInput(name="search_by_text", display_name="Search By Text", advanced=True),
-    ]
-
-    @check_cached_vector_store
-    def build_vector_store(self) -> Weaviate:
-        if self.api_key:
-            auth_config = weaviate.AuthApiKey(api_key=self.api_key)
-            client = weaviate.Client(url=self.url, auth_client_secret=auth_config)
-        else:
-            client = weaviate.Client(url=self.url)
-
-        if self.index_name != self.index_name.capitalize():
-            msg = f"Weaviate requires the index name to be capitalized. Use: {self.index_name.capitalize()}"
-            raise ValueError(msg)
-
-        # 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)
-
-        if documents and self.embedding:
-            return Weaviate.from_documents(
-                client=client,
-                index_name=self.index_name,
-                documents=documents,
-                embedding=self.embedding,
-                by_text=self.search_by_text,
-            )
-
-        return Weaviate(
-            client=client,
-            index_name=self.index_name,
-            text_key=self.text_key,
-            embedding=self.embedding,
-            by_text=self.search_by_text,
-        )
-
-    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,
-            )
-
-            data = docs_to_data(docs)
-            self.status = data
-            return data
-        return []

langflow/components/wikipedia/__init__.py

@@ -1,4 +0,0 @@
-from .wikidata import WikidataComponent
-from .wikipedia import WikipediaComponent
-
-__all__ = ["WikidataComponent", "WikipediaComponent"]

langflow/components/wikipedia/wikidata.py

@@ -1,86 +0,0 @@
-import httpx
-from httpx import HTTPError
-from langchain_core.tools import ToolException
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import MultilineInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class WikidataComponent(Component):
-    display_name = "Wikidata"
-    description = "Performs a search using the Wikidata API."
-    icon = "Wikipedia"
-
-    inputs = [
-        MultilineInput(
-            name="query",
-            display_name="Query",
-            info="The text query for similarity search on Wikidata.",
-            required=True,
-            tool_mode=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
-    ]
-
-    def run_model(self) -> DataFrame:
-        return self.fetch_content_dataframe()
-
-    def fetch_content(self) -> list[Data]:
-        try:
-            # Define request parameters for Wikidata API
-            params = {
-                "action": "wbsearchentities",
-                "format": "json",
-                "search": self.query,
-                "language": "en",
-            }
-
-            # Send request to Wikidata API
-            wikidata_api_url = "https://www.wikidata.org/w/api.php"
-            response = httpx.get(wikidata_api_url, params=params)
-            response.raise_for_status()
-            response_json = response.json()
-
-            # Extract search results
-            results = response_json.get("search", [])
-
-            if not results:
-                return [Data(data={"error": "No search results found for the given query."})]
-
-            # Transform the API response into Data objects
-            data = [
-                Data(
-                    text=f"{result['label']}: {result.get('description', '')}",
-                    data={
-                        "label": result["label"],
-                        "id": result.get("id"),
-                        "url": result.get("url"),
-                        "description": result.get("description", ""),
-                        "concepturi": result.get("concepturi"),
-                    },
-                )
-                for result in results
-            ]
-
-            self.status = data
-        except HTTPError as e:
-            error_message = f"HTTP Error in Wikidata Search API: {e!s}"
-            raise ToolException(error_message) from None
-        except KeyError as e:
-            error_message = f"Data parsing error in Wikidata API response: {e!s}"
-            raise ToolException(error_message) from None
-        except ValueError as e:
-            error_message = f"Value error in Wikidata API: {e!s}"
-            raise ToolException(error_message) from None
-        else:
-            return data
-
-    def fetch_content_dataframe(self) -> DataFrame:
-        data = self.fetch_content()
-        return DataFrame(data)