langflow-base-nightly 1.7.0.dev19__py3-none-any.whl → 1.7.0.dev21__py3-none-any.whl

langflow/api/utils/mcp/agentic_mcp.py

@@ -0,0 +1,365 @@
+"""Utilities for auto-configuring the Langflow Agentic MCP server."""
+
+import sys
+from uuid import UUID
+
+from fastapi import HTTPException
+from lfx.log.logger import logger
+from lfx.services.deps import get_settings_service
+from sqlalchemy import exc as sqlalchemy_exc
+from sqlmodel import select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from langflow.api.v2.mcp import get_server_list, update_server
+from langflow.services.database.models.user.model import User
+from langflow.services.deps import get_service, get_variable_service
+from langflow.services.schema import ServiceType
+from langflow.services.variable.constants import GENERIC_TYPE
+
+
+async def auto_configure_agentic_mcp_server(session: AsyncSession) -> None:
+    """Auto-configure the Langflow Agentic MCP server for all users.
+
+    This function adds the langflow-agentic MCP server to each user's MCP
+    configuration, making the agentic tools available in their MCP clients
+    (like Claude Desktop).
+
+    Args:
+        session: Database session for querying users.
+    """
+    settings_service = get_settings_service()
+
+    # Only configure if agentic experience is enabled
+    if not settings_service.settings.agentic_experience:
+        await logger.adebug("Agentic experience disabled, skipping agentic MCP server configuration")
+        return
+
+    await logger.ainfo("Auto-configuring Langflow Agentic MCP server for all users...")
+
+    try:
+        # Get all users in the system
+        users = (await session.exec(select(User))).all()
+        await logger.adebug(f"Found {len(users)} users in the system")
+
+        if not users:
+            await logger.adebug("No users found, skipping agentic MCP server configuration")
+            return
+
+        # Get services
+        storage_service = get_service(ServiceType.STORAGE_SERVICE)
+
+        # Server configuration
+        server_name = "langflow-agentic"
+        python_executable = sys.executable
+        server_config = {
+            "command": python_executable,
+            "args": ["-m", "langflow.agentic.mcp"],
+            "metadata": {
+                "description": "Langflow Agentic MCP server providing tools for flow/component operations, "
+                "template search, and graph visualization",
+                "auto_configured": True,
+                "langflow_internal": True,
+            },
+        }
+
+        # Add server to each user's configuration
+        servers_added = 0
+        servers_skipped = 0
+
+        for user in users:
+            try:
+                await logger.adebug(f"Configuring agentic MCP server for user: {user.username}")
+
+                # Check if server already exists for this user
+                try:
+                    server_list = await get_server_list(user, session, storage_service, settings_service)
+                    server_exists = server_name in server_list.get("mcpServers", {})
+
+                    if server_exists:
+                        await logger.adebug(f"Agentic MCP server already exists for user {user.username}, skipping")
+                        servers_skipped += 1
+                        continue
+
+                except (HTTPException, sqlalchemy_exc.SQLAlchemyError) as e:
+                    # If listing fails, skip this user to avoid duplicates
+                    await logger.awarning(
+                        f"Could not check existing servers for user {user.username}: {e}. "
+                        "Skipping to avoid potential duplicates."
+                    )
+                    servers_skipped += 1
+                    continue
+
+                # Add the server
+                await update_server(
+                    server_name=server_name,
+                    server_config=server_config,
+                    current_user=user,
+                    session=session,
+                    storage_service=storage_service,
+                    settings_service=settings_service,
+                )
+
+                servers_added += 1
+                await logger.adebug(f"Added agentic MCP server for user: {user.username}")
+
+            except (HTTPException, sqlalchemy_exc.SQLAlchemyError) as e:
+                await logger.aexception(f"Failed to configure agentic MCP server for user {user.username}: {e}")
+                continue
+
+        await logger.ainfo(
+            f"Agentic MCP server configuration complete: {servers_added} added, {servers_skipped} skipped"
+        )
+
+    except (
+        HTTPException,
+        sqlalchemy_exc.SQLAlchemyError,
+        OSError,
+        PermissionError,
+        FileNotFoundError,
+        RuntimeError,
+        ValueError,
+        AttributeError,
+    ) as e:
+        await logger.aexception(f"Error during agentic MCP server auto-configuration: {e}")
+
+
+async def remove_agentic_mcp_server(session: AsyncSession) -> None:
+    """Remove the Langflow Agentic MCP server from all users.
+
+    This function removes the langflow-agentic MCP server from each user's MCP
+    configuration. Used when agentic experience is disabled.
+
+    Args:
+        session: Database session for querying users.
+    """
+    await logger.ainfo("Removing Langflow Agentic MCP server from all users...")
+
+    try:
+        # Get all users
+        users = (await session.exec(select(User))).all()
+
+        if not users:
+            await logger.adebug("No users found")
+            return
+
+        # Get services
+        storage_service = get_service(ServiceType.STORAGE_SERVICE)
+        settings_service = get_settings_service()
+
+        server_name = "langflow-agentic"
+        servers_removed = 0
+
+        for user in users:
+            try:
+                # Remove the server by passing empty config
+                await update_server(
+                    server_name=server_name,
+                    server_config={},  # Empty config removes the server
+                    current_user=user,
+                    session=session,
+                    storage_service=storage_service,
+                    settings_service=settings_service,
+                )
+
+                servers_removed += 1
+                await logger.adebug(f"Removed agentic MCP server for user: {user.username}")
+
+            except (HTTPException, sqlalchemy_exc.SQLAlchemyError) as e:
+                await logger.adebug(f"Could not remove agentic MCP server for user {user.username}: {e}")
+                continue
+
+        await logger.ainfo(f"Removed agentic MCP server from {servers_removed} users")
+
+    except (
+        HTTPException,
+        sqlalchemy_exc.SQLAlchemyError,
+        OSError,
+        PermissionError,
+        FileNotFoundError,
+        RuntimeError,
+        ValueError,
+        AttributeError,
+    ) as e:
+        await logger.aexception(f"Error removing agentic MCP server: {e}")
+
+
+async def initialize_agentic_global_variables(session: AsyncSession) -> None:
+    """Initialize default global variables for agentic experience for all users.
+
+    This function creates agentic-specific global variables (FLOW_ID, COMPONENT_ID, FIELD_NAME)
+    for all users if they don't already exist. These variables are used by the agentic
+    experience to provide context-aware suggestions and operations.
+
+    Args:
+        session: Database session for querying users and creating variables.
+    """
+    settings_service = get_settings_service()
+
+    # Only initialize if agentic experience is enabled
+    if not settings_service.settings.agentic_experience:
+        await logger.adebug("Agentic experience disabled, skipping agentic variables initialization")
+        return
+
+    await logger.ainfo("Initializing agentic global variables for all users...")
+
+    try:
+        # Get all users in the system
+        users = (await session.exec(select(User))).all()
+        await logger.adebug(f"Found {len(users)} users for agentic variables initialization")
+
+        if not users:
+            await logger.adebug("No users found, skipping agentic variables initialization")
+            return
+
+        variable_service = get_variable_service()
+
+        # Define agentic variables with default values
+        agentic_variables = {
+            "FLOW_ID": "",
+            "COMPONENT_ID": "",
+            "FIELD_NAME": "",
+        }
+
+        # Initialize variables for each user
+        variables_created = 0
+        variables_skipped = 0
+
+        for user in users:
+            try:
+                await logger.adebug(f"Initializing agentic variables for user: {user.username}")
+
+                # Get existing variables for this user
+                existing_vars = await variable_service.list_variables(user.id, session)
+
+                for var_name, default_value in agentic_variables.items():
+                    try:
+                        if var_name not in existing_vars:
+                            # Create variable with default value
+                            await variable_service.create_variable(
+                                user_id=user.id,
+                                name=var_name,
+                                value=default_value,
+                                default_fields=[],
+                                type_=GENERIC_TYPE,
+                                session=session,
+                            )
+                            variables_created += 1
+                            await logger.adebug(f"Created agentic variable {var_name} for user {user.username}")
+                        else:
+                            variables_skipped += 1
+                            await logger.adebug(
+                                f"Agentic variable {var_name} already exists for user {user.username}, skipping"
+                            )
+                    except (
+                        HTTPException,
+                        sqlalchemy_exc.SQLAlchemyError,
+                        OSError,
+                        PermissionError,
+                        FileNotFoundError,
+                        RuntimeError,
+                        ValueError,
+                        AttributeError,
+                    ) as e:
+                        await logger.aexception(
+                            f"Error creating agentic variable {var_name} for user {user.username}: {e}"
+                        )
+                        continue
+
+            except (
+                HTTPException,
+                sqlalchemy_exc.SQLAlchemyError,
+                OSError,
+                PermissionError,
+                FileNotFoundError,
+                RuntimeError,
+                ValueError,
+                AttributeError,
+            ) as e:
+                await logger.aexception(f"Failed to initialize agentic variables for user {user.username}: {e}")
+                continue
+
+        await logger.ainfo(
+            f"Agentic variables initialization complete: {variables_created} created, {variables_skipped} skipped"
+        )
+
+    except (
+        HTTPException,
+        sqlalchemy_exc.SQLAlchemyError,
+        OSError,
+        PermissionError,
+        FileNotFoundError,
+        RuntimeError,
+        ValueError,
+        AttributeError,
+    ) as e:
+        await logger.aexception(f"Error during agentic variables initialization: {e}")
+
+
+async def initialize_agentic_user_variables(user_id: UUID | str, session: AsyncSession) -> None:
+    """Initialize agentic-specific global variables for a single user if they don't exist.
+
+    This function is called during user login or creation to ensure each user has the
+    required agentic variables (FLOW_ID, COMPONENT_ID, FIELD_NAME).
+
+    Args:
+        user_id: The user ID to initialize variables for.
+        session: Database session for creating variables.
+    """
+    settings_service = get_settings_service()
+
+    # Only initialize if agentic experience is enabled
+    if not settings_service.settings.agentic_experience:
+        await logger.adebug(f"Agentic experience disabled, skipping agentic variables for user {user_id}")
+        return
+
+    await logger.adebug(f"Initializing agentic variables for user {user_id}")
+
+    try:
+        variable_service = get_variable_service()
+
+        # Define agentic variables with defaults
+        agentic_variables = {
+            "FLOW_ID": "",
+            "COMPONENT_ID": "",
+            "FIELD_NAME": "",
+        }
+
+        existing_vars = await variable_service.list_variables(user_id, session)
+
+        for var_name, default_value in agentic_variables.items():
+            if var_name not in existing_vars:
+                try:
+                    await variable_service.create_variable(
+                        user_id=user_id,
+                        name=var_name,
+                        value=default_value,
+                        default_fields=[],
+                        type_=GENERIC_TYPE,
+                        session=session,
+                    )
+                    await logger.adebug(f"Created agentic variable {var_name} for user {user_id}")
+                except (
+                    HTTPException,
+                    sqlalchemy_exc.SQLAlchemyError,
+                    OSError,
+                    PermissionError,
+                    FileNotFoundError,
+                    RuntimeError,
+                    ValueError,
+                    AttributeError,
+                ) as e:
+                    await logger.aexception(f"Error creating agentic variable {var_name} for user {user_id}: {e}")
+            else:
+                await logger.adebug(f"Agentic variable {var_name} already exists for user {user_id}, skipping")
+
+    except (
+        HTTPException,
+        sqlalchemy_exc.SQLAlchemyError,
+        OSError,
+        PermissionError,
+        FileNotFoundError,
+        RuntimeError,
+        ValueError,
+        AttributeError,
+    ) as e:
+        await logger.aexception(f"Error initializing agentic variables for user {user_id}: {e}")

