🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
import { type LangfuseColumnDef } from "@/src/components/table/types";
import { Skeleton } from "@/src/components/ui/skeleton";
import { DatasetAggregateTableCell } from "@/src/features/datasets/components/DatasetAggregateTableCell";
import { type DatasetCompareRunRowData } from "@/src/features/datasets/components/DatasetCompareRunsTable";
import { PopoverFilterBuilder } from "@/src/features/filters/components/filter-builder";
import { type ColumnDefinition, type FilterState } from "@langfuse/shared";
import { type EnrichedDatasetRunItem } from "@langfuse/shared/src/server";
import { type Row } from "@tanstack/react-table";
import React, { useEffect, useRef, useState } from "react";
import { useDebounce } from "@/src/hooks/useDebounce";
import type { ScoreColumn } from "@/src/features/scores/types";
import { Toggle } from "@/src/components/design-system/Toggle/Toggle";
import { useRouter } from "next/router";
function DatasetAggregateCellWithBaselineDetection({
value,
runData,
runId,
projectId,
serverScoreColumns,
}: {
value: EnrichedDatasetRunItem;
runData: Record<string, EnrichedDatasetRunItem>;
runId: string;
projectId: string;
serverScoreColumns?: ScoreColumn[];
}) {
const router = useRouter();
const baselineRunId = router.query.baseline as string | undefined;
const baselineRunValue = baselineRunId ? runData[baselineRunId] : undefined;
const isBaselineRun = baselineRunId === runId;
return (
<DatasetAggregateTableCell
key={baselineRunId ?? runId}
value={value}
projectId={projectId}
serverScoreColumns={serverScoreColumns ?? []}
isBaselineRun={isBaselineRun}
baselineRunValue={baselineRunValue}
/>
);
}
function BaselineToggle({ runId }: { runId: string }) {
const router = useRouter();
const [isHovered, setIsHovered] = useState(false);
const justSetBaselineRef = useRef(false);
const previousBaselineRef = useRef<string | undefined>(undefined);
const baselineRunId = router.query.baseline as string | undefined;
const hasBaseline = Boolean(baselineRunId);
const isBaseline = baselineRunId === runId;
useEffect(() => {
if (baselineRunId === runId && previousBaselineRef.current !== runId) {
justSetBaselineRef.current = true;
}
previousBaselineRef.current = baselineRunId;
}, [baselineRunId, runId]);
const handleClick = () => {
if (isBaseline) {
const { baseline, ...restQuery } = router.query;
router.push({
pathname: router.pathname,
query: restQuery,
});
} else {
router.push({
pathname: router.pathname,
query: { ...router.query, baseline: runId },
});
}
};
const handleMouseEnter = () => {
setIsHovered(true);
};
const handleMouseLeave = () => {
setIsHovered(false);
justSetBaselineRef.current = false;
};
const baselineText =
isHovered && !justSetBaselineRef.current ? "Clear baseline" : "Baseline";
const comparisonText = isHovered ? "Set as baseline" : "Comparison";
const selectedText = isBaseline ? baselineText : comparisonText;
const text = hasBaseline ? selectedText : "Set as baseline";
return (
<Toggle
pressed={isBaseline}
onClick={handleClick}
onMouseEnter={handleMouseEnter}
onMouseLeave={handleMouseLeave}
>
{text}
</Toggle>
);
}
function RunAggregateHeader({
runId,
runName,
columns,
updateRunFilters,
getFiltersForRun,
}: {
runId: string;
runName: string;
columns: ColumnDefinition[];
updateRunFilters: (runId: string, filters: FilterState) => void;
getFiltersForRun: (runId: string) => FilterState;
}) {
// Debounce updateRunFilters with 500ms delay to prevent immediate table re-renders
const debouncedUpdateRunFilters = useDebounce(
(runId: string, filters: FilterState) => updateRunFilters(runId, filters),
500,
false, // Don't execute first call immediately
);
return (
<div className="flex w-full flex-row items-center gap-1">
<span className="flex-1 truncate" title={runName}>
{runName}
</span>
<div className="flex w-fit shrink-0 gap-1">
<PopoverFilterBuilder
buttonType="icon"
columns={columns}
filterState={getFiltersForRun(runId)}
onChange={(filters: FilterState) =>
debouncedUpdateRunFilters(runId, filters)
}
// Analytics (LFE-10781): per-run filtering in the dataset-run compare
// view — a v3/legacy surface (not the v4 events table).
tableName="dataset-runs-compare"
isV4={false}
/>
<BaselineToggle runId={runId} />
</div>
</div>
);
}
type RunAggregateColumnProps = {
id: string;
name: string;
description?: string;
createdAt?: Date;
};
const isScoreColumnsAvailable = (
scoreColumns?: ScoreColumn[],
): scoreColumns is ScoreColumn[] => {
return scoreColumns !== undefined;
};
export const constructDatasetRunAggregateColumns = ({
runAggregateColumnProps,
projectId,
datasetColumns,
updateRunFilters,
getFiltersForRun,
serverScoreColumns,
}: {
runAggregateColumnProps: RunAggregateColumnProps[];
projectId: string;
datasetColumns: ColumnDefinition[];
updateRunFilters: (runId: string, filters: FilterState) => void;
getFiltersForRun: (runId: string) => FilterState;
serverScoreColumns?: ScoreColumn[];
}): LangfuseColumnDef<DatasetCompareRunRowData>[] => {
const isDataLoading = !isScoreColumnsAvailable(serverScoreColumns);
return runAggregateColumnProps.map((col) => {
const { id, name, createdAt } = col;
return {
id,
accessorKey: id,
header: () => (
<RunAggregateHeader
runId={id}
runName={name}
columns={datasetColumns}
updateRunFilters={updateRunFilters}
getFiltersForRun={getFiltersForRun}
/>
),
size: 250,
cell: ({ row }: { row: Row<DatasetCompareRunRowData> }) => {
const runData: Record<string, EnrichedDatasetRunItem> =
row.getValue("runs") ?? {};
// if cell is loading or if run created at timestamp is less than 20 seconds ago, show skeleton
if (
isDataLoading ||
(createdAt && createdAt.getTime() + 20000 > Date.now())
)
return <Skeleton className="h-full min-h-0 w-full" />;
if (!Boolean(Object.keys(runData).length)) return null;
if (!runData.hasOwnProperty(id)) return null;
const value: EnrichedDatasetRunItem | undefined = runData[id];
if (!value) return null;
return (
<DatasetAggregateCellWithBaselineDetection
value={value}
runData={runData}
runId={id}
projectId={projectId}
serverScoreColumns={serverScoreColumns}
/>
);
},
};
});
};
export const getDatasetRunAggregateColumnProps = (isLoading: boolean) => ({
accessorKey: "runs",
header: "Experiments",
id: "runs",
isFixedPosition: true,
cell: () => {
return isLoading ? <Skeleton className="h-3 w-1/2" /> : null;
},
});