arize-phoenix 11.37.0__py3-none-any.whl → 12.0.0__py3-none-any.whl

phoenix/server/api/mutations/project_session_annotations_mutations.py

@@ -0,0 +1,161 @@
+from typing import Optional
+
+import strawberry
+from sqlalchemy.exc import IntegrityError as PostgreSQLIntegrityError
+from sqlean.dbapi2 import IntegrityError as SQLiteIntegrityError  # type: ignore[import-untyped]
+from starlette.requests import Request
+from strawberry import Info
+from strawberry.relay import GlobalID
+
+from phoenix.db import models
+from phoenix.server.api.auth import IsLocked, IsNotReadOnly
+from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import BadRequest, Conflict, NotFound, Unauthorized
+from phoenix.server.api.helpers.annotations import get_user_identifier
+from phoenix.server.api.input_types.CreateProjectSessionAnnotationInput import (
+    CreateProjectSessionAnnotationInput,
+)
+from phoenix.server.api.input_types.UpdateAnnotationInput import UpdateAnnotationInput
+from phoenix.server.api.queries import Query
+from phoenix.server.api.types.AnnotationSource import AnnotationSource
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.api.types.ProjectSessionAnnotation import (
+    ProjectSessionAnnotation,
+    to_gql_project_session_annotation,
+)
+from phoenix.server.bearer_auth import PhoenixUser
+from phoenix.server.dml_event import (
+    ProjectSessionAnnotationDeleteEvent,
+    ProjectSessionAnnotationInsertEvent,
+)
+
+
+@strawberry.type
+class ProjectSessionAnnotationMutationPayload:
+    project_session_annotation: ProjectSessionAnnotation
+    query: Query
+
+
+@strawberry.type
+class ProjectSessionAnnotationMutationMixin:
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsLocked])  # type: ignore
+    async def create_project_session_annotations(
+        self, info: Info[Context, None], input: CreateProjectSessionAnnotationInput
+    ) -> ProjectSessionAnnotationMutationPayload:
+        assert isinstance(request := info.context.request, Request)
+        user_id: Optional[int] = None
+        if "user" in request.scope and isinstance((user := info.context.user), PhoenixUser):
+            user_id = int(user.identity)
+
+        try:
+            project_session_id = from_global_id_with_expected_type(
+                input.project_session_id, "ProjectSession"
+            )
+        except ValueError:
+            raise BadRequest(f"Invalid session ID: {input.project_session_id}")
+
+        identifier = ""
+        if isinstance(input.identifier, str):
+            identifier = input.identifier  # Already trimmed in __post_init__
+        elif input.source == AnnotationSource.APP and user_id is not None:
+            identifier = get_user_identifier(user_id)
+
+        try:
+            async with info.context.db() as session:
+                anno = models.ProjectSessionAnnotation(
+                    project_session_id=project_session_id,
+                    name=input.name,
+                    label=input.label,
+                    score=input.score,
+                    explanation=input.explanation,
+                    annotator_kind=input.annotator_kind.value,
+                    metadata_=input.metadata,
+                    identifier=identifier,
+                    source=input.source.value,
+                    user_id=user_id,
+                )
+                session.add(anno)
+        except (PostgreSQLIntegrityError, SQLiteIntegrityError) as e:
+            raise Conflict(f"Error creating annotation: {e}")
+
+        info.context.event_queue.put(ProjectSessionAnnotationInsertEvent((anno.id,)))
+
+        return ProjectSessionAnnotationMutationPayload(
+            project_session_annotation=to_gql_project_session_annotation(anno),
+            query=Query(),
+        )
+
+    @strawberry.mutation(permission_classes=[IsNotReadOnly, IsLocked])  # type: ignore
+    async def update_project_session_annotations(
+        self, info: Info[Context, None], input: UpdateAnnotationInput
+    ) -> ProjectSessionAnnotationMutationPayload:
+        assert isinstance(request := info.context.request, Request)
+        user_id: Optional[int] = None
+        if "user" in request.scope and isinstance((user := info.context.user), PhoenixUser):
+            user_id = int(user.identity)
+
+        try:
+            id_ = from_global_id_with_expected_type(input.id, "ProjectSessionAnnotation")
+        except ValueError:
+            raise BadRequest(f"Invalid session annotation ID: {input.id}")
+
+        async with info.context.db() as session:
+            if not (anno := await session.get(models.ProjectSessionAnnotation, id_)):
+                raise NotFound(f"Could not find session annotation with ID: {input.id}")
+            if anno.user_id != user_id:
+                raise Unauthorized("Session annotation is not associated with the current user.")
+
+            # Update the annotation fields
+            anno.name = input.name
+            anno.label = input.label
+            anno.score = input.score
+            anno.explanation = input.explanation
+            anno.annotator_kind = input.annotator_kind.value
+            anno.metadata_ = input.metadata
+            anno.source = input.source.value
+
+            session.add(anno)
+            try:
+                await session.flush()
+            except (PostgreSQLIntegrityError, SQLiteIntegrityError) as e:
+                raise Conflict(f"Error updating annotation: {e}")
+
+        info.context.event_queue.put(ProjectSessionAnnotationInsertEvent((anno.id,)))
+        return ProjectSessionAnnotationMutationPayload(
+            project_session_annotation=to_gql_project_session_annotation(anno),
+            query=Query(),
+        )
+
+    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore
+    async def delete_project_session_annotation(
+        self, info: Info[Context, None], id: GlobalID
+    ) -> ProjectSessionAnnotationMutationPayload:
+        try:
+            id_ = from_global_id_with_expected_type(id, "ProjectSessionAnnotation")
+        except ValueError:
+            raise BadRequest(f"Invalid session annotation ID: {id}")
+
+        assert isinstance(request := info.context.request, Request)
+        user_id: Optional[int] = None
+        user_is_admin = False
+        if "user" in request.scope and isinstance((user := info.context.user), PhoenixUser):
+            user_id = int(user.identity)
+            user_is_admin = user.is_admin
+
+        async with info.context.db() as session:
+            if not (anno := await session.get(models.ProjectSessionAnnotation, id_)):
+                raise NotFound(f"Could not find session annotation with ID: {id}")
+
+            if not user_is_admin and anno.user_id != user_id:
+                raise Unauthorized(
+                    "Session annotation is not associated with the current user and "
+                    "the current user is not an admin."
+                )
+
+            await session.delete(anno)
+
+        deleted_gql_annotation = to_gql_project_session_annotation(anno)
+        info.context.event_queue.put(ProjectSessionAnnotationDeleteEvent((id_,)))
+        return ProjectSessionAnnotationMutationPayload(
+            project_session_annotation=deleted_gql_annotation, query=Query()
+        )

