A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
/* Copyright 2026 Marimo. All rights reserved. */
import type { AiModel as AiModelType, AiProvider } from "@marimo-team/llm-info";
import { models as modelsJson } from "@marimo-team/llm-info/models.json";
import { providers as providersJson } from "@marimo-team/llm-info/providers.json";
import { Logger } from "@/utils/Logger";
import { MultiMap } from "@/utils/multi-map";
import { once } from "@/utils/once";
import type { ProviderId } from "./ids/ids";
import { AiModelId, type QualifiedModelId, type ShortModelId } from "./ids/ids";
export interface AiModel extends AiModelType {
model: ShortModelId;
/** The provider this entry belongs to. */
provider: ProviderId;
/** Whether this is a custom model. */
custom: boolean;
}
// JSON shape matches the `AiModel` schema (Zod-validated at codegen time).
const models = modelsJson as unknown as Partial<
Record<ProviderId, AiModelType[]>
>;
const providers = providersJson as unknown as readonly AiProvider[];
interface KnownModelMaps {
/** Map of qualified model ID to model info */
modelMap: ReadonlyMap<QualifiedModelId, AiModel>;
/** Map of provider ID to first default model (supports chat or edit) */
defaultModelByProvider: ReadonlyMap<ProviderId, QualifiedModelId>;
}
export const getKnownModelMaps = once((): KnownModelMaps => {
const modelMap = new Map<QualifiedModelId, AiModel>();
const defaultModelByProvider = new Map<ProviderId, QualifiedModelId>();
for (const [providerKey, providerModels] of Object.entries(models)) {
if (!providerModels) {
continue;
}
const provider = providerKey as ProviderId;
for (const raw of providerModels) {
const modelId = raw.model as ShortModelId;
const modelInfo: AiModel = {
...raw,
model: modelId,
provider,
custom: false,
};
const qualifiedModelId: QualifiedModelId = `${provider}/${modelId}`;
modelMap.set(qualifiedModelId, modelInfo);
const supportsChatOrEdit =
modelInfo.roles.includes("chat") || modelInfo.roles.includes("edit");
if (supportsChatOrEdit && !defaultModelByProvider.has(provider)) {
defaultModelByProvider.set(provider, qualifiedModelId);
}
}
}
return { modelMap, defaultModelByProvider };
});
const getProviderMap = once(
(): {
providerMap: ReadonlyMap<ProviderId, AiProvider>;
providerToOrderIdx: ReadonlyMap<ProviderId, number>;
} => {
const providerMap = new Map<ProviderId, AiProvider>();
const providerToOrderIdx = new Map<ProviderId, number>();
providers.forEach((provider, idx) => {
providerMap.set(provider.id, provider);
providerToOrderIdx.set(provider.id, idx);
});
return { providerMap, providerToOrderIdx };
},
);
export class AiModelRegistry {
private modelsByProviderMap = new MultiMap<ProviderId, AiModel>();
private modelsMap: ReadonlyMap<QualifiedModelId, AiModel>;
private customModels: ReadonlySet<QualifiedModelId>;
private displayedModels: ReadonlySet<QualifiedModelId>;
private constructor(
customModels: QualifiedModelId[],
displayedModels: QualifiedModelId[],
) {
this.customModels = new Set(customModels);
this.displayedModels = new Set(displayedModels);
this.modelsMap = new Map<QualifiedModelId, AiModel>();
this.buildMaps();
}
public static getProviderInfo(providerId: ProviderId) {
const { providerMap } = getProviderMap();
return providerMap.get(providerId);
}
/**
* @param customModels - A list of custom models to use that are not from the default list.
* @param displayedModels - A list of models to display in the UI. If empty, all models will be displayed.
*
* Models should be in the format of `provider_id/short_model_id`.
*/
public static create(opts: {
customModels?: string[];
displayedModels?: string[];
}) {
const { customModels = [], displayedModels = [] } = opts;
return new AiModelRegistry(
customModels.map((model) => AiModelId.parse(model).id),
displayedModels.map((model) => AiModelId.parse(model).id),
);
}
/**
* Builds the maps of models by provider and custom models.
*/
private buildMaps() {
let result = AiModelRegistry.buildMapsFromConfig({
displayedModels: this.displayedModels,
customModels: this.customModels,
});
// If we got zero results, then build the maps with no displayedModels
// This can happen if displayedModels is configured to non existent models
if (result.modelsMap.size === 0) {
Logger.error(
"The configured displayed_models have filtered out all registered models. Reverting back to showing all models.",
[...this.displayedModels],
);
result = AiModelRegistry.buildMapsFromConfig({
displayedModels: new Set(),
customModels: this.customModels,
});
}
this.modelsByProviderMap = result.modelsByProviderMap;
this.modelsMap = result.modelsMap;
}
private static buildMapsFromConfig(opts: {
customModels: ReadonlySet<QualifiedModelId>;
displayedModels: ReadonlySet<QualifiedModelId>;
}) {
const { displayedModels, customModels } = opts;
const hasDisplayedModels = displayedModels.size > 0;
const knownModelMap = getKnownModelMaps().modelMap;
const customModelsMap = new Map<QualifiedModelId, AiModel>();
let modelsMap = new Map<QualifiedModelId, AiModel>();
const modelsByProviderMap = new MultiMap<ProviderId, AiModel>();
for (const model of customModels) {
if (hasDisplayedModels && !displayedModels.has(model)) {
continue;
}
const modelId = AiModelId.parse(model);
const modelInfo: AiModel = {
name: modelId.shortModelId,
model: modelId.shortModelId,
description: "Custom model",
provider: modelId.providerId,
roles: [],
capabilities: [],
input_types: [],
output_types: [],
release_date: "1970-01-01",
custom: true,
};
customModelsMap.set(model, modelInfo);
}
// Add known models
if (hasDisplayedModels) {
for (const model of displayedModels) {
const modelInfo = knownModelMap.get(model);
if (modelInfo) {
modelsMap.set(model, modelInfo);
}
}
} else {
modelsMap = new Map(knownModelMap);
}
// Set custom models first, then known models
// Known models will overwrite custom models (which is desired)
modelsMap = new Map([...customModelsMap, ...modelsMap]);
// Group by provider
for (const [qualifiedModelId, model] of modelsMap.entries()) {
const modelId = AiModelId.parse(qualifiedModelId);
modelsByProviderMap.add(modelId.providerId, model);
}
return { modelsByProviderMap, modelsMap };
}
public getDisplayedModels() {
return this.displayedModels;
}
public getCustomModels() {
return this.customModels;
}
public getModelsByProvider(provider: ProviderId) {
return this.modelsByProviderMap.get(provider) || [];
}
public getGroupedModelsByProvider() {
return this.modelsByProviderMap;
}
public getListModelsByProvider(): [ProviderId, AiModel[]][] {
const modelsByProvider = this.getGroupedModelsByProvider();
const arrayModels = [...modelsByProvider.entries()];
const providerToOrderIdx = getProviderMap().providerToOrderIdx;
arrayModels.sort((a, b) => {
const aProvider = a[0];
const bProvider = b[0];
const aOrderIdx = providerToOrderIdx.get(aProvider) ?? 0;
const bOrderIdx = providerToOrderIdx.get(bProvider) ?? 0;
return aOrderIdx - bOrderIdx;
});
return arrayModels;
}
public getModelsMap() {
return this.modelsMap;
}
public getModel(qualifiedModelId: QualifiedModelId) {
return this.modelsMap.get(qualifiedModelId);
}
}