arize-phoenix 4.5.0__py3-none-any.whl → 4.6.2__py3-none-any.whl

phoenix/server/api/types/TimeSeries.py

@@ -7,7 +7,7 @@ import pandas as pd
 import strawberry
 from strawberry import UNSET
 
-from phoenix.core.model_schema import CONTINUOUS, PRIMARY, REFERENCE, Column, Dataset, Dimension
+from phoenix.core.model_schema import CONTINUOUS, PRIMARY, REFERENCE, Column, Dimension, Inferences
 from phoenix.metrics import Metric, binning
 from phoenix.metrics.mixins import UnaryOperator
 from phoenix.metrics.timeseries import timeseries
@@ -15,7 +15,7 @@ from phoenix.server.api.input_types.Granularity import Granularity, to_timestamp
 from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.interceptor import GqlValueMediator
 from phoenix.server.api.types.DataQualityMetric import DataQualityMetric
-from phoenix.server.api.types.DatasetRole import DatasetRole
+from phoenix.server.api.types.InferencesRole import InferencesRole
 from phoenix.server.api.types.ScalarDriftMetricEnum import ScalarDriftMetric
 from phoenix.server.api.types.VectorDriftMetricEnum import VectorDriftMetric
 
@@ -97,7 +97,7 @@ def get_data_quality_timeseries_data(
     metric: DataQualityMetric,
     time_range: TimeRange,
     granularity: Granularity,
-    dataset_role: DatasetRole,
+    inferences_role: InferencesRole,
 ) -> List[TimeSeriesDataPoint]:
     metric_instance = metric.value()
     if isinstance(metric_instance, UnaryOperator):
