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

langflow/api/v1/knowledge_bases.py

@@ -9,6 +9,7 @@ from langchain_chroma import Chroma
 from loguru import logger
 from pydantic import BaseModel
 
+from langflow.api.utils import CurrentActiveUser
 from langflow.services.deps import get_settings_service
 
 router = APIRouter(tags=["Knowledge Bases"], prefix="/knowledge_bases")
@@ -290,17 +291,19 @@ def get_kb_metadata(kb_path: Path) -> dict:
 
 @router.get("", status_code=HTTPStatus.OK)
 @router.get("/", status_code=HTTPStatus.OK)
-async def list_knowledge_bases() -> list[KnowledgeBaseInfo]:
+async def list_knowledge_bases(current_user: CurrentActiveUser) -> list[KnowledgeBaseInfo]:
     """List all available knowledge bases."""
     try:
         kb_root_path = get_kb_root_path()
+        kb_user = current_user.username
+        kb_path = kb_root_path / kb_user
 
-        if not kb_root_path.exists():
+        if not kb_path.exists():
             return []
 
         knowledge_bases = []
 
-        for kb_dir in kb_root_path.iterdir():
+        for kb_dir in kb_path.iterdir():
             if not kb_dir.is_dir() or kb_dir.name.startswith("."):
                 continue
 
@@ -340,11 +343,12 @@ async def list_knowledge_bases() -> list[KnowledgeBaseInfo]:
 
 
 @router.get("/{kb_name}", status_code=HTTPStatus.OK)
-async def get_knowledge_base(kb_name: str) -> KnowledgeBaseInfo:
+async def get_knowledge_base(kb_name: str, current_user: CurrentActiveUser) -> KnowledgeBaseInfo:
     """Get detailed information about a specific knowledge base."""
     try:
         kb_root_path = get_kb_root_path()
-        kb_path = kb_root_path / kb_name
+        kb_user = current_user.username
+        kb_path = kb_root_path / kb_user / kb_name
 
         if not kb_path.exists() or not kb_path.is_dir():
             raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
@@ -374,11 +378,12 @@ async def get_knowledge_base(kb_name: str) -> KnowledgeBaseInfo:
 
 
 @router.delete("/{kb_name}", status_code=HTTPStatus.OK)
-async def delete_knowledge_base(kb_name: str) -> dict[str, str]:
+async def delete_knowledge_base(kb_name: str, current_user: CurrentActiveUser) -> dict[str, str]:
     """Delete a specific knowledge base."""
     try:
         kb_root_path = get_kb_root_path()
-        kb_path = kb_root_path / kb_name
+        kb_user = current_user.username
+        kb_path = kb_root_path / kb_user / kb_name
 
         if not kb_path.exists() or not kb_path.is_dir():
             raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
@@ -396,15 +401,17 @@ async def delete_knowledge_base(kb_name: str) -> dict[str, str]:
 
 @router.delete("", status_code=HTTPStatus.OK)
 @router.delete("/", status_code=HTTPStatus.OK)
-async def delete_knowledge_bases_bulk(request: BulkDeleteRequest) -> dict[str, object]:
+async def delete_knowledge_bases_bulk(request: BulkDeleteRequest, current_user: CurrentActiveUser) -> dict[str, object]:
     """Delete multiple knowledge bases."""
     try:
         kb_root_path = get_kb_root_path()
+        kb_user = current_user.username
+        kb_user_path = kb_root_path / kb_user
         deleted_count = 0
         not_found_kbs = []
 
         for kb_name in request.kb_names:
-            kb_path = kb_root_path / kb_name
+            kb_path = kb_user_path / kb_name
 
             if not kb_path.exists() or not kb_path.is_dir():
                 not_found_kbs.append(kb_name)

langflow/api/v2/files.py

