Langflow <> LFX Service Separation.

Author: dkaushik94

.gitignore

@@ -192,6 +192,10 @@ instance/
 # Scrapy stuff:
 .scrapy
 
+# AI Scratch work
+/scratch
+scratch/
+
 # Sphinx documentation
 docs/_build/
 

src/backend/base/langflow/services/database/service.py

@@ -9,13 +9,14 @@
 from contextlib import asynccontextmanager, contextmanager, nullcontext
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 import anyio
 import sqlalchemy as sa
 from alembic import command, util
 from alembic.config import Config
 from lfx.log.logger import logger
+from lfx.services.capabilities import Capability, Tier
 from lfx.services.deps import session_scope
 from sqlalchemy import event, inspect
 from sqlalchemy.dialects import sqlite as dialect_sqlite
@@ -255,6 +256,30 @@ def check_sqlite_database_path(database_url: str) -> None:
 class DatabaseService(Service):
     name = "database_service"
 
+    # Tier 1 infrastructure port. A real engine persists across restarts; SHARED
+    # (cross-process) is only true for Postgres, so the static class-level
+    # guarantee is the intersection: {PERSISTENT}. (A backend that wants to
+    # advertise SHARED can override per deployment.)
+    tier: ClassVar[Tier] = Tier.INFRASTRUCTURE
+    capabilities: ClassVar[frozenset[Capability]] = frozenset({Capability.PERSISTENT})
+
+    def session_scope(self):
+        """Async write session scope over this service (auto-commit/rollback).
+
+        Part of the Tier 1 database port (Option B): Tier 2 services call this on
+        their injected ``database_service``. Delegates to the shared helper so
+        semantics match the module-level ``lfx.services.deps.session_scope``.
+        """
+        from lfx.services.database.session import session_scope_for
+
+        return session_scope_for(self)
+
+    def session_scope_readonly(self):
+        """Read-only session scope over this service (no commit/rollback)."""
+        from lfx.services.database.session import session_scope_readonly_for
+
+        return session_scope_readonly_for(self)
+
     def __init__(self, settings_service: SettingsService):
         self._logged_pragma = False
         self.settings_service = settings_service

src/backend/base/langflow/services/factory.py

@@ -76,13 +76,23 @@ def import_all_services_into_a_dict():
         try:
             service_name = ServiceType(service_type).value.replace("_service", "")
 
-            # Special handling for mcp_composer which is now in lfx module
-            if service_name == "mcp_composer":
-                module_name = f"lfx.services.{service_name}.service"
-            else:
-                module_name = f"langflow.services.{service_name}.service"
+            # Some services are hosted in lfx rather than langflow (e.g. memory,
+            # mcp_composer). Prefer langflow's module when it exists (an override),
+            # otherwise fall back to the lfx module. A service whose ``.service``
+            # module exists in neither is simply skipped.
+            module = None
+            for module_name in (
+                f"langflow.services.{service_name}.service",
+                f"lfx.services.{service_name}.service",
+            ):
+                try:
+                    module = importlib.import_module(module_name)
+                    break
+                except ModuleNotFoundError:
+                    continue
+            if module is None:
+                continue
 
-            module = importlib.import_module(module_name)
             services.update(
                 {
                     name: obj

src/backend/base/langflow/services/memory/__init__.py

@@ -1,6 +1,11 @@
-"""Langflow's DB-backed chat-message memory service."""
+"""Langflow chat-message memory: the converged lfx Tier 2 service.
 
-from langflow.services.memory.factory import MemoryServiceFactory
-from langflow.services.memory.service import LangflowMemoryService
+Langflow no longer defines its own memory service class. It *selects* lfx's
+``DatabaseMemoryService`` and wires it over langflow's Tier 1 ``DatabaseService``
+(done in ``langflow.services.utils.register_all_service_factories``). This module
+re-exports the lfx class for any code that imported the langflow path.
+"""
 
-__all__ = ["LangflowMemoryService", "MemoryServiceFactory"]
+from lfx.services.memory.database import DatabaseMemoryService
+
+__all__ = ["DatabaseMemoryService"]

src/backend/base/langflow/services/memory/factory.py

@@ -566,6 +566,7 @@ def register_all_service_factories() -> None:
     service_manager = get_service_manager()
     from lfx.services.executor import factory as executor_factory
     from lfx.services.mcp_composer import factory as mcp_composer_factory
+    from lfx.services.memory.database import DatabaseMemoryService
     from lfx.services.settings import factory as settings_factory
 
     from langflow.services.auth import factory as auth_factory
@@ -576,7 +577,6 @@ def register_all_service_factories() -> None:
     from langflow.services.chat import factory as chat_factory
     from langflow.services.database import factory as database_factory
     from langflow.services.job_queue import factory as job_queue_factory
-    from langflow.services.memory import factory as memory_factory
     from langflow.services.session import factory as session_factory
     from langflow.services.shared_component_cache import factory as shared_component_cache_factory
     from langflow.services.state import factory as state_factory
@@ -597,7 +597,11 @@ def register_all_service_factories() -> None:
     service_manager.register_factory(session_factory.SessionServiceFactory())
     service_manager.register_factory(storage_factory.StorageServiceFactory())
     service_manager.register_factory(variable_factory.VariableServiceFactory())
-    service_manager.register_factory(memory_factory.MemoryServiceFactory())
+    # Memory (Tier 2) converges on the lfx implementation: langflow selects the
+    # lfx DatabaseMemoryService rather than subclassing. Registered as a service
+    # class (not a factory) so the manager injects its Tier 1 database_service
+    # dependency (Option B). This takes precedence over lfx's InMemory default.
+    service_manager.register_service_class(ServiceType.MEMORY_SERVICE, DatabaseMemoryService, override=True)
     service_manager.register_factory(telemetry_factory.TelemetryServiceFactory())
     service_manager.register_factory(tracing_factory.TracingServiceFactory())
     service_manager.register_factory(transaction_factory.TransactionServiceFactory())