phoenix/server/api/queries.py

@@ -48,6 +48,7 @@ from phoenix.server.api.types.AnnotationConfig import AnnotationConfig, to_gql_a
 from phoenix.server.api.types.Cluster import Cluster, to_gql_clusters
 from phoenix.server.api.types.Dataset import Dataset, to_gql_dataset
 from phoenix.server.api.types.DatasetExample import DatasetExample
+from phoenix.server.api.types.DatasetSplit import DatasetSplit, to_gql_dataset_split
 from phoenix.server.api.types.Dimension import to_gql_dimension
 from phoenix.server.api.types.EmbeddingDimension import (
     DEFAULT_CLUSTER_SELECTION_EPSILON,
@@ -959,6 +960,14 @@ class Query:
                 id_attr=example.id,
                 created_at=example.created_at,
             )
+        elif type_name == DatasetSplit.__name__:
+            async with info.context.db() as session:
+                dataset_split = await session.scalar(
+                    select(models.DatasetSplit).where(models.DatasetSplit.id == node_id)
+                )
+            if not dataset_split:
+                raise NotFound(f"Unknown dataset split: {id}")
+            return to_gql_dataset_split(dataset_split)
         elif type_name == Experiment.__name__:
             async with info.context.db() as session:
                 experiment = await session.scalar(
@@ -1140,6 +1149,29 @@ class Query:
                 args=args,
             )
 