@@ -123,7 +123,9 @@ async def upload_user_file(
             unique_filename = new_filename
         else:
             # For normal files, ensure unique name by appending a count if necessary
-            stmt = select(UserFile).where(col(UserFile.name).like(f"{root_filename}%"))
+            stmt = select(UserFile).where(
+                col(UserFile.name).like(f"{root_filename}%"), UserFile.user_id == current_user.id
+            )
             existing_files = await session.exec(stmt)
             files = existing_files.all()  # Fetch all matching records
 

langflow/base/data/kb_utils.py

@@ -1,5 +1,10 @@
 import math
 from collections import Counter
+from pathlib import Path
+from uuid import UUID
+
+from langflow.services.database.models.user.crud import get_user_by_id
+from langflow.services.deps import session_scope
 
 
 def compute_tfidf(documents: list[str], query_terms: list[str]) -> list[float]:
@@ -102,3 +107,31 @@ def compute_bm25(documents: list[str], query_terms: list[str], k1: float = 1.2,
         scores.append(doc_score)
 
     return scores
+
+
+async def get_knowledge_bases(kb_root: Path, user_id: UUID | str) -> list[str]:
+    """Retrieve a list of available knowledge bases.
+
+    Returns:
+        A list of knowledge base names.
+    """
+    if not kb_root.exists():
+        return []
+
+    # Get the current user
+    async with session_scope() as db:
+        if not user_id:
+            msg = "User ID is required for fetching knowledge bases."
+            raise ValueError(msg)
+        user_id = UUID(user_id) if isinstance(user_id, str) else user_id
+        current_user = await get_user_by_id(db, user_id)
+        if not current_user:
+            msg = f"User with ID {user_id} not found."
+            raise ValueError(msg)
+        kb_user = current_user.username
+    kb_path = kb_root / kb_user
+
+    if not kb_path.exists():
+        return []
+
+    return [str(d.name) for d in kb_path.iterdir() if not d.name.startswith(".") and d.is_dir()]

langflow/base/models/model.py

@@ -252,7 +252,7 @@ class LCModelComponent(Component):
             if stream:
                 lf_message, result = await self._handle_stream(runnable, inputs)
             else:
-                message = runnable.invoke(inputs)
+                message = await runnable.ainvoke(inputs)
                 result = message.content if hasattr(message, "content") else message
             if isinstance(message, AIMessage):
                 status_message = self.build_status_message(message)
@@ -288,7 +288,7 @@ class LCModelComponent(Component):
             else:
                 session_id = None
             model_message = Message(
-                text=runnable.stream(inputs),
+                text=runnable.astream(inputs),
                 sender=MESSAGE_SENDER_AI,
                 sender_name="AI",
                 properties={"icon": self.icon, "state": "partial"},
@@ -298,7 +298,7 @@ class LCModelComponent(Component):
             lf_message = await self.send_message(model_message)
             result = lf_message.text
         else:
-            message = runnable.invoke(inputs)
+            message = await runnable.ainvoke(inputs)
             result = message.content if hasattr(message, "content") else message
         return lf_message, result
 

langflow/components/agents/mcp_component.py

@@ -16,16 +16,15 @@ from langflow.base.mcp.util import (
 )
 from langflow.custom.custom_component.component_with_cache import ComponentWithCache
 from langflow.inputs.inputs import InputTypes  # noqa: TC001
-from langflow.io import DropdownInput, McpInput, MessageTextInput, Output, SecretStrInput
+from langflow.io import DropdownInput, McpInput, MessageTextInput, Output
 from langflow.io.schema import flatten_schema, schema_to_langflow_inputs
 from langflow.logging import logger
 from langflow.schema.dataframe import DataFrame
 from langflow.schema.message import Message
 
 # Import get_server from the backend API
-from langflow.services.auth.utils import create_user_longterm_token, get_current_user
 from langflow.services.database.models.user.crud import get_user_by_id
-from langflow.services.deps import get_session, get_settings_service, get_storage_service
+from langflow.services.deps import get_settings_service, get_storage_service, session_scope
 
 
 class MCPToolsComponent(ComponentWithCache):
@@ -96,13 +95,6 @@ class MCPToolsComponent(ComponentWithCache):
             show=False,
             tool_mode=False,
         ),
-        SecretStrInput(
-            name="api_key",
-            display_name="Langflow API Key",
-            info="Langflow API key for authentication when fetching MCP servers and tools.",
-            required=False,
-            advanced=True,
-        ),
     ]
 
     outputs = [
@@ -161,19 +153,11 @@ class MCPToolsComponent(ComponentWithCache):
             return self.tools, {"name": server_name, "config": server_config_from_value}
 
         try:
-            async for db in get_session():
-                # TODO: In 1.6, this may need to be removed or adjusted
-                # Try to get the super user token, if possible
-                if self.api_key:
-                    current_user = await get_current_user(
-                        token=None,
-                        query_param=self.api_key,
-                        header_param=None,
-                        db=db,
-                    )
-                else:
-                    user_id, _ = await create_user_longterm_token(db)
-                    current_user = await get_user_by_id(db, user_id)
+            async with session_scope() as db:
+                if not self.user_id:
+                    msg = "User ID is required for fetching MCP tools."
+                    raise ValueError(msg)
+                current_user = await get_user_by_id(db, self.user_id)
 
                 # Try to get server config from DB/API
                 server_config = await get_server(
@@ -184,39 +168,38 @@ class MCPToolsComponent(ComponentWithCache):
                     settings_service=get_settings_service(),
                 )
 
-                # If get_server returns empty but we have a config, use it
-                if not server_config and server_config_from_value:
-                    server_config = server_config_from_value
-
-                if not server_config:
-                    self.tools = []
-                    return [], {"name": server_name, "config": server_config}
+            # If get_server returns empty but we have a config, use it
+            if not server_config and server_config_from_value:
+                server_config = server_config_from_value
+
+            if not server_config:
+                self.tools = []
+                return [], {"name": server_name, "config": server_config}
+
+            _, tool_list, tool_cache = await update_tools(
+                server_name=server_name,
+                server_config=server_config,
+                mcp_stdio_client=self.stdio_client,
+                mcp_sse_client=self.sse_client,
+            )
+
+            self.tool_names = [tool.name for tool in tool_list if hasattr(tool, "name")]
+            self._tool_cache = tool_cache
+            self.tools = tool_list
+            # Cache the result using shared cache
+            cache_data = {
+                "tools": tool_list,
+                "tool_names": self.tool_names,
+                "tool_cache": tool_cache,
+                "config": server_config,
+            }
+
+            # Safely update the servers cache
+            current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+            if isinstance(current_servers_cache, dict):
+                current_servers_cache[server_name] = cache_data
+                safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
 
-                _, tool_list, tool_cache = await update_tools(
-                    server_name=server_name,
-                    server_config=server_config,
-                    mcp_stdio_client=self.stdio_client,
-                    mcp_sse_client=self.sse_client,
-                )
-
-                self.tool_names = [tool.name for tool in tool_list if hasattr(tool, "name")]
-                self._tool_cache = tool_cache
-                self.tools = tool_list
-                # Cache the result using shared cache
-                cache_data = {
-                    "tools": tool_list,
-                    "tool_names": self.tool_names,
-                    "tool_cache": tool_cache,
-                    "config": server_config,
-                }
-
-                # Safely update the servers cache
-                current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
-                if isinstance(current_servers_cache, dict):
-                    current_servers_cache[server_name] = cache_data
-                    safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
-
-                return tool_list, {"name": server_name, "config": server_config}
         except (TimeoutError, asyncio.TimeoutError) as e:
             msg = f"Timeout updating tool list: {e!s}"
             logger.exception(msg)
@@ -225,6 +208,8 @@ class MCPToolsComponent(ComponentWithCache):
             msg = f"Error updating tool list: {e!s}"
             logger.exception(msg)
             raise ValueError(msg) from e
+        else:
+            return tool_list, {"name": server_name, "config": server_config}
 
     async def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
         """Toggle the visibility of connection-specific fields based on the selected mode."""

langflow/components/data/kb_ingest.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import asyncio
+import contextlib
 import hashlib
 import json
 import re
@@ -14,6 +16,7 @@ from cryptography.fernet import InvalidToken
 from langchain_chroma import Chroma
 from loguru import logger
 
+from langflow.base.data.kb_utils import get_knowledge_bases
 from langflow.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
 from langflow.custom import Component
 from langflow.io import BoolInput, DataFrameInput, DropdownInput, IntInput, Output, SecretStrInput, StrInput, TableInput
@@ -21,7 +24,8 @@ from langflow.schema.data import Data
 from langflow.schema.dotdict import dotdict  # noqa: TC001
 from langflow.schema.table import EditMode
 from langflow.services.auth.utils import decrypt_api_key, encrypt_api_key
-from langflow.services.deps import get_settings_service
+from langflow.services.database.models.user.crud import get_user_by_id
+from langflow.services.deps import get_settings_service, get_variable_service, session_scope
 
 HUGGINGFACE_MODEL_NAMES = ["sentence-transformers/all-MiniLM-L6-v2", "sentence-transformers/all-mpnet-base-v2"]
 COHERE_MODEL_NAMES = ["embed-english-v3.0", "embed-multilingual-v3.0"]
@@ -43,6 +47,10 @@ class KBIngestionComponent(Component):
     icon = "database"
     name = "KBIngestion"
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._cached_kb_path: Path | None = None
+
     @dataclass
     class NewKnowledgeBaseInput:
         functionality: str = "create"
@@ -76,7 +84,7 @@ class KBIngestionComponent(Component):
                                 display_name="API Key",
                                 info="Provider API key for embedding model",
                                 required=True,
-                                load_from_db=True,
+                                load_from_db=False,
                             ),
                         },
                     },
@@ -91,11 +99,7 @@ class KBIngestionComponent(Component):
             display_name="Knowledge",
             info="Select the knowledge to load data from.",
             required=True,
-            options=[
-                str(d.name) for d in KNOWLEDGE_BASES_ROOT_PATH.iterdir() if not d.name.startswith(".") and d.is_dir()
-            ]
-            if KNOWLEDGE_BASES_ROOT_PATH.exists()
-            else [],
+            options=[],
             refresh_button=True,
             dialog_inputs=asdict(NewKnowledgeBaseInput()),
         ),
@@ -329,22 +333,23 @@ class KBIngestionComponent(Component):
 
         return metadata
 
-    def _create_vector_store(
+    async def _create_vector_store(
         self, df_source: pd.DataFrame, config_list: list[dict[str, Any]], embedding_model: str, api_key: str
     ) -> None:
         """Create vector store following Local DB component pattern."""
         try:
             # Set up vector store directory
-            base_dir = self._get_kb_root()
-
-            vector_store_dir = base_dir / self.knowledge_base
+            vector_store_dir = await self._kb_path()
+            if not vector_store_dir:
+                msg = "Knowledge base path is not set. Please create a new knowledge base first."
+                raise ValueError(msg)
             vector_store_dir.mkdir(parents=True, exist_ok=True)
 
             # Create embeddings model
             embedding_function = self._build_embeddings(embedding_model, api_key)
 
             # Convert DataFrame to Data objects (following Local DB pattern)
-            data_objects = self._convert_df_to_data_objects(df_source, config_list)
+            data_objects = await self._convert_df_to_data_objects(df_source, config_list)
 
             # Create vector store
             chroma = Chroma(
@@ -367,16 +372,18 @@ class KBIngestionComponent(Component):
         except (OSError, ValueError, RuntimeError) as e:
             self.log(f"Error creating vector store: {e}")
 
-    def _convert_df_to_data_objects(self, df_source: pd.DataFrame, config_list: list[dict[str, Any]]) -> list[Data]:
+    async def _convert_df_to_data_objects(
+        self, df_source: pd.DataFrame, config_list: list[dict[str, Any]]
+    ) -> list[Data]:
         """Convert DataFrame to Data objects for vector store."""
         data_objects: list[Data] = []
 
         # Set up vector store directory
-        base_dir = self._get_kb_root()
+        kb_path = await self._kb_path()
 
         # If we don't allow duplicates, we need to get the existing hashes
         chroma = Chroma(
-            persist_directory=str(base_dir / self.knowledge_base),
+            persist_directory=str(kb_path),
             collection_name=self.knowledge_base,
         )
 
@@ -466,10 +473,34 @@ class KBIngestionComponent(Component):
         # Check allowed characters (condition 3)
         return re.match(r"^[a-zA-Z0-9_-]+$", name) is not None
 
+    async def _kb_path(self) -> Path | None:
+        # Check if we already have the path cached
+        cached_path = getattr(self, "_cached_kb_path", None)
+        if cached_path is not None:
+            return cached_path
+
+        # If not cached, compute it
+        async with session_scope() as db:
+            if not self.user_id:
+                msg = "User ID is required for fetching knowledge base path."
+                raise ValueError(msg)
+            current_user = await get_user_by_id(db, self.user_id)
+            if not current_user:
+                msg = f"User with ID {self.user_id} not found."
+                raise ValueError(msg)
+            kb_user = current_user.username
+
+        kb_root = self._get_kb_root()
+
+        # Cache the result
+        self._cached_kb_path = kb_root / kb_user / self.knowledge_base
+
+        return self._cached_kb_path
+
     # ---------------------------------------------------------------------
     #                         OUTPUT METHODS
     # ---------------------------------------------------------------------
-    def build_kb_info(self) -> Data:
+    async def build_kb_info(self) -> Data:
         """Main ingestion routine → returns a dict with KB metadata."""
         try:
             # Get source DataFrame
@@ -479,11 +510,11 @@ class KBIngestionComponent(Component):
             config_list = self._validate_column_config(df_source)
             column_metadata = self._build_column_metadata(config_list, df_source)
 
-            # Prepare KB folder (using File Component patterns)
-            kb_root = self._get_kb_root()
-            kb_path = kb_root / self.knowledge_base
-
             # Read the embedding info from the knowledge base folder
+            kb_path = await self._kb_path()
+            if not kb_path:
+                msg = "Knowledge base path is not set. Please create a new knowledge base first."
+                raise ValueError(msg)
             metadata_path = kb_path / "embedding_metadata.json"
 
             # If the API key is not provided, try to read it from the metadata file
@@ -506,7 +537,7 @@ class KBIngestionComponent(Component):
                 )
 
             # Create vector store following Local DB component pattern
-            self._create_vector_store(df_source, config_list, embedding_model=embedding_model, api_key=api_key)
+            await self._create_vector_store(df_source, config_list, embedding_model=embedding_model, api_key=api_key)
 
             # Save KB files (using File Component storage patterns)
             self._save_kb_files(kb_path, config_list)
@@ -532,40 +563,77 @@ class KBIngestionComponent(Component):
             self.status = f"❌ KB ingestion failed: {e}"
             return Data(data={"error": str(e), "kb_name": self.knowledge_base})
 
-    def _get_knowledge_bases(self) -> list[str]:
-        """Retrieve a list of available knowledge bases.
-
-        Returns:
-            A list of knowledge base names.
-        """
-        # Return the list of directories in the knowledge base root path
-        kb_root_path = self._get_kb_root()
-
-        if not kb_root_path.exists():
-            return []
-
-        return [str(d.name) for d in kb_root_path.iterdir() if not d.name.startswith(".") and d.is_dir()]
+    async def _get_api_key_variable(self, field_value: dict[str, Any]):
+        async with session_scope() as db:
+            if not self.user_id:
+                msg = "User ID is required for fetching global variables."
+                raise ValueError(msg)
+            current_user = await get_user_by_id(db, self.user_id)
+            if not current_user:
+                msg = f"User with ID {self.user_id} not found."
+                raise ValueError(msg)
+            variable_service = get_variable_service()
+
+            # Process the api_key field variable
+            return await variable_service.get_variable(
+                user_id=current_user.id,
+                name=field_value["03_api_key"],
+                field="",
+                session=db,
+            )
 
-    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+    async def update_build_config(
+        self,
+        build_config: dotdict,
+        field_value: Any,
+        field_name: str | None = None,
+    ) -> dotdict:
         """Update build configuration based on provider selection."""
         # Create a new knowledge base
         if field_name == "knowledge_base":
+            async with session_scope() as db:
+                if not self.user_id:
+                    msg = "User ID is required for fetching knowledge base list."
+                    raise ValueError(msg)
+                current_user = await get_user_by_id(db, self.user_id)
+                if not current_user:
+                    msg = f"User with ID {self.user_id} not found."
+                    raise ValueError(msg)
+                kb_user = current_user.username
             if isinstance(field_value, dict) and "01_new_kb_name" in field_value:
                 # Validate the knowledge base name - Make sure it follows these rules:
                 if not self.is_valid_collection_name(field_value["01_new_kb_name"]):
                     msg = f"Invalid knowledge base name: {field_value['01_new_kb_name']}"
                     raise ValueError(msg)
 
+                api_key = field_value.get("03_api_key", None)
+                with contextlib.suppress(Exception):
+                    # If the API key is a variable, resolve it
+                    api_key = await self._get_api_key_variable(field_value)
+
+                # Make sure api_key is a string
+                if not isinstance(api_key, str):
+                    msg = "API key must be a string."
+                    raise ValueError(msg)
+
                 # We need to test the API Key one time against the embedding model
-                embed_model = self._build_embeddings(
-                    embedding_model=field_value["02_embedding_model"], api_key=field_value["03_api_key"]
-                )
+                embed_model = self._build_embeddings(embedding_model=field_value["02_embedding_model"], api_key=api_key)
 
-                # Try to generate a dummy embedding to validate the API key
-                embed_model.embed_query("test")
+                # Try to generate a dummy embedding to validate the API key without blocking the event loop
+                try:
+                    await asyncio.wait_for(
+                        asyncio.to_thread(embed_model.embed_query, "test"),
+                        timeout=10,
+                    )
+                except TimeoutError as e:
+                    msg = "Embedding validation timed out. Please verify network connectivity and key."
+                    raise ValueError(msg) from e
+                except Exception as e:
+                    msg = f"Embedding validation failed: {e!s}"
+                    raise ValueError(msg) from e
 
                 # Create the new knowledge base directory
-                kb_path = KNOWLEDGE_BASES_ROOT_PATH / field_value["01_new_kb_name"]
+                kb_path = KNOWLEDGE_BASES_ROOT_PATH / kb_user / field_value["01_new_kb_name"]
                 kb_path.mkdir(parents=True, exist_ok=True)
 
                 # Save the embedding metadata
@@ -573,11 +641,16 @@ class KBIngestionComponent(Component):
                 self._save_embedding_metadata(
                     kb_path=kb_path,
                     embedding_model=field_value["02_embedding_model"],
-                    api_key=field_value["03_api_key"],
+                    api_key=api_key,
                 )
 
             # Update the knowledge base options dynamically
-            build_config["knowledge_base"]["options"] = self._get_knowledge_bases()
+            build_config["knowledge_base"]["options"] = await get_knowledge_bases(
+                KNOWLEDGE_BASES_ROOT_PATH,
+                user_id=self.user_id,
+            )
+
+            # If the selected knowledge base is not available, reset it
             if build_config["knowledge_base"]["value"] not in build_config["knowledge_base"]["options"]:
                 build_config["knowledge_base"]["value"] = None