18710860243

Committed 22 Oct 2025 08:56AM UTC coverage: 81.332% (-0.6%) from 81.905%

Build # 18710860243

Build Type

Pull #662

github

Committed by

web-flow

Commit Message

Merge 89a556dbd into 17b595b2f

Pull Request Pull Request #662: chore: When querying with vectorSearch use the generated embeddings MCP-245

Run Details

1366 of 1859 branches covered (73.48%)

Branch coverage included in aggregate %.

97 of 182 new or added lines in 4 files covered. (53.3%)

8 existing lines in 2 files now uncovered.

6289 of 7553 relevant lines covered (83.26%)

146.1 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";
};

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

mongodb-js / mongodb-mcp-server / 18710860243

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