+    @strawberry.field
+    async def dataset_splits(
+        self,
+        info: Info[Context, None],
+        first: Optional[int] = 50,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection[DatasetSplit]:
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
+        async with info.context.db() as session:
+            splits = await session.stream_scalars(select(models.DatasetSplit))
+            data = [to_gql_dataset_split(split) async for split in splits]
+            return connection_from_list(
+                data=data,
+                args=args,
+            )
+
     @strawberry.field
     async def annotation_configs(
         self,

phoenix/server/api/routers/v1/__init__.py

@@ -14,6 +14,7 @@ from .experiment_runs import router as experiment_runs_router
 from .experiments import router as experiments_router
 from .projects import router as projects_router
 from .prompts import router as prompts_router
+from .sessions import router as sessions_router
 from .spans import router as spans_router
 from .traces import router as traces_router
 from .users import router as users_router
@@ -71,6 +72,7 @@ def create_v1_router(authentication_enabled: bool) -> APIRouter:
     router.include_router(evaluations_router)
     router.include_router(prompts_router)
     router.include_router(projects_router)
+    router.include_router(sessions_router)
     router.include_router(documents_router)
     router.include_router(users_router)
     return router

phoenix/server/api/routers/v1/annotations.py

@@ -14,6 +14,9 @@ from strawberry.relay import GlobalID
 from phoenix.db import models
 from phoenix.db.insertion.types import Precursors
 from phoenix.server.api.routers.v1.models import V1RoutesBaseModel
+from phoenix.server.api.types.ProjectSessionAnnotation import (
+    ProjectSessionAnnotation as SessionAnnotationNodeType,
+)
 from phoenix.server.api.types.SpanAnnotation import SpanAnnotation as SpanAnnotationNodeType
 from phoenix.server.api.types.TraceAnnotation import TraceAnnotation as TraceAnnotationNodeType
 from phoenix.server.api.types.User import User as UserNodeType
@@ -24,6 +27,7 @@ logger = logging.getLogger(__name__)
 
 SPAN_ANNOTATION_NODE_NAME = SpanAnnotationNodeType.__name__
 TRACE_ANNOTATION_NODE_NAME = TraceAnnotationNodeType.__name__
+SESSION_ANNOTATION_NODE_NAME = SessionAnnotationNodeType.__name__
 MAX_TRACE_IDS = 1_000
 USER_NODE_NAME = UserNodeType.__name__
 MAX_SPAN_IDS = 1_000
@@ -161,6 +165,35 @@ class TraceAnnotationsResponseBody(PaginatedResponseBody[TraceAnnotation]):
     pass
 
 
+class SessionAnnotationData(AnnotationData):
+    session_id: str = Field(description="Session ID")
+
+    def as_precursor(self, *, user_id: Optional[int] = None) -> Precursors.SessionAnnotation:
+        return Precursors.SessionAnnotation(
+            datetime.now(timezone.utc),
+            self.session_id,
+            models.ProjectSessionAnnotation(
+                name=self.name,
+                annotator_kind=self.annotator_kind,
+                score=self.result.score if self.result else None,
+                label=self.result.label if self.result else None,
+                explanation=self.result.explanation if self.result else None,
+                metadata_=self.metadata or {},
+                identifier=self.identifier,
+                source="API",
+                user_id=user_id,
+            ),
+        )
+
+
+class SessionAnnotation(SessionAnnotationData, Annotation):
+    pass
+
+
+class SessionAnnotationsResponseBody(PaginatedResponseBody[SessionAnnotation]):
+    pass
+
+
 @router.get(
     "/projects/{project_identifier}/span_annotations",
     operation_id="listSpanAnnotationsBySpanIds",
@@ -304,3 +337,290 @@ async def list_span_annotations(
         ]
 
     return SpanAnnotationsResponseBody(data=data, next_cursor=next_cursor)
+
+
+@router.get(
+    "/projects/{project_identifier}/trace_annotations",
+    operation_id="listTraceAnnotationsByTraceIds",
+    summary="Get trace annotations for a list of trace_ids.",
+    status_code=HTTP_200_OK,
+    responses=add_errors_to_responses(
+        [
+            {"status_code": HTTP_404_NOT_FOUND, "description": "Project or traces not found"},
+            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid parameters"},
+        ]
+    ),
+)
+async def list_trace_annotations(
+    request: Request,
+    project_identifier: str = Path(
+        description=(
+            "The project identifier: either project ID or project name. If using a project name as "
+            "the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) "
+            "characters."
+        )
+    ),
+    trace_ids: list[str] = Query(
+        ..., min_length=1, description="One or more trace id to fetch annotations for"
+    ),
+    include_annotation_names: Optional[list[str]] = Query(
+        default=None,
+        description=(
+            "Optional list of annotation names to include. If provided, only annotations with "
+            "these names will be returned. 'note' annotations are excluded by default unless "
+            "explicitly included in this list."
+        ),
+    ),
+    exclude_annotation_names: Optional[list[str]] = Query(
+        default=None, description="Optional list of annotation names to exclude from results."
+    ),
+    cursor: Optional[str] = Query(default=None, description="A cursor for pagination"),
+    limit: int = Query(
+        default=10,
+        gt=0,
+        le=10000,
+        description="The maximum number of annotations to return in a single request",
+    ),
+) -> TraceAnnotationsResponseBody:
+    trace_ids = list({*trace_ids})
+    if len(trace_ids) > MAX_TRACE_IDS:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Too many trace_ids supplied: {len(trace_ids)} (max {MAX_TRACE_IDS})",
+        )
+
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+        if not project:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Project with identifier {project_identifier} not found",
+            )
+
+        # Build the base query
+        where_conditions = [
+            models.Project.id == project.id,
+            models.Trace.trace_id.in_(trace_ids),
+        ]
+
+        # Add annotation name filtering
+        if include_annotation_names:
+            where_conditions.append(models.TraceAnnotation.name.in_(include_annotation_names))
+
+        if exclude_annotation_names:
+            where_conditions.append(models.TraceAnnotation.name.not_in(exclude_annotation_names))
+
+        stmt = (
+            select(models.Trace.trace_id, models.TraceAnnotation)
+            .join(models.Project, models.Trace.project_rowid == models.Project.id)
+            .join(models.TraceAnnotation, models.TraceAnnotation.trace_rowid == models.Trace.id)
+            .where(*where_conditions)
+            .order_by(models.TraceAnnotation.id.desc())
+            .limit(limit + 1)
+        )
+
+        if cursor:
+            try:
+                cursor_id = int(GlobalID.from_id(cursor).node_id)
+            except ValueError:
+                raise HTTPException(
+                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail="Invalid cursor value",
+                )
+            stmt = stmt.where(models.TraceAnnotation.id <= cursor_id)
+
+        rows: list[tuple[str, models.TraceAnnotation]] = [
+            r async for r in (await session.stream(stmt))
+        ]
+
+        next_cursor: Optional[str] = None
+        if len(rows) == limit + 1:
+            *rows, extra = rows
+            next_cursor = str(GlobalID(TRACE_ANNOTATION_NODE_NAME, str(extra[1].id)))
+
+        if not rows:
+            traces_exist = await session.scalar(
+                select(
+                    exists().where(
+                        models.Trace.trace_id.in_(trace_ids),
+                        models.Trace.project_rowid == project.id,
+                    )
+                )
+            )
+            if not traces_exist:
+                raise HTTPException(
+                    detail="None of the supplied trace_ids exist in this project",
+                    status_code=HTTP_404_NOT_FOUND,
+                )
+
+            return TraceAnnotationsResponseBody(data=[], next_cursor=None)
+
+        data = [
+            TraceAnnotation(
+                id=str(GlobalID(TRACE_ANNOTATION_NODE_NAME, str(anno.id))),
+                trace_id=trace_id,
+                name=anno.name,
+                result=AnnotationResult(
+                    label=anno.label,
+                    score=anno.score,
+                    explanation=anno.explanation,
+                ),
+                metadata=anno.metadata_,
+                annotator_kind=anno.annotator_kind,
+                created_at=anno.created_at,
+                updated_at=anno.updated_at,
+                identifier=anno.identifier,
+                source=anno.source,
+                user_id=str(GlobalID("User", str(anno.user_id))) if anno.user_id else None,
+            )
+            for trace_id, anno in rows
+        ]
+
+    return TraceAnnotationsResponseBody(data=data, next_cursor=next_cursor)
+
+
+@router.get(
+    "/projects/{project_identifier}/session_annotations",
+    operation_id="listSessionAnnotationsBySessionIds",
+    summary="Get session annotations for a list of session_ids.",
+    status_code=HTTP_200_OK,
+    responses=add_errors_to_responses(
+        [
+            {"status_code": HTTP_404_NOT_FOUND, "description": "Project or sessions not found"},
+            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid parameters"},
+        ]
+    ),
+)
+async def list_session_annotations(
+    request: Request,
+    project_identifier: str = Path(
+        description=(
+            "The project identifier: either project ID or project name. If using a project name as "
+            "the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) "
+            "characters."
+        )
+    ),
+    session_ids: list[str] = Query(
+        ..., min_length=1, description="One or more session id to fetch annotations for"
+    ),
+    include_annotation_names: Optional[list[str]] = Query(
+        default=None,
+        description=(
+            "Optional list of annotation names to include. If provided, only annotations with "
+            "these names will be returned. 'note' annotations are excluded by default unless "
+            "explicitly included in this list."
+        ),
+    ),
+    exclude_annotation_names: Optional[list[str]] = Query(
+        default=None, description="Optional list of annotation names to exclude from results."
+    ),
+    cursor: Optional[str] = Query(default=None, description="A cursor for pagination"),
+    limit: int = Query(
+        default=10,
+        gt=0,
+        le=10000,
+        description="The maximum number of annotations to return in a single request",
+    ),
+) -> SessionAnnotationsResponseBody:
+    session_ids = list({*session_ids})
+    if len(session_ids) > MAX_SESSION_IDS:
+        raise HTTPException(
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Too many session_ids supplied: {len(session_ids)} (max {MAX_SESSION_IDS})",
+        )
+
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+        if not project:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Project with identifier {project_identifier} not found",
+            )
+
+        # Build the base query
+        where_conditions = [
+            models.Project.id == project.id,
+            models.ProjectSession.session_id.in_(session_ids),
+        ]
+
+        # Add annotation name filtering
+        if include_annotation_names:
+            where_conditions.append(
+                models.ProjectSessionAnnotation.name.in_(include_annotation_names)
+            )
+
+        if exclude_annotation_names:
+            where_conditions.append(
+                models.ProjectSessionAnnotation.name.not_in(exclude_annotation_names)
+            )
+
+        stmt = (
+            select(models.ProjectSession.session_id, models.ProjectSessionAnnotation)
+            .join(models.Project, models.ProjectSession.project_id == models.Project.id)
+            .join(
+                models.ProjectSessionAnnotation,
+                models.ProjectSessionAnnotation.project_session_id == models.ProjectSession.id,
+            )
+            .where(*where_conditions)
+            .order_by(models.ProjectSessionAnnotation.id.desc())
+            .limit(limit + 1)
+        )
+
+        if cursor:
+            try:
+                cursor_id = int(GlobalID.from_id(cursor).node_id)
+            except ValueError:
+                raise HTTPException(
+                    status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+                    detail="Invalid cursor value",
+                )
+            stmt = stmt.where(models.ProjectSessionAnnotation.id <= cursor_id)
+
+        rows: list[tuple[str, models.ProjectSessionAnnotation]] = [
+            r async for r in (await session.stream(stmt))
+        ]
+
+        next_cursor: Optional[str] = None
+        if len(rows) == limit + 1:
+            *rows, extra = rows
+            next_cursor = str(GlobalID(SESSION_ANNOTATION_NODE_NAME, str(extra[1].id)))
+
+        if not rows:
+            sessions_exist = await session.scalar(
+                select(
+                    exists().where(
+                        models.ProjectSession.session_id.in_(session_ids),
+                        models.ProjectSession.project_id == project.id,
+                    )
+                )
+            )
+            if not sessions_exist:
+                raise HTTPException(
+                    detail="None of the supplied session_ids exist in this project",
+                    status_code=HTTP_404_NOT_FOUND,
+                )
+
+            return SessionAnnotationsResponseBody(data=[], next_cursor=None)
+
+        data = [
+            SessionAnnotation(
+                id=str(GlobalID(SESSION_ANNOTATION_NODE_NAME, str(anno.id))),
+                session_id=session_id,
+                name=anno.name,
+                result=AnnotationResult(
+                    label=anno.label,
+                    score=anno.score,
+                    explanation=anno.explanation,
+                ),
+                metadata=anno.metadata_,
+                annotator_kind=anno.annotator_kind,
+                created_at=anno.created_at,
+                updated_at=anno.updated_at,
+                identifier=anno.identifier,
+                source=anno.source,
+                user_id=str(GlobalID(USER_NODE_NAME, str(anno.user_id))) if anno.user_id else None,
+            )
+            for session_id, anno in rows
+        ]
+
+    return SessionAnnotationsResponseBody(data=data, next_cursor=next_cursor)

