18780521612

Committed 24 Oct 2025 01:00PM UTC coverage: 80.155% (+0.02%) from 80.134%

Build # 18780521612

Build Type

Pull #686

github

Committed by

web-flow

Commit Message

Merge 1162d4c4e into fe38463cc

Pull Request Pull Request #686: feat: add ability to specify enabled preview features

Run Details

1341 of 1811 branches covered (74.05%)

Branch coverage included in aggregate %.

14 of 15 new or added lines in 6 files covered. (93.33%)

1 existing line in 1 file now uncovered.

6293 of 7713 relevant lines covered (81.59%)

70.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.83

/src/common/search/embeddingsProvider.ts

import { createVoyage } from "voyage-ai-provider";
import type { VoyageProvider } from "voyage-ai-provider";
import { embedMany } from "ai";
import type { UserConfig } from "../config.js";
import assert from "assert";
import { createFetch } from "@mongodb-js/devtools-proxy-support";
import { z } from "zod";

type EmbeddingsInput = string;
type Embeddings = number[];
export type EmbeddingParameters = {
    inputType: "query" | "document";
};

export interface EmbeddingsProvider<
    SupportedModels extends string,
    SupportedEmbeddingParameters extends EmbeddingParameters,
> {
    embed(
        modelId: SupportedModels,
        content: EmbeddingsInput[],
        parameters: SupportedEmbeddingParameters
    ): Promise<Embeddings[]>;
}

export const zVoyageModels = z
    .enum(["voyage-3-large", "voyage-3.5", "voyage-3.5-lite", "voyage-code-3"])
    .default("voyage-3-large");

export const zVoyageEmbeddingParameters = z.object({
    outputDimension: z
        .union([z.literal(256), z.literal(512), z.literal(1024), z.literal(2048), z.literal(4096)])
        .optional()
        .default(1024),
    outputDType: z.enum(["float", "int8", "uint8", "binary", "ubinary"]).optional().default("float"),
});

type VoyageModels = z.infer<typeof zVoyageModels>;
type VoyageEmbeddingParameters = z.infer<typeof zVoyageEmbeddingParameters> & EmbeddingParameters;

class VoyageEmbeddingsProvider implements EmbeddingsProvider<VoyageModels, VoyageEmbeddingParameters> {
    private readonly voyage: VoyageProvider;

    constructor({ voyageApiKey }: UserConfig, providedFetch?: typeof fetch) {
        assert(voyageApiKey, "The VoyageAI API Key does not exist. This is likely a bug.");

        // We should always use, by default, any enterprise proxy that the user has configured.
        // Direct requests to VoyageAI might get blocked by the network if they don't go through
        // the provided proxy.
        const customFetch: typeof fetch = (providedFetch ??
            createFetch({ useEnvironmentVariableProxies: true })) as unknown as typeof fetch;

        this.voyage = createVoyage({ apiKey: voyageApiKey, fetch: customFetch });
    }

    static isConfiguredIn({ voyageApiKey, previewFeatures }: UserConfig): boolean {
        return previewFeatures.includes("vectorSearch") && !!voyageApiKey;
    }

    async embed<Model extends VoyageModels>(
        modelId: Model,
        content: EmbeddingsInput[],
        parameters: VoyageEmbeddingParameters
    ): Promise<Embeddings[]> {
        const model = this.voyage.textEmbeddingModel(modelId);
        const { embeddings } = await embedMany({
            model,
            values: content,
            providerOptions: { voyage: parameters },
        });

        return embeddings;
    }
}

export function getEmbeddingsProvider(
    userConfig: UserConfig
): EmbeddingsProvider<VoyageModels, VoyageEmbeddingParameters> | undefined {
    if (VoyageEmbeddingsProvider.isConfiguredIn(userConfig)) {
        return new VoyageEmbeddingsProvider(userConfig);
    }

    return undefined;
}

export const zSupportedEmbeddingParameters = zVoyageEmbeddingParameters.extend({ model: zVoyageModels });
export type SupportedEmbeddingParameters = z.infer<typeof zSupportedEmbeddingParameters>;

