arize-phoenix 5.7.0__py3-none-any.whl → 5.9.0__py3-none-any.whl

phoenix/server/api/subscriptions.py

@@ -1,14 +1,16 @@
+import asyncio
 import logging
-from asyncio import FIRST_COMPLETED, Task, create_task, wait
-from collections.abc import Iterator
+from asyncio import FIRST_COMPLETED, Queue, QueueEmpty, Task, create_task, wait, wait_for
+from collections.abc import AsyncIterator, Iterator
+from datetime import datetime, timezone
 from typing import (
     Any,
-    AsyncIterator,
-    Collection,
     Iterable,
     Mapping,
     Optional,
+    Sequence,
     TypeVar,
+    cast,
 )
 
 import strawberry
@@ -19,9 +21,10 @@ from strawberry.relay.types import GlobalID
 from strawberry.types import Info
 from typing_extensions import TypeAlias, assert_never
 
+from phoenix.datetime_utils import local_now, normalize_datetime
 from phoenix.db import models
 from phoenix.server.api.context import Context
-from phoenix.server.api.exceptions import BadRequest
+from phoenix.server.api.exceptions import BadRequest, NotFound
 from phoenix.server.api.helpers.playground_clients import (
     PlaygroundStreamingClient,
     initialize_playground_clients,
@@ -29,27 +32,33 @@ from phoenix.server.api.helpers.playground_clients import (
 from phoenix.server.api.helpers.playground_registry import (
     PLAYGROUND_CLIENT_REGISTRY,
 )
-from phoenix.server.api.helpers.playground_spans import streaming_llm_span
+from phoenix.server.api.helpers.playground_spans import (
+    get_db_experiment_run,
+    get_db_span,
+    get_db_trace,
+    streaming_llm_span,
+)
 from phoenix.server.api.input_types.ChatCompletionInput import (
     ChatCompletionInput,
     ChatCompletionOverDatasetInput,
 )
 from phoenix.server.api.types.ChatCompletionMessageRole import ChatCompletionMessageRole
 from phoenix.server.api.types.ChatCompletionSubscriptionPayload import (
-    ChatCompletionOverDatasetSubscriptionResult,
     ChatCompletionSubscriptionError,
+    ChatCompletionSubscriptionExperiment,
     ChatCompletionSubscriptionPayload,
-    FinishedChatCompletion,
+    ChatCompletionSubscriptionResult,
 )
 from phoenix.server.api.types.Dataset import Dataset
 from phoenix.server.api.types.DatasetExample import DatasetExample
 from phoenix.server.api.types.DatasetVersion import DatasetVersion
 from phoenix.server.api.types.Experiment import to_gql_experiment
+from phoenix.server.api.types.ExperimentRun import to_gql_experiment_run
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.Span import to_gql_span
 from phoenix.server.api.types.TemplateLanguage import TemplateLanguage
 from phoenix.server.dml_event import SpanInsertEvent
-from phoenix.trace.attributes import get_attribute_value
+from phoenix.server.types import DbSessionFactory
 from phoenix.utilities.template_formatters import (
     FStringTemplateFormatter,
     MustacheTemplateFormatter,
@@ -67,6 +76,9 @@ ChatCompletionMessage: TypeAlias = tuple[
     ChatCompletionMessageRole, str, Optional[str], Optional[list[str]]
 ]
 DatasetExampleID: TypeAlias = GlobalID
+ChatCompletionResult: TypeAlias = tuple[
+    DatasetExampleID, Optional[models.Span], models.ExperimentRun
+]
 PLAYGROUND_PROJECT_NAME = "playground"
 
 
@@ -116,8 +128,8 @@ class Subscription:
                 span.add_response_chunk(chunk)
                 yield chunk
             span.set_attributes(llm_client.attributes)
-        if span.error_message is not None:
-            yield ChatCompletionSubscriptionError(message=span.error_message)
+        if span.status_message is not None:
+            yield ChatCompletionSubscriptionError(message=span.status_message)
         async with info.context.db() as session:
             if (
                 playground_project_id := await session.scalar(
@@ -132,10 +144,12 @@ class Subscription:
                         description="Traces from prompt playground",
                     )
                 )
-            db_span = span.add_to_session(session, playground_project_id)
+            db_trace = get_db_trace(span, playground_project_id)
+            db_span = get_db_span(span, db_trace)
+            session.add(db_span)
             await session.flush()
-            yield FinishedChatCompletion(span=to_gql_span(db_span))
         info.context.event_queue.put(SpanInsertEvent(ids=(playground_project_id,)))
+        yield ChatCompletionSubscriptionResult(span=to_gql_span(db_span))
 
     @strawberry.subscription
     async def chat_completion_over_dataset(
@@ -154,58 +168,68 @@ class Subscription:
             if input.dataset_version_id
             else None
         )
-        revision_ids = (
-            select(func.max(models.DatasetExampleRevision.id))
-            .join(models.DatasetExample)
-            .where(models.DatasetExample.dataset_id == dataset_id)
-            .group_by(models.DatasetExampleRevision.dataset_example_id)
-        )
-        if version_id:
-            version_id_subquery = (
-                select(models.DatasetVersion.id)
-                .where(models.DatasetVersion.dataset_id == dataset_id)
-                .where(models.DatasetVersion.id == version_id)
-                .scalar_subquery()
-            )
-            revision_ids = revision_ids.where(
-                models.DatasetExampleRevision.dataset_version_id <= version_id_subquery
-            )
-        query = (
-            select(models.DatasetExampleRevision)
-            .where(
-                and_(
-                    models.DatasetExampleRevision.id.in_(revision_ids),
-                    models.DatasetExampleRevision.revision_kind != "DELETE",
+        async with info.context.db() as session:
+            if (
+                dataset := await session.scalar(
+                    select(models.Dataset).where(models.Dataset.id == dataset_id)
                 )
-            )
-            .order_by(models.DatasetExampleRevision.dataset_example_id.asc())
-            .options(
-                load_only(
-                    models.DatasetExampleRevision.dataset_example_id,
-                    models.DatasetExampleRevision.input,
+            ) is None:
+                raise NotFound(f"Could not find dataset with ID {dataset_id}")
+            if version_id is None:
+                if (
+                    resolved_version_id := await session.scalar(
+                        select(models.DatasetVersion.id)
+                        .where(models.DatasetVersion.dataset_id == dataset_id)
+                        .order_by(models.DatasetVersion.id.desc())
+                        .limit(1)
+                    )
+                ) is None:
+                    raise NotFound(f"No versions found for dataset with ID {dataset_id}")
+            else:
+                if (
+                    resolved_version_id := await session.scalar(
+                        select(models.DatasetVersion.id).where(
+                            and_(
+                                models.DatasetVersion.dataset_id == dataset_id,
+                                models.DatasetVersion.id == version_id,
+                            )
+                        )
+                    )
+                ) is None:
+                    raise NotFound(f"Could not find dataset version with ID {version_id}")
+            revision_ids = (
+                select(func.max(models.DatasetExampleRevision.id))
+                .join(models.DatasetExample)
+                .where(
+                    and_(
+                        models.DatasetExample.dataset_id == dataset_id,
+                        models.DatasetExampleRevision.dataset_version_id <= resolved_version_id,
+                    )
                 )
+                .group_by(models.DatasetExampleRevision.dataset_example_id)
             )
-        )
-        async with info.context.db() as session:
-            revisions = [revision async for revision in await session.stream_scalars(query)]
-        if not revisions:
-            raise BadRequest("No examples found for the given dataset and version")
-
-        spans: dict[DatasetExampleID, streaming_llm_span] = {}
-        async for payload in _merge_iterators(
-            [
-                _stream_chat_completion_over_dataset_example(
-                    input=input,
-                    llm_client_class=llm_client_class,
-                    revision=revision,
-                    spans=spans,
-                )
-                for revision in revisions
-            ]
-        ):
-            yield payload
-
-        async with info.context.db() as session:
+            if not (
+                revisions := [
+                    rev
+                    async for rev in await session.stream_scalars(
+                        select(models.DatasetExampleRevision)
+                        .where(
+                            and_(
+                                models.DatasetExampleRevision.id.in_(revision_ids),
+                                models.DatasetExampleRevision.revision_kind != "DELETE",
+                            )
+                        )
+                        .order_by(models.DatasetExampleRevision.dataset_example_id.asc())
+                        .options(
+                            load_only(
+                                models.DatasetExampleRevision.dataset_example_id,
+                                models.DatasetExampleRevision.input,
+                            )
+                        )
+                    )
+                ]
+            ):
+                raise NotFound("No examples found for the given dataset and version")
             if (
                 playground_project_id := await session.scalar(
                     select(models.Project.id).where(models.Project.name == PLAYGROUND_PROJECT_NAME)
@@ -219,81 +243,70 @@ class Subscription:
                         description="Traces from prompt playground",
                     )
                 )
-            db_spans = {
-                example_id: span.add_to_session(session, playground_project_id)
-                for example_id, span in spans.items()
-            }
-            assert (
-                dataset_name := await session.scalar(
-                    select(models.Dataset.name).where(models.Dataset.id == dataset_id)
-                )
-            ) is not None
-            if version_id is None:
-                resolved_version_id = await session.scalar(
-                    select(models.DatasetVersion.id)
-                    .where(models.DatasetVersion.dataset_id == dataset_id)
-                    .order_by(models.DatasetVersion.id.desc())
-                    .limit(1)
-                )
-            else:
-                resolved_version_id = await session.scalar(
-                    select(models.DatasetVersion.id).where(
-                        and_(
-                            models.DatasetVersion.dataset_id == dataset_id,
-                            models.DatasetVersion.id == version_id,
-                        )
-                    )
-                )
-            assert resolved_version_id is not None
-            resolved_version_node_id = GlobalID(DatasetVersion.__name__, str(resolved_version_id))
             experiment = models.Experiment(
                 dataset_id=from_global_id_with_expected_type(input.dataset_id, Dataset.__name__),
                 dataset_version_id=resolved_version_id,
-                name=input.experiment_name or _DEFAULT_PLAYGROUND_EXPERIMENT_NAME,
+                name=input.experiment_name or _default_playground_experiment_name(),
                 description=input.experiment_description
-                or _default_playground_experiment_description(dataset_name=dataset_name),
+                or _default_playground_experiment_description(dataset_name=dataset.name),
                 repetitions=1,
                 metadata_=input.experiment_metadata
                 or _default_playground_experiment_metadata(
-                    dataset_name=dataset_name,
+                    dataset_name=dataset.name,
                     dataset_id=input.dataset_id,
-                    version_id=resolved_version_node_id,
+                    version_id=GlobalID(DatasetVersion.__name__, str(resolved_version_id)),
                 ),
                 project_name=PLAYGROUND_PROJECT_NAME,
             )
             session.add(experiment)
             await session.flush()
-            runs = [
-                models.ExperimentRun(
-                    experiment_id=experiment.id,
-                    dataset_example_id=from_global_id_with_expected_type(
-                        example_id, DatasetExample.__name__
-                    ),
-                    trace_id=span.trace_id,
-                    output=models.ExperimentRunOutput(
-                        task_output=_get_playground_experiment_task_output(span)
-                    ),
-                    repetition_number=1,
-                    start_time=span.start_time,
-                    end_time=span.end_time,
-                    error=error_message
-                    if (error_message := span.error_message) is not None
-                    else None,
-                    prompt_token_count=get_attribute_value(span.attributes, LLM_TOKEN_COUNT_PROMPT),
-                    completion_token_count=get_attribute_value(
-                        span.attributes, LLM_TOKEN_COUNT_COMPLETION
-                    ),
-                )
-                for example_id, span in spans.items()
-            ]
-            session.add_all(runs)
-            await session.flush()
-        for example_id in spans:
-            yield FinishedChatCompletion(
-                span=to_gql_span(db_spans[example_id]),
-                dataset_example_id=example_id,
+        yield ChatCompletionSubscriptionExperiment(
+            experiment=to_gql_experiment(experiment)
+        )  # eagerly yields experiment so it can be linked by consumers of the subscription
+
+        results_queue: Queue[ChatCompletionResult] = Queue()
+        chat_completion_streams = [
+            _stream_chat_completion_over_dataset_example(
+                input=input,
+                llm_client_class=llm_client_class,
+                revision=revision,
+                results_queue=results_queue,
+                experiment_id=experiment.id,
+                project_id=playground_project_id,
             )
-        yield ChatCompletionOverDatasetSubscriptionResult(experiment=to_gql_experiment(experiment))
+            for revision in revisions
+        ]
+        stream_to_async_tasks: dict[
+            AsyncIterator[ChatCompletionSubscriptionPayload],
+            Task[ChatCompletionSubscriptionPayload],
+        ] = {iterator: _create_task_with_timeout(iterator) for iterator in chat_completion_streams}
+        batch_size = 10
+        while stream_to_async_tasks:
+            async_tasks_to_run = [task for task in stream_to_async_tasks.values()]
+            completed_tasks, _ = await wait(async_tasks_to_run, return_when=FIRST_COMPLETED)
+            for task in completed_tasks:
+                iterator = next(it for it, t in stream_to_async_tasks.items() if t == task)
+                try:
+                    yield task.result()
+                except (StopAsyncIteration, asyncio.TimeoutError):
+                    del stream_to_async_tasks[iterator]  # removes exhausted iterator
+                except Exception as error:
+                    del stream_to_async_tasks[iterator]  # removes failed iterator
+                    logger.exception(error)
+                else:
+                    stream_to_async_tasks[iterator] = _create_task_with_timeout(iterator)
+                if results_queue.qsize() >= batch_size:
+                    result_iterator = _chat_completion_result_payloads(
+                        db=info.context.db, results=_drain_no_wait(results_queue)
+                    )
+                    stream_to_async_tasks[result_iterator] = _create_task_with_timeout(
+                        result_iterator
+                    )
+        if remaining_results := await _drain(results_queue):
+            async for result_payload in _chat_completion_result_payloads(
+                db=info.context.db, results=remaining_results
+            ):
+                yield result_payload
 
 
 async def _stream_chat_completion_over_dataset_example(
@@ -301,7 +314,9 @@ async def _stream_chat_completion_over_dataset_example(
     input: ChatCompletionOverDatasetInput,
     llm_client_class: type["PlaygroundStreamingClient"],
     revision: models.DatasetExampleRevision,
-    spans: dict[DatasetExampleID, streaming_llm_span],
+    results_queue: Queue[ChatCompletionResult],
+    experiment_id: int,
+    project_id: int,
 ) -> AsyncIterator[ChatCompletionSubscriptionPayload]:
     example_id = GlobalID(DatasetExample.__name__, str(revision.dataset_example_id))
     llm_client = llm_client_class(
@@ -319,6 +334,7 @@ async def _stream_chat_completion_over_dataset_example(
         for message in input.messages
     ]
     try:
+        format_start_time = cast(datetime, normalize_datetime(dt=local_now(), tz=timezone.utc))
         messages = list(
             _formatted_messages(
                 messages=messages,
@@ -327,15 +343,31 @@ async def _stream_chat_completion_over_dataset_example(
             )
         )
     except TemplateFormatterError as error:
+        format_end_time = cast(datetime, normalize_datetime(dt=local_now(), tz=timezone.utc))
         yield ChatCompletionSubscriptionError(message=str(error), dataset_example_id=example_id)
+        await results_queue.put(
+            (
+                example_id,
+                None,
+                models.ExperimentRun(
+                    experiment_id=experiment_id,
+                    dataset_example_id=revision.dataset_example_id,
+                    trace_id=None,
+                    output={},
+                    repetition_number=1,
+                    start_time=format_start_time,
+                    end_time=format_end_time,
+                    error=str(error),
+                    trace=None,
+                ),
+            )
+        )
         return
-    span = streaming_llm_span(
+    async with streaming_llm_span(
         input=input,
         messages=messages,
         invocation_parameters=invocation_parameters,
-    )
-    spans[example_id] = span
-    async with span:
+    ) as span:
         async for chunk in llm_client.chat_completion_create(
             messages=messages, tools=input.tools or [], **invocation_parameters
         ):
@@ -343,35 +375,60 @@ async def _stream_chat_completion_over_dataset_example(
             chunk.dataset_example_id = example_id
             yield chunk
         span.set_attributes(llm_client.attributes)
-    if span.error_message is not None:
+    db_trace = get_db_trace(span, project_id)
+    db_span = get_db_span(span, db_trace)
+    db_run = get_db_experiment_run(
+        db_span, db_trace, experiment_id=experiment_id, example_id=revision.dataset_example_id
+    )
+    await results_queue.put((example_id, db_span, db_run))
+    if span.status_message is not None:
         yield ChatCompletionSubscriptionError(
-            message=span.error_message, dataset_example_id=example_id
+            message=span.status_message, dataset_example_id=example_id
         )
 
 
-async def _merge_iterators(
-    iterators: Collection[AsyncIterator[GenericType]],
-) -> AsyncIterator[GenericType]:
-    tasks: dict[AsyncIterator[GenericType], Task[GenericType]] = {
-        iterable: _as_task(iterable) for iterable in iterators
-    }
-    while tasks:
-        completed_tasks, _ = await wait(tasks.values(), return_when=FIRST_COMPLETED)
-        for task in completed_tasks:
-            iterator = next(it for it, t in tasks.items() if t == task)
-            try:
-                yield task.result()
-            except StopAsyncIteration:
-                del tasks[iterator]
-            except Exception as error:
-                del tasks[iterator]
-                logger.exception(error)
-            else:
-                tasks[iterator] = _as_task(iterator)
+async def _chat_completion_result_payloads(
+    *,
+    db: DbSessionFactory,
+    results: Sequence[ChatCompletionResult],
+) -> AsyncIterator[ChatCompletionSubscriptionResult]:
+    if not results:
+        return
+    async with db() as session:
+        for _, span, run in results:
+            if span:
+                session.add(span)
+            session.add(run)
+        await session.flush()
+    for example_id, span, run in results:
+        yield ChatCompletionSubscriptionResult(
+            span=to_gql_span(span) if span else None,
+            experiment_run=to_gql_experiment_run(run),
+            dataset_example_id=example_id,
+        )
+
+
+def _create_task_with_timeout(
+    iterable: AsyncIterator[GenericType], timeout_in_seconds: int = 60
+) -> Task[GenericType]:
+    return create_task(wait_for(_as_coroutine(iterable), timeout=timeout_in_seconds))
+
 
+async def _drain(queue: Queue[GenericType]) -> list[GenericType]:
+    values: list[GenericType] = []
+    while not queue.empty():
+        values.append(await queue.get())
+    return values
 
-def _as_task(iterable: AsyncIterator[GenericType]) -> Task[GenericType]:
-    return create_task(_as_coroutine(iterable))
+
+def _drain_no_wait(queue: Queue[GenericType]) -> list[GenericType]:
+    values: list[GenericType] = []
+    while True:
+        try:
+            values.append(queue.get_nowait())
+        except QueueEmpty:
+            break
+    return values
 
 
 async def _as_coroutine(iterable: AsyncIterator[GenericType]) -> GenericType:
@@ -413,13 +470,8 @@ def _template_formatter(template_language: TemplateLanguage) -> TemplateFormatte
     assert_never(template_language)
 
 
-def _get_playground_experiment_task_output(
-    span: streaming_llm_span,
-) -> Any:
-    return get_attribute_value(span.attributes, LLM_OUTPUT_MESSAGES)
-
-
-_DEFAULT_PLAYGROUND_EXPERIMENT_NAME = "playground-experiment"
+def _default_playground_experiment_name() -> str:
+    return "playground-experiment"
 
 
 def _default_playground_experiment_description(dataset_name: str) -> str:

phoenix/server/api/types/ChatCompletionSubscriptionPayload.py

@@ -4,6 +4,7 @@ import strawberry
 from strawberry.relay import GlobalID
 
 from .Experiment import Experiment
+from .ExperimentRun import ExperimentRun
 from .Span import Span
 
 
@@ -30,8 +31,9 @@ class ToolCallChunk(ChatCompletionSubscriptionPayload):
 
 
 @strawberry.type
-class FinishedChatCompletion(ChatCompletionSubscriptionPayload):
-    span: Span
+class ChatCompletionSubscriptionResult(ChatCompletionSubscriptionPayload):
+    span: Optional[Span] = None
+    experiment_run: Optional[ExperimentRun] = None
 
 
 @strawberry.type
@@ -40,5 +42,5 @@ class ChatCompletionSubscriptionError(ChatCompletionSubscriptionPayload):
 
 
 @strawberry.type
-class ChatCompletionOverDatasetSubscriptionResult(ChatCompletionSubscriptionPayload):
+class ChatCompletionSubscriptionExperiment(ChatCompletionSubscriptionPayload):
     experiment: Experiment

phoenix/server/api/types/ExperimentRun.py

@@ -1,7 +1,9 @@
 from datetime import datetime
-from typing import Optional
+from typing import TYPE_CHECKING, Annotated, Optional
 
 import strawberry
+from sqlalchemy import select
+from sqlalchemy.orm import load_only
 from strawberry import UNSET
 from strawberry.relay import Connection, GlobalID, Node, NodeID
 from strawberry.scalars import JSON
@@ -20,6 +22,9 @@ from phoenix.server.api.types.pagination import (
 )
 from phoenix.server.api.types.Trace import Trace
 
+if TYPE_CHECKING:
+    from phoenix.server.api.types.DatasetExample import DatasetExample
+
 
 @strawberry.type
 class ExperimentRun(Node):
@@ -62,6 +67,38 @@ class ExperimentRun(Node):
         trace_rowid, project_rowid = trace
         return Trace(id_attr=trace_rowid, trace_id=self.trace_id, project_rowid=project_rowid)
 
+    @strawberry.field
+    async def example(
+        self, info: Info
+    ) -> Annotated[
+        "DatasetExample", strawberry.lazy("phoenix.server.api.types.DatasetExample")
+    ]:  # use lazy types to avoid circular import: https://strawberry.rocks/docs/types/lazy
+        from phoenix.server.api.types.DatasetExample import DatasetExample
+
+        async with info.context.db() as session:
+            assert (
+                result := await session.execute(
+                    select(models.DatasetExample, models.Experiment.dataset_version_id)
+                    .select_from(models.ExperimentRun)
+                    .join(
+                        models.DatasetExample,
+                        models.DatasetExample.id == models.ExperimentRun.dataset_example_id,
+                    )
+                    .join(
+                        models.Experiment,
+                        models.Experiment.id == models.ExperimentRun.experiment_id,
+                    )
+                    .where(models.ExperimentRun.id == self.id_attr)
+                    .options(load_only(models.DatasetExample.id, models.DatasetExample.created_at))
+                )
+            ) is not None
+            example, version_id = result.first()
+        return DatasetExample(
+            id_attr=example.id,
+            created_at=example.created_at,
+            version_id=version_id,
+        )
+
 
 def to_gql_experiment_run(run: models.ExperimentRun) -> ExperimentRun:
     """

phoenix/server/api/types/GenerativeProvider.py

@@ -8,6 +8,7 @@ class GenerativeProviderKey(Enum):
     OPENAI = "OpenAI"
     ANTHROPIC = "Anthropic"
     AZURE_OPENAI = "Azure OpenAI"
+    GEMINI = "Google AI Studio"
 
 
 @strawberry.type
@@ -24,7 +25,7 @@ class GenerativeProvider:
 
         default_client = PLAYGROUND_CLIENT_REGISTRY.get_client(self.key, PROVIDER_DEFAULT)
         if default_client:
-            return default_client.dependencies()
+            return [dependency.name for dependency in default_client.dependencies()]
         return []
 
     @strawberry.field

phoenix/server/app.py

@@ -26,6 +26,7 @@ import strawberry
 from fastapi import APIRouter, Depends, FastAPI
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.utils import is_body_allowed_for_status_code
+from grpc.aio import ServerInterceptor
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
 from starlette.datastructures import State as StarletteState
@@ -54,6 +55,7 @@ from phoenix.config import (
     get_env_csrf_trusted_origins,
     get_env_fastapi_middleware_paths,
     get_env_gql_extension_paths,
+    get_env_grpc_interceptor_paths,
     get_env_host,
     get_env_port,
     server_instrumentation_is_enabled,
@@ -251,7 +253,7 @@ class Static(StaticFiles):
 
 
 class RequestOriginHostnameValidator(BaseHTTPMiddleware):
-    def __init__(self, trusted_hostnames: list[str], *args: Any, **kwargs: Any) -> None:
+    def __init__(self, *args: Any, trusted_hostnames: list[str], **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._trusted_hostnames = trusted_hostnames
 
@@ -305,6 +307,17 @@ def user_gql_extensions() -> list[Union[type[SchemaExtension], SchemaExtension]]
     return extensions
 
 
+def user_grpc_interceptors() -> list[ServerInterceptor]:
+    paths = get_env_grpc_interceptor_paths()
+    interceptors = []
+    for file_path, object_name in paths:
+        interceptor_class = import_object_from_file(file_path, object_name)
+        if not issubclass(interceptor_class, ServerInterceptor):
+            raise TypeError(f"{interceptor_class} is not a subclass of ServerInterceptor")
+        interceptors.append(interceptor_class)
+    return interceptors
+
+
 ProjectRowId: TypeAlias = int
 
 
@@ -479,6 +492,7 @@ def _lifespan(
                 tracer_provider=tracer_provider,
                 enable_prometheus=enable_prometheus,
                 token_store=token_store,
+                interceptors=user_grpc_interceptors(),
             )
             await stack.enter_async_context(grpc_server)
             await stack.enter_async_context(dml_event_handler)
@@ -753,7 +767,12 @@ def create_app(
     middlewares.extend(user_fastapi_middlewares())
     if origins := get_env_csrf_trusted_origins():
         trusted_hostnames = [h for o in origins if o and (h := urlparse(o).hostname)]
-        middlewares.append(Middleware(RequestOriginHostnameValidator, trusted_hostnames))
+        middlewares.append(
+            Middleware(
+                RequestOriginHostnameValidator,
+                trusted_hostnames=trusted_hostnames,
+            )
+        )
     elif email_sender or oauth2_client_configs:
         logger.warning(
             "CSRF protection can be enabled by listing trusted origins via "