langflow-base-nightly 0.5.0.dev30__py3-none-any.whl → 0.5.0.dev32__py3-none-any.whl

langflow/__main__.py

@@ -15,7 +15,9 @@ import click
 import httpx
 import typer
 from dotenv import load_dotenv
+from fastapi import HTTPException
 from httpx import HTTPError
+from jose import JWTError
 from multiprocess import cpu_count
 from multiprocess.context import Process
 from packaging import version as pkg_version
@@ -29,9 +31,9 @@ from langflow.cli.progress import create_langflow_progress
 from langflow.initial_setup.setup import get_or_create_default_folder
 from langflow.logging.logger import configure, logger
 from langflow.main import setup_app
-from langflow.services.database.utils import session_getter
+from langflow.services.auth.utils import check_key, get_current_user_by_jwt
 from langflow.services.deps import get_db_service, get_settings_service, session_scope
-from langflow.services.settings.constants import DEFAULT_SUPERUSER
+from langflow.services.settings.constants import DEFAULT_SUPERUSER, DEFAULT_SUPERUSER_PASSWORD
 from langflow.services.utils import initialize_services
 from langflow.utils.version import fetch_latest_version, get_version_info
 from langflow.utils.version import is_pre_release as langflow_is_pre_release
@@ -632,41 +634,138 @@ def print_banner(host: str, port: int, protocol: str) -> None:
 
 @app.command()
 def superuser(
-    username: str = typer.Option(..., prompt=True, help="Username for the superuser."),
-    password: str = typer.Option(..., prompt=True, hide_input=True, help="Password for the superuser."),
+    username: str = typer.Option(
+        None, help="Username for the superuser. Defaults to 'langflow' when AUTO_LOGIN is enabled."
+    ),
+    password: str = typer.Option(
+        None, help="Password for the superuser. Defaults to 'langflow' when AUTO_LOGIN is enabled."
+    ),
     log_level: str = typer.Option("error", help="Logging level.", envvar="LANGFLOW_LOG_LEVEL"),
+    auth_token: str = typer.Option(
+        None, help="Authentication token of existing superuser.", envvar="LANGFLOW_SUPERUSER_TOKEN"
+    ),
 ) -> None:
-    """Create a superuser."""
+    """Create a superuser.
+
+    When AUTO_LOGIN is enabled, uses default credentials.
+    In production mode, requires authentication.
+    """
     configure(log_level=log_level)
-    db_service = get_db_service()
 
-    async def _create_superuser():
-        await initialize_services()
-        async with session_getter(db_service) as session:
-            from langflow.services.auth.utils import create_super_user
-
-            if await create_super_user(db=session, username=username, password=password):
-                # Verify that the superuser was created
-                from langflow.services.database.models.user.model import User
-
-                stmt = select(User).where(User.username == username)
-                user: User = (await session.exec(stmt)).first()
-                if user is None or not user.is_superuser:
-                    typer.echo("Superuser creation failed.")
-                    return
-                # Now create the first folder for the user
-                result = await get_or_create_default_folder(session, user.id)
-                if result:
-                    typer.echo("Default folder created successfully.")
-                else:
-                    msg = "Could not create default folder."
-                    raise RuntimeError(msg)
-                typer.echo("Superuser created successfully.")
+    asyncio.run(_create_superuser(username, password, auth_token))
 