1	import { createVoyage } from "voyage-ai-provider";	3✔
2	import type { VoyageProvider } from "voyage-ai-provider";
3	import { embedMany } from "ai";	3✔
4	import type { UserConfig } from "../config.js";
5	import assert from "assert";	3✔
6	import { createFetch } from "@mongodb-js/devtools-proxy-support";	3✔
7	import { z } from "zod";	3✔
8
9	type EmbeddingsInput = string;
10	type Embeddings = number[];
11	export type EmbeddingParameters = {
12	inputType: "query" \| "document";
13	};
14
15	export interface EmbeddingsProvider<
16	SupportedModels extends string,
17	SupportedEmbeddingParameters extends EmbeddingParameters,
18	> {
19	embed(
20	modelId: SupportedModels,
21	content: EmbeddingsInput[],
22	parameters: SupportedEmbeddingParameters
23	): Promise<Embeddings[]>;
24	}
25
26	export const zVoyageModels = z	3✔
27	.enum(["voyage-3-large", "voyage-3.5", "voyage-3.5-lite", "voyage-code-3"])	3✔
28	.default("voyage-3-large");	3✔
29
30	export const zVoyageEmbeddingParameters = z.object({	3✔
31	outputDimension: z	3✔
32	.union([z.literal(256), z.literal(512), z.literal(1024), z.literal(2048), z.literal(4096)])	3✔
33	.optional()	3✔
34	.default(1024),	3✔
35	outputDType: z.enum(["float", "int8", "uint8", "binary", "ubinary"]).optional().default("float"),	3✔
36	});	3✔
37
38	type VoyageModels = z.infer<typeof zVoyageModels>;
39	type VoyageEmbeddingParameters = z.infer<typeof zVoyageEmbeddingParameters> & EmbeddingParameters;
40
41	class VoyageEmbeddingsProvider implements EmbeddingsProvider<VoyageModels, VoyageEmbeddingParameters> {	3✔
42	private readonly voyage: VoyageProvider;
43
44	constructor({ voyageApiKey }: UserConfig, providedFetch?: typeof fetch) {	3✔
45	assert(voyageApiKey, "The VoyageAI API Key does not exist. This is likely a bug.");	×
46
47	// We should always use, by default, any enterprise proxy that the user has configured.
48	// Direct requests to VoyageAI might get blocked by the network if they don't go through
49	// the provided proxy.
50	const customFetch: typeof fetch = (providedFetch ??	×
51	createFetch({ useEnvironmentVariableProxies: true })) as unknown as typeof fetch;	×
52
53	this.voyage = createVoyage({ apiKey: voyageApiKey, fetch: customFetch });	×
54	}	×
55
56	static isConfiguredIn({ voyageApiKey, previewFeatures }: UserConfig): boolean {	3✔
NEW 57	return previewFeatures.includes("vectorSearch") && !!voyageApiKey;	×
UNCOV 58	}	×
59
60	async embed<Model extends VoyageModels>(	3✔
61	modelId: Model,	×
62	content: EmbeddingsInput[],	×
63	parameters: VoyageEmbeddingParameters	×
64	): Promise<Embeddings[]> {	×
65	const model = this.voyage.textEmbeddingModel(modelId);	×
66	const { embeddings } = await embedMany({	×
67	model,	×
68	values: content,	×
69	providerOptions: { voyage: parameters },	×
70	});	×
71
72	return embeddings;	×
73	}	×
74	}	3✔
75
76	export function getEmbeddingsProvider(	3✔
77	userConfig: UserConfig	×
78	): EmbeddingsProvider<VoyageModels, VoyageEmbeddingParameters> \| undefined {	×
79	if (VoyageEmbeddingsProvider.isConfiguredIn(userConfig)) {	×
80	return new VoyageEmbeddingsProvider(userConfig);	×
81	}	×
82
83	return undefined;	×
84	}	×
85
86	export const zSupportedEmbeddingParameters = zVoyageEmbeddingParameters.extend({ model: zVoyageModels });	3✔
87	export type SupportedEmbeddingParameters = z.infer<typeof zSupportedEmbeddingParameters>;

mongodb-js / mongodb-mcp-server / 18780521612

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous