Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Fix sensible visualization options in MCP Apps visualization selector (#75876)

Phoomparin Mano03ed418f8068
diff --git a/frontend/src/metabase/embedding/mcp/McpQuestionView.tsx b/frontend/src/metabase/embedding/mcp/McpQuestionView.tsx
index 839c242073c..45f007bb633 100644
--- a/frontend/src/metabase/embedding/mcp/McpQuestionView.tsx
+++ b/frontend/src/metabase/embedding/mcp/McpQuestionView.tsx
@@ -15,10 +15,14 @@ const QUERY_BAR_RESERVED_HEIGHT = "calc(2rem + var(--mantine-spacing-sm))";
const RECLAIMED_CONTENT_BOTTOM_PADDING = "var(--mantine-spacing-lg)";
export interface McpQuestionViewProps {
+ queryKey: string | null;
safeAreaPaddingTop: number;
}
-export function McpQuestionView({ safeAreaPaddingTop }: McpQuestionViewProps) {
+export function McpQuestionView({
+ queryKey,
+ safeAreaPaddingTop,
+}: McpQuestionViewProps) {
const {
hasChartTypeSelector,
hasTimeControls,
@@ -27,7 +31,7 @@ export function McpQuestionView({ safeAreaPaddingTop }: McpQuestionViewProps) {
chartTypes,
currentChartType,
onChartTypeChange,
- } = useMcpQueryControls();
+ } = useMcpQueryControls(queryKey);
const isTableVisualization = currentChartType === "table";
diff --git a/frontend/src/metabase/embedding/mcp/McpUiAppRoute.tsx b/frontend/src/metabase/embedding/mcp/McpUiAppRoute.tsx
index 2ab2ff5af21..9f11d044b45 100644
--- a/frontend/src/metabase/embedding/mcp/McpUiAppRoute.tsx
+++ b/frontend/src/metabase/embedding/mcp/McpUiAppRoute.tsx
@@ -189,7 +189,10 @@ function McpUiAppRouteContent({
return (
<>
- <McpQuestionView safeAreaPaddingTop={safeAreaPadding.top} />
+ <McpQuestionView
+ queryKey={query}
+ safeAreaPaddingTop={safeAreaPadding.top}
+ />
<McpCardFooter
app={app}
diff --git a/frontend/src/metabase/embedding/mcp/hooks/useMcpQueryControls.ts b/frontend/src/metabase/embedding/mcp/hooks/useMcpQueryControls.ts
index fa2506d7136..565a20042aa 100644
--- a/frontend/src/metabase/embedding/mcp/hooks/useMcpQueryControls.ts
+++ b/frontend/src/metabase/embedding/mcp/hooks/useMcpQueryControls.ts
@@ -1,18 +1,19 @@
import { useSdkQuestionContext } from "embedding-sdk-bundle/components/private/SdkQuestion/context";
-import { useChartTypes } from "./useChartTypes";
import { useDateFilter } from "./useDateFilter";
+import { useMcpVisualizationSelector } from "./useMcpVisualizationSelector";
import { useTemporalGranularity } from "./useTemporalGranularity";
-export function useMcpQueryControls() {
+export function useMcpQueryControls(queryKey: string | null) {
const { question, updateQuestion, queryResults } = useSdkQuestionContext();
- const {
- sensibleChartTypes,
- hasOnlyTable,
- selectedChartType,
- handleDisplayChange,
- } = useChartTypes(question, queryResults, updateQuestion);
+ const { sensibleChartTypes, selectedChartType, handleDisplayChange } =
+ useMcpVisualizationSelector({
+ question,
+ queryResults,
+ updateQuestion,
+ queryKey,
+ });
const {
temporalColumn,
@@ -55,10 +56,8 @@ export function useMcpQueryControls() {
: undefined;
const hasQueryResults = !!question && !!queryResults;
- const canShowChartControls = hasQueryResults && !hasOnlyTable;
- const hasChartTypeSelector =
- canShowChartControls && sensibleChartTypes.length > 1;
+ const hasChartTypeSelector = hasQueryResults && sensibleChartTypes.length > 1;
const hasTimeControls = hasQueryResults && !!(timeRange || timeGranularity);
diff --git a/frontend/src/metabase/embedding/mcp/hooks/useChartTypes.ts b/frontend/src/metabase/embedding/mcp/hooks/useMcpVisualizationSelector.ts
similarity index 50%
rename from frontend/src/metabase/embedding/mcp/hooks/useChartTypes.ts
rename to frontend/src/metabase/embedding/mcp/hooks/useMcpVisualizationSelector.ts
index 1f46d065091..31c584178a6 100644
--- a/frontend/src/metabase/embedding/mcp/hooks/useChartTypes.ts
+++ b/frontend/src/metabase/embedding/mcp/hooks/useMcpVisualizationSelector.ts
@@ -4,37 +4,61 @@ import { getSensibleVisualizations } from "metabase/visualizations/lib/sensibili
import type Question from "metabase-lib/v1/Question";
import type { CardDisplayType, Dataset } from "metabase-types/api";
+import {
+ type DefaultDisplayState,
+ captureDefaultDisplay,
+} from "../utils/captureDefaultDisplay";
import {
type McpChartTypeEntry,
getMcpChartTypes,
} from "../utils/getMcpChartTypes";
-interface UseChartTypesResult {
+interface UseMcpVisualizationSelectorInput {
+ queryKey: string | null;
+ question: Question | undefined;
+ queryResults: Dataset[] | null | undefined;
+ updateQuestion: (question: Question, opts: { run: boolean }) => void;
+}
+
+interface UseMcpVisualizationSelectorResult {
sensibleChartTypes: McpChartTypeEntry[];
- hasOnlyTable: boolean;
selectedChartType: CardDisplayType | null;
handleDisplayChange: (type: CardDisplayType) => void;
}
-export function useChartTypes(
- question: Question | undefined,
- queryResults: Dataset[] | null | undefined,
- updateQuestion: (question: Question, opts: { run: boolean }) => void,
-): UseChartTypesResult {
+/**
+ * Re-builds the chart type picker options for MCP Apps questions.
+ *
+ * The SDK question can still show the previous query's question and results
+ * after the MCP host sends a new query. We track the default display
+ * by query key and wait for fresh results before updating it.
+ */
+export function useMcpVisualizationSelector({
+ queryKey,
+ question,
+ queryResults,
+ updateQuestion,
+}: UseMcpVisualizationSelectorInput): UseMcpVisualizationSelectorResult {
const queryResult = queryResults?.[0] ?? null;
const currentDisplay = question?.display() ?? null;
- const defaultDisplayRef = useRef<{
- queryResult: Dataset | null;
- display: CardDisplayType | null;
- } | null>(null);
+ const defaultDisplayRef = useRef<DefaultDisplayState>({
+ queryKey,
+ defaultDisplay: null,
+ lastQueryResult: null,
+ });
- if (defaultDisplayRef.current?.queryResult !== queryResult) {
- defaultDisplayRef.current = {
- queryResult,
- display: currentDisplay,
- };
- }
+ // Always show the default visualization for a question
+ // as the first item in the selector.
+ // Every visualization type is possible here.
+ const defaultDisplayState = captureDefaultDisplay({
+ currentDisplay,
+ queryKey,
+ queryResult,
+ previousState: defaultDisplayRef.current,
+ });
+
+ defaultDisplayRef.current = defaultDisplayState;
const { sensibleVisualizations } = useMemo(
() => getSensibleVisualizations({ result: queryResult }),
@@ -44,14 +68,11 @@ export function useChartTypes(
const rowCount = queryResult?.data?.rows?.length ?? 0;
const sensibleChartTypes = getMcpChartTypes({
- defaultDisplay: defaultDisplayRef.current?.display ?? null,
+ defaultDisplay: defaultDisplayState.defaultDisplay,
sensibleVisualizations: sensibleVisualizations as CardDisplayType[],
canShowTable: rowCount >= 2,
});
- const hasOnlyTable =
- sensibleChartTypes.length === 1 && sensibleChartTypes[0].type === "table";
-
const handleDisplayChange = (type: CardDisplayType) => {
if (!question) {
return;
@@ -64,7 +85,6 @@ export function useChartTypes(
return {
sensibleChartTypes,
- hasOnlyTable,
selectedChartType: currentDisplay,
handleDisplayChange,
};
diff --git a/frontend/src/metabase/embedding/mcp/hooks/useMcpVisualizationSelector.unit.spec.ts b/frontend/src/metabase/embedding/mcp/hooks/useMcpVisualizationSelector.unit.spec.ts
new file mode 100644
index 00000000000..2ede3f8068d
--- /dev/null
+++ b/frontend/src/metabase/embedding/mcp/hooks/useMcpVisualizationSelector.unit.spec.ts
@@ -0,0 +1,199 @@
+import { renderHook } from "@testing-library/react";
+
+import { getSensibleVisualizations } from "metabase/visualizations/lib/sensibility";
+import type Question from "metabase-lib/v1/Question";
+import type { CardDisplayType, Dataset } from "metabase-types/api";
+
+import { useMcpVisualizationSelector } from "./useMcpVisualizationSelector";
+
+interface HookProps {
+ question: Question;
+ queryKey: string;
+ queryResults: Dataset[] | null;
+}
+
+jest.mock("metabase/visualizations/lib/sensibility", () => ({
+ getSensibleVisualizations: jest.fn(),
+}));
+
+const mockGetSensibleVisualizations = jest.mocked(getSensibleVisualizations);
+
+const createQuestion = (display: CardDisplayType): Question =>
+ ({
+ display: jest.fn(() => display),
+ setDisplay: jest.fn(
+ (nextDisplay: CardDisplayType): Question => createQuestion(nextDisplay),
+ ),
+ lockDisplay: jest.fn(function (this: Question) {
+ return this;
+ }),
+ }) as unknown as Question;
+
+const createQueryResult = (rowCount: number) =>
+ ({
+ data: { rows: Array.from({ length: rowCount }, () => []) },
+ }) as unknown as Dataset;
+
+describe("useMcpVisualizationSelector", () => {
+ beforeEach(() => {
+ mockGetSensibleVisualizations.mockReturnValue({
+ sensibleVisualizations: ["bar"],
+ nonSensibleVisualizations: [],
+ });
+ });
+
+ it("keeps the default visualization after re-running questions", () => {
+ const updateQuestion = jest.fn();
+
+ const firstResult = createQueryResult(3);
+ const rerunResult = createQueryResult(3);
+ const expected = ["line", "bar", "table"];
+
+ const initialProps: HookProps = {
+ question: createQuestion("table"),
+ queryKey: "query-1",
+ queryResults: null,
+ };
+
+ const { result, rerender } = renderHook(
+ ({ question, queryKey, queryResults }: HookProps) =>
+ useMcpVisualizationSelector({
+ question,
+ queryResults,
+ updateQuestion,
+ queryKey,
+ }),
+ { initialProps },
+ );
+
+ rerender({
+ question: createQuestion("line"),
+ queryKey: "query-1",
+ queryResults: [firstResult],
+ });
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual(
+ expected,
+ );
+
+ rerender({
+ question: createQuestion("table"),
+ queryKey: "query-1",
+ queryResults: [rerunResult],
+ });
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual(
+ expected,
+ );
+ });
+
+ it("resets the default visualization for a new MCP query", () => {
+ const updateQuestion = jest.fn();
+ const firstResult = createQueryResult(3);
+ const nextResult = createQueryResult(1);
+
+ mockGetSensibleVisualizations.mockImplementation(({ result }) => ({
+ sensibleVisualizations: result === nextResult ? ["scalar"] : ["bar"],
+ nonSensibleVisualizations: [],
+ }));
+
+ const initialProps: HookProps = {
+ question: createQuestion("line"),
+ queryKey: "query-1",
+ queryResults: [firstResult],
+ };
+
+ const { result, rerender } = renderHook(
+ ({ question, queryKey, queryResults }: HookProps) =>
+ useMcpVisualizationSelector({
+ question,
+ queryResults,
+ updateQuestion,
+ queryKey,
+ }),
+ { initialProps },
+ );
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual([
+ "line",
+ "bar",
+ "table",
+ ]);
+
+ rerender({
+ question: createQuestion("scalar"),
+ queryKey: "query-2",
+ queryResults: [nextResult],
+ });
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual([
+ "scalar",
+ ]);
+ });
+
+ it("waits for the new query result before capturing the default visualization", () => {
+ const updateQuestion = jest.fn();
+ const firstResult = createQueryResult(3);
+ const nextResult = createQueryResult(1);
+
+ mockGetSensibleVisualizations.mockImplementation(({ result }) => ({
+ sensibleVisualizations: result === nextResult ? ["scalar"] : ["bar"],
+ nonSensibleVisualizations: [],
+ }));
+
+ const initialProps: HookProps = {
+ question: createQuestion("line"),
+ queryKey: "query-1",
+ queryResults: [firstResult],
+ };
+
+ const { result, rerender } = renderHook(
+ ({ question, queryKey, queryResults }: HookProps) =>
+ useMcpVisualizationSelector({
+ question,
+ queryResults,
+ updateQuestion,
+ queryKey,
+ }),
+ { initialProps },
+ );
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual([
+ "line",
+ "bar",
+ "table",
+ ]);
+
+ rerender({
+ question: createQuestion("line"),
+ queryKey: "query-2",
+ queryResults: [firstResult],
+ });
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual([
+ "bar",
+ "table",
+ ]);
+
+ rerender({
+ question: createQuestion("line"),
+ queryKey: "query-2",
+ queryResults: [firstResult],
+ });
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual([
+ "bar",
+ "table",
+ ]);
+
+ rerender({
+ question: createQuestion("scalar"),
+ queryKey: "query-2",
+ queryResults: [nextResult],
+ });
+
+ expect(result.current.sensibleChartTypes.map(({ type }) => type)).toEqual([
+ "scalar",
+ ]);
+ });
+});
diff --git a/frontend/src/metabase/embedding/mcp/utils/captureDefaultDisplay.ts b/frontend/src/metabase/embedding/mcp/utils/captureDefaultDisplay.ts
new file mode 100644
index 00000000000..8db61617fca
--- /dev/null
+++ b/frontend/src/metabase/embedding/mcp/utils/captureDefaultDisplay.ts
@@ -0,0 +1,66 @@
+import type { CardDisplayType, Dataset } from "metabase-types/api";
+
+export interface DefaultDisplayState {
+ defaultDisplay: CardDisplayType | null;
+
+ queryKey: string | null;
+ lastQueryResult: Dataset | null;
+}
+
+/**
+ * Captures the display that Metabase picked as the default for a query.
+ *
+ * The default display comes from the SDK question lifecycle, which calls
+ * `Lib.defaultDisplay` and applies other adjustments in the `Question` class.
+ */
+export function captureDefaultDisplay({
+ currentDisplay,
+ queryKey,
+ queryResult,
+ previousState,
+}: {
+ currentDisplay: CardDisplayType | null;
+ queryKey: string | null;
+ queryResult: Dataset | null;
+ previousState: DefaultDisplayState;
+}): DefaultDisplayState {
+ const hasQueryChanged = previousState.queryKey !== queryKey;
+
+ const hasQueryResultChanged =
+ queryResult !== null && queryResult !== previousState.lastQueryResult;
+
+ const previousDefaultDisplay = hasQueryChanged
+ ? null
+ : previousState.defaultDisplay;
+
+ const isQueryResultFresh =
+ queryResult !== null &&
+ currentDisplay !== null &&
+ (!hasQueryChanged || hasQueryResultChanged);
+
+ // Only update the query key when the SDK query result caught up.
+ // If we refresh the key too early, the next stale render will capture the old display for the new query.
+ if (!isQueryResultFresh) {
+ return {
+ defaultDisplay: previousDefaultDisplay,
+ queryKey: previousState.queryKey,
+ lastQueryResult: previousState.lastQueryResult,
+ };
+ }
+
+ // Ad-hoc questions in MCP Apps initializes as `table`.
+ // Replace that placeholder when default display actually loads.
+ // see `getMcpDeserializedCard` in `embedding/mcp/McpUiAppRoute.utils.ts`
+ const shouldReplaceTablePlaceholder =
+ previousDefaultDisplay === "table" && currentDisplay !== "table";
+
+ // SDK only updates the question display *after* the query result arrives.
+ // We replace the display when that happens.
+ // see `runQuestionQuerySdk` in `sdk-question/run-question-query.ts`
+ const defaultDisplay =
+ previousDefaultDisplay === null || shouldReplaceTablePlaceholder
+ ? currentDisplay
+ : previousDefaultDisplay;
+
+ return { defaultDisplay, queryKey, lastQueryResult: queryResult };
+}
diff --git a/frontend/src/metabase/embedding/mcp/utils/captureDefaultDisplay.unit.spec.ts b/frontend/src/metabase/embedding/mcp/utils/captureDefaultDisplay.unit.spec.ts
new file mode 100644
index 00000000000..7dbc4d5c632
--- /dev/null
+++ b/frontend/src/metabase/embedding/mcp/utils/captureDefaultDisplay.unit.spec.ts
@@ -0,0 +1,94 @@
+import type { CardDisplayType, Dataset } from "metabase-types/api";
+
+import {
+ type DefaultDisplayState,
+ captureDefaultDisplay,
+} from "./captureDefaultDisplay";
+
+const createQueryResult = () => ({}) as Dataset;
+
+const createState = ({
+ defaultDisplay,
+ lastQueryResult,
+ queryKey = "query-1",
+}: {
+ defaultDisplay: CardDisplayType | null;
+ lastQueryResult: Dataset | null;
+ queryKey?: string | null;
+}): DefaultDisplayState => ({
+ defaultDisplay,
+ lastQueryResult,
+ queryKey,
+});
+
+describe("captureDefaultDisplay", () => {
+ it("does not capture stale SDK state after the query changes", () => {
+ const previousResult = createQueryResult();
+
+ const firstStaleState = captureDefaultDisplay({
+ currentDisplay: "line",
+ queryKey: "query-2",
+ queryResult: previousResult,
+ previousState: createState({
+ defaultDisplay: "bar",
+ lastQueryResult: previousResult,
+ }),
+ });
+
+ expect(firstStaleState.defaultDisplay).toBeNull();
+ expect(firstStaleState.queryKey).toBe("query-1");
+ expect(firstStaleState.lastQueryResult).toBe(previousResult);
+
+ const secondStaleState = captureDefaultDisplay({
+ currentDisplay: "line",
+ queryKey: "query-2",
+ queryResult: previousResult,
+ previousState: firstStaleState,
+ });
+
+ expect(secondStaleState.defaultDisplay).toBeNull();
+ expect(secondStaleState.queryKey).toBe("query-1");
+ expect(secondStaleState.lastQueryResult).toBe(previousResult);
+
+ const nextResult = createQueryResult();
+
+ const nextState = captureDefaultDisplay({
+ currentDisplay: "scalar",
+ queryKey: "query-2",
+ queryResult: nextResult,
+ previousState: secondStaleState,
+ });
+
+ expect(nextState.defaultDisplay).toBe("scalar");
+ expect(nextState.queryKey).toBe("query-2");
+ expect(nextState.lastQueryResult).toBe(nextResult);
+ });
+
+ it("captures the current display when the SDK state has updated", () => {
+ expect(
+ captureDefaultDisplay({
+ currentDisplay: "line",
+ queryKey: "query-1",
+ queryResult: createQueryResult(),
+ previousState: createState({
+ defaultDisplay: null,
+ lastQueryResult: null,
+ }),
+ }).defaultDisplay,
+ ).toBe("line");
+ });
+
+ it("replaces the table placeholder with the settled default display", () => {
+ expect(
+ captureDefaultDisplay({
+ currentDisplay: "line",
+ queryKey: "query-1",
+ queryResult: createQueryResult(),
+ previousState: createState({
+ defaultDisplay: "table",
+ lastQueryResult: createQueryResult(),
+ }),
+ }).defaultDisplay,
+ ).toBe("line");
+ });
+});
diff --git a/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.ts b/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.ts
index 81617e5ab4f..56f37352f4e 100644
--- a/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.ts
+++ b/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.ts
@@ -56,15 +56,15 @@ export function getMcpChartTypes({
);
const chartTypes: Array<CardDisplayType | null> = [
- // Slot 1: the original visualization
- // Lets them go back the original viz even if it's not bar/line/area.
+ // Slot 1: the default visualization
+ // Lets them go back to the default viz even if it's not bar/line/area.
defaultDisplay,
- // Slot 2: sensible visualization that isn't already the default
+ // Slot 2: sensible visualization that isn't already the default display
candidates.find((type) => sensibleVisualizations.includes(type)) ?? null,
- // Slot 3: show table if we can, otherwise show area as the fallback
- canShowTable ? "table" : "area",
+ // Slot 3: show table when it has enough data to be useful.
+ canShowTable ? "table" : null,
];
return Array.from(new Set(chartTypes))
diff --git a/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.unit.spec.ts b/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.unit.spec.ts
index b1b4a0f454e..d2e2f2a7901 100644
--- a/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.unit.spec.ts
+++ b/frontend/src/metabase/embedding/mcp/utils/getMcpChartTypes.unit.spec.ts
@@ -45,13 +45,13 @@ describe("getMcpChartTypes", () => {
).toEqual(["bar", "table"]);
});
- it("shows area instead of table when table is not visible", () => {
+ it("does not add a fallback chart for scalar results when table is not visible", () => {
expect(
getChartTypes({
- defaultDisplay: "pie",
- sensibleVisualizations: ["pie", "bar", "line"],
+ defaultDisplay: "scalar",
+ sensibleVisualizations: ["scalar"],
canShowTable: false,
}),
- ).toEqual(["pie", "bar", "area"]);
+ ).toEqual(["scalar"]);
});
});
diff --git a/src/metabase/mcp/resources.clj b/src/metabase/mcp/resources.clj
index 2b0ba30e8eb..fc86ccb97f6 100644
--- a/src/metabase/mcp/resources.clj
+++ b/src/metabase/mcp/resources.clj
@@ -305,7 +305,7 @@
"ui://metabase/visualize-query.html"
"agent:viz:mcp-ui:query"
{:name "Visualize Query"
- :description "Interactive Metabase SDK visualization for a query"
+ :description "Lightweight MCP Apps visualization for a query"
:prefersBorder true
:render-fn (visualize-query-render-fn "visualize-query")})
@@ -314,7 +314,7 @@
"ui://metabase/render-drill-through.html"
"agent:viz:mcp-ui:drill-through"
{:name "Render Drill Through"
- :description "Interactive Metabase SDK visualization for a drill-through follow-up"
+ :description "Lightweight MCP Apps visualization for a drill-through follow-up"
:prefersBorder true
:render-fn (visualize-query-render-fn "render-drill-through")})
@@ -322,6 +322,10 @@
:visualize-query
{:name "visualize_query"
:description (str "Visualize a previously constructed query as an interactive chart or table. "
+ "This renders a lightweight MCP Apps visualization, not the full Metabase "
+ "query builder or standard Metabase UI. Do not tell the user to switch "
+ "display types, use visualization settings, or use a Metabase panel, "
+ "sidebar, or right-hand panel. "
"Use this for prompts that ask to show, display, visualize, plot, chart, "
"or present results, for example: `Show me customers in Metabase`, "
"`Show me orders by month`, `Display revenue by region`, or "
@@ -379,6 +383,10 @@
:render-drill-through
{:name "render_drill_through"
:description (str "Render the drill-through visualization the user just navigated into. "
+ "This renders a lightweight MCP Apps visualization, not the full Metabase "
+ "query builder or standard Metabase UI. Do not tell the user to switch "
+ "display types, use visualization settings, or use a Metabase panel, "
+ "sidebar, or right-hand panel. "
"Use this tool, not execute_query, when the user asks to show the result and "
"their message includes a `handle` UUID. This is the exact follow-up for the "
"phrase `Show me the result`. Do not execute the query yourself; pass the "