-            else:
+
+async def _create_superuser(username: str, password: str, auth_token: str | None):
+    """Create a superuser."""
+    await initialize_services()
+
+    settings_service = get_settings_service()
+    # Check if superuser creation via CLI is enabled
+    if not settings_service.auth_settings.ENABLE_SUPERUSER_CLI:
+        typer.echo("Error: Superuser creation via CLI is disabled.")
+        typer.echo("Set LANGFLOW_ENABLE_SUPERUSER_CLI=true to enable this feature.")
+        raise typer.Exit(1)
+
+    if settings_service.auth_settings.AUTO_LOGIN:
+        # Force default credentials for AUTO_LOGIN mode
+        username = DEFAULT_SUPERUSER
+        password = DEFAULT_SUPERUSER_PASSWORD
+    else:
+        # Production mode - prompt for credentials if not provided
+        if not username:
+            username = typer.prompt("Username")
+        if not password:
+            password = typer.prompt("Password", hide_input=True)
+
+    from langflow.services.database.models.user.crud import get_all_superusers
+
+    existing_superusers = []
+    async with session_scope() as session:
+        # Note that the default superuser is created by the initialize_services() function,
+        # but leaving this check here in case we change that behavior
+        existing_superusers = await get_all_superusers(session)
+    is_first_setup = len(existing_superusers) == 0
+
+    # If AUTO_LOGIN is true, only allow default superuser creation
+    if settings_service.auth_settings.AUTO_LOGIN:
+        if not is_first_setup:
+            typer.echo("Error: Cannot create additional superusers when AUTO_LOGIN is enabled.")
+            typer.echo("AUTO_LOGIN mode is for development with only the default superuser.")
+            typer.echo("To create additional superusers:")
+            typer.echo("1. Set LANGFLOW_AUTO_LOGIN=false")
+            typer.echo("2. Run this command again with --auth-token")
+            raise typer.Exit(1)
+
+        typer.echo(f"AUTO_LOGIN enabled. Creating default superuser '{username}'...")
+        typer.echo(f"Note: Default credentials are {DEFAULT_SUPERUSER}/{DEFAULT_SUPERUSER_PASSWORD}")
+    # AUTO_LOGIN is false - production mode
+    elif is_first_setup:
+        typer.echo("No superusers found. Creating first superuser...")
+    else:
+        # Authentication is required in production mode
+        if not auth_token:
+            typer.echo("Error: Creating a superuser requires authentication.")
+            typer.echo("Please provide --auth-token with a valid superuser API key or JWT token.")
+            typer.echo("To get a token, use: `uv run langflow api_key`")
+            raise typer.Exit(1)
+
+        # Validate the auth token
+        try:
+            auth_user = None
+            async with session_scope() as session:
+                # Try JWT first
+                user = None
+                try:
+                    user = await get_current_user_by_jwt(auth_token, session)
+                except (JWTError, HTTPException):
+                    # Try API key
+                    api_key_result = await check_key(session, auth_token)
+                    if api_key_result and hasattr(api_key_result, "is_superuser"):
+                        user = api_key_result
+                auth_user = user
+
+            if not auth_user or not auth_user.is_superuser:
+                typer.echo(
+                    "Error: Invalid token or insufficient privileges. Only superusers can create other superusers."
+                )
+                raise typer.Exit(1)
+        except typer.Exit:
+            raise  # Re-raise typer.Exit without wrapping
+        except Exception as e:  # noqa: BLE001
+            typer.echo(f"Error: Authentication failed - {e!s}")
+            raise typer.Exit(1) from None
+
+    # Auth complete, create the superuser
+    async with session_scope() as session:
+        from langflow.services.auth.utils import create_super_user
+
+        if await create_super_user(db=session, username=username, password=password):
+            # Verify that the superuser was created
+            from langflow.services.database.models.user.model import User
+
+            stmt = select(User).where(User.username == username)
+            created_user: User = (await session.exec(stmt)).first()
+            if created_user is None or not created_user.is_superuser:
                 typer.echo("Superuser creation failed.")
+                return
+            # Now create the first folder for the user
+            result = await get_or_create_default_folder(session, created_user.id)
+            if result:
+                typer.echo("Default folder created successfully.")
+            else:
+                msg = "Could not create default folder."
+                raise RuntimeError(msg)
 
-    asyncio.run(_create_superuser())
+            # Log the superuser creation for audit purposes
+            logger.warning(
+                f"SECURITY AUDIT: New superuser '{username}' created via CLI command"
+                + (" by authenticated user" if auth_token else " (first-time setup)")
+            )
+            typer.echo("Superuser created successfully.")
+
+        else:
+            logger.error(f"SECURITY AUDIT: Failed attempt to create superuser '{username}' via CLI")
+            typer.echo("Superuser creation failed.")
 
 
 # command to copy the langflow database from the cache to the current directory