phoenix/server/api/routers/v1/datasets.py

@@ -48,6 +48,7 @@ from phoenix.server.api.types.DatasetVersion import DatasetVersion as DatasetVer
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.utils import delete_projects, delete_traces
 from phoenix.server.authorization import is_not_locked
+from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import DatasetInsertEvent
 
 from .models import V1RoutesBaseModel
@@ -478,6 +479,9 @@ async def upload_dataset(
             detail="Invalid request Content-Type",
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
         )
+    user_id: Optional[int] = None
+    if request.app.state.authentication_enabled and isinstance(request.user, PhoenixUser):
+        user_id = int(request.user.identity)
     operation = cast(
         Callable[[AsyncSession], Awaitable[DatasetExampleAdditionEvent]],
         partial(
@@ -486,6 +490,7 @@ async def upload_dataset(
             action=action,
             name=name,
             description=description,
+            user_id=user_id,
         ),
     )
     if sync:

phoenix/server/api/routers/v1/experiments.py

@@ -15,10 +15,14 @@ from starlette.status import HTTP_200_OK, HTTP_404_NOT_FOUND, HTTP_422_UNPROCESS
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
-from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.helpers import (
+    SupportedSQLDialect,
+    insert_experiment_with_examples_snapshot,
+)
 from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.authorization import is_not_locked
+from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import ExperimentInsertEvent
 from phoenix.server.experiments.utils import generate_experiment_project_name
 
@@ -157,6 +161,9 @@ async def create_experiment(
                     detail=f"DatasetVersion with ID {dataset_version_globalid} does not exist",
                     status_code=HTTP_404_NOT_FOUND,
                 )
+        user_id: Optional[int] = None
+        if request.app.state.authentication_enabled and isinstance(request.user, PhoenixUser):
+            user_id = int(request.user.identity)
 
         # generate a semi-unique name for the experiment
         experiment_name = request_body.name or _generate_experiment_name(dataset_name)
@@ -172,9 +179,9 @@ async def create_experiment(
             repetitions=request_body.repetitions,
             metadata_=request_body.metadata or {},
             project_name=project_name,
+            user_id=user_id,
         )
-        session.add(experiment)
-        await session.flush()
+        await insert_experiment_with_examples_snapshot(session, experiment)
 
         dialect = SupportedSQLDialect(session.bind.dialect.name)
         project_rowid = await session.scalar(