Skip to content

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

Add AI provider step to onboarding flow (#78001)

Maksym Yakubychecf701f7f6dd
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index d5f5782f73b..8f6b5cb4da5 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -1216,6 +1216,7 @@
premium-features
request
settings
+ setup
sql-tools
sync
util
diff --git a/e2e/support/helpers/e2e-mock-llm-tasks.ts b/e2e/support/helpers/e2e-mock-llm-tasks.ts
index 5357ebd2019..83554cd13d4 100644
--- a/e2e/support/helpers/e2e-mock-llm-tasks.ts
+++ b/e2e/support/helpers/e2e-mock-llm-tasks.ts
@@ -74,11 +74,18 @@ function buildAnthropicToolUseSSE({ name, input }: MockLlmToolCall): string {
return lines.join("\n");
}
+const MOCK_MODEL_CATALOG = [
+ { id: "claude-haiku-4-5", display_name: "Claude Haiku 4.5" },
+ { id: "claude-sonnet-4-6", display_name: "Claude Sonnet 4.6" },
+];
+
/**
- * Start a mock server that impersonates the Anthropic Messages API.
+ * Start a mock server that impersonates the Anthropic API.
*
- * Every POST to /v1/messages responds with a valid SSE stream containing
- * either the given `responseText` or a tool-use call. The server listens on `port`.
+ * GET /v1/models responds with a static model catalog (used by the provider
+ * credential validation when connecting). Every other request responds with a
+ * valid /v1/messages SSE stream containing either the given `responseText` or
+ * a tool-use call. The server listens on `port`.
*
* Call `stopMockLlmServer` to tear it down.
*/
@@ -97,7 +104,13 @@ export function startMockLlmServer(
? buildAnthropicToolUseSSE(options.toolCall)
: buildAnthropicSSE(options.responseText);
- server = http.createServer((_req, res) => {
+ server = http.createServer((req, res) => {
+ if (req.method === "GET" && req.url?.includes("/models")) {
+ res.writeHead(200, { "content-type": "application/json" });
+ res.end(JSON.stringify({ data: MOCK_MODEL_CATALOG }));
+ return;
+ }
+
res.writeHead(200, {
"content-type": "text/event-stream",
"cache-control": "no-cache",
diff --git a/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts b/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts
index 10e2143cbeb..4a608ef1341 100644
--- a/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts
+++ b/e2e/test/scenarios/onboarding/setup/setup.cy.spec.ts
@@ -415,7 +415,7 @@ describe("scenarios > setup", () => {
cy.button("Connect database").click();
});
- cy.findByRole("status").should("contain", `Connected to ${dbName}`);
+ H.undoToastList().should("contain", `Connected to ${dbName}`);
skipLicenseStepOnEE();
@@ -537,6 +537,228 @@ describe("scenarios > setup", () => {
});
});
+describe("scenarios > setup > AI config step", () => {
+ const MOCK_LLM_PORT = 6123;
+
+ beforeEach(() => {
+ H.restore("blank");
+ });
+
+ afterEach(() => {
+ cy.task("stopMockLlmServer");
+ });
+
+ const navigateToAiConfigStep = () => {
+ navigateToDatabaseStep();
+ cy.findByTestId("setup-forms")
+ .findByText("Continue with sample data")
+ .click();
+ finishSetup();
+ startAiConfigStep();
+ };
+
+ it("should offer BYOK providers without the managed option and allow skipping", () => {
+ navigateToAiConfigStep();
+
+ cy.findByLabelText("Connect to an AI provider")
+ .findByLabelText("Provider")
+ .click();
+
+ H.popover().within(() => {
+ cy.findByText("Anthropic").should("be.visible");
+ cy.findByText("OpenAI").should("be.visible");
+ cy.findByText("OpenRouter").should("be.visible");
+ cy.findByText("Microsoft Azure").should("be.visible");
+ cy.findByText("Amazon Bedrock").should("be.visible");
+ cy.findByText("Metabase").should("not.exist");
+ });
+ H.popover().findByText("Anthropic").click();
+
+ cy.findByLabelText("Connect to an AI provider").within(() => {
+ cy.findByLabelText("API key").should("be.visible");
+ cy.button("I'll set this up later").click();
+ });
+
+ cy.findByLabelText("I'll set up AI later").should("be.visible");
+ cy.findByTestId("setup-forms").within(() => {
+ cy.findByText("You're all set up!").should("be.visible");
+ cy.button("Set up AI").should("not.exist");
+ });
+ });
+
+ it("should connect an Anthropic API key during setup", () => {
+ cy.task("startMockLlmServer", {
+ port: MOCK_LLM_PORT,
+ responseText: "Hello from mock LLM!",
+ });
+ cy.intercept("PUT", "/api/metabot/settings").as("connectProvider");
+
+ navigateToAiConfigStep();
+
+ // The wizard runs as the freshly created admin, so settings can be
+ // updated mid-flow. Point the Anthropic client at the mock server that
+ // answers the credential-validating /v1/models call.
+ H.updateSetting(
+ "llm-anthropic-api-base-url",
+ `http://localhost:${MOCK_LLM_PORT}`,
+ );
+
+ cy.findByLabelText("Connect to an AI provider")
+ .findByLabelText("Provider")
+ .click();
+ H.popover().findByText("Anthropic").click();
+
+ cy.findByLabelText("Connect to an AI provider").within(() => {
+ cy.findByLabelText("API key").type("sk-ant-api03-e2e-test-key");
+ cy.button("Connect").click();
+ cy.wait("@connectProvider");
+
+ cy.findByLabelText("Model").should("be.visible");
+ cy.button("Done").click();
+ });
+
+ cy.findByLabelText("Connected to Anthropic").should("be.visible");
+ });
+
+ it("should connect the Metabase managed provider during setup", () => {
+ // The "Metabase" provider option is gated on token features read at page
+ // bootstrap (plugin init), before any interceptable API call — so patch
+ // the server-embedded payload as it is assigned. We can't use
+ // `H.activateToken` here because the endpoint requires a user.. which
+ // isn't created yet.
+ // The store-backed calls (add-ons pricing, the managed connect itself)
+ // have no real backing in e2e and are stubbed at the network layer.
+ type BootstrapPayload = {
+ "token-features"?: Record<string, boolean>;
+ } & Record<string, unknown>;
+
+ const enableManagedAiFeatures = (win: Cypress.AUTWindow) => {
+ let bootstrap: BootstrapPayload | undefined;
+ Object.defineProperty(win, "MetabaseBootstrap", {
+ configurable: true,
+ get: () => bootstrap,
+ set: (value: BootstrapPayload) => {
+ bootstrap = {
+ ...value,
+ "token-features": {
+ ...value["token-features"],
+ "metabase-ai-managed": true,
+ "offer-metabase-ai-managed": true,
+ },
+ };
+ },
+ });
+ };
+
+ let isConnected = false;
+ cy.intercept("GET", "/api/session/properties", (req) => {
+ req.reply((res) => {
+ res.body["token-features"] = {
+ ...res.body["token-features"],
+ "metabase-ai-managed": true,
+ "offer-metabase-ai-managed": true,
+ };
+ if (isConnected) {
+ res.body["llm-metabot-configured?"] = true;
+ res.body["llm-metabot-provider"] =
+ "metabase/anthropic/claude-sonnet-4-6";
+ }
+ });
+ });
+ cy.intercept("GET", "/api/ee/cloud-add-ons/addons", [
+ {
+ id: 1,
+ active: true,
+ self_service: true,
+ deployment: "hosting",
+ billing_period_months: 1,
+ default_base_fee: 0,
+ default_included_units: 0,
+ default_prepaid_units: 1,
+ free_units: 1_000_000,
+ default_price_per_unit: 3.75 / 1_000_000,
+ default_total_units: 1,
+ description: null,
+ is_metered: true,
+ name: "Metabase AI Managed",
+ product_tiers: [],
+ product_type: "metabase-ai-managed",
+ short_name: "Metabase AI Managed",
+ token_features: [],
+ trial_days: null,
+ },
+ ]);
+ cy.intercept("GET", "/api/ee/metabot/usage", {
+ is_locked: false,
+ tokens: 0,
+ free_tokens: 1000000,
+ updated_at: null,
+ });
+ cy.intercept("POST", "/api/premium-features/token/refresh", {});
+ cy.intercept("PUT", "/api/metabot/settings", (req) => {
+ isConnected = true;
+ req.reply({ value: "metabase/anthropic/claude-sonnet-4-6", models: [] });
+ }).as("connectManaged");
+
+ cy.visit(
+ "/setup?first_name=John&last_name=Doe&[email protected]&site_name=Doe%20Unlimited",
+ { onBeforeLoad: enableManagedAiFeatures },
+ );
+
+ skipWelcomePage();
+
+ cy.findByTestId("setup-forms").within(() => {
+ const password = "12341234";
+ cy.findByLabelText("Create a password").type(password);
+ cy.findByLabelText("Confirm your password").type(password);
+ cy.button("Next").click();
+
+ cy.findByLabelText("What will you use Metabase for?").should(
+ "be.visible",
+ );
+ cy.button("Next").click();
+
+ cy.findByText("Continue with sample data").click();
+
+ // the patched token features make this a paid plan, so the license step
+ // is skipped even on EE
+ cy.findByText("Finish").click();
+ });
+
+ startAiConfigStep();
+
+ cy.findByLabelText("Connect to an AI provider").within(() => {
+ cy.findByLabelText("Provider").should("have.value", "Metabase");
+ cy.findByText("About Metabase AI service").should("be.visible");
+ cy.findByText(/You get 1M tokens for free/).should("be.visible");
+ cy.button("Connect").click();
+ });
+
+ cy.wait("@connectManaged")
+ .its("request.body")
+ .should("deep.equal", { provider: "metabase", model: "" });
+ cy.findByLabelText("Connected to Metabase").should("be.visible");
+ });
+
+ it("should not offer the step when AI features are disabled", () => {
+ H.mockSessionProperty("ai-features-enabled?", false);
+
+ navigateToDatabaseStep();
+ cy.findByTestId("setup-forms")
+ .findByText("Continue with sample data")
+ .click();
+
+ skipLicenseStepOnEE();
+ cy.findByLabelText("Usage data preferences").should("be.visible");
+ cy.findByTestId("setup-forms").within(() => {
+ cy.findByText("Finish").click();
+
+ cy.findByText("You're all set up!").should("be.visible");
+ cy.button("Set up AI").should("not.exist");
+ });
+ });
+});
+
describe("scenarios > setup (EE)", () => {
beforeEach(() => H.restore("blank"));
@@ -665,6 +887,26 @@ describe("scenarios > setup", () => {
step: "completed",
});
+ cy.button("Set up AI").click();
+
+ H.expectUnstructuredSnowplowEvent({
+ event: "ai_setup_started",
+ triggered_from: "setup",
+ });
+
+ H.expectUnstructuredSnowplowEvent({
+ event: "step_seen",
+ step_number: IS_ENTERPRISE ? 6 : 5,
+ step: "ai_config",
+ });
+
+ cy.button("I'll set this up later").click();
+
+ H.expectUnstructuredSnowplowEvent({
+ event: "ai_setup_later_clicked",
+ triggered_from: "setup",
+ });
+
cy.findByLabelText(
"Get infrequent emails about new releases and feature updates.",
).click();
@@ -747,6 +989,17 @@ const skipLicenseStepOnEE = () => {
}
};
+const finishSetup = () => {
+ skipLicenseStepOnEE();
+ cy.findByText("Finish").click();
+};
+
+const startAiConfigStep = () => {
+ cy.findByText("You're all set up!").should("be.visible");
+ cy.button("Set up AI").click();
+ cy.findByLabelText("Connect to an AI provider").should("be.visible");
+};
+
const typeToken = (token: string) => {
// hides the requests from the logs as the token is passed as a GET param
cy.intercept({ resourceType: "xhr" }, { log: false });
diff --git a/frontend/src/metabase-types/analytics/event.ts b/frontend/src/metabase-types/analytics/event.ts
index a4dbfb65cd4..270276ae1df 100644
--- a/frontend/src/metabase-types/analytics/event.ts
+++ b/frontend/src/metabase-types/analytics/event.ts
@@ -47,6 +47,22 @@ export type CustomVizEvent =
| CustomVizPluginRefreshedEvent
| CustomVizSelectedEvent;
+export type AiSetupStartedEvent = ValidateEvent<{
+ event: "ai_setup_started";
+ triggered_from: "setup";
+}>;
+
+export type AiProviderConnectedEvent = ValidateEvent<{
+ event: "ai_provider_connected";
+ triggered_from: "setup";
+ event_detail: string | null;
+}>;
+
+export type AiSetupLaterClickedEvent = ValidateEvent<{
+ event: "ai_setup_later_clicked";
+ triggered_from: "setup";
+}>;
+
export type UserInvitedEvent = ValidateEvent<{
event: "user_invited";
triggered_from: "admin" | "setup" | "dashboard" | "question";
diff --git a/frontend/src/metabase-types/analytics/setup.ts b/frontend/src/metabase-types/analytics/setup.ts
index e4d58b0af98..a0532fb6191 100644
--- a/frontend/src/metabase-types/analytics/setup.ts
+++ b/frontend/src/metabase-types/analytics/setup.ts
@@ -14,7 +14,7 @@ type ValidateEvent<
Record<Exclude<keyof T, keyof SetupEventSchema>, never>,
> = T;
-export type SetupVersion = "1.4.0";
+export type SetupVersion = "1.5.0";
export type StepSeenEvent = ValidateEvent<{
event: "step_seen";
@@ -24,6 +24,7 @@ export type StepSeenEvent = ValidateEvent<{
| "language"
| "user_info"
| "db_connection"
+ | "ai_config"
| "usage_question"
| "license_token"
| "db_scheduling"
diff --git a/frontend/src/metabase/analytics/event.ts b/frontend/src/metabase/analytics/event.ts
index 88baa6ca91a..02958d7e674 100644
--- a/frontend/src/metabase/analytics/event.ts
+++ b/frontend/src/metabase/analytics/event.ts
@@ -28,7 +28,7 @@ const VERSIONS: Record<SchemaType, SchemaVersion> = {
search: "1-1-4",
serialization: "1-0-1",
settings: "1-0-2",
- setup: "1-0-3",
+ setup: "1-0-4",
timeline: "1-0-0",
upsell: "1-0-0",
};
diff --git a/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx b/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx
index 4072168fe5e..b4f8bbc8671 100644
--- a/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx
+++ b/frontend/src/metabase/metabot/components/AIProviderConfigurationForm/AIProviderConfigurationForm.tsx
@@ -15,7 +15,18 @@ import { ConfirmModal } from "metabase/common/components/ConfirmModal";
import { SetByEnvVar } from "metabase/common/components/SetByEnvVar";
import { useSetting, useToast } from "metabase/common/hooks";
import { PLUGIN_METABOT } from "metabase/plugins";
-import { Button, Flex, Group, Select, Stack, Text } from "metabase/ui";
+import {
+ Box,
+ Button,
+ Center,
+ Divider,
+ Flex,
+ Group,
+ Loader,
+ Select,
+ Stack,
+ Text,
+} from "metabase/ui";
import type { MetabotProvider } from "metabase-types/api";
import { AIProviderConfigurationContext } from "./AIProviderConfigurationContext";
@@ -29,13 +40,38 @@ import {
parseProviderAndModel,
} from "./utils";
-export function AIProviderConfigurationForm({
+interface AIProviderConfigurationFormProps {
+ isModal?: boolean;
+ defaultProvider?: MetabotProvider;
+ onClose?: (connectedProvider?: MetabotProvider) => void;
+ onSkip?: VoidFunction;
+}
+
+export function AIProviderConfigurationForm(
+ props: AIProviderConfigurationFormProps,
+) {
+ const { isLoading } = useAdminSetting("llm-metabot-provider");
+
+ // The saved provider loads asynchronously, and the form body computes its
+ // initial selection once at mount. Mounting before the value arrives would
+ // let `defaultProvider` win over an existing connection.
+ if (props.defaultProvider && isLoading) {
+ return (
+ <Center p="lg">
+ <Loader data-testid="loading-indicator" />
+ </Center>
+ );
+ }
+
+ return <AIProviderConfigurationFormBody {...props} />;
+}
+
+function AIProviderConfigurationFormBody({
isModal = false,
+ defaultProvider,
onClose,
-}: {
- isModal?: boolean;
- onClose?: VoidFunction;
-}) {
+ onSkip,
+}: AIProviderConfigurationFormProps) {
const MetabaseAIProviderSetup = PLUGIN_METABOT.MetabaseAIProviderSetup;
const offerMetabaseAiManaged = PLUGIN_METABOT.isEnabled;
const [sendToast] = useToast();
@@ -57,9 +93,16 @@ export function AIProviderConfigurationForm({
);
const connectedProvider = isConfigured ? config?.provider : undefined;
const connectedModel = isConfigured ? config?.model : undefined;
- const [provider, setProvider] = useState<MetabotProvider | undefined>(
- isModal ? undefined : connectedProvider,
- );
+ // `defaultProvider` is only a suggestion for the unconfigured state — an
+ // existing connection always wins over it. A modal without a suggestion
+ // starts unselected on purpose, even when connected (the "switch provider"
+ // flow).
+ const [provider, setProvider] = useState<MetabotProvider | undefined>(() => {
+ if (!isModal) {
+ return connectedProvider;
+ }
+ return defaultProvider ? (connectedProvider ?? defaultProvider) : undefined;
+ });
const isCurrentConfigured = connectedProvider === provider && isConfigured;
@@ -260,7 +303,9 @@ export function AIProviderConfigurationForm({
? null
: match(provider)
.with("metabase", () => (
- <MetabaseAIProviderSetup onConnect={onClose} />
+ <MetabaseAIProviderSetup
+ onConnect={() => onClose?.("metabase")}
+ />
))
.with("azure", () => (
<AzureProviderFields
@@ -290,14 +335,14 @@ export function AIProviderConfigurationForm({
{envSettingName && <SetByEnvVar varName={envSettingName} />}
- <Flex justify="end">
+ <Flex justify={onSkip ? "flex-start" : "end"}>
{match({ isCurrentConfigured, isConnectButtonEnabled, isModal })
.with({ isModal: true, isCurrentConfigured: true }, () => (
<Button
variant="filled"
loading={isMutating}
disabled={isMutating}
- onClick={onClose}
+ onClick={() => onClose?.(provider)}
>
{t`Done`}
</Button>
@@ -331,6 +376,24 @@ export function AIProviderConfigurationForm({
)
.exhaustive()}
</Flex>
+
+ {onSkip && !isCurrentConfigured && (
+ <>
+ <Divider mx={{ base: "-2rem", sm: "-4rem" }} mt="xl" mb="md" />
+ <Box>
+ <Button
+ onClick={onSkip}
+ variant="subtle"
+ px={0}
+ fw="normal"
+ disabled={isMutating}
+ >{t`I'll set this up later`}</Button>
+ <Text c="text-disabled" size="sm">
+ {t`You won't be able to use AI features until you connect a provider.`}
+ </Text>
+ </Box>
+ </>
+ )}
<ConfirmModal
opened={isDisconnectConfirmOpen}
onClose={() => setIsDisconnectConfirmOpen(false)}
diff --git a/frontend/src/metabase/redux/store/mocks/setup.ts b/frontend/src/metabase/redux/store/mocks/setup.ts
index 5b457b7eb59..8cd813a6b47 100644
--- a/frontend/src/metabase/redux/store/mocks/setup.ts
+++ b/frontend/src/metabase/redux/store/mocks/setup.ts
@@ -45,5 +45,6 @@ export const createMockSetupState = (
isEmbeddingUseCase: false,
isLocaleLoaded: false,
isTrackingAllowed: true,
+ isAiConfigRequested: false,
...opts,
});
diff --git a/frontend/src/metabase/redux/store/setup.ts b/frontend/src/metabase/redux/store/setup.ts
index afa114884a1..56d73abc80d 100644
--- a/frontend/src/metabase/redux/store/setup.ts
+++ b/frontend/src/metabase/redux/store/setup.ts
@@ -6,6 +6,7 @@ export type SetupStep =
| "user_info"
| "usage_question"
| "db_connection"
+ | "ai_config"
| "license_token"
| "data_usage"
| "completed";
@@ -45,5 +46,6 @@ export interface SetupState {
isEmbeddingUseCase: boolean;
isLocaleLoaded: boolean;
isTrackingAllowed: boolean;
+ isAiConfigRequested: boolean;
licenseToken?: string | null;
}
diff --git a/frontend/src/metabase/setup/actions.ts b/frontend/src/metabase/setup/actions.ts
index dad1b82cd64..13cbd213b02 100644
--- a/frontend/src/metabase/setup/actions.ts
+++ b/frontend/src/metabase/setup/actions.ts
@@ -19,6 +19,7 @@ import type {
State,
UserInfo,
} from "metabase/redux/store";
+import { refreshCurrentUser } from "metabase/redux/user";
import { createAsyncThunk } from "metabase/redux/utils";
import { getSetting } from "metabase/selectors/settings";
import MetabaseSettings from "metabase/utils/settings";
@@ -26,6 +27,9 @@ import type { DatabaseData, Settings, UsageReason } from "metabase-types/api";
import {
trackAddDataLaterClicked,
+ trackAiProviderConnected,
+ trackAiSetupLaterClicked,
+ trackAiSetupStarted,
trackDatabaseSelected,
trackLicenseTokenStepSubmitted,
trackTrackingChanged,
@@ -117,6 +121,8 @@ export const submitUser = createAsyncThunk<void, UserInfo, ThunkConfig>(
dispatch(goToNextStep());
// load the settings after the user is logged, needed later by setEmbeddingHomepageFlags
dispatch(refetchSiteSettings());
+ // the AI config step needs to know the created user is an admin
+ dispatch(refreshCurrentUser());
},
);
@@ -197,6 +203,33 @@ export const submitUserInvite = createAsyncThunk(
},
);
+export const START_AI_CONFIG = "metabase/setup/START_AI_CONFIG";
+export const startAiConfig = createAsyncThunk(
+ START_AI_CONFIG,
+ (_: void, { dispatch }) => {
+ trackAiSetupStarted();
+ dispatch(selectStep("ai_config"));
+ },
+);
+
+export const SUBMIT_AI_CONFIG = "metabase/setup/SUBMIT_AI_CONFIG";
+export const submitAiConfig = createAsyncThunk(
+ SUBMIT_AI_CONFIG,
+ (provider: string | undefined, { dispatch }) => {
+ trackAiProviderConnected(provider);
+ dispatch(selectStep("completed"));
+ },
+);
+
+export const SKIP_AI_CONFIG = "metabase/setup/SKIP_AI_CONFIG";
+export const skipAiConfig = createAsyncThunk(
+ SKIP_AI_CONFIG,
+ (_: void, { dispatch }) => {
+ trackAiSetupLaterClicked();
+ dispatch(selectStep("completed"));
+ },
+);
+
export const submitLicenseToken = createAsyncThunk(
"metabase/setup/SUBMIT_LICENSE_TOKEN",
async (licenseToken: string | null, { dispatch, rejectWithValue }) => {
diff --git a/frontend/src/metabase/setup/analytics.ts b/frontend/src/metabase/setup/analytics.ts
index 4a1d8eb5eda..833c9412b52 100644
--- a/frontend/src/metabase/setup/analytics.ts
+++ b/frontend/src/metabase/setup/analytics.ts
@@ -1,4 +1,4 @@
-import { trackSchemaEvent } from "metabase/analytics";
+import { trackSchemaEvent, trackSimpleEvent } from "metabase/analytics";
import type { SetupStep } from "metabase/redux/store";
import type { SetupVersion } from "metabase-types/analytics/setup";
import type { UsageReason } from "metabase-types/api";
@@ -9,7 +9,7 @@ import type { UsageReason } from "metabase-types/api";
* entry to the corresponding Notion doc:
* {@link https://www.notion.so/metabase/Set-up-step-seen-19f39925938d401da2111f8a3d0dc36c}.
*/
-const ONBOARDING_VERSION: SetupVersion = "1.4.0";
+const ONBOARDING_VERSION: SetupVersion = "1.5.0";
export const trackStepSeen = ({
stepName,
@@ -58,6 +58,28 @@ export const trackAddDataLaterClicked = (engine?: string) => {
});
};
+export const trackAiSetupStarted = () => {
+ trackSimpleEvent({
+ event: "ai_setup_started",
+ triggered_from: "setup",
+ });
+};
+
+export const trackAiProviderConnected = (provider?: string) => {
+ trackSimpleEvent({
+ event: "ai_provider_connected",
+ event_detail: provider ?? null,
+ triggered_from: "setup",
+ });
+};
+
+export const trackAiSetupLaterClicked = () => {
+ trackSimpleEvent({
+ event: "ai_setup_later_clicked",
+ triggered_from: "setup",
+ });
+};
+
export const trackTrackingChanged = (isTrackingAllowed: boolean) => {
trackSchemaEvent("settings", {
event: isTrackingAllowed
diff --git a/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.tsx b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.tsx
new file mode 100644
index 00000000000..f2a293a3aa3
--- /dev/null
+++ b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.tsx
@@ -0,0 +1,85 @@
+import { P, match } from "ts-pattern";
+import { t } from "ttag";
+
+import { useSetting } from "metabase/common/hooks";
+import {
+ AIProviderConfigurationForm,
+ getProviderOptions,
+ parseProviderAndModel,
+} from "metabase/metabot";
+import { PLUGIN_METABOT } from "metabase/plugins";
+import { useDispatch } from "metabase/redux";
+import { Text } from "metabase/ui";
+import type { MetabotProvider } from "metabase-types/api";
+
+import { skipAiConfig, submitAiConfig } from "../../actions";
+import { useStep } from "../../useStep";
+import { ActiveStep } from "../ActiveStep";
+import { InactiveStep } from "../InactiveStep";
+import type { NumberedStepProps } from "../types";
+
+export const AIConfigStep = ({ stepLabel }: NumberedStepProps) => {
+ const { isStepActive, isStepCompleted } = useStep("ai_config");
+ const dispatch = useDispatch();
+ const offerMetabaseAiManaged = PLUGIN_METABOT.isEnabled;
+
+ const isConfigured = !!useSetting("llm-metabot-configured?");
+ const savedProviderValue = useSetting("llm-metabot-provider");
+ const connectedProvider = isConfigured
+ ? parseProviderAndModel(savedProviderValue)?.provider
+ : undefined;
+
+ const handleSubmit = (provider?: MetabotProvider) => {
+ dispatch(submitAiConfig(provider ?? connectedProvider));
+ };
+
+ const handleSkip = () => {
+ dispatch(skipAiConfig());
+ };
+
+ if (!isStepActive) {
+ return (
+ <InactiveStep
+ title={getStepTitle({
+ connectedProvider,
+ isStepCompleted,
+ offerMetabaseAiManaged,
+ })}
+ label={stepLabel}
+ isStepCompleted={isStepCompleted}
+ />
+ );
+ }
+
+ return (
+ <ActiveStep title={t`Connect to an AI provider`} label={stepLabel}>
+ <Text mb="lg" c="text-secondary">
+ {t`Select your AI provider to use AI explorations, SQL generation and Metabot.`}
+ </Text>
+ <AIProviderConfigurationForm
+ isModal
+ defaultProvider={offerMetabaseAiManaged ? "metabase" : undefined}
+ onClose={handleSubmit}
+ onSkip={handleSkip}
+ />
+ </ActiveStep>
+ );
+};
+
+const getStepTitle = ({
+ connectedProvider,
+ isStepCompleted,
+ offerMetabaseAiManaged,
+}: {
+ connectedProvider: MetabotProvider | undefined;
+ isStepCompleted: boolean;
+ offerMetabaseAiManaged: boolean;
+}): string =>
+ match({ isStepCompleted, connectedProvider })
+ .with({ isStepCompleted: false }, () => t`Connect to an AI provider`)
+ .with({ connectedProvider: P.nonNullable }, ({ connectedProvider }) => {
+ return t`Connected to ${
+ getProviderOptions(offerMetabaseAiManaged)[connectedProvider]?.label
+ }`;
+ })
+ .otherwise(() => t`I'll set up AI later`);
diff --git a/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.unit.spec.tsx b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.unit.spec.tsx
new file mode 100644
index 00000000000..bcf6a9ca10a
--- /dev/null
+++ b/frontend/src/metabase/setup/components/AIConfigStep/AIConfigStep.unit.spec.tsx
@@ -0,0 +1,298 @@
+import userEvent from "@testing-library/user-event";
+import fetchMock from "fetch-mock";
+
+import { setupEnterpriseOnlyPlugin } from "__support__/enterprise";
+import {
+ setupMetabaseManagedAiEndpoints,
+ setupMetabotSettingsEndpoint,
+ setupPropertiesEndpoints,
+} from "__support__/server-mocks";
+import { mockSettings } from "__support__/settings";
+import { renderWithProviders, screen } from "__support__/ui";
+import { reinitialize } from "metabase/plugins";
+import type { SetupStep } from "metabase/redux/store";
+import {
+ createMockSetupState,
+ createMockState,
+} from "metabase/redux/store/mocks";
+import type {
+ EnterpriseSettings,
+ SettingDefinition,
+ TokenFeatures,
+} from "metabase-types/api";
+import {
+ createMockSettingDefinition,
+ createMockSettings,
+ createMockTokenFeatures,
+ createMockUser,
+} from "metabase-types/api/mocks";
+
+import { AIConfigStep } from "./AIConfigStep";
+
+interface SetupOpts {
+ step?: SetupStep;
+ settings?: Partial<EnterpriseSettings>;
+ tokenFeatures?: Partial<TokenFeatures>;
+ hasMetabotPlugin?: boolean;
+ settingOverrides?: SettingDefinition[];
+}
+
+const setup = ({
+ step = "ai_config",
+ settings = {},
+ tokenFeatures = {},
+ hasMetabotPlugin = false,
+ settingOverrides = [],
+}: SetupOpts = {}) => {
+ const state = createMockState({
+ currentUser: createMockUser({ is_superuser: true }),
+ setup: createMockSetupState({ step, isAiConfigRequested: true }),
+ settings: mockSettings({
+ ...settings,
+ "token-features": createMockTokenFeatures(tokenFeatures),
+ }),
+ });
+
+ if (hasMetabotPlugin) {
+ setupEnterpriseOnlyPlugin("metabot");
+ }
+
+ // Served through closures so tests can mutate them to simulate the backend
+ // state changing after a connect.
+ const sessionProperties = createMockSettings({
+ ...settings,
+ "token-features": createMockTokenFeatures(tokenFeatures),
+ });
+ const settingDefinitions = [...settingOverrides];
+
+ fetchMock.get("path:/api/setting", () => settingDefinitions);
+ setupPropertiesEndpoints(sessionProperties);
+
+ renderWithProviders(<AIConfigStep stepLabel={5} />, {
+ storeInitialState: state,
+ });
+
+ return { sessionProperties, settingDefinitions };
+};
+
+const ANTHROPIC_MODELS = [
+ { id: "claude-haiku-4-5", display_name: "Claude Haiku 4.5" },
+ { id: "claude-sonnet-4-6", display_name: "Claude Sonnet 4.6" },
+];
+
+const connectAnthropic = async ({
+ sessionProperties,
+ settingDefinitions,
+}: ReturnType<typeof setup>) => {
+ setupMetabotSettingsEndpoint({
+ provider: "anthropic",
+ response: { value: "anthropic/claude-haiku-4-5", models: ANTHROPIC_MODELS },
+ });
+ fetchMock.put("path:/api/metabot/settings", () => {
+ sessionProperties["llm-metabot-provider"] = "anthropic/claude-haiku-4-5";
+ sessionProperties["llm-metabot-configured?"] = true;
+ settingDefinitions.push(
+ createMockSettingDefinition({
+ key: "llm-anthropic-api-key",
+ value: "**********ey",
+ }),
+ );
+ return { value: "anthropic/claude-haiku-4-5", models: ANTHROPIC_MODELS };
+ });
+
+ await userEvent.click(screen.getByLabelText("Provider"));
+ await userEvent.click(
+ await screen.findByRole("option", { name: "Anthropic" }),
+ );
+ await userEvent.type(
+ screen.getByLabelText("API key"),
+ "sk-ant-api03-unit-test-key",
+ );
+ await userEvent.click(screen.getByRole("button", { name: "Connect" }));
+};
+
+describe("AIConfigStep", () => {
+ afterEach(() => {
+ reinitialize();
+ });
+
+ it("should render in inactive state", () => {
+ setup({ step: "db_connection" });
+
+ expect(screen.getByText("Connect to an AI provider")).toBeInTheDocument();
+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();
+ });
+
+ it("should not offer the managed provider without access to it", async () => {
+ setup();
+
+ await userEvent.click(screen.getByLabelText("Provider"));
+
+ expect(
+ await screen.findByRole("option", { name: "Anthropic" }),
+ ).toBeInTheDocument();
+ expect(screen.getByRole("option", { name: /OpenAI/ })).toBeInTheDocument();
+ expect(
+ screen.queryByRole("option", { name: "Metabase" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should not preselect a provider without access to the managed provider", () => {
+ setup();
+
+ expect(screen.getByLabelText("Provider")).toHaveValue("");
+ });
+
+ it("should suggest the managed provider when the instance has access to it", async () => {
+ setupMetabaseManagedAiEndpoints();
+ setup({
+ tokenFeatures: { "offer-metabase-ai-managed": true },
+ hasMetabotPlugin: true,
+ });
+
+ expect(await screen.findByLabelText("Provider")).toHaveValue("Metabase");
+ expect(
+ await screen.findByText("About Metabase AI service"),
+ ).toBeInTheDocument();
+ expect(
+ await screen.findByRole("checkbox", {
+ name: /I agree with the Metabase AI Service/i,
+ }),
+ ).toBeInTheDocument();
+ });
+
+ it("should show the existing connection instead of the managed suggestion when already connected", async () => {
+ setupMetabaseManagedAiEndpoints();
+ setupMetabotSettingsEndpoint({
+ provider: "anthropic",
+ response: { value: "anthropic/claude-haiku-4-5", models: [] },
+ });
+ setup({
+ tokenFeatures: { "offer-metabase-ai-managed": true },
+ hasMetabotPlugin: true,
+ settings: {
+ "llm-metabot-configured?": true,
+ "llm-metabot-provider": "anthropic/claude-haiku-4-5",
+ },
+ settingOverrides: [
+ createMockSettingDefinition({
+ key: "llm-metabot-provider",
+ value: "anthropic/claude-haiku-4-5",
+ }),
+ createMockSettingDefinition({
+ key: "llm-anthropic-api-key",
+ value: "**********45",
+ }),
+ ],
+ });
+
+ expect(
+ await screen.findByRole("button", { name: "Done" }),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByText("About Metabase AI service"),
+ ).not.toBeInTheDocument();
+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "I'll set this up later" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should advance to the next step when skipping", async () => {
+ setup();
+
+ await userEvent.click(
+ screen.getByRole("button", { name: "I'll set this up later" }),
+ );
+
+ expect(await screen.findByText("I'll set up AI later")).toBeInTheDocument();
+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();
+ });
+
+ it("should show the model picker after connecting a provider", async () => {
+ const mocks = setup();
+
+ await connectAnthropic(mocks);
+
+ expect(await screen.findByLabelText("Model")).toBeInTheDocument();
+ expect(
+ await screen.findByRole("button", { name: "Done" }),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "I'll set this up later" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should advance to the next step after confirming the connection", async () => {
+ const mocks = setup();
+
+ await connectAnthropic(mocks);
+ await userEvent.click(await screen.findByRole("button", { name: "Done" }));
+
+ expect(
+ await screen.findByText("Connected to Anthropic"),
+ ).toBeInTheDocument();
+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();
+ expect(screen.queryByLabelText("Model")).not.toBeInTheDocument();
+ });
+
+ it("should connect the managed provider and advance to the next step", async () => {
+ setupMetabaseManagedAiEndpoints();
+ fetchMock.post("path:/api/premium-features/token/refresh", 200);
+
+ const { sessionProperties } = setup({
+ tokenFeatures: {
+ "offer-metabase-ai-managed": true,
+ "metabase-ai-managed": true,
+ },
+ hasMetabotPlugin: true,
+ });
+
+ fetchMock.put("path:/api/metabot/settings", () => {
+ sessionProperties["llm-metabot-provider"] =
+ "metabase/anthropic/claude-sonnet-4-6";
+ sessionProperties["llm-metabot-configured?"] = true;
+ return { value: "metabase/anthropic/claude-sonnet-4-6", models: [] };
+ });
+
+ expect(
+ await screen.findByText("About Metabase AI service"),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByRole("checkbox", {
+ name: /I agree with the Metabase AI Service/i,
+ }),
+ ).not.toBeInTheDocument();
+
+ await userEvent.click(screen.getByRole("button", { name: "Connect" }));
+
+ expect(
+ await screen.findByText("Connected to Metabase"),
+ ).toBeInTheDocument();
+ expect(screen.queryByLabelText("Provider")).not.toBeInTheDocument();
+ expect(
+ fetchMock.callHistory.called("path:/api/metabot/settings", {
+ method: "PUT",
+ body: { provider: "metabase", model: "" },
+ }),
+ ).toBe(true);
+ });
+
+ it("should show the connected provider when completed after connecting", () => {
+ setup({
+ step: "completed",
+ settings: {
+ "llm-metabot-configured?": true,
+ "llm-metabot-provider": "anthropic/claude-haiku-4-5",
+ },
+ });
+
+ expect(screen.getByText("Connected to Anthropic")).toBeInTheDocument();
+ });
+
+ it("should show the skipped title when completed without connecting", () => {
+ setup({ step: "completed" });
+
+ expect(screen.getByText("I'll set up AI later")).toBeInTheDocument();
+ });
+});
diff --git a/frontend/src/metabase/setup/components/AIConfigStep/index.ts b/frontend/src/metabase/setup/components/AIConfigStep/index.ts
new file mode 100644
index 00000000000..833f271f2ec
--- /dev/null
+++ b/frontend/src/metabase/setup/components/AIConfigStep/index.ts
@@ -0,0 +1 @@
+export { AIConfigStep } from "./AIConfigStep";
diff --git a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx
index b3e120085cc..100530f8c37 100644
--- a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx
+++ b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.tsx
@@ -3,11 +3,16 @@ import { type ChangeEvent, useState } from "react";
import { t } from "ttag";
import ButtonsS from "metabase/css/components/buttons.module.css";
-import { useSelector } from "metabase/redux";
+import { useDispatch, useSelector } from "metabase/redux";
import { subscribeToNewsletter } from "metabase/setup/utils";
-import { Switch, Title } from "metabase/ui";
+import { Box, Button, Flex, Switch, Text, Title } from "metabase/ui";
-import { getIsStepActive, getUserEmail } from "../../selectors";
+import { startAiConfig } from "../../actions";
+import {
+ getIsStepActive,
+ getShouldOfferAiConfig,
+ getUserEmail,
+} from "../../selectors";
import { StepBody, StepFooter, StepRoot } from "./CompletedStep.styled";
import { trackNewsletterToggleClicked } from "./analytics";
@@ -15,6 +20,8 @@ import { trackNewsletterToggleClicked } from "./analytics";
export const CompletedStep = (): JSX.Element | null => {
const [checkboxValue, setCheckboxValue] = useState(false);
const email = useSelector(getUserEmail);
+ const shouldOfferAiConfig = useSelector(getShouldOfferAiConfig);
+ const dispatch = useDispatch();
const isStepActive = useSelector((state) =>
getIsStepActive(state, "completed"),
@@ -39,6 +46,22 @@ export const CompletedStep = (): JSX.Element | null => {
return (
<StepRoot>
<Title order={2}>{t`You're all set up!`}</Title>
+ {shouldOfferAiConfig && (
+ <StepBody>
+ <Flex align="center" justify="space-between" gap="lg">
+ <Box>
+ <Text fw="bold">{t`Want to use AI in Metabase?`}</Text>
+ <Text c="text-secondary">
+ {t`Connect an AI provider to use AI explorations, SQL generation and Metabot.`}
+ </Text>
+ </Box>
+ <Button
+ flex="0 0 auto"
+ onClick={() => dispatch(startAiConfig())}
+ >{t`Set up AI`}</Button>
+ </Flex>
+ </StepBody>
+ )}
<StepBody>
<Switch
checked={checkboxValue}
diff --git a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx
index 302432db5ea..456d22de375 100644
--- a/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx
+++ b/frontend/src/metabase/setup/components/CompletedStep/CompletedStep.unit.spec.tsx
@@ -1,21 +1,32 @@
+import { mockSettings } from "__support__/settings";
import { renderWithProviders, screen } from "__support__/ui";
-import type { SetupStep } from "metabase/redux/store";
+import type { SetupState, SetupStep } from "metabase/redux/store";
import {
createMockSetupState,
createMockState,
} from "metabase/redux/store/mocks";
+import type { EnterpriseSettings } from "metabase-types/api";
+import { createMockSettings } from "metabase-types/api/mocks";
import { CompletedStep } from "./CompletedStep";
interface SetupOpts {
step?: SetupStep;
+ setupState?: Partial<SetupState>;
+ settings?: Partial<EnterpriseSettings>;
}
-const setup = ({ step = "completed" }: SetupOpts = {}) => {
+const setup = ({
+ step = "completed",
+ setupState = {},
+ settings = {},
+}: SetupOpts = {}) => {
const state = createMockState({
setup: createMockSetupState({
step,
+ ...setupState,
}),
+ settings: mockSettings(createMockSettings(settings)),
});
renderWithProviders(<CompletedStep />, { storeInitialState: state });
@@ -38,4 +49,27 @@ describe("CompletedStep", () => {
).toBeInTheDocument();
expect(screen.getByText("Take me to Metabase")).toBeInTheDocument();
});
+
+ it("should offer to set up AI", () => {
+ setup();
+
+ expect(screen.getByText("Want to use AI in Metabase?")).toBeInTheDocument();
+ expect(screen.getByRole("button", { name: "Set up AI" })).toBeEnabled();
+ });
+
+ it("should not offer to set up AI once it has been requested", () => {
+ setup({ setupState: { isAiConfigRequested: true } });
+
+ expect(
+ screen.queryByRole("button", { name: "Set up AI" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should not offer to set up AI when AI features are disabled", () => {
+ setup({ settings: { "ai-features-enabled?": false } });
+
+ expect(
+ screen.queryByRole("button", { name: "Set up AI" }),
+ ).not.toBeInTheDocument();
+ });
});
diff --git a/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx b/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx
index f436bfd4f82..44611575a5b 100644
--- a/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx
+++ b/frontend/src/metabase/setup/components/SettingsPage/SettingsPage.tsx
@@ -5,6 +5,7 @@ import type { SetupStep } from "metabase/redux/store";
import { getSteps } from "metabase/setup/selectors";
import { Box, Flex, Icon, Text, Tooltip } from "metabase/ui";
+import { AIConfigStep } from "../AIConfigStep";
import { CloudMigrationHelp } from "../CloudMigrationHelp";
import { CompletedStep } from "../CompletedStep";
import { DataUsageStep } from "../DataUsageStep";
@@ -27,6 +28,7 @@ const STEP_COMPONENTS: Partial<
user_info: UserStep,
usage_question: UsageQuestionStep,
db_connection: DatabaseStep,
+ ai_config: AIConfigStep,
license_token: LicenseTokenStep,
data_usage: DataUsageStep,
};
diff --git a/frontend/src/metabase/setup/reducers.ts b/frontend/src/metabase/setup/reducers.ts
index 5ab17f47913..5ec4c0245bc 100644
--- a/frontend/src/metabase/setup/reducers.ts
+++ b/frontend/src/metabase/setup/reducers.ts
@@ -6,6 +6,7 @@ import {
loadLocaleDefaults,
selectStep,
skipDatabase,
+ startAiConfig,
submitDatabase,
submitLicenseToken,
submitUsageReason,
@@ -44,6 +45,7 @@ const initialState: SetupState = {
step: getInitialStep(),
isLocaleLoaded: false,
isTrackingAllowed: true,
+ isAiConfigRequested: false,
user: getUserFromQueryParams(),
isEmbeddingUseCase,
};
@@ -95,6 +97,9 @@ export const reducer = createReducer(initialState, (builder) => {
state.database = undefined;
state.invite = undefined;
});
+ builder.addCase(startAiConfig.pending, (state) => {
+ state.isAiConfigRequested = true;
+ });
builder.addCase(updateTracking.fulfilled, (state, { meta }) => {
state.isTrackingAllowed = meta.arg;
});
diff --git a/frontend/src/metabase/setup/selectors.ts b/frontend/src/metabase/setup/selectors.ts
index 6489505bfb6..89db847fe1b 100644
--- a/frontend/src/metabase/setup/selectors.ts
+++ b/frontend/src/metabase/setup/selectors.ts
@@ -85,6 +85,31 @@ export const getIsEmailConfigured = (state: State): boolean => {
return getSetting(state, "email-configured?");
};
+export const getIsAiConfigRequested = (state: State): boolean => {
+ return state.setup.isAiConfigRequested;
+};
+
+export const getIsAiConfigAvailable = createSelector(
+ [
+ (state: State) => getUsageReason(state),
+ (state: State) => getIsEmbeddingUseCase(state),
+ (state: State) => getSetting(state, "ai-features-enabled?"),
+ ],
+ (usageReason, isEmbeddingUseCase, areAiFeaturesEnabled) =>
+ usageReason !== "embedding" &&
+ !isEmbeddingUseCase &&
+ areAiFeaturesEnabled !== false,
+);
+
+export const getShouldOfferAiConfig = createSelector(
+ [
+ (state: State) => getIsAiConfigAvailable(state),
+ (state: State) => getIsAiConfigRequested(state),
+ ],
+ (isAiConfigAvailable, isAiConfigRequested) =>
+ isAiConfigAvailable && !isAiConfigRequested,
+);
+
export const getSteps = createSelector(
[
(state: State) => getUsageReason(state),
@@ -92,6 +117,8 @@ export const getSteps = createSelector(
(state: State) => getSetting(state, "token-features"),
(state: State) => state.setup.licenseToken,
(state: State) => getIsEmbeddingUseCase(state),
+ (state: State) => getIsAiConfigAvailable(state),
+ (state: State) => getIsAiConfigRequested(state),
],
(
usageReason,
@@ -99,6 +126,8 @@ export const getSteps = createSelector(
tokenFeatures,
licenseToken,
isEmbeddingUseCase,
+ isAiConfigAvailable,
+ isAiConfigRequested,
) => {
const isPaidPlan =
tokenFeatures &&
@@ -136,6 +165,10 @@ export const getSteps = createSelector(
),
...maybeAddStep("license_token", shouldShowLicenseStep),
...maybeAddStep("data_usage", shouldShowDataUsageStep),
+ // Opted into from the completed step, so it always comes last. The
+ // managed-AI offer relies on PLUGIN_METABOT.isEnabled, which is frozen
+ // at plugin init: a token entered in license_token can't surface it.
+ ...maybeAddStep("ai_config", isAiConfigAvailable && isAiConfigRequested),
"completed",
];
diff --git a/frontend/src/metabase/setup/selectors.unit.spec.ts b/frontend/src/metabase/setup/selectors.unit.spec.ts
new file mode 100644
index 00000000000..126767c9a8f
--- /dev/null
+++ b/frontend/src/metabase/setup/selectors.unit.spec.ts
@@ -0,0 +1,101 @@
+import { mockSettings } from "__support__/settings";
+import type { SetupState } from "metabase/redux/store";
+import {
+ createMockSetupState,
+ createMockState,
+} from "metabase/redux/store/mocks";
+import type { EnterpriseSettings } from "metabase-types/api";
+import { createMockSettings } from "metabase-types/api/mocks";
+
+import { getShouldOfferAiConfig, getSteps } from "./selectors";
+
+interface SetupOpts {
+ setup?: Partial<SetupState>;
+ settings?: Partial<EnterpriseSettings>;
+}
+
+const getStepKeys = ({ setup = {}, settings = {} }: SetupOpts = {}) => {
+ const state = createMockState({
+ setup: createMockSetupState(setup),
+ settings: mockSettings(createMockSettings(settings)),
+ });
+
+ return getSteps(state).map((step) => step.key);
+};
+
+const getShouldOffer = ({ setup = {}, settings = {} }: SetupOpts = {}) => {
+ const state = createMockState({
+ setup: createMockSetupState(setup),
+ settings: mockSettings(createMockSettings(settings)),
+ });
+
+ return getShouldOfferAiConfig(state);
+};
+
+describe("getSteps", () => {
+ it("should omit the AI config step until it is requested", () => {
+ expect(getStepKeys()).toEqual([
+ "welcome",
+ "user_info",
+ "usage_question",
+ "db_connection",
+ "data_usage",
+ "completed",
+ ]);
+ });
+
+ it("should append the AI config step after the last step once requested", () => {
+ expect(getStepKeys({ setup: { isAiConfigRequested: true } })).toEqual([
+ "welcome",
+ "user_info",
+ "usage_question",
+ "db_connection",
+ "data_usage",
+ "ai_config",
+ "completed",
+ ]);
+ });
+
+ it("should omit the requested AI config step when AI features are disabled", () => {
+ const stepKeys = getStepKeys({
+ setup: { isAiConfigRequested: true },
+ settings: { "ai-features-enabled?": false },
+ });
+
+ expect(stepKeys).not.toContain("ai_config");
+ });
+
+ it("should omit the requested AI config step for the embedding usage reason", () => {
+ const stepKeys = getStepKeys({
+ setup: { isAiConfigRequested: true, usageReason: "embedding" },
+ });
+
+ expect(stepKeys).not.toContain("ai_config");
+ });
+});
+
+describe("getShouldOfferAiConfig", () => {
+ it("should offer the AI config step by default", () => {
+ expect(getShouldOffer()).toBe(true);
+ });
+
+ it("should not offer the AI config step once it has been requested", () => {
+ expect(getShouldOffer({ setup: { isAiConfigRequested: true } })).toBe(
+ false,
+ );
+ });
+
+ it("should not offer the AI config step when AI features are disabled", () => {
+ expect(
+ getShouldOffer({ settings: { "ai-features-enabled?": false } }),
+ ).toBe(false);
+ });
+
+ it("should not offer the AI config step for the embedding usage reason", () => {
+ expect(getShouldOffer({ setup: { usageReason: "embedding" } })).toBe(false);
+ });
+
+ it("should not offer the AI config step for the embedding use case", () => {
+ expect(getShouldOffer({ setup: { isEmbeddingUseCase: true } })).toBe(false);
+ });
+});
diff --git a/frontend/src/metabase/setup/tests/common.unit.spec.tsx b/frontend/src/metabase/setup/tests/common.unit.spec.tsx
index 12eb244bf0b..431cb27a84b 100644
--- a/frontend/src/metabase/setup/tests/common.unit.spec.tsx
+++ b/frontend/src/metabase/setup/tests/common.unit.spec.tsx
@@ -1,10 +1,12 @@
import userEvent from "@testing-library/user-event";
+import fetchMock from "fetch-mock";
import { screen } from "__support__/ui";
import { createMockSettingDefinition } from "metabase-types/api/mocks";
import { SUBSCRIBE_TOKEN, SUBSCRIBE_URL } from "../constants";
+import type { SetupOpts } from "./setup";
import {
clickNextStep,
expectSectionToHaveLabel,
@@ -13,7 +15,9 @@ import {
getSection,
selectUsageReason,
setup,
+ skipAiConfigStep,
skipWelcomeScreen,
+ startAiConfigStep,
submitUserInfoStep,
} from "./setup";
@@ -123,6 +127,59 @@ describe("setup (OSS)", () => {
});
});
+ describe("AI config step", () => {
+ const completeSetup = async (opts?: SetupOpts) => {
+ await setup(opts);
+ await skipWelcomeScreen();
+ await submitUserInfoStep();
+ await selectUsageReason("self-service-analytics");
+ await clickNextStep();
+ await userEvent.click(screen.getByText("Continue with sample data"));
+ await userEvent.click(screen.getByText("Finish"));
+ };
+
+ it("should not be part of the wizard until it is opted into", async () => {
+ await completeSetup();
+
+ expect(
+ screen.queryByText("Connect to an AI provider"),
+ ).not.toBeInTheDocument();
+ expect(screen.getByText("You're all set up!")).toBeInTheDocument();
+ });
+
+ it("should become the last step when opting in from the completed step", async () => {
+ await completeSetup();
+ await startAiConfigStep();
+
+ expect(getSection("Connect to an AI provider")).toHaveAttribute(
+ "aria-current",
+ "step",
+ );
+ expectSectionToHaveLabel("Connect to an AI provider", "5");
+ expect(screen.queryByText("You're all set up!")).not.toBeInTheDocument();
+ });
+
+ it("should go back to the completed step when skipping, without offering AI again", async () => {
+ await completeSetup();
+ await startAiConfigStep();
+ await skipAiConfigStep();
+
+ expect(await screen.findByText("You're all set up!")).toBeInTheDocument();
+ expect(screen.getByText("I'll set up AI later")).toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "Set up AI" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("should not offer the step when AI features are disabled", async () => {
+ await completeSetup({ settings: { "ai-features-enabled?": false } });
+
+ expect(
+ screen.queryByRole("button", { name: "Set up AI" }),
+ ).not.toBeInTheDocument();
+ });
+ });
+
describe("embedding homepage flags", () => {
it("should set the correct flags when interested in embedding", async () => {
await setup();
@@ -161,8 +218,9 @@ describe("setup (OSS)", () => {
});
it("should not autoenable embedding if it was set by an env", async () => {
- await setup({
- settingOverrides: [
+ await setup();
+ fetchMock.modifyRoute("settings-list", {
+ response: [
createMockSettingDefinition({
key: "enable-embedding",
value: false,
diff --git a/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx b/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx
index 2399fa97371..48faa511174 100644
--- a/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx
+++ b/frontend/src/metabase/setup/tests/enterprise.unit.spec.tsx
@@ -1,8 +1,12 @@
import userEvent from "@testing-library/user-event";
import fetchMock from "fetch-mock";
-import { setupForTokenCheckEndpoint } from "__support__/server-mocks";
+import {
+ setupForTokenCheckEndpoint,
+ setupMetabaseManagedAiEndpoints,
+} from "__support__/server-mocks";
import { screen, waitFor } from "__support__/ui";
+import { createMockTokenFeatures } from "metabase-types/api/mocks";
import { trackLicenseTokenStepSubmitted } from "../analytics";
@@ -16,6 +20,7 @@ import {
setup,
skipTokenStep,
skipWelcomeScreen,
+ startAiConfigStep,
submitUserInfoStep,
} from "./setup";
@@ -159,6 +164,38 @@ describe("setup (EE build, but no token)", () => {
});
});
});
+
+ describe("AI config step with the managed AI offer", () => {
+ it("should preselect the managed provider and ask the admin to accept the terms", async () => {
+ await setupEnterprise({
+ tokenFeatures: createMockTokenFeatures({
+ hosting: true,
+ "offer-metabase-ai-managed": true,
+ }),
+ });
+ setupMetabaseManagedAiEndpoints();
+
+ await skipWelcomeScreen();
+ await submitUserInfoStep();
+ await selectUsageReason("self-service-analytics");
+ await clickNextStep();
+ await userEvent.click(screen.getByText("Continue with sample data"));
+ await startAiConfigStep();
+
+ expect(
+ await screen.findByText("About Metabase AI service"),
+ ).toBeInTheDocument();
+ expect(screen.getByLabelText("Provider")).toHaveValue("Metabase");
+ expect(
+ await screen.findByRole("checkbox", {
+ name: /I agree with the Metabase AI Service/i,
+ }),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByText("Please ask an Admin user to enable this for you."),
+ ).not.toBeInTheDocument();
+ });
+ });
});
const input = () => screen.getByRole("textbox", { name: "Token" });
diff --git a/frontend/src/metabase/setup/tests/setup.tsx b/frontend/src/metabase/setup/tests/setup.tsx
index 60e20559afc..742ecc0e21d 100644
--- a/frontend/src/metabase/setup/tests/setup.tsx
+++ b/frontend/src/metabase/setup/tests/setup.tsx
@@ -7,6 +7,7 @@ import {
setupEnterprisePlugins,
} from "__support__/enterprise";
import {
+ setupCurrentUserEndpoint,
setupPropertiesEndpoints,
setupSettingsEndpoints,
} from "__support__/server-mocks";
@@ -18,13 +19,14 @@ import {
createMockState,
} from "metabase/redux/store/mocks";
import type {
- SettingDefinition,
+ EnterpriseSettings,
TokenFeatures,
UsageReason,
} from "metabase-types/api";
import {
createMockSettings,
createMockTokenFeatures,
+ createMockUser,
} from "metabase-types/api/mocks";
import { Setup } from "../components/Setup";
@@ -33,13 +35,13 @@ export interface SetupOpts {
step?: SetupStep;
tokenFeatures?: TokenFeatures;
enterprisePlugins?: Parameters<typeof setupEnterpriseOnlyPlugin>[0][] | "*";
- settingOverrides?: SettingDefinition[];
+ settings?: Partial<EnterpriseSettings>;
}
export async function setup({
tokenFeatures = createMockTokenFeatures(),
enterprisePlugins,
- settingOverrides = [],
+ settings = {},
}: SetupOpts = {}) {
localStorage.clear();
jest.clearAllMocks();
@@ -50,6 +52,7 @@ export async function setup({
}),
settings: mockSettings(
createMockSettings({
+ ...settings,
"token-features": tokenFeatures,
"available-locales": [["en", "English"]],
}),
@@ -66,11 +69,12 @@ export async function setup({
fetchMock.post("path:/api/session/password-check", { valid: true });
fetchMock.post("path:/api/setup", {});
+ setupCurrentUserEndpoint(createMockUser({ is_superuser: true }));
fetchMock.put("path:/api/setting/anon-tracking-enabled", 200);
setupPropertiesEndpoints(
- createMockSettings({ "token-features": tokenFeatures }),
+ createMockSettings({ ...settings, "token-features": tokenFeatures }),
);
- setupSettingsEndpoints(settingOverrides);
+ setupSettingsEndpoints([]);
fetchMock.put("path:/api/setting", 200);
renderWithProviders(<Setup />, { storeInitialState: state });
@@ -168,3 +172,11 @@ export const getLastSettingsPutPayload = async () => {
export const skipTokenStep = async (name = "Skip") =>
await userEvent.click(screen.getByRole("button", { name }));
+
+export const startAiConfigStep = async () =>
+ await userEvent.click(screen.getByRole("button", { name: "Set up AI" }));
+
+export const skipAiConfigStep = async () =>
+ await userEvent.click(
+ screen.getByRole("button", { name: "I'll set this up later" }),
+ );
diff --git a/snowplow/iglu-client-embedded/schemas/com.metabase/setup/jsonschema/1-0-4 b/snowplow/iglu-client-embedded/schemas/com.metabase/setup/jsonschema/1-0-4
new file mode 100644
index 00000000000..ffe3502a820
--- /dev/null
+++ b/snowplow/iglu-client-embedded/schemas/com.metabase/setup/jsonschema/1-0-4
@@ -0,0 +1,105 @@
+{
+ "$schema": "http://iglucentral.com/schemas/com.snowplowanalytics.self-desc/schema/jsonschema/1-0-0#",
+ "description": "Setup flow",
+ "self": {
+ "vendor": "com.metabase",
+ "name": "setup",
+ "format": "jsonschema",
+ "version": "1-0-4"
+ },
+ "type": "object",
+ "properties": {
+ "event": {
+ "description": "Event name",
+ "type": "string",
+ "enum": [
+ "step_seen",
+ "usage_reason_selected",
+ "license_token_step_submitted",
+ "database_selected",
+ "add_data_later_clicked"
+ ],
+ "maxLength": 1024
+ },
+ "version": {
+ "description": "String describing the version of onboarding we're on",
+ "type": "string",
+ "maxLength": 1024
+ },
+ "step": {
+ "description": "String describing the step that the set up step",
+ "type": [
+ "string",
+ "null"
+ ],
+ "enum": [
+ "welcome",
+ "language",
+ "user_info",
+ "db_connection",
+ "ai_config",
+ "usage_question",
+ "license_token",
+ "db_scheduling",
+ "data_usage",
+ "completed"
+ ],
+ "maxLength": 1024
+ },
+ "step_number": {
+ "description": "Integer describing the order of the referenced step",
+ "type": [
+ "integer",
+ "null"
+ ],
+ "minimum": 0,
+ "maximum": 1024
+ },
+ "usage_reason": {
+ "description": "Answer to the usage reason question",
+ "type": [
+ "string",
+ "null"
+ ],
+ "enum": [
+ "self-service-analytics",
+ "embedding",
+ "both",
+ "not-sure"
+ ],
+ "maxLength": 1024
+ },
+ "database": {
+ "description": "String with the database type that the user selected",
+ "type": [
+ "string",
+ "null"
+ ],
+ "maxLength": 1024
+ },
+ "valid_token_present": {
+ "description": "Boolean indicating if a valid token was submitted",
+ "type": [
+ "boolean",
+ "null"
+ ]
+ },
+ "source": {
+ "description": "String with the product location that the event took place",
+ "type": [
+ "string",
+ "null"
+ ],
+ "enum": [
+ "pre_selection",
+ "post_selection"
+ ],
+ "maxLength": 1024
+ }
+ },
+ "required": [
+ "event",
+ "version"
+ ],
+ "additionalProperties": true
+}
diff --git a/src/metabase/llm/startup.clj b/src/metabase/llm/startup.clj
index 50279ae88bf..418425d3937 100644
--- a/src/metabase/llm/startup.clj
+++ b/src/metabase/llm/startup.clj
@@ -5,6 +5,7 @@
[metabase.metabot.settings :as metabot.settings]
[metabase.premium-features.core :as premium-features]
[metabase.settings.core :as setting]
+ [metabase.setup.core :as setup]
[metabase.util.log :as log]))
(set! *warn-on-reflection* true)
@@ -32,6 +33,11 @@
(defn check-and-sync-settings-on-startup!
"For legacy `:metabot-v3` customers that do not have `:metabase-ai-managed`,
switch the default unmanaged Metabot provider to the managed `metabase/...`
- provider on startup."
+ provider on startup.
+
+ This is a migration for existing instances only: it is skipped until initial
+ setup has completed, so fresh instances choose their AI provider in the setup
+ wizard instead of booting pre-configured."
[]
- (maybe-sync-managed-metabot-provider!))
+ (when (setup/has-user-setup)
+ (maybe-sync-managed-metabot-provider!)))
diff --git a/test/metabase/llm/startup_test.clj b/test/metabase/llm/startup_test.clj
index fb473c7a6e7..c2909a39607 100644
--- a/test/metabase/llm/startup_test.clj
+++ b/test/metabase/llm/startup_test.clj
@@ -13,15 +13,29 @@
(deftest check-and-sync-settings-on-startup-syncs-legacy-metabot-default-test
(mt/discard-setting-changes [llm-metabot-provider]
(mt/with-temporary-raw-setting-values [llm-metabot-provider nil]
- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
- (fn [feature]
- (case feature
- :metabot-v3 true
- :metabase-ai-managed false))
- metabot.settings/llm-metabot-configured? (constantly false)]
- (llm.startup/check-and-sync-settings-on-startup!)
- (is (= metabot.settings/default-metabase-llm-metabot-provider
- (metabot.settings/llm-metabot-provider)))))))
+ (mt/with-temporary-setting-values [has-user-setup true]
+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
+ (fn [feature]
+ (case feature
+ :metabot-v3 true
+ :metabase-ai-managed false))
+ metabot.settings/llm-metabot-configured? (constantly false)]
+ (llm.startup/check-and-sync-settings-on-startup!)
+ (is (= metabot.settings/default-metabase-llm-metabot-provider
+ (metabot.settings/llm-metabot-provider))))))))
+
+(deftest check-and-sync-settings-on-startup-skips-fresh-instances-test
+ (mt/discard-setting-changes [llm-metabot-provider]
+ (mt/with-temporary-raw-setting-values [llm-metabot-provider nil]
+ (mt/with-temporary-setting-values [has-user-setup false]
+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
+ (fn [feature]
+ (case feature
+ :metabot-v3 true
+ :metabase-ai-managed false))
+ metabot.settings/llm-metabot-configured? (constantly false)]
+ (llm.startup/check-and-sync-settings-on-startup!)
+ (is (nil? (setting/db-stored-value :llm-metabot-provider))))))))
(deftest check-and-sync-settings-on-startup-feature-permutations-test
(doseq [legacy-result [nil false true]
@@ -29,34 +43,37 @@
(testing (format ":metabot-v3=%s :metabase-ai-managed=%s" legacy-result managed-result)
(mt/discard-setting-changes [llm-metabot-provider]
(mt/with-temporary-raw-setting-values [llm-metabot-provider nil]
- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
- (fn [feature]
- (case feature
- :metabot-v3 legacy-result
- :metabase-ai-managed managed-result))
- metabot.settings/llm-metabot-configured? (constantly false)]
- (llm.startup/check-and-sync-settings-on-startup!)
- (is (= (case [legacy-result managed-result]
- [true false] metabot.settings/default-metabase-llm-metabot-provider
- nil)
- (setting/db-stored-value :llm-metabot-provider)))))))))
+ (mt/with-temporary-setting-values [has-user-setup true]
+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
+ (fn [feature]
+ (case feature
+ :metabot-v3 legacy-result
+ :metabase-ai-managed managed-result))
+ metabot.settings/llm-metabot-configured? (constantly false)]
+ (llm.startup/check-and-sync-settings-on-startup!)
+ (is (= (case [legacy-result managed-result]
+ [true false] metabot.settings/default-metabase-llm-metabot-provider
+ nil)
+ (setting/db-stored-value :llm-metabot-provider))))))))))
(deftest check-and-sync-settings-on-startup-does-not-overwrite-configured-byok-test
(mt/discard-setting-changes [llm-metabot-provider]
(mt/with-temporary-raw-setting-values [llm-metabot-provider nil]
- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
- (fn [feature]
- (case feature
- :metabot-v3 true
- :metabase-ai-managed false))
- metabot.settings/llm-metabot-configured? (constantly true)]
- (llm.startup/check-and-sync-settings-on-startup!)
- (is (= metabot.settings/default-llm-metabot-provider
- (metabot.settings/llm-metabot-provider)))))))
+ (mt/with-temporary-setting-values [has-user-setup true]
+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
+ (fn [feature]
+ (case feature
+ :metabot-v3 true
+ :metabase-ai-managed false))
+ metabot.settings/llm-metabot-configured? (constantly true)]
+ (llm.startup/check-and-sync-settings-on-startup!)
+ (is (= metabot.settings/default-llm-metabot-provider
+ (metabot.settings/llm-metabot-provider))))))))
(deftest check-and-sync-settings-on-startup-does-not-overwrite-explicit-provider-test
(mt/discard-setting-changes [llm-metabot-provider]
- (mt/with-temporary-setting-values [llm-metabot-provider "openai/gpt-4.1-mini"]
+ (mt/with-temporary-setting-values [llm-metabot-provider "openai/gpt-4.1-mini"
+ has-user-setup true]
(mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
(fn [feature]
(case feature
@@ -70,12 +87,13 @@
(deftest check-and-sync-settings-on-startup-syncs-blank-provider-test
(mt/discard-setting-changes [llm-metabot-provider]
(mt/with-temporary-raw-setting-values [llm-metabot-provider ""]
- (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
- (fn [feature]
- (case feature
- :metabot-v3 true
- :metabase-ai-managed false))
- metabot.settings/llm-metabot-configured? (constantly false)]
- (llm.startup/check-and-sync-settings-on-startup!)
- (is (= metabot.settings/default-metabase-llm-metabot-provider
- (metabot.settings/llm-metabot-provider)))))))
+ (mt/with-temporary-setting-values [has-user-setup true]
+ (mt/with-dynamic-fn-redefs [premium-features/canonically-has-feature?
+ (fn [feature]
+ (case feature
+ :metabot-v3 true
+ :metabase-ai-managed false))
+ metabot.settings/llm-metabot-configured? (constantly false)]
+ (llm.startup/check-and-sync-settings-on-startup!)
+ (is (= metabot.settings/default-metabase-llm-metabot-provider
+ (metabot.settings/llm-metabot-provider))))))))