@@ -749,6 +848,7 @@ def api_key(
         settings_service = get_settings_service()
         auth_settings = settings_service.auth_settings
         if not auth_settings.AUTO_LOGIN:
+            # TODO: Allow non-auto-login users to create API keys via CLI
             typer.echo("Auto login is disabled. API keys cannot be created through the CLI.")
             return None
 

langflow/api/router.py

@@ -8,6 +8,7 @@ from langflow.api.v1 import (
     files_router,
     flows_router,
     folders_router,
+    knowledge_bases_router,
     login_router,
     mcp_projects_router,
     mcp_router,
@@ -45,6 +46,7 @@ router_v1.include_router(monitor_router)
 router_v1.include_router(folders_router)
 router_v1.include_router(projects_router)
 router_v1.include_router(starter_projects_router)
+router_v1.include_router(knowledge_bases_router)
 router_v1.include_router(mcp_router)
 router_v1.include_router(voice_mode_router)
 router_v1.include_router(mcp_projects_router)

langflow/api/v1/__init__.py

@@ -4,6 +4,7 @@ from langflow.api.v1.endpoints import router as endpoints_router
 from langflow.api.v1.files import router as files_router
 from langflow.api.v1.flows import router as flows_router
 from langflow.api.v1.folders import router as folders_router
+from langflow.api.v1.knowledge_bases import router as knowledge_bases_router
 from langflow.api.v1.login import router as login_router
 from langflow.api.v1.mcp import router as mcp_router
 from langflow.api.v1.mcp_projects import router as mcp_projects_router
@@ -23,6 +24,7 @@ __all__ = [
     "files_router",
     "flows_router",
     "folders_router",
+    "knowledge_bases_router",
     "login_router",
     "mcp_projects_router",
     "mcp_router",

langflow/api/v1/knowledge_bases.py

@@ -0,0 +1,437 @@
+import json
+import shutil
+from http import HTTPStatus
+from pathlib import Path
+
+import pandas as pd
+from fastapi import APIRouter, HTTPException
+from langchain_chroma import Chroma
+from loguru import logger
+from pydantic import BaseModel
+
+from langflow.services.deps import get_settings_service
+
+router = APIRouter(tags=["Knowledge Bases"], prefix="/knowledge_bases")
+
+
+settings = get_settings_service().settings
+knowledge_directory = settings.knowledge_bases_dir
+if not knowledge_directory:
+    msg = "Knowledge bases directory is not set in the settings."
+    raise ValueError(msg)
+KNOWLEDGE_BASES_DIR = Path(knowledge_directory).expanduser()
+
+
+class KnowledgeBaseInfo(BaseModel):
+    id: str
+    name: str
+    embedding_provider: str | None = "Unknown"
+    embedding_model: str | None = "Unknown"
+    size: int = 0
+    words: int = 0
+    characters: int = 0
+    chunks: int = 0
+    avg_chunk_size: float = 0.0
+
+
+class BulkDeleteRequest(BaseModel):
+    kb_names: list[str]
+
+
+def get_kb_root_path() -> Path:
+    """Get the knowledge bases root path."""
+    return KNOWLEDGE_BASES_DIR
+
+
+def get_directory_size(path: Path) -> int:
+    """Calculate the total size of all files in a directory."""
+    total_size = 0
+    try:
+        for file_path in path.rglob("*"):
+            if file_path.is_file():
+                total_size += file_path.stat().st_size
+    except (OSError, PermissionError):
+        pass
+    return total_size
+
+
+def detect_embedding_provider(kb_path: Path) -> str:
+    """Detect the embedding provider from config files and directory structure."""
+    # Provider patterns to check for
+    provider_patterns = {
+        "OpenAI": ["openai", "text-embedding-ada", "text-embedding-3"],
+        "HuggingFace": ["sentence-transformers", "huggingface", "bert-"],
+        "Cohere": ["cohere", "embed-english", "embed-multilingual"],
+        "Google": ["palm", "gecko", "google"],
+        "Chroma": ["chroma"],
+    }
+
+    # Check JSON config files for provider information
+    for config_file in kb_path.glob("*.json"):
+        try:
+            with config_file.open("r", encoding="utf-8") as f:
+                config_data = json.load(f)
+                if not isinstance(config_data, dict):
+                    continue
+
+                config_str = json.dumps(config_data).lower()
+
+                # Check for explicit provider fields first
+                provider_fields = ["embedding_provider", "provider", "embedding_model_provider"]
+                for field in provider_fields:
+                    if field in config_data:
+                        provider_value = str(config_data[field]).lower()
+                        for provider, patterns in provider_patterns.items():
+                            if any(pattern in provider_value for pattern in patterns):
+                                return provider
+
+                # Check for model name patterns
+                for provider, patterns in provider_patterns.items():
+                    if any(pattern in config_str for pattern in patterns):
+                        return provider
+
+        except (OSError, json.JSONDecodeError) as _:
+            logger.exception("Error reading config file '%s'", config_file)
+            continue
+
+    # Fallback to directory structure
+    if (kb_path / "chroma").exists():
+        return "Chroma"
+    if (kb_path / "vectors.npy").exists():
+        return "Local"
+
+    return "Unknown"
+
+
+def detect_embedding_model(kb_path: Path) -> str:
+    """Detect the embedding model from config files."""
+    # First check the embedding metadata file (most accurate)
+    metadata_file = kb_path / "embedding_metadata.json"
+    if metadata_file.exists():
+        try:
+            with metadata_file.open("r", encoding="utf-8") as f:
+                metadata = json.load(f)
+                if isinstance(metadata, dict) and "embedding_model" in metadata:
+                    # Check for embedding model field
+                    model_value = str(metadata.get("embedding_model", "unknown"))
+                    if model_value and model_value.lower() != "unknown":
+                        return model_value
+        except (OSError, json.JSONDecodeError) as _:
+            logger.exception("Error reading embedding metadata file '%s'", metadata_file)
+
+    # Check other JSON config files for model information
+    for config_file in kb_path.glob("*.json"):
+        # Skip the embedding metadata file since we already checked it
+        if config_file.name == "embedding_metadata.json":
+            continue
+
+        try:
+            with config_file.open("r", encoding="utf-8") as f:
+                config_data = json.load(f)
+                if not isinstance(config_data, dict):
+                    continue
+
+                # Check for explicit model fields first and return the actual model name
+                model_fields = ["embedding_model", "model", "embedding_model_name", "model_name"]
+                for field in model_fields:
+                    if field in config_data:
+                        model_value = str(config_data[field])
+                        if model_value and model_value.lower() != "unknown":
+                            return model_value
+
+                # Check for OpenAI specific model names
+                if "openai" in json.dumps(config_data).lower():
+                    openai_models = ["text-embedding-ada-002", "text-embedding-3-small", "text-embedding-3-large"]
+                    config_str = json.dumps(config_data).lower()
+                    for model in openai_models:
+                        if model in config_str:
+                            return model
+
+                # Check for HuggingFace model names (usually in model field)
+                if "model" in config_data:
+                    model_name = str(config_data["model"])
+                    # Common HuggingFace embedding models
+                    hf_patterns = ["sentence-transformers", "all-MiniLM", "all-mpnet", "multi-qa"]
+                    if any(pattern in model_name for pattern in hf_patterns):
+                        return model_name
+
+        except (OSError, json.JSONDecodeError) as _:
+            logger.exception("Error reading config file '%s'", config_file)
+            continue
+
+    return "Unknown"
+
+
+def get_text_columns(df: pd.DataFrame, schema_data: list | None = None) -> list[str]:
+    """Get the text columns to analyze for word/character counts."""
+    # First try schema-defined text columns
+    if schema_data:
+        text_columns = [
+            col["column_name"]
+            for col in schema_data
+            if col.get("vectorize", False) and col.get("data_type") == "string"
+        ]
+        if text_columns:
+            return [col for col in text_columns if col in df.columns]
+
+    # Fallback to common text column names
+    common_names = ["text", "content", "document", "chunk"]
+    text_columns = [col for col in df.columns if col.lower() in common_names]
+    if text_columns:
+        return text_columns
+
+    # Last resort: all string columns
+    return [col for col in df.columns if df[col].dtype == "object"]
+
+
+def calculate_text_metrics(df: pd.DataFrame, text_columns: list[str]) -> tuple[int, int]:
+    """Calculate total words and characters from text columns."""
+    total_words = 0
+    total_characters = 0
+
+    for col in text_columns:
+        if col not in df.columns:
+            continue
+
+        text_series = df[col].astype(str).fillna("")
+        total_characters += text_series.str.len().sum()
+        total_words += text_series.str.split().str.len().sum()
+
+    return int(total_words), int(total_characters)
+
+
+def get_kb_metadata(kb_path: Path) -> dict:
+    """Extract metadata from a knowledge base directory."""
+    metadata: dict[str, float | int | str] = {
+        "chunks": 0,
+        "words": 0,
+        "characters": 0,
+        "avg_chunk_size": 0.0,
+        "embedding_provider": "Unknown",
+        "embedding_model": "Unknown",
+    }
+
+    try:
+        # First check embedding metadata file for accurate provider and model info
+        metadata_file = kb_path / "embedding_metadata.json"
+        if metadata_file.exists():
+            try:
+                with metadata_file.open("r", encoding="utf-8") as f:
+                    embedding_metadata = json.load(f)
+                    if isinstance(embedding_metadata, dict):
+                        if "embedding_provider" in embedding_metadata:
+                            metadata["embedding_provider"] = embedding_metadata["embedding_provider"]
+                        if "embedding_model" in embedding_metadata:
+                            metadata["embedding_model"] = embedding_metadata["embedding_model"]
+            except (OSError, json.JSONDecodeError) as _:
+                logger.exception("Error reading embedding metadata file '%s'", metadata_file)
+
+        # Fallback to detection if not found in metadata file
+        if metadata["embedding_provider"] == "Unknown":
+            metadata["embedding_provider"] = detect_embedding_provider(kb_path)
+        if metadata["embedding_model"] == "Unknown":
+            metadata["embedding_model"] = detect_embedding_model(kb_path)
+
+        # Read schema for text column information
+        schema_data = None
+        schema_file = kb_path / "schema.json"
+        if schema_file.exists():
+            try:
+                with schema_file.open("r", encoding="utf-8") as f:
+                    schema_data = json.load(f)
+                    if not isinstance(schema_data, list):
+                        schema_data = None
+            except (ValueError, TypeError, OSError) as _:
+                logger.exception("Error reading schema file '%s'", schema_file)
+
+        # Create vector store
+        chroma = Chroma(
+            persist_directory=str(kb_path),
+            collection_name=kb_path.name,
+        )
+
+        # Access the raw collection
+        collection = chroma._collection
+
+        # Fetch all documents and metadata
+        results = collection.get(include=["documents", "metadatas"])
+
+        # Convert to pandas DataFrame
+        source_chunks = pd.DataFrame(
+            {
+                "document": results["documents"],
+                "metadata": results["metadatas"],
+            }
+        )
+
+        # Process the source data for metadata
+        try:
+            metadata["chunks"] = len(source_chunks)
+
+            # Get text columns and calculate metrics
+            text_columns = get_text_columns(source_chunks, schema_data)
+            if text_columns:
+                words, characters = calculate_text_metrics(source_chunks, text_columns)
+                metadata["words"] = words
+                metadata["characters"] = characters
+
+                # Calculate average chunk size
+                if int(metadata["chunks"]) > 0:
+                    metadata["avg_chunk_size"] = round(int(characters) / int(metadata["chunks"]), 1)
+
+        except (OSError, ValueError, TypeError) as _:
+            logger.exception("Error processing Chroma DB '%s'", kb_path.name)
+
+    except (OSError, ValueError, TypeError) as _:
+        logger.exception("Error processing knowledge base directory '%s'", kb_path)
+
+    return metadata
+
+
+@router.get("", status_code=HTTPStatus.OK)
+@router.get("/", status_code=HTTPStatus.OK)
+async def list_knowledge_bases() -> list[KnowledgeBaseInfo]:
+    """List all available knowledge bases."""
+    try:
+        kb_root_path = get_kb_root_path()
+
+        if not kb_root_path.exists():
+            return []
+
+        knowledge_bases = []
+
+        for kb_dir in kb_root_path.iterdir():
+            if not kb_dir.is_dir() or kb_dir.name.startswith("."):
+                continue
+
+            try:
+                # Get size of the directory
+                size = get_directory_size(kb_dir)
+
+                # Get metadata from KB files
+                metadata = get_kb_metadata(kb_dir)
+
+                kb_info = KnowledgeBaseInfo(
+                    id=kb_dir.name,
+                    name=kb_dir.name.replace("_", " ").replace("-", " ").title(),
+                    embedding_provider=metadata["embedding_provider"],
+                    embedding_model=metadata["embedding_model"],
+                    size=size,
+                    words=metadata["words"],
+                    characters=metadata["characters"],
+                    chunks=metadata["chunks"],
+                    avg_chunk_size=metadata["avg_chunk_size"],
+                )
+
+                knowledge_bases.append(kb_info)
+
+            except OSError as _:
+                # Log the exception and skip directories that can't be read
+                logger.exception("Error reading knowledge base directory '%s'", kb_dir)
+                continue
+
+        # Sort by name alphabetically
+        knowledge_bases.sort(key=lambda x: x.name)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error listing knowledge bases: {e!s}") from e
+    else:
+        return knowledge_bases
+
+
+@router.get("/{kb_name}", status_code=HTTPStatus.OK)
+async def get_knowledge_base(kb_name: str) -> KnowledgeBaseInfo:
+    """Get detailed information about a specific knowledge base."""
+    try:
+        kb_root_path = get_kb_root_path()
+        kb_path = kb_root_path / 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")
+
+        # Get size of the directory
+        size = get_directory_size(kb_path)
+
+        # Get metadata from KB files
+        metadata = get_kb_metadata(kb_path)
+
+        return KnowledgeBaseInfo(
+            id=kb_name,
+            name=kb_name.replace("_", " ").replace("-", " ").title(),
+            embedding_provider=metadata["embedding_provider"],
+            embedding_model=metadata["embedding_model"],
+            size=size,
+            words=metadata["words"],
+            characters=metadata["characters"],
+            chunks=metadata["chunks"],
+            avg_chunk_size=metadata["avg_chunk_size"],
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting knowledge base '{kb_name}': {e!s}") from e
+
+
+@router.delete("/{kb_name}", status_code=HTTPStatus.OK)
+async def delete_knowledge_base(kb_name: str) -> dict[str, str]:
+    """Delete a specific knowledge base."""
+    try:
+        kb_root_path = get_kb_root_path()
+        kb_path = kb_root_path / 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")
+
+        # Delete the entire knowledge base directory
+        shutil.rmtree(kb_path)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error deleting knowledge base '{kb_name}': {e!s}") from e
+    else:
+        return {"message": f"Knowledge base '{kb_name}' deleted successfully"}
+
+
+@router.delete("", status_code=HTTPStatus.OK)
+@router.delete("/", status_code=HTTPStatus.OK)
+async def delete_knowledge_bases_bulk(request: BulkDeleteRequest) -> dict[str, object]:
+    """Delete multiple knowledge bases."""
+    try:
+        kb_root_path = get_kb_root_path()
+        deleted_count = 0
+        not_found_kbs = []
+
+        for kb_name in request.kb_names:
+            kb_path = kb_root_path / kb_name
+
+            if not kb_path.exists() or not kb_path.is_dir():
+                not_found_kbs.append(kb_name)
+                continue
+
+            try:
+                # Delete the entire knowledge base directory
+                shutil.rmtree(kb_path)
+                deleted_count += 1
+            except (OSError, PermissionError) as e:
+                logger.exception("Error deleting knowledge base '%s': %s", kb_name, e)
+                # Continue with other deletions even if one fails
+
+        if not_found_kbs and deleted_count == 0:
+            raise HTTPException(status_code=404, detail=f"Knowledge bases not found: {', '.join(not_found_kbs)}")
+
+        result = {
+            "message": f"Successfully deleted {deleted_count} knowledge base(s)",
+            "deleted_count": deleted_count,
+        }
+
+        if not_found_kbs:
+            result["not_found"] = ", ".join(not_found_kbs)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error deleting knowledge bases: {e!s}") from e
+    else:
+        return result