langflow/api/v1/chat.py

@@ -289,6 +289,7 @@ async def build_vertex(
         if isinstance(cache, CacheMiss):
             # If there's no cache
             await logger.awarning(f"No cache found for {flow_id_str}. Building graph starting at {vertex_id}")
+
             async with session_scope() as session:
                 graph = await build_graph_from_db(
                     flow_id=flow_id,

langflow/api/v1/endpoints.py

@@ -346,28 +346,26 @@ async def check_flow_user_permission(
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="You do not have permission to run this flow")
 
 
-@router.post("/run/{flow_id_or_name}", response_model=None, response_model_exclude_none=True)
-async def simplified_run_flow(
+async def _run_flow_internal(
     *,
     background_tasks: BackgroundTasks,
-    flow: Annotated[FlowRead | None, Depends(get_flow_by_id_or_endpoint_name)],
-    input_request: SimplifiedAPIRequest | None = None,
-    stream: bool = False,
-    api_key_user: Annotated[UserRead, Depends(api_key_security)],
-    context: dict | None = None,
+    flow: FlowRead | None,
+    input_request: SimplifiedAPIRequest | None,
+    stream: bool,
+    api_key_user: User | UserRead,
+    context: dict | None,
     http_request: Request,
-):
-    """Executes a specified flow by ID with support for streaming and telemetry.
+) -> StreamingResponse | RunResponse:
+    """Internal function containing the core business logic for running a flow.
 
-    This endpoint executes a flow identified by ID or name, with options for streaming the response
-    and tracking execution metrics. It handles both streaming and non-streaming execution modes.
+    This function is shared between session-based and API key-based authentication endpoints.
 
     Args:
         background_tasks (BackgroundTasks): FastAPI background task manager
         flow (FlowRead | None): The flow to execute, loaded via dependency
         input_request (SimplifiedAPIRequest | None): Input parameters for the flow
         stream (bool): Whether to stream the response
-        api_key_user (UserRead): Authenticated user from API key
+        api_key_user (User | UserRead): Authenticated user (either from session or API key)
         context (dict | None): Optional context to pass to the flow
         http_request (Request): The incoming HTTP request for extracting global variables
 
@@ -378,18 +376,6 @@ async def simplified_run_flow(
     Raises:
         HTTPException: For flow not found (404) or invalid input (400)
         APIException: For internal execution errors (500)
-
-    Notes:
-        - Supports both streaming and non-streaming execution modes
-        - Tracks execution time and success/failure via telemetry
-        - Handles graceful client disconnection in streaming mode
-        - Provides detailed error handling with appropriate HTTP status codes
-        - Extracts global variables from HTTP headers with prefix X-LANGFLOW-GLOBAL-VAR-*
-        - Merges extracted variables with the context parameter as "request_variables"
-        - In streaming mode, uses EventManager to handle events:
-            - "add_message": New messages during execution
-            - "token": Individual tokens during streaming
-            - "end": Final execution result
     """
     await check_flow_user_permission(flow=flow, api_key_user=api_key_user)
 
@@ -498,6 +484,122 @@ async def simplified_run_flow(
     return result
 
 
+@router.post("/run/{flow_id_or_name}", response_model=None, response_model_exclude_none=True)
+async def simplified_run_flow(
+    *,
+    background_tasks: BackgroundTasks,
+    flow: Annotated[FlowRead | None, Depends(get_flow_by_id_or_endpoint_name)],
+    input_request: SimplifiedAPIRequest | None = None,
+    stream: bool = False,
+    api_key_user: Annotated[UserRead, Depends(api_key_security)],
+    context: dict | None = None,
+    http_request: Request,
+):
+    """Executes a specified flow by ID with support for streaming and telemetry (API key auth).
+
+    This endpoint executes a flow identified by ID or name, with options for streaming the response
+    and tracking execution metrics. It handles both streaming and non-streaming execution modes.
+    This endpoint uses API key authentication (Bearer token).
+
+    Args:
+        background_tasks (BackgroundTasks): FastAPI background task manager
+        flow (FlowRead | None): The flow to execute, loaded via dependency
+        input_request (SimplifiedAPIRequest | None): Input parameters for the flow
+        stream (bool): Whether to stream the response
+        api_key_user (UserRead): Authenticated user from API key
+        context (dict | None): Optional context to pass to the flow
+        http_request (Request): The incoming HTTP request for extracting global variables
+
+    Returns:
+        Union[StreamingResponse, RunResponse]: Either a streaming response for real-time results
+        or a RunResponse with the complete execution results
+
+    Raises:
+        HTTPException: For flow not found (404) or invalid input (400)
+        APIException: For internal execution errors (500)
+
+    Notes:
+        - Supports both streaming and non-streaming execution modes
+        - Tracks execution time and success/failure via telemetry
+        - Handles graceful client disconnection in streaming mode
+        - Provides detailed error handling with appropriate HTTP status codes
+        - Extracts global variables from HTTP headers with prefix X-LANGFLOW-GLOBAL-VAR-*
+        - Merges extracted variables with the context parameter as "request_variables"
+        - In streaming mode, uses EventManager to handle events:
+            - "add_message": New messages during execution
+            - "token": Individual tokens during streaming
+            - "end": Final execution result
+        - Authentication: Requires API key (Bearer token)
+    """
+    return await _run_flow_internal(
+        background_tasks=background_tasks,
+        flow=flow,
+        input_request=input_request,
+        stream=stream,
+        api_key_user=api_key_user,
+        context=context,
+        http_request=http_request,
+    )
+
+
+@router.post("/run/session/{flow_id_or_name}", response_model=None, response_model_exclude_none=True)
+async def simplified_run_flow_session(
+    *,
+    background_tasks: BackgroundTasks,
+    flow: Annotated[FlowRead | None, Depends(get_flow_by_id_or_endpoint_name)],
+    input_request: SimplifiedAPIRequest | None = None,
+    stream: bool = False,
+    api_key_user: CurrentActiveUser,
+    context: dict | None = None,
+    http_request: Request,
+):
+    """Executes a specified flow by ID with support for streaming and telemetry (session auth).
+
+    This endpoint executes a flow identified by ID or name, with options for streaming the response
+    and tracking execution metrics. It handles both streaming and non-streaming execution modes.
+    This endpoint uses session-based authentication (cookies).
+
+    Args:
+        background_tasks (BackgroundTasks): FastAPI background task manager
+        flow (FlowRead | None): The flow to execute, loaded via dependency
+        input_request (SimplifiedAPIRequest | None): Input parameters for the flow
+        stream (bool): Whether to stream the response
+        api_key_user (User): Authenticated user from session
+        context (dict | None): Optional context to pass to the flow
+        http_request (Request): The incoming HTTP request for extracting global variables
+
+    Returns:
+        Union[StreamingResponse, RunResponse]: Either a streaming response for real-time results
+        or a RunResponse with the complete execution results
+
+    Raises:
+        HTTPException: For flow not found (404) or invalid input (400)
+        APIException: For internal execution errors (500)
+
+    Notes:
+        - Supports both streaming and non-streaming execution modes
+        - Tracks execution time and success/failure via telemetry
+        - Handles graceful client disconnection in streaming mode
+        - Provides detailed error handling with appropriate HTTP status codes
+        - Extracts global variables from HTTP headers with prefix X-LANGFLOW-GLOBAL-VAR-*
+        - Merges extracted variables with the context parameter as "request_variables"
+        - In streaming mode, uses EventManager to handle events:
+            - "add_message": New messages during execution
+            - "token": Individual tokens during streaming
+            - "end": Final execution result
+        - Authentication: Requires active session (cookies)
+    """
+    return await _run_flow_internal(
+        background_tasks=background_tasks,
+        flow=flow,
+        input_request=input_request,
+        stream=stream,
+        api_key_user=api_key_user,
+        context=context,
+        http_request=http_request,
+    )
+
+
 @router.post("/webhook/{flow_id_or_name}", response_model=dict, status_code=HTTPStatus.ACCEPTED)  # noqa: RUF100, FAST003
 async def webhook_run_flow(
     flow_id_or_name: str,

langflow/api/v1/files.py

@@ -173,10 +173,9 @@ async def list_profile_pictures(
         people_path = config_path / "profile_pictures" / "People"
         space_path = config_path / "profile_pictures" / "Space"
 
-        # List files directly from local filesystem
+        # List files directly from local filesystem - bundled with the container
         people = [f.name for f in people_path.iterdir() if f.is_file()] if people_path.exists() else []
         space = [f.name for f in space_path.iterdir() if f.is_file()] if space_path.exists() else []
-
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e)) from e
 

langflow/api/v1/flows.py

@@ -160,11 +160,12 @@ async def create_flow(
 ):
     try:
         db_flow = await _new_flow(session=session, flow=flow, user_id=current_user.id)
-        await session.commit()
+        await session.flush()
         await session.refresh(db_flow)
-
         await _save_flow_to_fs(db_flow)
 
+        # Convert to FlowRead while session is still active to avoid detached instance errors
+        flow_read = FlowRead.model_validate(db_flow, from_attributes=True)
     except Exception as e:
         if "UNIQUE constraint failed" in str(e):
             # Get the name of the column that failed
@@ -180,7 +181,7 @@ async def create_flow(
         if isinstance(e, HTTPException):
             raise
         raise HTTPException(status_code=500, detail=str(e)) from e
-    return db_flow
+    return flow_read
 
 
 @router.get("/", response_model=list[FlowRead] | Page[FlowRead] | list[FlowHeader], status_code=200)
@@ -258,8 +259,9 @@ async def read_flows(
                 flow_headers = [FlowHeader.model_validate(flow, from_attributes=True) for flow in flows]
                 return compress_response(flow_headers)
 
-            # Compress the full flows response
-            return compress_response(flows)
+            # Convert to FlowRead while session is still active to avoid detached instance errors
+            flow_reads = [FlowRead.model_validate(flow, from_attributes=True) for flow in flows]
+            return compress_response(flow_reads)
 
         stmt = stmt.where(Flow.folder_id == folder_id)
 
@@ -295,7 +297,8 @@ async def read_flow(
 ):
     """Read a flow."""
     if user_flow := await _read_flow(session, flow_id, current_user.id):
-        return user_flow
+        # Convert to FlowRead while session is still active to avoid detached instance errors
+        return FlowRead.model_validate(user_flow, from_attributes=True)
     raise HTTPException(status_code=404, detail="Flow not found")
 
 
@@ -358,11 +361,13 @@ async def update_flow(
                 db_flow.folder_id = default_folder.id
 
         session.add(db_flow)
-        await session.commit()
+        await session.flush()
         await session.refresh(db_flow)
-
         await _save_flow_to_fs(db_flow)
 
+        # Convert to FlowRead while session is still active to avoid detached instance errors
+        flow_read = FlowRead.model_validate(db_flow, from_attributes=True)
+
     except Exception as e:
         if "UNIQUE constraint failed" in str(e):
             # Get the name of the column that failed
@@ -379,7 +384,7 @@ async def update_flow(
             raise HTTPException(status_code=e.status_code, detail=str(e)) from e
         raise HTTPException(status_code=500, detail=str(e)) from e
 
-    return db_flow
+    return flow_read
 
 
 @router.delete("/{flow_id}", status_code=200)
@@ -398,7 +403,6 @@ async def delete_flow(
     if not flow:
         raise HTTPException(status_code=404, detail="Flow not found")
     await cascade_delete_flow(session, flow.id)
-    await session.commit()
     return {"message": "Flow deleted successfully"}
 
 
@@ -416,10 +420,12 @@ async def create_flows(
         db_flow = Flow.model_validate(flow, from_attributes=True)
         session.add(db_flow)
         db_flows.append(db_flow)
-    await session.commit()
+
+    await session.flush()
     for db_flow in db_flows:
         await session.refresh(db_flow)
-    return db_flows
+
+    return [FlowRead.model_validate(db_flow, from_attributes=True) for db_flow in db_flows]
 
 
 @router.post("/upload/", response_model=list[FlowRead], status_code=201)
@@ -444,10 +450,13 @@ async def upload_file(
         response_list.append(response)
 
     try:
-        await session.commit()
+        await session.flush()
         for db_flow in response_list:
             await session.refresh(db_flow)
             await _save_flow_to_fs(db_flow)
+
+        # Convert to FlowRead while session is still active to avoid detached instance errors
+        flow_reads = [FlowRead.model_validate(db_flow, from_attributes=True) for db_flow in response_list]
     except Exception as e:
         if "UNIQUE constraint failed" in str(e):
             # Get the name of the column that failed
@@ -464,7 +473,7 @@ async def upload_file(
             raise
         raise HTTPException(status_code=500, detail=str(e)) from e
 
-    return response_list
+    return flow_reads
 
 
 @router.delete("/")
@@ -491,7 +500,7 @@ async def delete_multiple_flows(
         for flow in flows_to_delete:
             await cascade_delete_flow(db, flow.id)
 
-        await db.commit()
+        await db.flush()
         return {"deleted": len(flows_to_delete)}
     except Exception as exc:
         raise HTTPException(status_code=500, detail=str(exc)) from exc