@@ -106,7 +106,7 @@ def get_data_quality_timeseries_data(
             operand=Column(dimension.name),
         )
     df = pd.DataFrame(
-        {dimension.name: dimension[dataset_role.value]},
+        {dimension.name: dimension[inferences_role.value]},
         copy=False,
     )
     return get_timeseries_data(
@@ -160,12 +160,12 @@ class PerformanceTimeSeries(TimeSeries):
 
 
 def ensure_timeseries_parameters(
-    dataset: Dataset,
+    inferences: Inferences,
     time_range: Optional[TimeRange] = UNSET,
     granularity: Optional[Granularity] = UNSET,
 ) -> Tuple[TimeRange, Granularity]:
     if not isinstance(time_range, TimeRange):
-        start, stop = dataset.time_range
+        start, stop = inferences.time_range
         time_range = TimeRange(start=start, end=stop)
     if not isinstance(granularity, Granularity):
         total_minutes = int((time_range.end - time_range.start).total_seconds()) // 60

phoenix/server/api/types/Trace.py

@@ -1,17 +1,18 @@
+from __future__ import annotations
+
 from typing import List, Optional
 
 import strawberry
 from sqlalchemy import desc, select
 from sqlalchemy.orm import contains_eager
-from strawberry import UNSET
+from strawberry import UNSET, Private
+from strawberry.relay import Connection, GlobalID, Node, NodeID
 from strawberry.types import Info
 
 from phoenix.db import models
 from phoenix.server.api.context import Context
 from phoenix.server.api.types.Evaluation import TraceEvaluation
-from phoenix.server.api.types.node import Node
 from phoenix.server.api.types.pagination import (
-    Connection,
     ConnectionArgs,
     CursorString,
     connection_from_list,
@@ -21,6 +22,16 @@ from phoenix.server.api.types.Span import Span, to_gql_span
 
 @strawberry.type
 class Trace(Node):
+    id_attr: NodeID[int]
+    project_rowid: Private[int]
+    trace_id: str
+
+    @strawberry.field
+    async def project_id(self) -> GlobalID:
+        from phoenix.server.api.types.Project import Project
+
+        return GlobalID(type_name=Project.__name__, node_id=str(self.project_rowid))
+
     @strawberry.field
     async def spans(
         self,
@@ -40,7 +51,7 @@ class Trace(Node):
             select(models.Span)
             .join(models.Trace)
             .where(models.Trace.id == self.id_attr)
-            .options(contains_eager(models.Span.trace))
+            .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
             # Sort descending because the root span tends to show up later
             # in the ingestion process.
             .order_by(desc(models.Span.id))

phoenix/server/api/types/UMAPPoints.py

@@ -3,13 +3,13 @@ from typing import List, Union
 import numpy as np
 import numpy.typing as npt
 import strawberry
+from strawberry.relay.types import GlobalID
 from strawberry.scalars import ID
 
 from phoenix.server.api.types.Cluster import Cluster
 
 from .EmbeddingMetadata import EmbeddingMetadata
 from .EventMetadata import EventMetadata
-from .node import GlobalID
 from .Retrieval import Retrieval
 
 

phoenix/server/api/types/node.py

@@ -1,36 +1,19 @@
-import base64
-import dataclasses
-from typing import Tuple, Union
+from typing import Tuple
 
-import strawberry
-from graphql import GraphQLID
-from strawberry.custom_scalar import ScalarDefinition
-from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
+from strawberry.relay import GlobalID
 
 
-def to_global_id(type_name: str, node_id: int) -> str:
-    """
-    Encode the given id into a global id.
-
-    :param type_name: The type of the node.
-    :param node_id: The id of the node.
-    :return: A global id.
-    """
-    return base64.b64encode(f"{type_name}:{node_id}".encode("utf-8")).decode()
-
-
-def from_global_id(global_id: str) -> Tuple[str, int]:
+def from_global_id(global_id: GlobalID) -> Tuple[str, int]:
     """
     Decode the given global id into a type and id.
 
     :param global_id: The global id to decode.
     :return: A tuple of type and id.
     """
-    type_name, node_id = base64.b64decode(global_id).decode().split(":")
-    return type_name, int(node_id)
+    return global_id.type_name, int(global_id.node_id)
 
 
-def from_global_id_with_expected_type(global_id: str, expected_type_name: str) -> int:
+def from_global_id_with_expected_type(global_id: GlobalID, expected_type_name: str) -> int:
     """
     Decodes the given global id and return the id, checking that the type
     matches the expected type.
@@ -42,92 +25,3 @@ def from_global_id_with_expected_type(global_id: str, expected_type_name: str) -
             f"but instead corresponds to a node of type: {type_name}"
         )
     return node_id
-
-
-class GlobalIDValueError(ValueError):
-    """GlobalID value error, usually related to parsing or serialization."""
-
-
-@dataclasses.dataclass(frozen=True)
-class GlobalID:
-    """Global ID for relay types.
-    Different from `strawberry.ID`, this ID wraps the original object ID in a string
-    that contains both its GraphQL type name and the ID itself, and encodes it
-    to a base64_ string.
-    This object contains helpers to work with that, including method to retrieve
-    the python object type or even the encoded node itself.
-    Attributes:
-        type_name:
-            The type name part of the id
-        node_id:
-            The node id part of the id
-    .. _base64:
-        https://en.wikipedia.org/wiki/Base64
-    """
-
-    type_name: str
-    node_id: int
-
-    def __post_init__(self) -> None:
-        if not isinstance(self.type_name, str):
-            raise GlobalIDValueError(
-                f"type_name is expected to be a string, found {self.type_name}"
-            )
-        try:
-            # node_id could be numpy.int64, hence the need for coercion
-            object.__setattr__(self, "node_id", int(self.node_id))
-        except ValueError:
-            raise GlobalIDValueError(f"node_id is expected to be an int, found {self.node_id}")
-
-    def __str__(self) -> str:
-        return to_global_id(self.type_name, self.node_id)
-
-    @classmethod
-    def from_id(cls, value: Union[str, strawberry.ID]) -> "GlobalID":
-        """Create a new GlobalID from parsing the given value.
-        Args:
-            value:
-                The value to be parsed, as a base64 string in the "TypeName:NodeID" format
-        Returns:
-            An instance of GLobalID
-        Raises:
-            GlobalIDValueError:
-                If the value is not in a GLobalID format
-        """
-        try:
-            type_name, node_id = from_global_id(value)
-        except ValueError as e:
-            raise GlobalIDValueError(str(e)) from e
-
-        return cls(type_name=type_name, node_id=node_id)
-
-
-@strawberry.interface(description="A node in the graph with a globally unique ID")
-class Node:
-    """
-    All types that are relay ready should inherit from this interface and
-    implement the following methods.
-
-    Attributes:
-        id_attr:
-            The raw id field of node. Typically a database id or index
-    """
-
-    id_attr: strawberry.Private[int]
-
-    @strawberry.field
-    def id(self) -> GlobalID:
-        return GlobalID(type(self).__name__, self.id_attr)
-
-
-# Register our GlobalID scalar
-DEFAULT_SCALAR_REGISTRY[GlobalID] = ScalarDefinition(
-    # Use the same name/description/parse_literal from GraphQLID
-    # specs expect this type to be "ID".
-    name="GlobalID",
-    description=GraphQLID.description,
-    parse_literal=lambda v, vars=None: GlobalID.from_id(GraphQLID.parse_literal(v, vars)),
-    parse_value=GlobalID.from_id,
-    serialize=str,
-    specified_by_url="https://relay.dev/graphql/objectidentification.htm",
-)

phoenix/server/api/types/pagination.py

@@ -2,60 +2,18 @@ import base64
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum, auto
-from typing import ClassVar, Generic, List, Optional, Tuple, TypeVar, Union
+from typing import Any, ClassVar, List, Optional, Tuple, Union
 
-import strawberry
 from strawberry import UNSET
+from strawberry.relay.types import Connection, Edge, NodeType, PageInfo
 from typing_extensions import TypeAlias, assert_never
 
 ID: TypeAlias = int
-GenericType = TypeVar("GenericType")
 CursorSortColumnValue: TypeAlias = Union[str, int, float, datetime]
 
-
-@strawberry.type
-class Connection(Generic[GenericType]):
-    """Represents a paginated relationship between two entities
-
-    This pattern is used when the relationship itself has attributes.
-    """
-
-    page_info: "PageInfo"
-    edges: List["Edge[GenericType]"]
-
-
-@strawberry.type
-class PageInfo:
-    """Pagination context to navigate objects with cursor-based pagination
-
-    Instead of classic offset pagination via `page` and `limit` parameters,
-    here we have a cursor of the last object and we fetch items starting from that one
-
-    Read more at:
-        - https://graphql.org/learn/pagination/#pagination-and-edges
-        - https://relay.dev/graphql/connections.htm
-    """
-
-    has_next_page: bool
-    has_previous_page: bool
-    start_cursor: Optional[str]
-    end_cursor: Optional[str]
-
-
 # A type alias for the connection cursor implementation
 CursorString = str
 
-
-@strawberry.type
-class Edge(Generic[GenericType]):
-    """
-    An edge may contain additional information of the relationship. This is the trivial case
-    """
-
-    node: GenericType
-    cursor: str
-
-
 # The hashing prefix for a connection cursor
 CURSOR_PREFIX = "connection:"
 
@@ -218,9 +176,9 @@ class ConnectionArgs:
 
 
 def connection_from_list(
-    data: List[GenericType],
+    data: List[NodeType],
     args: ConnectionArgs,
-) -> Connection[GenericType]:
+) -> Connection[NodeType]:
     """
     A simple function that accepts a list and connection arguments, and returns
     a connection object for use in GraphQL. It uses list offsets as pagination,
@@ -230,11 +188,11 @@ def connection_from_list(
 
 
 def connection_from_list_slice(
-    list_slice: List[GenericType],
+    list_slice: List[NodeType],
     args: ConnectionArgs,
     slice_start: int,
     list_length: int,
-) -> Connection[GenericType]:
+) -> Connection[NodeType]:
     """
     Given a slice (subset) of a list, returns a connection object for use in
     GraphQL.
@@ -295,12 +253,12 @@ def connection_from_list_slice(
     )
 
 
-def connections(
-    data: List[Tuple[Cursor, GenericType]],
+def connection_from_cursors_and_nodes(
+    cursors_and_nodes: List[Tuple[Any, NodeType]],
     has_previous_page: bool,
     has_next_page: bool,
-) -> Connection[GenericType]:
-    edges = [Edge(node=node, cursor=str(cursor)) for cursor, node in data]
+) -> Connection[NodeType]:
+    edges = [Edge(node=node, cursor=str(cursor)) for cursor, node in cursors_and_nodes]
     has_edges = len(edges) > 0
     first_edge = edges[0] if has_edges else None
     last_edge = edges[-1] if has_edges else None

phoenix/server/app.py

@@ -33,7 +33,6 @@ from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoin
 from starlette.requests import Request
 from starlette.responses import FileResponse, PlainTextResponse, Response
 from starlette.routing import Mount, Route
-from starlette.schemas import SchemaGenerator
 from starlette.staticfiles import StaticFiles
 from starlette.templating import Jinja2Templates
 from starlette.types import Scope, StatefulLifespan
@@ -57,19 +56,30 @@ from phoenix.exceptions import PhoenixMigrationError
 from phoenix.pointcloud.umap_parameters import UMAPParameters
 from phoenix.server.api.context import Context, DataLoaders
 from phoenix.server.api.dataloaders import (
+    AverageExperimentRunLatencyDataLoader,
     CacheForDataLoaders,
+    DatasetExampleRevisionsDataLoader,
+    DatasetExampleSpansDataLoader,
     DocumentEvaluationsDataLoader,
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
     EvaluationSummaryDataLoader,
+    ExperimentAnnotationSummaryDataLoader,
+    ExperimentErrorRatesDataLoader,
+    ExperimentRunCountsDataLoader,
+    ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
     MinStartOrMaxEndTimeDataLoader,
+    ProjectByNameDataLoader,
     RecordCountDataLoader,
     SpanDescendantsDataLoader,
     SpanEvaluationsDataLoader,
+    SpanProjectsDataLoader,
     TokenCountDataLoader,
     TraceEvaluationsDataLoader,
+    TraceRowIdsDataLoader,
 )
+from phoenix.server.api.openapi.schema import OPENAPI_SCHEMA_GENERATOR
 from phoenix.server.api.routers.v1 import V1_ROUTES
 from phoenix.server.api.schema import schema
 from phoenix.server.grpc_server import GrpcServer
@@ -84,10 +94,6 @@ logger = logging.getLogger(__name__)
 
 templates = Jinja2Templates(directory=SERVER_DIR / "templates")
 
-schemas = SchemaGenerator(
-    {"openapi": "3.0.0", "info": {"title": "ArizePhoenix API", "version": "1.0"}}
-)
-
 
 class AppConfig(NamedTuple):
     has_inferences: bool
@@ -126,6 +132,7 @@ class Static(StaticFiles):
                     "n_neighbors": self._app_config.n_neighbors,
                     "n_samples": self._app_config.n_samples,
                     "basename": request.scope.get("root_path", ""),
+                    "platform_version": phoenix.__version__,
                     "request": request,
                 },
             )
@@ -185,6 +192,9 @@ class GraphQLWithContext(GraphQL):  # type: ignore
             export_path=self.export_path,
             streaming_last_updated_at=self.streaming_last_updated_at,
             data_loaders=DataLoaders(
+                average_experiment_run_latency=AverageExperimentRunLatencyDataLoader(self.db),
+                dataset_example_revisions=DatasetExampleRevisionsDataLoader(self.db),
+                dataset_example_spans=DatasetExampleSpansDataLoader(self.db),
                 document_evaluation_summaries=DocumentEvaluationSummaryDataLoader(
                     self.db,
                     cache_map=self.cache_for_dataloaders.document_evaluation_summary
@@ -199,6 +209,10 @@ class GraphQLWithContext(GraphQL):  # type: ignore
                     if self.cache_for_dataloaders
                     else None,
                 ),
+                experiment_annotation_summaries=ExperimentAnnotationSummaryDataLoader(self.db),
+                experiment_error_rates=ExperimentErrorRatesDataLoader(self.db),
+                experiment_run_counts=ExperimentRunCountsDataLoader(self.db),
+                experiment_sequence_number=ExperimentSequenceNumberDataLoader(self.db),
                 latency_ms_quantile=LatencyMsQuantileDataLoader(
                     self.db,
                     cache_map=self.cache_for_dataloaders.latency_ms_quantile
@@ -219,6 +233,7 @@ class GraphQLWithContext(GraphQL):  # type: ignore
                 ),
                 span_descendants=SpanDescendantsDataLoader(self.db),
                 span_evaluations=SpanEvaluationsDataLoader(self.db),
+                span_projects=SpanProjectsDataLoader(self.db),
                 token_counts=TokenCountDataLoader(
                     self.db,
                     cache_map=self.cache_for_dataloaders.token_count
@@ -226,6 +241,8 @@ class GraphQLWithContext(GraphQL):  # type: ignore
                     else None,
                 ),
                 trace_evaluations=TraceEvaluationsDataLoader(self.db),
+                trace_row_ids=TraceRowIdsDataLoader(self.db),
+                project_by_name=ProjectByNameDataLoader(self.db),
             ),
             cache_for_dataloaders=self.cache_for_dataloaders,
             read_only=self.read_only,
@@ -272,7 +289,11 @@ def _lifespan(
 ) -> StatefulLifespan[Starlette]:
     @contextlib.asynccontextmanager
     async def lifespan(_: Starlette) -> AsyncIterator[Dict[str, Any]]:
-        async with bulk_inserter as (queue_span, queue_evaluation), GrpcServer(
+        async with bulk_inserter as (
+            queue_span,
+            queue_evaluation,
+            enqueue_operation,
+        ), GrpcServer(
             queue_span,
             disabled=read_only,
             tracer_provider=tracer_provider,
@@ -281,6 +302,7 @@ def _lifespan(
             yield {
                 "queue_span_for_bulk_insert": queue_span,
                 "queue_evaluation_for_bulk_insert": queue_evaluation,
+                "enqueue_operation": enqueue_operation,
             }
         for clean_up in clean_ups:
             clean_up()
@@ -293,15 +315,63 @@ async def check_healthz(_: Request) -> PlainTextResponse:
 
 
 async def openapi_schema(request: Request) -> Response:
-    return schemas.OpenAPIResponse(request=request)
+    return OPENAPI_SCHEMA_GENERATOR.OpenAPIResponse(request=request)
 
 
 async def api_docs(request: Request) -> Response:
     return get_swagger_ui_html(openapi_url="/schema", title="arize-phoenix API")
 
 
-def create_app(
+class SessionFactory:
+    def __init__(
+        self,
+        session_factory: Callable[[], AsyncContextManager[AsyncSession]],
+        dialect: str,
+    ):
+        self.session_factory = session_factory
+        self.dialect = SupportedSQLDialect(dialect)
+
+    def __call__(self) -> AsyncContextManager[AsyncSession]:
+        return self.session_factory()
+
+
+def create_engine_and_run_migrations(
     database_url: str,
+) -> AsyncEngine:
+    try:
+        return create_engine(database_url)
+    except PhoenixMigrationError as e:
+        msg = (
+            "\n\n⚠️⚠️ Phoenix failed to migrate the database to the latest version. ⚠️⚠️\n\n"
+            "The database may be in a dirty state. To resolve this, the Alembic CLI can be used\n"
+            "from the `src/phoenix/db` directory inside the Phoenix project root. From here,\n"
+            "revert any partial migrations and run `alembic stamp` to reset the migration state,\n"
+            "then try starting Phoenix again.\n\n"
+            "If issues persist, please reach out for support in the Arize community Slack:\n"
+            "https://arize-ai.slack.com\n\n"
+            "You can also refer to the Alembic documentation for more information:\n"
+            "https://alembic.sqlalchemy.org/en/latest/tutorial.html\n\n"
+            ""
+        )
+        raise PhoenixMigrationError(msg) from e
+
+
+def instrument_engine_if_enabled(engine: AsyncEngine) -> List[Callable[[], None]]:
+    instrumentation_cleanups = []
+    if server_instrumentation_is_enabled():
+        from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+
+        tracer_provider = initialize_opentelemetry_tracer_provider()
+        SQLAlchemyInstrumentor().instrument(
+            engine=engine.sync_engine,
+            tracer_provider=tracer_provider,
+        )
+        instrumentation_cleanups.append(SQLAlchemyInstrumentor().uninstrument)
+    return instrumentation_cleanups
+
+
+def create_app(
+    db: SessionFactory,
     export_path: Path,
     model: Model,
     umap_params: UMAPParameters,
@@ -311,8 +381,10 @@ def create_app(
     enable_prometheus: bool = False,
     initial_spans: Optional[Iterable[Union[Span, Tuple[Span, str]]]] = None,
     initial_evaluations: Optional[Iterable[pb.Evaluation]] = None,
+    serve_ui: bool = True,
+    clean_up_callbacks: List[Callable[[], None]] = [],
 ) -> Starlette:
-    clean_ups: List[Callable[[], None]] = []  # To be called at app shutdown.
+    clean_ups: List[Callable[[], None]] = clean_up_callbacks  # To be called at app shutdown.
     initial_batch_of_spans: Iterable[Tuple[Span, str]] = (
         ()
         if initial_spans is None
@@ -322,28 +394,10 @@ def create_app(
         )
     )
     initial_batch_of_evaluations = () if initial_evaluations is None else initial_evaluations
-    try:
-        engine = create_engine(database_url)
-    except PhoenixMigrationError as e:
-        msg = (
-            "\n\n⚠️⚠️ Phoenix failed to migrate the database to the latest version. ⚠️⚠️\n\n"
-            "The database may be in a dirty state. To resolve this, the Alembic CLI can be used\n"
-            "from the `src/phoenix/db` directory inside the Phoenix project root. From here,\n"
-            "revert any partial migrations and run `alembic stamp` to reset the migration state,\n"
-            "then try starting Phoenix again.\n\n"
-            "If issues persist, please reach out for support in the Arize community Slack:\n"
-            "https://arize-ai.slack.com\n\n"
-            "You can also refer to the Alembic documentation for more information:\n"
-            "https://alembic.sqlalchemy.org/en/latest/tutorial.html\n\n"
-            ""
-        )
-        raise PhoenixMigrationError(msg) from e
     cache_for_dataloaders = (
-        CacheForDataLoaders()
-        if SupportedSQLDialect(engine.dialect.name) is SupportedSQLDialect.SQLITE
-        else None
+        CacheForDataLoaders() if db.dialect is SupportedSQLDialect.SQLITE else None
     )
-    db = _db(engine)
+
     bulk_inserter = BulkInserter(
         db,
         enable_prometheus=enable_prometheus,
@@ -354,16 +408,9 @@ def create_app(
     tracer_provider = None
     strawberry_extensions = schema.get_extensions()
     if server_instrumentation_is_enabled():
-        from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
         from opentelemetry.trace import TracerProvider
         from strawberry.extensions.tracing import OpenTelemetryExtension
 
-        tracer_provider = initialize_opentelemetry_tracer_provider()
-        SQLAlchemyInstrumentor().instrument(
-            engine=engine.sync_engine,
-            tracer_provider=tracer_provider,
-        )
-        clean_ups.append(SQLAlchemyInstrumentor().uninstrument)
         if TYPE_CHECKING:
             # Type-check the class before monkey-patching its private attribute.
             assert OpenTelemetryExtension._tracer
@@ -377,6 +424,7 @@ def create_app(
                 self._tracer = cast(TracerProvider, tracer_provider).get_tracer("strawberry")
 
         strawberry_extensions.append(_OpenTelemetryExtension)
+
     graphql = GraphQLWithContext(
         db=db,
         schema=strawberry.Schema(
@@ -433,21 +481,27 @@ def create_app(
                 "/graphql",
                 graphql,
             ),
-            Mount(
-                "/",
-                app=Static(
-                    directory=SERVER_DIR / "static",
-                    app_config=AppConfig(
-                        has_inferences=model.is_empty is not True,
-                        has_corpus=corpus is not None,
-                        min_dist=umap_params.min_dist,
-                        n_neighbors=umap_params.n_neighbors,
-                        n_samples=umap_params.n_samples,
+        ]
+        + (
+            [
+                Mount(
+                    "/",
+                    app=Static(
+                        directory=SERVER_DIR / "static",
+                        app_config=AppConfig(
+                            has_inferences=model.is_empty is not True,
+                            has_corpus=corpus is not None,
+                            min_dist=umap_params.min_dist,
+                            n_neighbors=umap_params.n_neighbors,
+                            n_samples=umap_params.n_samples,
+                        ),
                     ),
+                    name="static",
                 ),
-                name="static",
-            ),
-        ],
+            ]
+            if serve_ui
+            else []
+        ),
     )
     app.state.read_only = read_only
     app.state.db = db