Skip to content

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

feat: metabase as an AI provider (#71655)

Maksym Yakubychee7663ccd1b9
diff --git a/.clj-kondo/config/modules/config.edn b/.clj-kondo/config/modules/config.edn
index 5843e1eccd2..432ac2bc9a3 100644
--- a/.clj-kondo/config/modules/config.edn
+++ b/.clj-kondo/config/modules/config.edn
@@ -2957,7 +2957,8 @@
enterprise/metabot
{:team "Metabot"
- :api #{metabase-enterprise.metabot.api.routes
+ :api #{metabase-enterprise.metabot.api
+ metabase-enterprise.metabot.api.routes
metabase-enterprise.metabot.init}
:friends #{enterprise/agent-api
slackbot
@@ -2967,6 +2968,7 @@
lib-be
metabot
models
+ permissions
premium-features
settings
task
diff --git a/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj b/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj
index 2f5f897ad12..1410531c32f 100644
--- a/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj
+++ b/enterprise/backend/src/metabase_enterprise/api_routes/routes.clj
@@ -24,6 +24,7 @@
[metabase-enterprise.embedding-hub.api]
[metabase-enterprise.gsheets.api :as gsheets.api]
[metabase-enterprise.library.api]
+ [metabase-enterprise.metabot.api]
[metabase-enterprise.metabot.api.routes]
[metabase-enterprise.permission-debug.api]
[metabase-enterprise.remote-sync.api]
@@ -66,6 +67,7 @@
:tenants (deferred-tru "Tenants")
:upload-management (deferred-tru "Upload Management")
:database-routing (deferred-tru "Database Routing")
+ :metabot-v3 (deferred-tru "Metabot")
:cloud-custom-smtp (deferred-tru "Custom SMTP")
:support-users (deferred-tru "Support Users")
:transforms-python (deferred-tru "Transforms Python")
@@ -115,6 +117,7 @@
(premium-handler :etl-connections))
"/library" (premium-handler metabase-enterprise.library.api/routes :library)
"/logs" (premium-handler 'metabase-enterprise.advanced-config.api.logs :audit-app)
+ "/metabot" (premium-handler 'metabase-enterprise.metabot.api :metabot-v3)
"/permission_debug" (premium-handler metabase-enterprise.permission-debug.api/routes :advanced-permissions)
;; TODO (Ngoc 2026-03-25) -- use :transforms-advanced feature flag once it exists
"/transforms" (premium-handler metabase-enterprise.transforms.api/routes :transforms-python)
diff --git a/enterprise/backend/src/metabase_enterprise/cloud_add_ons/api.clj b/enterprise/backend/src/metabase_enterprise/cloud_add_ons/api.clj
index bfd37280cd7..b759c2c7f02 100644
--- a/enterprise/backend/src/metabase_enterprise/cloud_add_ons/api.clj
+++ b/enterprise/backend/src/metabase_enterprise/cloud_add_ons/api.clj
@@ -13,7 +13,7 @@
[metabase.util.log :as log]))
(def ^:private requires-terms-of-service?
- #{"metabase-ai" "metabase-ai-tiered"})
+ #{"metabase-ai" "metabase-ai-tiered" "metabase-ai-managed"})
(def ^:private error-no-connection
(deferred-tru "Could not establish a connection to Metabase Cloud."))
@@ -108,7 +108,7 @@
(api.macros/defendpoint :post "/:product-type"
"Purchase an add-on."
[{:keys [product-type]} :- [:map
- [:product-type [:enum "metabase-ai" "metabase-ai-tiered" "python-execution" "transforms" "transforms-basic" "transforms-advanced" "transforms-basic-metered" "transforms-advanced-metered"]]]
+ [:product-type [:enum "metabase-ai" "metabase-ai-tiered" "metabase-ai-managed" "python-execution" "transforms" "transforms-basic" "transforms-advanced" "transforms-basic-metered" "transforms-advanced-metered"]]]
_query-params
{:keys [quantity]
terms-of-service :terms_of_service} :- [:map
diff --git a/enterprise/backend/src/metabase_enterprise/metabot/api.clj b/enterprise/backend/src/metabase_enterprise/metabot/api.clj
new file mode 100644
index 00000000000..42e920d9aa0
--- /dev/null
+++ b/enterprise/backend/src/metabase_enterprise/metabot/api.clj
@@ -0,0 +1,21 @@
+(ns metabase-enterprise.metabot.api
+ "Enterprise-only Metabot API routes."
+ (:require
+ [metabase.api.macros :as api.macros]
+ [metabase.permissions.core :as perms]
+ [metabase.premium-features.core :as premium-features]))
+
+(def ^:private metabot-usage-response-schema
+ [:map
+ [:tokens [:maybe int?]]
+ [:updated-at [:maybe :string]]])
+
+(api.macros/defendpoint :get "/usage"
+ :- metabot-usage-response-schema
+ "Fetch current Metabot token usage for the current billing period."
+ [_route-params
+ _query-params]
+ (perms/check-has-application-permission :setting)
+ (let [token-status (premium-features/token-status)]
+ {:tokens (some-> token-status :meters :metabot-tokens :meter-value)
+ :updated-at (some-> token-status :meters :metabot-tokens :meter-updated-at)}))
diff --git a/enterprise/backend/test/metabase_enterprise/api/session_test.clj b/enterprise/backend/test/metabase_enterprise/api/session_test.clj
index 1ba684a4f43..1a89f015672 100644
--- a/enterprise/backend/test/metabase_enterprise/api/session_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/api/session_test.clj
@@ -29,6 +29,8 @@
:embedding-simple
:embedding-hub
:hosting
+ :metabase-ai-managed
+ :offer-metabase-ai-managed
:no-upsell
:official-collections
:query-reference-validation
@@ -75,6 +77,8 @@
:embedding_sdk true
:embedding_simple true
:hosting true
+ :metabase-ai-managed true
+ :offer-metabase-ai-managed true
:official_collections true
:query_reference_validation true
:remote_sync true
diff --git a/enterprise/backend/test/metabase_enterprise/metabot/api_test.clj b/enterprise/backend/test/metabase_enterprise/metabot/api_test.clj
index 06980eb3eab..496a122d235 100644
--- a/enterprise/backend/test/metabase_enterprise/metabot/api_test.clj
+++ b/enterprise/backend/test/metabase_enterprise/metabot/api_test.clj
@@ -44,3 +44,15 @@
(mt/with-dynamic-fn-redefs
[premium-features/premium-embedding-token (constantly nil)]
(mt/user-http-request :rasta :post 400 "metabot/feedback" {:foo "bar"})))))
+
+(deftest usage-get-returns-token-status-usage-test
+ (mt/with-premium-features #{:metabot-v3}
+ (with-redefs [premium-features/token-status (constantly {:meters {:metabot-tokens {:meter-value 12345
+ :meter-updated-at "2026-04-02T19:29:12Z"}}})]
+ (is (= {:tokens 12345
+ :updated-at "2026-04-02T19:29:12Z"}
+ (mt/user-http-request :crowberto :get 200 "ee/metabot/usage"))))))
+
+(deftest usage-permissions-test
+ (mt/with-premium-features #{:metabot-v3}
+ (mt/user-http-request :rasta :get 403 "ee/metabot/usage")))
diff --git a/enterprise/frontend/src/metabase-enterprise/api/index.ts b/enterprise/frontend/src/metabase-enterprise/api/index.ts
index f86311916fc..39aa34c4452 100644
--- a/enterprise/frontend/src/metabase-enterprise/api/index.ts
+++ b/enterprise/frontend/src/metabase-enterprise/api/index.ts
@@ -8,6 +8,7 @@ export * from "./db-routing";
export * from "./dependencies";
export * from "./gdrive";
export * from "./library";
+export * from "./metabot";
export * from "./remote-sync";
export * from "./oidc";
export * from "./replacement";
diff --git a/enterprise/frontend/src/metabase-enterprise/api/metabot.ts b/enterprise/frontend/src/metabase-enterprise/api/metabot.ts
new file mode 100644
index 00000000000..8e0855d1062
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/api/metabot.ts
@@ -0,0 +1,19 @@
+import { EnterpriseApi } from "./api";
+
+export type MetabotUsageResponse = {
+ tokens: number | null;
+ "updated-at": string | null;
+};
+
+export const metabotApi = EnterpriseApi.injectEndpoints({
+ endpoints: (builder) => ({
+ getMetabotUsage: builder.query<MetabotUsageResponse, void>({
+ query: () => ({
+ method: "GET",
+ url: "/api/ee/metabot/usage",
+ }),
+ }),
+ }),
+});
+
+export const { useGetMetabotUsageQuery } = metabotApi;
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdmin/MetabaseAIProviderSetup.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdmin/MetabaseAIProviderSetup.tsx
new file mode 100644
index 00000000000..db32486ae1b
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdmin/MetabaseAIProviderSetup.tsx
@@ -0,0 +1,318 @@
+import { useState } from "react";
+import { match } from "ts-pattern";
+import { jt, t } from "ttag";
+
+import { getErrorMessage } from "metabase/api/utils";
+import { useSetting } from "metabase/common/hooks";
+import { formatNumber } from "metabase/lib/formatting";
+import { useSelector } from "metabase/lib/redux";
+import { getStoreUsers } from "metabase/selectors/store-users";
+import {
+ Anchor,
+ Box,
+ Button,
+ Checkbox,
+ Flex,
+ Group,
+ Icon,
+ Skeleton,
+ Stack,
+ Text,
+ Title,
+ Tooltip,
+ UnstyledButton,
+} from "metabase/ui";
+import { hasPremiumFeature } from "metabase-enterprise/settings";
+
+import { useGetMetabotUsageQuery } from "../../../api";
+import {
+ METABASE_MANAGED_AI_FEATURE,
+ METABASE_MANAGED_AI_TERMS_URL,
+} from "../../constants";
+import { formatMetabaseCost } from "../../format";
+import {
+ type MetabaseManagedAiPricing,
+ useMetabaseManagedAiPricing,
+} from "../../useMetabaseManagedAiPricing";
+import { usePurchaseMetabaseManagedAi } from "../../usePurchaseMetabaseManagedAi";
+
+import { MetabotSettingUpModal } from "./MetabotSettingUpModal";
+
+type MetabaseAIProviderSetupProps = {
+ isMetabaseProviderConnected: boolean;
+ isSavingMetabaseConnection: boolean;
+ onConnect: () => Promise<void>;
+};
+
+export function MetabaseAIProviderSetup({
+ isMetabaseProviderConnected,
+ isSavingMetabaseConnection,
+ onConnect,
+}: MetabaseAIProviderSetupProps) {
+ const llmProxyConfigured = useSetting("llm-proxy-configured?");
+ const hasMetabaseManagedAiProviderFeature = !!hasPremiumFeature(
+ METABASE_MANAGED_AI_FEATURE,
+ );
+ const { isStoreUser, anyStoreUserEmailAddress } = useSelector(getStoreUsers);
+
+ const {
+ pricing: metabaseManagedAiPricing,
+ isLoading: isLoadingMetabaseManagedAiPricing,
+ } = useMetabaseManagedAiPricing(!!llmProxyConfigured);
+
+ const metabaseManagedAiPurchase = usePurchaseMetabaseManagedAi();
+
+ const [hasAcceptedTerms, setHasAcceptedTerms] = useState(false);
+ const [isSettingUpModalOpen, setIsSettingUpModalOpen] = useState(false);
+
+ const metabaseManagedAiPurchaseError = metabaseManagedAiPurchase.error
+ ? getErrorMessage(
+ metabaseManagedAiPurchase.error,
+ t`Unable to connect to this AI provider.`,
+ )
+ : undefined;
+
+ const handleMetabasePurchase = async () => {
+ setIsSettingUpModalOpen(true);
+
+ try {
+ await metabaseManagedAiPurchase.purchaseMetabaseManagedAi(
+ hasAcceptedTerms,
+ );
+ } catch {
+ setIsSettingUpModalOpen(false);
+ }
+ };
+
+ return (
+ <>
+ {isMetabaseProviderConnected ? (
+ <MetabaseManagedProviderCard
+ isLoadingPricing={isLoadingMetabaseManagedAiPricing}
+ pricing={metabaseManagedAiPricing}
+ />
+ ) : (
+ <>
+ <Stack gap="md">
+ <Title order={4}>{
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Metabase AI service
+ t`About Metabase AI service`
+ }</Title>
+ <Text>{
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Metabase AI service
+ t`The simplest way to get started with AI in Metabase. We pick a benchmarked, cost effective model for you, and billing is managed through your Metabase account.`
+ }</Text>
+ {isLoadingMetabaseManagedAiPricing ? (
+ <Group gap="xs" align="center">
+ <Skeleton h="1rem" w="14rem" />
+ <Skeleton h={14} w={14} circle />
+ </Group>
+ ) : metabaseManagedAiPricing ? (
+ <MetabasePricingText pricing={metabaseManagedAiPricing} />
+ ) : null}
+ </Stack>
+
+ {match({
+ hasMetabaseManagedAiProviderFeature,
+ isStoreUser,
+ })
+ .with({ hasMetabaseManagedAiProviderFeature: true }, () => (
+ <Button
+ loading={isSavingMetabaseConnection}
+ onClick={onConnect}
+ >{t`Connect`}</Button>
+ ))
+ .with({ isStoreUser: false }, () => (
+ <Text fw="bold">
+ {/* eslint-disable-next-line metabase/no-literal-metabase-strings -- This string only shows for admins. */}
+ {t`Please ask a Metabase Store Admin${anyStoreUserEmailAddress && ` (${anyStoreUserEmailAddress})`} of your organization to enable this for you.`}
+ </Text>
+ ))
+ .otherwise(() => (
+ <Stack gap="sm">
+ <Checkbox
+ checked={hasAcceptedTerms}
+ onChange={(event) =>
+ setHasAcceptedTerms(event.currentTarget.checked)
+ }
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Metabase AI service
+ label={jt`I agree with the Metabase AI add-on ${(
+ <Anchor
+ key="metabase-ai-terms-link"
+ href={METABASE_MANAGED_AI_TERMS_URL}
+ target="_blank"
+ >
+ {t`Terms of Service`}
+ </Anchor>
+ )}`}
+ />
+ <Button
+ disabled={!hasAcceptedTerms}
+ loading={
+ metabaseManagedAiPurchase.isLoading || isSettingUpModalOpen
+ }
+ onClick={handleMetabasePurchase}
+ >{t`Connect`}</Button>
+ </Stack>
+ ))}
+ </>
+ )}
+
+ {metabaseManagedAiPurchaseError && (
+ <Text size="sm" c="error">
+ {metabaseManagedAiPurchaseError}
+ </Text>
+ )}
+
+ <MetabotSettingUpModal
+ isSavingConfiguration={
+ isSettingUpModalOpen && isSavingMetabaseConnection
+ }
+ onActivated={onConnect}
+ opened={isSettingUpModalOpen}
+ onClose={() => setIsSettingUpModalOpen(false)}
+ />
+ </>
+ );
+}
+
+function MetabaseManagedProviderCard({
+ isLoadingPricing,
+ pricing,
+}: {
+ isLoadingPricing: boolean;
+ pricing: MetabaseManagedAiPricing | null;
+}) {
+ const { data: metabotUsage } = useGetMetabotUsageQuery();
+ const totalCost = getMetabaseUsageCost(metabotUsage?.tokens, pricing);
+
+ return (
+ <Stack gap="lg">
+ <Group align="flex-start" gap="md" wrap="nowrap">
+ <Title order={4}>{
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Metabase AI service
+ t`Connected to Metabase AI service`
+ }</Title>
+ </Group>
+
+ <Stack gap="md">
+ <Text c="text-secondary" lh="1">{t`Current billing cycle`}</Text>
+
+ <MetabaseUsageRow
+ label={t`Total tokens`}
+ value={formatNumber(metabotUsage?.tokens ?? 0)}
+ />
+
+ {isLoadingPricing ? (
+ <Flex align="center" justify="space-between" gap="md">
+ <Skeleton h="1rem" w="7rem" />
+ <Box flex={1} h={1} bg="border" />
+ <Skeleton h="1rem" w="8rem" />
+ </Flex>
+ ) : pricing ? (
+ <MetabasePricingRow pricing={pricing} />
+ ) : null}
+
+ <MetabaseUsageRow
+ label={t`Total cost`}
+ value={formatMetabaseCost(totalCost)}
+ />
+ </Stack>
+ </Stack>
+ );
+}
+
+function MetabaseUsageRow({ label, value }: { label: string; value: string }) {
+ return (
+ <Flex align="center" justify="space-between" gap="md">
+ <Text lh={1}>{label}</Text>
+ <Box
+ flex={1}
+ h={1}
+ style={{
+ alignSelf: "end",
+ borderBottom: "1px dotted var(--mb-color-border)",
+ }}
+ />
+ <Text lh={1} fw="500">
+ {value}
+ </Text>
+ </Flex>
+ );
+}
+
+function MetabasePricingRow({
+ pricing,
+}: {
+ pricing: MetabaseManagedAiPricing;
+}) {
+ return (
+ <Flex align="center" justify="space-between" gap="md">
+ <Text lh="1">
+ <Flex align="center" gap="sm">
+ {t`Price per token`}
+ <Tooltip
+ label={t`Tokens are chunks of text used by AI models. Usage includes both prompts and responses.`}
+ multiline
+ maw="20rem"
+ >
+ <UnstyledButton
+ aria-label={t`AI pricing details`}
+ data-testid="metabase-ai-pricing-details"
+ style={{ lineHeight: 0 }}
+ >
+ <Icon name="info" size={14} c="text-secondary" />
+ </UnstyledButton>
+ </Tooltip>
+ </Flex>
+ </Text>
+ <Box
+ flex={1}
+ h={1}
+ style={{
+ alignSelf: "end",
+ borderBottom: "1px dotted var(--mb-color-border)",
+ }}
+ />
+ <Text lh={1} fw="500">
+ {t`${pricing.price} per ${pricing.unit} tokens`}
+ </Text>
+ </Flex>
+ );
+}
+
+function MetabasePricingText({
+ pricing,
+}: {
+ pricing: MetabaseManagedAiPricing;
+}) {
+ return (
+ <Group gap="xs" align="center">
+ <Text lh="1">{t`Price per token - ${pricing.price} per ${pricing.unit} tokens`}</Text>
+ <Tooltip
+ label={t`Tokens are chunks of text used by AI models. Usage includes both prompts and responses.`}
+ multiline
+ maw="20rem"
+ >
+ <UnstyledButton
+ aria-label={t`AI pricing details`}
+ data-testid="metabase-ai-pricing-details"
+ style={{ lineHeight: 0 }}
+ >
+ <Icon name="info" size={14} c="text-secondary" />
+ </UnstyledButton>
+ </Tooltip>
+ </Group>
+ );
+}
+
+function getMetabaseUsageCost(
+ tokens: number | null | undefined,
+ pricing: MetabaseManagedAiPricing | null,
+) {
+ if (!tokens || !pricing) {
+ return 0;
+ }
+
+ return (tokens / pricing.unitCount) * pricing.pricePerUnit;
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdmin/MetabotSettingUpModal.tsx b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdmin/MetabotSettingUpModal.tsx
new file mode 100644
index 00000000000..557b64e66cf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/components/MetabotAdmin/MetabotSettingUpModal.tsx
@@ -0,0 +1,105 @@
+import { t } from "ttag";
+
+import { useTokenRefreshUntil } from "metabase/api/utils/use-token-refresh";
+import { MetabotLogo } from "metabase/common/components/MetabotLogo";
+import {
+ Box,
+ Button,
+ Flex,
+ Loader,
+ Modal,
+ type ModalProps,
+ Stack,
+ Text,
+ Title,
+} from "metabase/ui";
+import { hasPremiumFeature } from "metabase-enterprise/settings";
+
+import { METABASE_MANAGED_AI_FEATURE } from "../../constants";
+
+export function MetabotSettingUpModal({
+ isSavingConfiguration = false,
+ onActivated,
+ onClose,
+ opened,
+}: Pick<ModalProps, "opened" | "onClose"> & {
+ isSavingConfiguration?: boolean;
+ onActivated?: () => void | Promise<void>;
+}) {
+ const isSettingUp =
+ isSavingConfiguration || !hasPremiumFeature(METABASE_MANAGED_AI_FEATURE);
+
+ useTokenRefreshUntil(METABASE_MANAGED_AI_FEATURE, {
+ intervalMs: 1000,
+ onSatisfied: onActivated,
+ skip: !opened || !isSettingUp,
+ });
+
+ return (
+ <Modal
+ opened={opened}
+ onClose={onClose}
+ closeOnClickOutside={false}
+ closeOnEscape={false}
+ withCloseButton={false}
+ size="30rem"
+ padding="2.5rem"
+ mah="80%"
+ >
+ <Stack align="center" gap="lg" my="4.5rem">
+ <Box h={96} pos="relative" w={96}>
+ <MetabotLogo variant="cloud" alt={t`Metabot Cloud`} />
+
+ {isSettingUp && (
+ <Flex
+ bottom={0}
+ align="center"
+ direction="row"
+ gap={0}
+ justify="center"
+ pos="absolute"
+ right={0}
+ wrap="nowrap"
+ bg="white"
+ fz={0}
+ p="sm"
+ ta="center"
+ style={{
+ borderRadius: "100%",
+ boxShadow: `0 1px 6px 0 var(--mb-color-shadow)`,
+ }}
+ >
+ <Loader size="xs" ml={1} mt={1} />
+ </Flex>
+ )}
+ </Box>
+
+ {isSettingUp ? (
+ <Box ta="center">
+ <Title c="text-primary" fz="lg">
+ {t`Setting up Metabot AI, please wait`}
+ </Title>
+ <Text c="text-secondary" fz="md" lh={1.43}>
+ {t`This will take just a minute or so`}
+ </Text>
+ </Box>
+ ) : (
+ <>
+ <Box ta="center">
+ <Title c="text-primary" fz="lg">
+ {t`Metabot AI is ready`}
+ </Title>
+ <Text c="text-secondary" fz="md" lh={1.43}>
+ {t`Happy exploring!`}
+ </Text>
+ </Box>
+
+ <Button variant="filled" size="md" onClick={onClose}>
+ {t`Done`}
+ </Button>
+ </>
+ )}
+ </Stack>
+ </Modal>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts b/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts
new file mode 100644
index 00000000000..0c5e5955630
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/constants.ts
@@ -0,0 +1,5 @@
+export const METABASE_MANAGED_AI_FEATURE = "metabase-ai-managed";
+export const METABASE_MANAGED_AI_PRODUCT_TYPE = "metabase-ai-managed";
+export const METABASE_MANAGED_AI_TERMS_URL =
+ "https://www.metabase.com/license/hosting";
+export const METABASE_MANAGED_AI_UNIT_MULTIPLIER = 1_000_000;
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/format.ts b/enterprise/frontend/src/metabase-enterprise/metabot/format.ts
new file mode 100644
index 00000000000..aafe6203f90
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/format.ts
@@ -0,0 +1,10 @@
+import { formatNumber } from "metabase/lib/formatting";
+
+export function formatMetabaseCost(value: number) {
+ return formatNumber(value, {
+ currency: "USD",
+ number_style: "currency",
+ minimumFractionDigits: 2,
+ maximumFractionDigits: 2,
+ });
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/index.ts b/enterprise/frontend/src/metabase-enterprise/metabot/index.ts
new file mode 100644
index 00000000000..9ad51a50cbf
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/index.ts
@@ -0,0 +1,11 @@
+import { PLUGIN_METABOT } from "metabase/plugins";
+import { hasPremiumFeature } from "metabase-enterprise/settings";
+
+import { MetabaseAIProviderSetup } from "./components/MetabotAdmin/MetabaseAIProviderSetup";
+
+export function initializePlugin() {
+ if (hasPremiumFeature("offer-metabase-ai-managed")) {
+ PLUGIN_METABOT.isEnabled = true;
+ PLUGIN_METABOT.MetabaseAIProviderSetup = MetabaseAIProviderSetup;
+ }
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/useMetabaseManagedAiPricing.ts b/enterprise/frontend/src/metabase-enterprise/metabot/useMetabaseManagedAiPricing.ts
new file mode 100644
index 00000000000..0e07d89af0e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/useMetabaseManagedAiPricing.ts
@@ -0,0 +1,73 @@
+import { useMemo } from "react";
+
+import {
+ type FormatNumberOptions,
+ formatNumber,
+} from "metabase/lib/formatting";
+import { useListAddOnsQuery } from "metabase-enterprise/api";
+import type { GetCloudAddOnsResponse } from "metabase-types/api";
+
+import {
+ METABASE_MANAGED_AI_PRODUCT_TYPE,
+ METABASE_MANAGED_AI_UNIT_MULTIPLIER,
+} from "./constants";
+import { formatMetabaseCost } from "./format";
+
+export type MetabaseManagedAiPricing = {
+ price: string;
+ unit: string;
+ pricePerUnit: number;
+ unitCount: number;
+};
+
+type UseMetabaseManagedAiPricingResult = {
+ isLoading: boolean;
+ pricing: MetabaseManagedAiPricing | null;
+};
+
+const COMPACT_NUMBER_FORMAT_OPTIONS: FormatNumberOptions = {
+ compact: true,
+ maximumFractionDigits: 0,
+};
+
+export function useMetabaseManagedAiPricing(
+ shouldLoadMetabaseBilling: boolean,
+): UseMetabaseManagedAiPricingResult {
+ const { data: addOns, isLoading } = useListAddOnsQuery(undefined, {
+ skip: !shouldLoadMetabaseBilling,
+ });
+
+ const pricing = useMemo(() => getMetabaseManagedAiPricing(addOns), [addOns]);
+
+ return {
+ isLoading: shouldLoadMetabaseBilling && isLoading,
+ pricing,
+ };
+}
+
+function getMetabaseManagedAiPricing(
+ addOns: GetCloudAddOnsResponse | undefined,
+): MetabaseManagedAiPricing | null {
+ const addOn = addOns?.find(
+ ({ active, product_type, self_service }) =>
+ active &&
+ self_service &&
+ product_type === METABASE_MANAGED_AI_PRODUCT_TYPE,
+ );
+
+ if (addOn?.default_price_per_unit == null) {
+ return null;
+ }
+
+ const unitCount =
+ addOn.default_total_units * METABASE_MANAGED_AI_UNIT_MULTIPLIER;
+ const pricePerUnit =
+ addOn.default_price_per_unit * METABASE_MANAGED_AI_UNIT_MULTIPLIER;
+
+ return {
+ price: formatMetabaseCost(pricePerUnit),
+ unit: formatNumber(unitCount, COMPACT_NUMBER_FORMAT_OPTIONS),
+ pricePerUnit,
+ unitCount,
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/metabot/usePurchaseMetabaseManagedAi.ts b/enterprise/frontend/src/metabase-enterprise/metabot/usePurchaseMetabaseManagedAi.ts
new file mode 100644
index 00000000000..f6878ddc417
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/metabot/usePurchaseMetabaseManagedAi.ts
@@ -0,0 +1,39 @@
+import { useCallback, useMemo } from "react";
+
+import { usePurchaseCloudAddOnMutation } from "metabase-enterprise/api";
+
+import { METABASE_MANAGED_AI_PRODUCT_TYPE } from "./constants";
+
+type MetabaseManagedAiPurchaseResult = {
+ purchaseMetabaseManagedAi: (hasAcceptedTerms: boolean) => Promise<void>;
+ error: unknown | null;
+ isLoading: boolean;
+};
+
+export function usePurchaseMetabaseManagedAi(): MetabaseManagedAiPurchaseResult {
+ const [purchaseCloudAddOn, purchaseCloudAddOnResult] =
+ usePurchaseCloudAddOnMutation();
+
+ const purchaseMetabaseManagedAi = useCallback(
+ async (hasAcceptedTerms: boolean) => {
+ await purchaseCloudAddOn({
+ product_type: METABASE_MANAGED_AI_PRODUCT_TYPE,
+ terms_of_service: hasAcceptedTerms,
+ }).unwrap();
+ },
+ [purchaseCloudAddOn],
+ );
+
+ return useMemo(
+ () => ({
+ purchaseMetabaseManagedAi,
+ error: purchaseCloudAddOnResult.error,
+ isLoading: purchaseCloudAddOnResult.isLoading,
+ }),
+ [
+ purchaseCloudAddOnResult.error,
+ purchaseCloudAddOnResult.isLoading,
+ purchaseMetabaseManagedAi,
+ ],
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/plugins.ts b/enterprise/frontend/src/metabase-enterprise/plugins.ts
index 6dad7dcc701..ad43d20ba50 100644
--- a/enterprise/frontend/src/metabase-enterprise/plugins.ts
+++ b/enterprise/frontend/src/metabase-enterprise/plugins.ts
@@ -30,6 +30,7 @@ import { initializePlugin as initializeEmbeddingIframeSdk } from "./embedding_if
import { initializePlugin as initializeEmbeddingIframeSdkSetup } from "./embedding_iframe_sdk_setup";
import { initializePlugin as initializeFeatureLevelPermissions } from "./feature_level_permissions";
import { initializePlugin as initializeGroupManagers } from "./group_managers";
+import { initializePlugin as initializeMetabot } from "./metabot";
import { initializePlugin as initializeModelPersistence } from "./model_persistence";
import { initializePlugin as initializeModeration } from "./moderation";
import { initializePlugin as initializeRemoteSync } from "./remote_sync";
@@ -78,6 +79,7 @@ export function initializePlugins() {
initializeModeration();
initializeAdvancedPermissions();
initializeAuditApp();
+ initializeMetabot();
initializeModelPersistence();
initializeFeatureLevelPermissions();
initializeApplicationPermissions();
diff --git a/frontend/src/metabase-types/api/cloud-add-ons.ts b/frontend/src/metabase-types/api/cloud-add-ons.ts
index d705eccb5b7..d7d0c3605b6 100644
--- a/frontend/src/metabase-types/api/cloud-add-ons.ts
+++ b/frontend/src/metabase-types/api/cloud-add-ons.ts
@@ -2,6 +2,7 @@ export interface PurchaseCloudAddOnRequest {
product_type:
| "metabase-ai"
| "metabase-ai-tiered"
+ | "metabase-ai-managed"
| "python-execution"
| "transforms-basic"
| "transforms-advanced";
diff --git a/frontend/src/metabase-types/api/mocks/settings.ts b/frontend/src/metabase-types/api/mocks/settings.ts
index 70797351f8c..2fd0de61c5c 100644
--- a/frontend/src/metabase-types/api/mocks/settings.ts
+++ b/frontend/src/metabase-types/api/mocks/settings.ts
@@ -112,6 +112,8 @@ export const createMockTokenFeatures = (
etl_connections: false,
etl_connections_pg: false,
hosting: false,
+ "metabase-ai-managed": false,
+ "offer-metabase-ai-managed": false,
official_collections: false,
sandboxes: false,
scim: false,
diff --git a/frontend/src/metabase-types/api/settings.ts b/frontend/src/metabase-types/api/settings.ts
index 189ddfe4935..628731a2fbe 100644
--- a/frontend/src/metabase-types/api/settings.ts
+++ b/frontend/src/metabase-types/api/settings.ts
@@ -264,6 +264,7 @@ const tokenStatusFeatures = [
"embedding-simple",
"embedding-hub",
"hosting",
+ "metabase-ai-managed",
"metabase-store-managed",
"no-upsell",
"official-collections",
@@ -327,6 +328,8 @@ export const tokenFeatures = [
"embedding_sdk",
"embedding_simple",
"hosting",
+ "offer-metabase-ai-managed",
+ "metabase-ai-managed",
"official_collections",
"sandboxes",
"scim",
@@ -782,6 +785,7 @@ export interface EnterpriseSettings extends Settings {
"llm-metabot-provider"?: string | null;
"llm-anthropic-api-key"?: string | null;
"llm-anthropic-model": string;
+ "llm-proxy-configured?"?: boolean | null;
"metabot-slack-signing-secret"?: string | null;
"slack-connect-enabled"?: boolean | null;
"slack-connect-client-id"?: string | null;
diff --git a/frontend/src/metabase/api/utils/use-token-refresh.ts b/frontend/src/metabase/api/utils/use-token-refresh.ts
index 01e30ffd043..12b7efc7510 100644
--- a/frontend/src/metabase/api/utils/use-token-refresh.ts
+++ b/frontend/src/metabase/api/utils/use-token-refresh.ts
@@ -1,4 +1,4 @@
-import { useCallback, useEffect } from "react";
+import { useCallback, useEffect, useRef } from "react";
import {
Api,
@@ -45,24 +45,43 @@ export function useTokenRefreshUntil(
tokenFeature: TokenStatusFeature,
{
intervalMs = REFRESH_INTERVAL,
+ onSatisfied,
skip = false,
- }: { intervalMs?: number; skip?: boolean },
+ }: {
+ intervalMs?: number;
+ onSatisfied?: () => void | Promise<void>;
+ skip?: boolean;
+ },
) {
/* in order to force this hook to re-run on every request, even if the response data is the same, we can't destructure only the data prop from this hook, as is the pattern in many components */
const res = useGetSettingsQuery();
const dispatch = useDispatch();
const [refreshTokenStatus] = useRefreshTokenStatusMutation();
+ const hasCalledOnSatisfied = useRef(false);
+
+ if (skip) {
+ hasCalledOnSatisfied.current = false;
+ }
const refreshToken = useCallback(async () => {
// Bust the server-side cache first; the mutation's invalidatesTags will
// also invalidate session-properties on success, but we do it in finally
// too so the UI updates even if the request fails.
try {
- await refreshTokenStatus().unwrap();
+ const status = await refreshTokenStatus().unwrap();
+
+ if (
+ onSatisfied &&
+ !hasCalledOnSatisfied.current &&
+ status.features?.includes(tokenFeature)
+ ) {
+ hasCalledOnSatisfied.current = true;
+ onSatisfied();
+ }
} finally {
dispatch(Api.util.invalidateTags(["session-properties"]));
}
- }, [dispatch, refreshTokenStatus]);
+ }, [dispatch, onSatisfied, refreshTokenStatus, tokenFeature]);
useEffect(() => {
if (skip) {
diff --git a/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.tsx b/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.tsx
index 53d933c3b91..3d8bcf7281a 100644
--- a/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.tsx
+++ b/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
import { t } from "ttag";
import _ from "underscore";
@@ -15,6 +15,7 @@ import {
useAdminSettings,
} from "metabase/api/utils";
import { useSetting } from "metabase/common/hooks";
+import { PLUGIN_METABOT } from "metabase/plugins";
import {
Badge,
type ComboboxItem,
@@ -44,15 +45,33 @@ type MetabotModelOption = ComboboxItem & {
group?: string | null;
};
+function getModelDescription(provider: MetabotProvider | undefined) {
+ if (provider === "metabase") {
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Metabase AI service
+ return t`Available models are provided by Metabase.`;
+ }
+
+ return t`Available models are fetched from the selected provider using its configured API key.`;
+}
+
export function MetabotSetup() {
+ const MetabaseAIProviderSetup = PLUGIN_METABOT.MetabaseAIProviderSetup;
+ const offerMetabaseAiManaged = PLUGIN_METABOT.isEnabled;
+
const { value, settingDetails } = useAdminSetting("llm-metabot-provider");
- const config = useMemo(() => parseProviderAndModel(value), [value]);
const isEnvSetting =
!!settingDetails &&
!!settingDetails.is_env_setting &&
!!settingDetails.env_name;
const envSettingName = isEnvSetting ? settingDetails?.env_name : undefined;
+ const [updateMetabotSettings, updateMetabotSettingsResult] =
+ useUpdateMetabotSettingsMutation();
+ const savedProviderValue = updateMetabotSettingsResult.data?.value ?? value;
+ const config = useMemo(
+ () => parseProviderAndModel(savedProviderValue),
+ [savedProviderValue],
+ );
const [provider, setProvider] = useState<MetabotProvider | undefined>(
config?.provider,
);
@@ -62,11 +81,13 @@ export function MetabotSetup() {
setModel(config?.model ?? "");
}, [config]);
+ const handleMetabaseConnect = useCallback(async () => {
+ await updateMetabotSettings({ provider: "metabase", model: "" });
+ }, [updateMetabotSettings]);
+
const metabotSettingsQuery = useGetMetabotSettingsQuery(
- provider ? { provider } : skipToken,
+ provider && provider !== "metabase" ? { provider } : skipToken,
);
- const [updateMetabotSettings, updateMetabotSettingsResult] =
- useUpdateMetabotSettingsMutation();
const isConfigured = useSetting("llm-metabot-configured?");
const { details: providerApiKeyDetails } = useAdminSettings([
@@ -76,12 +97,12 @@ export function MetabotSetup() {
] as const);
const providerOptions = useMemo(() => {
- const options = Object.values(getProviderOptions(false));
+ const options = Object.values(getProviderOptions(offerMetabaseAiManaged));
return options.map((o) => ({
...o,
disabled: !isAvailableProvider(o.value),
}));
- }, []);
+ }, [offerMetabaseAiManaged]);
const modelOptions = useMemo(
() => getLlmModelOptions(metabotSettingsQuery.currentData?.models ?? []),
@@ -113,11 +134,15 @@ export function MetabotSetup() {
}
};
- const isConnected =
+ const isConnected = Boolean(
!updateMetabotSettingsResult.isLoading &&
- config?.provider &&
- config?.model &&
- isConfigured;
+ config?.provider &&
+ config?.model &&
+ isConfigured,
+ );
+ const isMetabaseProviderConnected = Boolean(
+ isConnected && provider === "metabase" && config?.provider === "metabase",
+ );
const selectedApiKeySetting =
provider && isApiKeyMetabotProvider(provider)
@@ -128,6 +153,8 @@ export function MetabotSetup() {
!!provider &&
!!selectedApiKeySetting &&
(!hasConfiguredSettingValue(selectedApiKeySetting) || !!apiKeyError);
+ const showModelSelector =
+ !needsApiKey && !isMetabaseProviderConnected && provider !== "metabase";
return (
<SettingsSection
@@ -150,7 +177,7 @@ export function MetabotSetup() {
)}
</Flex>
}
- description={t`Select your AI provider and configure your API key to get started with Metabot.`}
+ description={t`Select your AI provider to get started with Metabot.`}
>
<Stack gap="md">
<Select
@@ -181,11 +208,19 @@ export function MetabotSetup() {
)}
/>
+ {provider === "metabase" && (
+ <MetabaseAIProviderSetup
+ isMetabaseProviderConnected={isMetabaseProviderConnected}
+ isSavingMetabaseConnection={updateMetabotSettingsResult.isLoading}
+ onConnect={handleMetabaseConnect}
+ />
+ )}
+
{provider && isApiKeyMetabotProvider(provider) && (
<MetabotProviderApiKey provider={provider} error={apiKeyError} />
)}
- {!needsApiKey && (
+ {showModelSelector && (
<Select
label={t`Model`}
placeholder={
@@ -195,7 +230,7 @@ export function MetabotSetup() {
: t`Select a model`
: t`Select a provider first`
}
- description={t`Available models are fetched from the selected provider using its configured API key.`}
+ description={getModelDescription(provider)}
error={modelError}
data={modelOptions}
value={model}
diff --git a/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.unit.spec.tsx b/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.unit.spec.tsx
index 8faf88734b3..f88e1ea5a0d 100644
--- a/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.unit.spec.tsx
+++ b/frontend/src/metabase/metabot/components/MetabotAdmin/MetabotSetup.unit.spec.tsx
@@ -2,20 +2,27 @@ import userEvent from "@testing-library/user-event";
import fetchMock from "fetch-mock";
import { Route } from "react-router";
+import { setupEnterpriseOnlyPlugin } from "__support__/enterprise";
import {
+ setupBillingEndpoints,
+ setupMetabaseManagedAiEndpoints,
setupPropertiesEndpoints,
setupSettingsEndpoints,
} from "__support__/server-mocks";
-import { renderWithProviders, screen, waitFor } from "__support__/ui";
+import { mockSettings } from "__support__/settings";
+import { act, renderWithProviders, screen, waitFor } from "__support__/ui";
+import { reinitialize } from "metabase/plugins";
import type {
MetabotProvider,
MetabotSettingsResponse,
+ TokenStatusFeature,
} from "metabase-types/api";
import {
createMockSettingDefinition,
createMockSettings,
+ createMockTokenFeatures,
+ createMockTokenStatus,
} from "metabase-types/api/mocks";
-import { createMockSettingsState } from "metabase-types/store/mocks";
import { MetabotSetup } from "./MetabotSetup";
import type { MetabotApiKeyProvider } from "./utils";
@@ -37,11 +44,20 @@ jest.mock("./MetabotProviderApiKey", () => ({
const DEFAULT_RESPONSES: Record<MetabotProvider, MetabotSettingsResponse> = {
metabase: {
- value: "metabase/smart",
+ value: "metabase/anthropic/claude-sonnet-4-6",
models: [
- { id: "fast", display_name: "Fast" },
- { id: "smart", display_name: "Smart" },
- { id: "genius", display_name: "Genius" },
+ {
+ id: "anthropic/claude-haiku-4-5",
+ display_name: "Claude Haiku 4.5",
+ },
+ {
+ id: "anthropic/claude-sonnet-4-6",
+ display_name: "Claude Sonnet 4.6",
+ },
+ {
+ id: "anthropic/claude-opus-4-1",
+ display_name: "Claude Opus 4.1",
+ },
],
},
anthropic: {
@@ -78,12 +94,26 @@ const DEFAULT_RESPONSES: Record<MetabotProvider, MetabotSettingsResponse> = {
},
};
+type MetabotUsageQuota = {
+ tokens: number | null;
+ updated_at: string | null;
+};
+
type SetupOptions = {
isHosted?: boolean;
+ llmProxyConfigured?: boolean;
savedProviderValue?: string | null;
isConfigured?: boolean;
providerSettingIsEnv?: boolean;
providerSettingEnvName?: string;
+ isStoreUser?: boolean;
+ anyStoreUserEmailAddress?: string;
+ metabasePricePerUnit?: number;
+ metabaseBillingPeriodMonths?: number;
+ metabotUsageQuotas?: MetabotUsageQuota[] | null;
+ tokenStatusFeatures?: TokenStatusFeature[];
+ refreshedTokenStatusFeatures?: TokenStatusFeature[];
+ purchaseCloudAddOnResponse?: number | { status: number; body: unknown };
apiKeyValues?: Partial<Record<MetabotProvider, string | null>>;
responses?: Partial<
Record<
@@ -96,10 +126,19 @@ type SetupOptions = {
async function setup({
isHosted = false,
+ llmProxyConfigured = isHosted,
savedProviderValue = "anthropic/claude-haiku-4-5",
isConfigured = true,
providerSettingIsEnv = false,
providerSettingEnvName = "LLM_METABOT_PROVIDER",
+ isStoreUser = isHosted,
+ anyStoreUserEmailAddress = "[email protected]",
+ metabasePricePerUnit = 3.75,
+ metabaseBillingPeriodMonths = 1,
+ metabotUsageQuotas = null,
+ tokenStatusFeatures = [],
+ refreshedTokenStatusFeatures = tokenStatusFeatures,
+ purchaseCloudAddOnResponse = 200,
apiKeyValues,
responses,
updateResponse = {
@@ -117,13 +156,29 @@ async function setup({
...apiKeyValues,
};
- setupPropertiesEndpoints(
- createMockSettings({
- "is-hosted?": isHosted,
- "llm-metabot-provider": savedProviderValue,
- "llm-metabot-configured?": isConfigured,
+ const sessionProperties = createMockSettings({
+ "is-hosted?": isHosted,
+ "llm-proxy-configured?": llmProxyConfigured,
+ "llm-metabot-provider": savedProviderValue,
+ "llm-metabot-configured?": isConfigured,
+ "token-features": createMockTokenFeatures({
+ hosting: isHosted,
+ "offer-metabase-ai-managed": isHosted,
+ "metabase-ai-managed": tokenStatusFeatures.includes(
+ "metabase-ai-managed",
+ ),
}),
- );
+ "token-status": createMockTokenStatus({
+ features: tokenStatusFeatures,
+ "store-users": isStoreUser
+ ? [{ email: "[email protected]" }]
+ : anyStoreUserEmailAddress
+ ? [{ email: anyStoreUserEmailAddress }]
+ : [],
+ }),
+ });
+
+ setupPropertiesEndpoints(sessionProperties);
setupSettingsEndpoints([
createMockSettingDefinition({
@@ -148,6 +203,39 @@ async function setup({
const responseMap = { ...DEFAULT_RESPONSES, ...responses };
+ if (isHosted) {
+ setupBillingEndpoints({
+ billingPeriodMonths: metabaseBillingPeriodMonths,
+ hasBasicTransformsAddOn: false,
+ hasAdvancedTransformsAddOn: false,
+ skipCloudAddOns: true,
+ });
+ setupMetabaseManagedAiEndpoints({
+ billingPeriodMonths: metabaseBillingPeriodMonths,
+ metabasePricePerUnit,
+ metabotUsageQuota: metabotUsageQuotas?.[0] ?? null,
+ purchaseCloudAddOnResponse,
+ });
+
+ fetchMock.post("path:/api/premium-features/token/refresh", () => {
+ sessionProperties["token-features"] = createMockTokenFeatures({
+ hosting: isHosted,
+ "offer-metabase-ai-managed": isHosted,
+ "metabase-ai-managed": refreshedTokenStatusFeatures.includes(
+ "metabase-ai-managed",
+ ),
+ });
+ sessionProperties["token-status"] = createMockTokenStatus({
+ features: refreshedTokenStatusFeatures,
+ });
+
+ return sessionProperties["token-status"];
+ });
+ }
+
+ const settings = mockSettings(sessionProperties);
+ setupEnterpriseOnlyPlugin("metabot");
+
for (const provider of Object.keys(responseMap) as MetabotProvider[]) {
const response = responseMap[provider];
@@ -158,7 +246,12 @@ async function setup({
});
}
- fetchMock.put("path:/api/metabot/settings", updateResponse);
+ fetchMock.put("path:/api/metabot/settings", () => {
+ sessionProperties["llm-metabot-provider"] = updateResponse.value;
+ sessionProperties["llm-metabot-configured?"] = true;
+
+ return updateResponse;
+ });
const { history } = renderWithProviders(
<Route path="/admin/metabot*" component={MetabotSetup} />,
@@ -166,9 +259,7 @@ async function setup({
withRouter: true,
initialRoute: "/admin/metabot/setup",
storeInitialState: {
- settings: createMockSettingsState({
- "is-hosted?": isHosted,
- }),
+ settings,
},
},
);
@@ -185,7 +276,16 @@ async function openModelSelector() {
await userEvent.keyboard("{ArrowDown}");
}
+async function selectProvider(name: string) {
+ await userEvent.click(screen.getByLabelText("Provider"));
+ await userEvent.click(await screen.findByRole("option", { name }));
+}
+
describe("MetabotSetup", () => {
+ afterEach(() => {
+ reinitialize();
+ });
+
it("shows the env var message and disables both provider and model inputs when provider is env-backed", async () => {
await setup({
providerSettingIsEnv: true,
@@ -357,6 +457,252 @@ describe("MetabotSetup", () => {
expect(screen.queryByLabelText("Model")).not.toBeInTheDocument();
});
+ it("shows the connected Metabase-managed state without an API key or model picker", async () => {
+ await setup({
+ isHosted: true,
+ savedProviderValue: "metabase/anthropic/claude-sonnet-4-6",
+ });
+
+ expect(
+ await screen.findByText("Current billing cycle"),
+ ).toBeInTheDocument();
+ expect(screen.queryByText(/Provider API key:/)).not.toBeInTheDocument();
+ expect(screen.queryByLabelText("Model")).not.toBeInTheDocument();
+ });
+
+ it("shows pricing details in a tooltip for the Metabase provider", async () => {
+ await setup({
+ isHosted: true,
+ savedProviderValue: "metabase/anthropic/claude-sonnet-4-6",
+ isConfigured: false,
+ });
+
+ await screen.findByText("About Metabase AI service");
+ await screen.findByTestId("metabase-ai-pricing-details");
+
+ await userEvent.hover(screen.getByTestId("metabase-ai-pricing-details"));
+
+ expect(
+ await screen.findByText(
+ "Tokens are chunks of text used by AI models. Usage includes both prompts and responses.",
+ ),
+ ).toBeInTheDocument();
+
+ expect(
+ screen.getByRole("link", { name: "Terms of Service" }),
+ ).toHaveAttribute("href", "https://www.metabase.com/license/hosting");
+ });
+
+ it("shows a contact-admin notice for non-store users on the Metabase provider", async () => {
+ await setup({
+ isHosted: true,
+ savedProviderValue: "metabase/anthropic/claude-sonnet-4-6",
+ isConfigured: false,
+ isStoreUser: false,
+ anyStoreUserEmailAddress: "[email protected]",
+ });
+
+ expect(
+ await screen.findByText(
+ "Please ask a Metabase Store Admin ([email protected]) of your organization to enable this for you.",
+ ),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "Accept terms & connect" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("shows a direct connect button when the Metabase provider feature is already enabled", async () => {
+ const user = userEvent.setup();
+
+ await setup({
+ isHosted: true,
+ savedProviderValue: "anthropic/claude-haiku-4-5",
+ isConfigured: true,
+ isStoreUser: false,
+ tokenStatusFeatures: ["metabase-ai-managed"],
+ updateResponse: {
+ value: "metabase/anthropic/claude-sonnet-4-6",
+ models: DEFAULT_RESPONSES.metabase.models,
+ },
+ });
+
+ await selectProvider("Metabase");
+
+ const connectButton = await screen.findByRole("button", {
+ name: "Connect",
+ });
+
+ expect(
+ screen.queryByRole("checkbox", {
+ name: /I agree with the Metabase AI add-on/i,
+ }),
+ ).not.toBeInTheDocument();
+
+ await user.click(connectButton);
+
+ await waitFor(() => {
+ expect(fetchMock.callHistory.called("path:/api/metabot/settings")).toBe(
+ true,
+ );
+ });
+
+ expect(
+ fetchMock.callHistory.called(
+ "path:/api/ee/cloud-add-ons/metabase-ai-managed",
+ ),
+ ).toBe(false);
+
+ const settingsRequest = fetchMock.callHistory
+ .calls("path:/api/metabot/settings")
+ .find((call) => call.request?.method === "PUT");
+
+ expect(settingsRequest?.options?.body).toBe(
+ JSON.stringify({ provider: "metabase", model: "" }),
+ );
+ });
+
+ it("polls until the Metabase provider feature is enabled, then saves the default Metabase model", async () => {
+ try {
+ jest.useFakeTimers({ advanceTimers: true });
+ const user = userEvent.setup({
+ advanceTimers: jest.advanceTimersByTime,
+ });
+
+ await setup({
+ isHosted: true,
+ savedProviderValue: "metabase/anthropic/claude-sonnet-4-6",
+ isConfigured: false,
+ isStoreUser: true,
+ tokenStatusFeatures: [],
+ refreshedTokenStatusFeatures: ["metabase-ai-managed"],
+ updateResponse: {
+ value: "metabase/anthropic/claude-sonnet-4-6",
+ models: DEFAULT_RESPONSES.metabase.models,
+ },
+ });
+
+ const termsCheckbox = await screen.findByRole("checkbox", {
+ name: /I agree with the Metabase AI add-on/i,
+ });
+ const connectButton = await screen.findByRole("button", {
+ name: "Connect",
+ });
+
+ expect(connectButton).toBeDisabled();
+ expect(screen.queryByLabelText("Model")).not.toBeInTheDocument();
+
+ await user.click(termsCheckbox);
+
+ expect(connectButton).toBeEnabled();
+
+ await user.click(connectButton);
+
+ expect(connectButton).toBeDisabled();
+ expect(
+ await screen.findByText("Setting up Metabot AI, please wait"),
+ ).toBeInTheDocument();
+
+ await waitFor(() => {
+ expect(
+ fetchMock.callHistory.called(
+ "path:/api/ee/cloud-add-ons/metabase-ai-managed",
+ ),
+ ).toBe(true);
+ });
+
+ const request = fetchMock.callHistory
+ .calls("path:/api/ee/cloud-add-ons/metabase-ai-managed")
+ .find((call) => call.request?.method === "POST");
+
+ expect(request?.options?.body).toBe(
+ JSON.stringify({ terms_of_service: true }),
+ );
+
+ await Promise.resolve();
+
+ act(() => {
+ jest.advanceTimersByTime(11 * 1000);
+ });
+
+ await waitFor(() => {
+ expect(
+ fetchMock.callHistory.called(
+ "path:/api/premium-features/token/refresh",
+ ),
+ ).toBe(true);
+ });
+
+ await waitFor(() => {
+ expect(
+ fetchMock.callHistory
+ .calls("path:/api/metabot/settings")
+ .some(
+ (call) =>
+ call.request?.method === "PUT" ||
+ call.options?.method === "PUT",
+ ),
+ ).toBe(true);
+ });
+
+ expect(
+ await screen.findByText("Metabot AI is ready"),
+ ).toBeInTheDocument();
+ expect(screen.queryByLabelText("Model")).not.toBeInTheDocument();
+ expect(
+ screen.queryByRole("button", { name: "Connect" }),
+ ).not.toBeInTheDocument();
+
+ const settingsRequest = fetchMock.callHistory
+ .calls("path:/api/metabot/settings")
+ .find(
+ (call) =>
+ call.request?.method === "PUT" || call.options?.method === "PUT",
+ );
+
+ expect(settingsRequest?.options?.body).toBe(
+ JSON.stringify({ provider: "metabase", model: "" }),
+ );
+ } finally {
+ jest.useRealTimers();
+ }
+ });
+
+ it("shows live pricing for the Metabase provider", async () => {
+ await setup({
+ isHosted: true,
+ savedProviderValue: "metabase/anthropic/claude-sonnet-4-6",
+ metabasePricePerUnit: 4.25,
+ });
+
+ expect(await screen.findByText("Price per token")).toBeInTheDocument();
+ expect(screen.getByText("$4.25 per 1M tokens")).toBeInTheDocument();
+ });
+
+ it("shows usage summary for the connected Metabase provider", async () => {
+ const updatedAt = "2026-04-02T19:29:12Z";
+ await setup({
+ isHosted: true,
+ savedProviderValue: "metabase/anthropic/claude-sonnet-4-6",
+ metabasePricePerUnit: 4.25,
+ metabotUsageQuotas: [
+ {
+ tokens: 250000,
+ updated_at: updatedAt,
+ },
+ ],
+ });
+
+ expect(
+ await screen.findByText("Current billing cycle"),
+ ).toBeInTheDocument();
+ expect(await screen.findByText("250,000")).toBeInTheDocument();
+ expect(screen.queryByText("Unavailable")).not.toBeInTheDocument();
+ expect(screen.getByText("Total tokens")).toBeInTheDocument();
+ expect(screen.getByText("Total cost")).toBeInTheDocument();
+ expect(screen.getByText("$1.06")).toBeInTheDocument();
+ });
+
it("saves when picking a model from the model picker", async () => {
await setup();
await screen.findByLabelText("Model");
diff --git a/frontend/src/metabase/metabot/components/MetabotAdmin/utils.ts b/frontend/src/metabase/metabot/components/MetabotAdmin/utils.ts
index 5279ec957ee..1bff5589a20 100644
--- a/frontend/src/metabase/metabot/components/MetabotAdmin/utils.ts
+++ b/frontend/src/metabase/metabot/components/MetabotAdmin/utils.ts
@@ -84,7 +84,7 @@ export function isApiKeyMetabotProvider(
}
export function isAvailableProvider(provider: MetabotProvider): boolean {
- return provider === "anthropic";
+ return provider === "anthropic" || provider === "metabase";
}
export const API_KEY_SETTING_BY_PROVIDER: Record<
diff --git a/frontend/src/metabase/plugins/index.ts b/frontend/src/metabase/plugins/index.ts
index d7a7218f43c..3bb5fd2a4a3 100644
--- a/frontend/src/metabase/plugins/index.ts
+++ b/frontend/src/metabase/plugins/index.ts
@@ -74,6 +74,7 @@ export {
type PublishTablesModalProps,
type UnpublishTablesModalProps,
} from "./oss/library";
+export { PLUGIN_METABOT } from "./oss/metabot";
export { PLUGIN_MODEL_PERSISTENCE } from "./oss/model-persistence";
export {
PLUGIN_MODERATION,
@@ -177,6 +178,7 @@ import { reinitialize as reinitializeEmbeddingIframeSdkSetup } from "./oss/embed
import { reinitialize as reinitializeEmbeddingSdk } from "./oss/embedding-sdk";
import { reinitialize as reinitializeEntities } from "./oss/entities";
import { reinitialize as reinitializeLibrary } from "./oss/library";
+import { reinitialize as reinitializeMetabot } from "./oss/metabot";
import { reinitialize as reinitializeModelPersistence } from "./oss/model-persistence";
import { reinitialize as reinitializeModeration } from "./oss/moderation";
import { reinitialize as reinitializePermissions } from "./oss/permissions";
@@ -217,6 +219,7 @@ export function reinitialize() {
reinitializeEmbeddingSdk();
reinitializeEntities();
reinitializeLibrary();
+ reinitializeMetabot();
reinitializeModelPersistence();
reinitializeModeration();
reinitializePermissions();
diff --git a/frontend/src/metabase/plugins/oss/metabot.ts b/frontend/src/metabase/plugins/oss/metabot.ts
new file mode 100644
index 00000000000..672e7811ed3
--- /dev/null
+++ b/frontend/src/metabase/plugins/oss/metabot.ts
@@ -0,0 +1,27 @@
+import type { ComponentType } from "react";
+
+import { PluginPlaceholder } from "metabase/plugins/components/PluginPlaceholder";
+
+type MetabaseAIProviderSetupProps = {
+ isMetabaseProviderConnected: boolean;
+ isSavingMetabaseConnection: boolean;
+ onConnect: () => Promise<void>;
+};
+
+const getDefaultPluginMetabot = () => ({
+ isEnabled: false,
+ MetabaseAIProviderSetup:
+ PluginPlaceholder as ComponentType<MetabaseAIProviderSetupProps>,
+});
+
+export const PLUGIN_METABOT: {
+ isEnabled: boolean;
+ MetabaseAIProviderSetup: ComponentType<MetabaseAIProviderSetupProps>;
+} = getDefaultPluginMetabot();
+
+/**
+ * @internal Do not call directly. Use the main reinitialize function from metabase/plugins instead.
+ */
+export function reinitialize() {
+ Object.assign(PLUGIN_METABOT, getDefaultPluginMetabot());
+}
diff --git a/frontend/test/__support__/enterprise-typed.ts b/frontend/test/__support__/enterprise-typed.ts
index 99081834278..00068fc8929 100644
--- a/frontend/test/__support__/enterprise-typed.ts
+++ b/frontend/test/__support__/enterprise-typed.ts
@@ -11,7 +11,7 @@ export const ENTERPRISE_PLUGIN_NAME_MAPPING = {
tools: "metabase-enterprise/tools",
advanced_permissions: "metabase-enterprise/advanced_permissions",
sharing: "metabase-enterprise/sharing",
- metabot: "metabase/metabot",
+ metabot: "metabase-enterprise/metabot",
rich_text_editing: "metabase-enterprise/rich_text_editing",
license: "metabase-enterprise/license",
user_provisioning: "metabase-enterprise/user_provisioning",
diff --git a/frontend/test/__support__/server-mocks/metabot.ts b/frontend/test/__support__/server-mocks/metabot.ts
index 0862bf326bf..243a4806830 100644
--- a/frontend/test/__support__/server-mocks/metabot.ts
+++ b/frontend/test/__support__/server-mocks/metabot.ts
@@ -8,6 +8,7 @@ import type {
MetabotInstanceLimit,
MetabotSettingsResponse,
MetabotTenantLimit,
+ PurchaseCloudAddOnRequest,
SuggestedMetabotPrompt,
SuggestedMetabotPromptsResponse,
UpdateMetabotSettingsRequest,
@@ -15,6 +16,10 @@ import type {
} from "metabase-types/api";
import { createMockUserMetabotPermissions } from "metabase-types/api/mocks/metabot";
+const METABASE_MANAGED_AI_PRODUCT_TYPE: PurchaseCloudAddOnRequest["product_type"] =
+ "metabase-ai-managed";
+const METABASE_MANAGED_AI_UNIT_MULTIPLIER = 1_000_000;
+
export function setupMetabotsEndpoints(
metabots: MetabotInfo[],
statusCode?: number,
@@ -154,6 +159,60 @@ export function setupUpdateMetabotSettingsEndpointWithError(
fetchMock.put("path:/api/metabot/settings", { status, body });
}
+type SetupMetabaseManagedAiEndpointsOptions = {
+ billingPeriodMonths?: number;
+ metabasePricePerUnit?: number;
+ metabotUsageQuota?: {
+ tokens: number | null;
+ updated_at: string | null;
+ } | null;
+ purchaseCloudAddOnResponse?: number | { status: number; body: unknown };
+};
+
+export function setupMetabaseManagedAiEndpoints({
+ billingPeriodMonths = 1,
+ metabasePricePerUnit = 3.75,
+ metabotUsageQuota = null,
+ purchaseCloudAddOnResponse = 200,
+}: SetupMetabaseManagedAiEndpointsOptions = {}) {
+ fetchMock.get("path:/api/ee/metabot/usage", {
+ tokens: metabotUsageQuota?.tokens ?? null,
+ updated_at: metabotUsageQuota?.updated_at ?? null,
+ });
+
+ fetchMock.get("path:/api/ee/cloud-add-ons/addons", [
+ {
+ id: 1,
+ active: true,
+ self_service: true,
+ deployment: "cloud",
+ billing_period_months: billingPeriodMonths,
+ default_base_fee: 0,
+ default_included_units: 0,
+ default_prepaid_units: 1,
+ // The API returns a per-token price; tests pass a per-1M-tokens price.
+ default_price_per_unit:
+ metabasePricePerUnit / METABASE_MANAGED_AI_UNIT_MULTIPLIER,
+ default_total_units: 1,
+ description: null,
+ is_metered: true,
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Used for fetch mock only
+ name: "Metabase AI",
+ product_tiers: [],
+ product_type: METABASE_MANAGED_AI_PRODUCT_TYPE,
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- Used for fetch mock only
+ short_name: "Metabase AI",
+ token_features: [],
+ trial_days: null,
+ },
+ ]);
+
+ fetchMock.post(
+ `path:/api/ee/cloud-add-ons/${METABASE_MANAGED_AI_PRODUCT_TYPE}`,
+ purchaseCloudAddOnResponse,
+ );
+}
+
const METABOT_GROUP_PERMISSIONS_ROUTE_NAME = "metabot-group-permissions";
export function setupMetabotGroupPermissionsEndpoint(
diff --git a/frontend/test/__support__/server-mocks/store.ts b/frontend/test/__support__/server-mocks/store.ts
index 196f572d8d9..52f82856b91 100644
--- a/frontend/test/__support__/server-mocks/store.ts
+++ b/frontend/test/__support__/server-mocks/store.ts
@@ -7,6 +7,7 @@ export function setupBillingEndpoints({
billingPeriodMonths = 12,
hasBasicTransformsAddOn = true,
hasAdvancedTransformsAddOn = true,
+ skipCloudAddOns = false,
transformsBasicPrice = 100,
transformsAdvancedPrice = 250,
trialDays,
@@ -15,6 +16,7 @@ export function setupBillingEndpoints({
billingPeriodMonths?: number;
hasBasicTransformsAddOn?: boolean;
hasAdvancedTransformsAddOn?: boolean;
+ skipCloudAddOns?: boolean;
transformsBasicPrice?: number;
transformsAdvancedPrice?: number;
trialDays?: number;
@@ -74,7 +76,10 @@ export function setupBillingEndpoints({
: []),
];
- fetchMock.get("path:/api/ee/cloud-add-ons/addons", cloudAddOns);
+ if (!skipCloudAddOns) {
+ fetchMock.get("path:/api/ee/cloud-add-ons/addons", cloudAddOns);
+ }
+
fetchMock.get("path:/api/ee/billing", {
version: "0",
data: {
diff --git a/src/metabase/llm/settings.clj b/src/metabase/llm/settings.clj
index 78d4100122d..ed340627562 100644
--- a/src/metabase/llm/settings.clj
+++ b/src/metabase/llm/settings.clj
@@ -123,14 +123,23 @@
;;; --------------------------------------------------- Proxy ---------------------------------------------------
(defsetting llm-proxy-base-url
- (deferred-tru "Base URL for the LLM proxy. When set, all LLM requests are routed through this proxy and authenticated with the instance token instead of provider API keys.")
- :feature :metabase-ai-provider
+ (deferred-tru "Base URL for the LLM proxy. When set, requests to the managed Metabase AI service are routed through this proxy and authenticated with the instance token instead of a provider API key.")
+ :feature :metabase-ai-managed
:encryption :no
:visibility :internal
:default nil
:export? false
:doc false)
+(defsetting llm-proxy-configured?
+ (deferred-tru "Whether the LLM proxy is configured for the managed Metabase AI service.")
+ :encryption :no
+ :visibility :settings-manager
+ :export? false
+ :setter :none
+ :getter #(boolean (some? (llm-proxy-base-url)))
+ :doc false)
+
;;; -------------------------------------------------- General --------------------------------------------------
(defsetting llm-max-tokens
diff --git a/src/metabase/metabot/api.clj b/src/metabase/metabot/api.clj
index 0728cb11462..6b1e42bc104 100644
--- a/src/metabase/metabot/api.clj
+++ b/src/metabase/metabot/api.clj
@@ -300,9 +300,12 @@
(def ^:private metabot-settings-request-schema
[:map
[:provider metabot-provider-schema]
- [:model {:optional true} ms/NonBlankString]
+ [:model {:optional true} [:maybe :string]]
[:api-key {:optional true} [:maybe :string]]])
+(def ^:private metabase-default-model
+ "anthropic/claude-sonnet-4-6")
+
(defn- provider-api-key-setting-key
[provider]
(case provider
@@ -317,6 +320,13 @@
(when-not (str/blank? trimmed)
trimmed))))
+(defn- effective-provider-model
+ [provider model]
+ (cond
+ (nil? model) nil
+ (and (= provider provider-util/metabase-provider-prefix) (str/blank? model)) metabase-default-model
+ :else (non-blank-string model)))
+
(def ^:private invalid-api-key-statuses
#{401 403})
@@ -364,9 +374,20 @@
"openrouter" (assoc model :group (openrouter-model-group model))
model))
+(defn- normalize-metabase-model
+ [model]
+ (update model :id (fn [id]
+ (when id
+ (if (str/includes? id "/")
+ id
+ (str "anthropic/" id))))))
+
(defn- decorate-provider-models
[provider models]
- (let [decorated-models (map #(decorate-provider-model provider %) models)]
+ (let [models (if (= provider provider-util/metabase-provider-prefix)
+ (map normalize-metabase-model models)
+ models)
+ decorated-models (map #(decorate-provider-model provider %) models)]
(if (contains? #{"anthropic" "openrouter"} provider)
(let [grouped-models (group-by :group decorated-models)]
(->> grouped-models
@@ -380,20 +401,24 @@
([provider]
(provider-models-response provider nil))
([provider api-key-override]
- (let [effective-api-key (or (non-blank-string api-key-override)
- (non-blank-string
- (metabot.settings/configured-provider-api-key provider)))]
- (if (and provider effective-api-key)
- (try
- {:models (decorate-provider-models
- provider
- (:models (metabot.self/list-models provider {:api-key effective-api-key})))}
- (catch clojure.lang.ExceptionInfo e
- (if (invalid-api-key-error? e)
- {:models []
- :api-key-error (.getMessage e)}
- (throw e))))
- {:models []}))))
+ (if (= provider provider-util/metabase-provider-prefix)
+ {:models (decorate-provider-models
+ provider
+ (:models (metabot.self/list-models "anthropic" {:ai-proxy? true})))}
+ (let [effective-api-key (or (non-blank-string api-key-override)
+ (non-blank-string
+ (metabot.settings/configured-provider-api-key provider)))]
+ (if (and provider effective-api-key)
+ (try
+ {:models (decorate-provider-models
+ provider
+ (:models (metabot.self/list-models provider {:api-key effective-api-key})))}
+ (catch clojure.lang.ExceptionInfo e
+ (if (invalid-api-key-error? e)
+ {:models []
+ :api-key-error (.getMessage e)}
+ (throw e))))
+ {:models []})))))
(defn- settings-response
([provider]
@@ -438,7 +463,8 @@
_query-params
body :- metabot-settings-request-schema]
(perms/check-has-application-permission :setting)
- (let [{:keys [provider model api-key]} body]
+ (let [{:keys [provider model api-key]} body
+ model (effective-provider-model provider model)]
(verify-api-key! provider api-key)
(when (contains? body :api-key)
(setting/set! (provider-api-key-setting-key provider) (non-blank-string api-key)))
diff --git a/src/metabase/premium_features/core.clj b/src/metabase/premium_features/core.clj
index 6f8e13850c8..ba77e268b42 100644
--- a/src/metabase/premium_features/core.clj
+++ b/src/metabase/premium_features/core.clj
@@ -28,6 +28,7 @@
has-feature?
log-enabled?
max-users-allowed
+ meters
plan-alias
quotas
TokenStatus
@@ -54,6 +55,7 @@
enable-database-auth-providers?
enable-database-routing?
enable-library?
+ enable-metabase-ai-managed?
enable-dependencies?
enable-email-allow-list?
enable-email-restrict-recipients?
diff --git a/src/metabase/premium_features/settings.clj b/src/metabase/premium_features/settings.clj
index 1034c1f23ab..43b8b205db3 100644
--- a/src/metabase/premium_features/settings.clj
+++ b/src/metabase/premium_features/settings.clj
@@ -300,6 +300,14 @@
"Should we allow users to use workspaces?"
:workspaces)
+(define-premium-feature ^{:added "0.60.0"} enable-metabase-ai-managed?
+ "Should we allow users to use the Metabase-managed AI provider?"
+ :metabase-ai-managed)
+
+(define-premium-feature ^{:added "0.60.0"} enable-offer-metabase-ai-managed?
+ "Should we offer users the Metabase-managed AI provider?"
+ :offer-metabase-ai-managed)
+
(define-premium-feature enable-writable-connection?
"Should we allow admins to configure separate write connection credentials?"
:writable-connection)
@@ -334,6 +342,8 @@
:etl_connections (enable-etl-connections?)
:etl_connections_pg (enable-etl-connections-pg?)
:hosting (is-hosted?)
+ :metabase-ai-managed (enable-metabase-ai-managed?)
+ :offer-metabase-ai-managed (enable-offer-metabase-ai-managed?)
:official_collections (enable-official-collections?)
:query_reference_validation (enable-query-reference-validation?)
:remote_sync (enable-remote-sync?)
diff --git a/src/metabase/premium_features/token_check.clj b/src/metabase/premium_features/token_check.clj
index cfedd44eb63..58669aded71 100644
--- a/src/metabase/premium_features/token_check.clj
+++ b/src/metabase/premium_features/token_check.clj
@@ -172,6 +172,7 @@
[:company {:optional true} [:string {:min 1}]]
[:store-users {:optional true} [:maybe [:sequential [:map
[:email :string]]]]]
+ [:meters {:optional true} :map]
[:quotas {:optional true} [:sequential [:map]]]])
(defn- http-fetch
@@ -621,6 +622,14 @@
(check-token)
:quotas))
+(mu/defn meters :- [:maybe :map]
+ "Returns a map of current metered usage for the subscription."
+ []
+ (clear-cache!)
+ (some-> (premium-features.settings/premium-embedding-token)
+ (check-token)
+ :meters))
+
(defn has-any-features?
"True if we have a valid premium features token with ANY features."
[]
diff --git a/test/metabase/analytics/stats_test.clj b/test/metabase/analytics/stats_test.clj
index 143d75546b3..d1612aea300 100644
--- a/test/metabase/analytics/stats_test.clj
+++ b/test/metabase/analytics/stats_test.clj
@@ -567,7 +567,9 @@
:enhancements
:etl-connections
:etl-connections-pg
+ :offer-metabase-ai-managed
:query-reference-validation
+ :metabase-ai-managed
:cloud-custom-smtp
:session-timeout-config
:sso-oidc})
diff --git a/test/metabase/llm/settings_test.clj b/test/metabase/llm/settings_test.clj
index 292759f4d83..9b08a05e2c1 100644
--- a/test/metabase/llm/settings_test.clj
+++ b/test/metabase/llm/settings_test.clj
@@ -42,19 +42,19 @@
;;; ------------------------------------------- llm-proxy-base-url Feature Guard Tests -------------------------------------------
(deftest llm-proxy-base-url-feature-guard-test
- (testing "can be set and read when :metabase-ai-provider feature is enabled"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (testing "can be set and read when :metabase-ai-managed feature is enabled"
+ (mt/with-premium-features #{:metabase-ai-managed}
(mt/with-temporary-setting-values [llm-proxy-base-url "https://proxy.example"]
(is (= "https://proxy.example" (llm.settings/llm-proxy-base-url)))
- (testing "returns default (nil) when :metabase-ai-provider feature is not enabled, even if a value is set"
+ (testing "returns default (nil) when :metabase-ai-managed feature is not enabled, even if a value is set"
(mt/with-premium-features #{}
(is (nil? (llm.settings/llm-proxy-base-url))))))))
- (testing "cannot be set when :metabase-ai-provider feature is not enabled"
+ (testing "cannot be set when :metabase-ai-managed feature is not enabled"
(mt/with-premium-features #{}
(is (thrown-with-msg?
clojure.lang.ExceptionInfo
- #"Setting llm-proxy-base-url is not enabled because feature :metabase-ai-provider is not available"
+ #"Setting llm-proxy-base-url is not enabled because feature :metabase-ai-managed is not available"
(llm.settings/llm-proxy-base-url! "https://proxy.example"))))))
;;; ------------------------------------------- Settings Defaults Tests -------------------------------------------
diff --git a/test/metabase/metabot/api_test.clj b/test/metabase/metabot/api_test.clj
index 139e3c1e859..75d42d45801 100644
--- a/test/metabase/metabot/api_test.clj
+++ b/test/metabase/metabot/api_test.clj
@@ -268,6 +268,24 @@
(mt/user-http-request :crowberto :get 200 "metabot/settings"
:provider "openrouter"))))))
+(deftest settings-get-returns-metabase-models-without-api-key-test
+ (mt/with-temporary-setting-values [metabot.settings/llm-metabot-provider "metabase/anthropic/claude-sonnet-4-6"]
+ (with-redefs [metabot.self/list-models (fn
+ ([provider]
+ (is false (str "unexpected list-models call: " provider)))
+ ([provider opts]
+ (is (= "anthropic" provider))
+ (is (= {:ai-proxy? true} opts))
+ {:models [{:id "claude-haiku-4-5" :display_name "Claude Haiku 4.5"}
+ {:id "claude-sonnet-4-6" :display_name "Claude Sonnet 4.6"}
+ {:id "claude-opus-4-1" :display_name "Claude Opus 4.1"}]}))]
+ (is (= {:value "metabase/anthropic/claude-sonnet-4-6"
+ :models [{:id "anthropic/claude-haiku-4-5" :display_name "Claude Haiku 4.5"}
+ {:id "anthropic/claude-sonnet-4-6" :display_name "Claude Sonnet 4.6"}
+ {:id "anthropic/claude-opus-4-1" :display_name "Claude Opus 4.1"}]}
+ (mt/user-http-request :crowberto :get 200 "metabot/settings"
+ :provider "metabase"))))))
+
(deftest settings-put-updates-provider-test
(mt/with-temporary-setting-values [metabot.settings/llm-metabot-provider "anthropic/claude-haiku-4-5"
llm.settings/llm-openai-api-key "sk-valid"]
@@ -290,6 +308,48 @@
(is (= "openai/gpt-4.1-mini"
(metabot.settings/llm-metabot-provider))))))
+(deftest settings-put-updates-metabase-provider-without-api-key-test
+ (mt/with-temporary-setting-values [metabot.settings/llm-metabot-provider "anthropic/claude-haiku-4-5"]
+ (with-redefs [metabot.self/list-models (fn
+ ([provider]
+ (is false (str "unexpected list-models call: " provider)))
+ ([provider opts]
+ (is (= "anthropic" provider))
+ (is (= {:ai-proxy? true} opts))
+ {:models [{:id "claude-haiku-4-5" :display_name "Claude Haiku 4.5"}
+ {:id "claude-sonnet-4-6" :display_name "Claude Sonnet 4.6"}
+ {:id "claude-opus-4-1" :display_name "Claude Opus 4.1"}]}))]
+ (is (= {:value "metabase/anthropic/claude-opus-4-1"
+ :models [{:id "anthropic/claude-haiku-4-5" :display_name "Claude Haiku 4.5"}
+ {:id "anthropic/claude-sonnet-4-6" :display_name "Claude Sonnet 4.6"}
+ {:id "anthropic/claude-opus-4-1" :display_name "Claude Opus 4.1"}]}
+ (mt/user-http-request :crowberto :put 200 "metabot/settings"
+ {:provider "metabase"
+ :model "anthropic/claude-opus-4-1"})))
+ (is (= "metabase/anthropic/claude-opus-4-1"
+ (metabot.settings/llm-metabot-provider))))))
+
+(deftest settings-put-defaults-empty-metabase-model-test
+ (mt/with-temporary-setting-values [metabot.settings/llm-metabot-provider "anthropic/claude-haiku-4-5"]
+ (with-redefs [metabot.self/list-models (fn
+ ([provider]
+ (is false (str "unexpected list-models call: " provider)))
+ ([provider opts]
+ (is (= "anthropic" provider))
+ (is (= {:ai-proxy? true} opts))
+ {:models [{:id "claude-haiku-4-5" :display_name "Claude Haiku 4.5"}
+ {:id "claude-sonnet-4-6" :display_name "Claude Sonnet 4.6"}
+ {:id "claude-opus-4-1" :display_name "Claude Opus 4.1"}]}))]
+ (is (= {:value "metabase/anthropic/claude-sonnet-4-6"
+ :models [{:id "anthropic/claude-haiku-4-5" :display_name "Claude Haiku 4.5"}
+ {:id "anthropic/claude-sonnet-4-6" :display_name "Claude Sonnet 4.6"}
+ {:id "anthropic/claude-opus-4-1" :display_name "Claude Opus 4.1"}]}
+ (mt/user-http-request :crowberto :put 200 "metabot/settings"
+ {:provider "metabase"
+ :model ""})))
+ (is (= "metabase/anthropic/claude-sonnet-4-6"
+ (metabot.settings/llm-metabot-provider))))))
+
(deftest settings-put-verifies-and-saves-api-keys-test
(mt/with-temp-env-var-value! [mb-llm-anthropic-api-key nil]
(mt/with-temporary-setting-values [llm.settings/llm-anthropic-api-key nil]
@@ -370,6 +430,15 @@
{:provider "anthropic"
:model "claude-haiku-4-5"}))
+(deftest metabot-provider-without-api-key-is-configured-test
+ (mt/with-premium-features #{:metabase-ai-managed}
+ (mt/with-temporary-setting-values [metabot.settings/llm-metabot-provider "metabase/anthropic/claude-sonnet-4-6"
+ llm.settings/llm-proxy-base-url "https://proxy.example.com"
+ llm.settings/llm-anthropic-api-key nil
+ llm.settings/llm-openai-api-key nil
+ llm.settings/llm-openrouter-api-key nil]
+ (is (true? (metabot.settings/llm-metabot-configured?))))))
+
(deftest endpoints-require-authentication-test
(testing "Metabot v3 endpoints require authentication"
(testing "/agent-streaming"
diff --git a/test/metabase/metabot/self/claude_test.clj b/test/metabase/metabot/self/claude_test.clj
index ccb3b2952a4..5a02fc5ae32 100644
--- a/test/metabase/metabot/self/claude_test.clj
+++ b/test/metabase/metabot/self/claude_test.clj
@@ -164,7 +164,7 @@
{:type :text :text ""}])))))
(deftest claude-auth-preferences-test
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(mt/with-dynamic-fn-redefs [premium-features/premium-embedding-token (constantly "proxy-token")]
(mt/with-temporary-setting-values [llm.settings/llm-anthropic-api-key "sk-ant-byok"
llm.settings/llm-proxy-base-url "https://proxy.example"]
@@ -204,7 +204,7 @@
(claude/claude-raw {:input [{:role :user :content "hi"}]}))))))))))
(deftest claude-list-models-auth-preferences-test
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(mt/with-dynamic-fn-redefs [premium-features/premium-embedding-token (constantly "proxy-token")]
(mt/with-temporary-setting-values [llm.settings/llm-anthropic-api-key "sk-ant-byok"
llm.settings/llm-proxy-base-url "https://proxy.example"]
diff --git a/test/metabase/metabot/self/openai_test.clj b/test/metabase/metabot/self/openai_test.clj
index 7a63bfd644b..3411212829b 100644
--- a/test/metabase/metabot/self/openai_test.clj
+++ b/test/metabase/metabot/self/openai_test.clj
@@ -165,7 +165,7 @@
[{:type :tool-output :id "call-1" :error {:message "Tool failed"}}])))))
(deftest openai-auth-preferences-test
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(with-redefs [premium-features/premium-embedding-token (constantly "proxy-token")]
(mt/with-temporary-setting-values [llm.settings/llm-openai-api-key "sk-ant-byok"
llm.settings/llm-proxy-base-url "https://proxy.example"]
diff --git a/test/metabase/metabot/self/openrouter_test.clj b/test/metabase/metabot/self/openrouter_test.clj
index ba5cfbef9d4..114700c3657 100644
--- a/test/metabase/metabot/self/openrouter_test.clj
+++ b/test/metabase/metabot/self/openrouter_test.clj
@@ -185,7 +185,7 @@
(is (< 10 (count (filter #(= (:type %) :text) res)))))))
(deftest openrouter-auth-preferences-test
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(with-redefs [premium-features/premium-embedding-token (constantly "proxy-token")]
(mt/with-temporary-setting-values [llm.settings/llm-openrouter-api-key "sk-or-v1-byok"
llm.settings/llm-proxy-base-url "https://proxy.example"]
diff --git a/test/metabase/metabot/self_test.clj b/test/metabase/metabot/self_test.clj
index 36443b49aaf..f2a8a38d39e 100644
--- a/test/metabase/metabot/self_test.clj
+++ b/test/metabase/metabot/self_test.clj
@@ -52,27 +52,30 @@
(deftest call-llm-tool-choice-test
(testing "passes required tool choice to LLM providers"
(let [captured (atom nil)]
- (mt/with-dynamic-fn-redefs [http/request (fn [opts]
- (when (:body opts)
- (reset! captured (json/decode+kw (:body opts))))
- (throw (ex-info "stop" {::skip true :status 401 :body "skip parsing"})))]
- (mt/with-temporary-setting-values [llm-anthropic-api-key "sk-ant-test-key"
- llm-openrouter-api-key "sk-or-v1-test-key"
- llm-openai-api-key "sk-test-key"]
- (doseq [[model expected] [["anthropic/test-model" {:type "any"}]
- ["openrouter/test-model" "required"]
- ["openai/test-model" "required"]]]
- (try
- (run! identity (self/call-llm model
- nil
- []
- {"search" (get test-util/TOOLS "get-time")}
- {:tag "agent"}
- {:tool-choice "required"}))
- (catch Exception e
- (when-not (::skip (ex-data e))
- (throw e))))
- (is (= expected (:tool_choice @captured)))))))))
+ (mt/with-premium-features #{:metabase-ai-managed}
+ (mt/with-dynamic-fn-redefs [http/request (fn [opts]
+ (when (:body opts)
+ (reset! captured (json/decode+kw (:body opts))))
+ (throw (ex-info "stop" {::skip true :status 401 :body "skip parsing"})))]
+ (mt/with-temporary-setting-values [llm-anthropic-api-key "sk-ant-test-key"
+ llm-proxy-base-url "http://proxy.example"
+ llm-openrouter-api-key "sk-or-v1-test-key"
+ llm-openai-api-key "sk-test-key"]
+ (doseq [[model expected] [["anthropic/test-model" {:type "any"}]
+ ["metabase/anthropic/claude-sonnet-4-6" {:type "any"}]
+ ["openrouter/test-model" "required"]
+ ["openai/test-model" "required"]]]
+ (try
+ (run! identity (self/call-llm model
+ nil
+ []
+ {"search" (get test-util/TOOLS "get-time")}
+ {:tag "agent"}
+ {:tool-choice "required"}))
+ (catch Exception e
+ (when-not (::skip (ex-data e))
+ (throw e))))
+ (is (= expected (:tool_choice @captured))))))))))
;;; utils tests
diff --git a/test/metabase/metabot/settings_test.clj b/test/metabase/metabot/settings_test.clj
index 76605782d8b..b01d3fce90a 100644
--- a/test/metabase/metabot/settings_test.clj
+++ b/test/metabase/metabot/settings_test.clj
@@ -79,14 +79,14 @@
(deftest metabot-configured-with-metabase-provider-and-proxy-url-test
(testing "returns true when metabase-proxied provider and proxy URL is set"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(mt/with-temporary-setting-values [llm-metabot-provider "metabase/anthropic/claude-sonnet-4"
llm-proxy-base-url "https://proxy.example.com"]
(is (true? (metabot.settings/llm-metabot-configured?)))))))
(deftest metabot-configured-with-metabase-provider-no-proxy-url-test
(testing "returns false when metabase-proxied provider and no proxy URL"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(mt/with-temporary-setting-values [llm-metabot-provider "metabase/anthropic/claude-sonnet-4"
llm-proxy-base-url nil]
(is (false? (metabot.settings/llm-metabot-configured?)))))))
@@ -105,7 +105,7 @@
(deftest metabot-configured-proxy-url-not-fallback-for-direct-provider-test
(testing "proxy URL alone does not make a direct provider configured"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(with-redefs [llm.settings/llm-anthropic-api-key (constantly nil)]
(mt/with-temporary-setting-values [llm-metabot-provider "anthropic/claude-sonnet-4"
llm-proxy-base-url "https://proxy.example.com"]
@@ -134,14 +134,14 @@
(deftest validate-metabot-provider-rejects-unknown-inner-provider-test
(testing "rejects unknown inner provider under metabase/ prefix"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(is (thrown-with-msg?
clojure.lang.ExceptionInfo #"Unknown inner provider"
(metabot.settings/llm-metabot-provider! "metabase/foobar/some-model"))))))
(deftest validate-metabot-provider-rejects-metabase-prefix-without-model-test
(testing "rejects metabase/provider with no model"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(is (thrown-with-msg?
clojure.lang.ExceptionInfo #"Model name is required"
(metabot.settings/llm-metabot-provider! "metabase/anthropic/"))))))
@@ -157,7 +157,7 @@
(deftest validate-metabot-provider-accepts-valid-metabase-prefixed-test
(testing "accepts valid metabase/ prefixed provider strings"
- (mt/with-premium-features #{:metabase-ai-provider}
+ (mt/with-premium-features #{:metabase-ai-managed}
(mt/with-temporary-setting-values [llm-metabot-provider "metabase/anthropic/claude-sonnet-4"]
(is (= "metabase/anthropic/claude-sonnet-4" (metabot.settings/llm-metabot-provider))))
(mt/with-temporary-setting-values [llm-metabot-provider "metabase/openrouter/anthropic/claude-haiku-4-5"]