mcp: support workspace folder-level servers

src/vs/workbench/contrib/mcp/browser/mcpLanguageFeatures.ts

@@ -32,7 +32,11 @@ export class McpLanguageFeatures extends Disposable implements IWorkbenchContrib
 	) {
 		super();
 
-		const patterns = [{ pattern: '**/.vscode/mcp.json' }, { pattern: '**/settings.json' }];
+		const patterns = [
+			{ pattern: '**/.vscode/mcp.json' },
+			{ pattern: '**/settings.json' },
+			{ pattern: '**/workspace.json' },
+		];
 
 		const onDidChangeCodeLens = this._register(new Emitter<CodeLensProvider>());
 		const codeLensProvider: CodeLensProvider = {
@@ -61,13 +65,13 @@ export class McpLanguageFeatures extends Disposable implements IWorkbenchContrib
 	}
 
 	private async _provideCodeLenses(model: ITextModel, onDidChangeCodeLens: () => void): Promise<CodeLensList | undefined> {
-		const inConfig = this._mcpConfigPathsService.paths.find(u => isEqual(u.uri, model.uri));
+		const inConfig = this._mcpConfigPathsService.paths.get().find(u => isEqual(u.uri, model.uri));
 		if (!inConfig) {
 			return undefined;
 		}
 
 		const tree = this._parseModel(model);
-		const serversNode = findNodeAtLocation(tree, inConfig.section ? [inConfig.section, 'servers'] : ['servers']);
+		const serversNode = findNodeAtLocation(tree, inConfig.section ? [...inConfig.section, 'servers'] : ['servers']);
 		if (!serversNode) {
 			return undefined;
 		}
@@ -182,13 +186,13 @@ export class McpLanguageFeatures extends Disposable implements IWorkbenchContrib
 	}
 
 	private async _provideInlayHints(model: ITextModel, range: Range): Promise<InlayHintList | undefined> {
-		const inConfig = this._mcpConfigPathsService.paths.find(u => isEqual(u.uri, model.uri));
+		const inConfig = this._mcpConfigPathsService.paths.get().find(u => isEqual(u.uri, model.uri));
 		if (!inConfig) {
 			return undefined;
 		}
 
 		const tree = this._parseModel(model);
-		const mcpSection = inConfig.section ? findNodeAtLocation(tree, [inConfig.section]) : tree;
+		const mcpSection = inConfig.section ? findNodeAtLocation(tree, [...inConfig.section]) : tree;
 		if (!mcpSection) {
 			return undefined;
 		}

src/vs/workbench/contrib/mcp/common/discovery/configMcpDiscovery.ts

@@ -6,7 +6,7 @@
 import { equals as arrayEquals } from '../../../../../base/common/arrays.js';
 import { Throttler } from '../../../../../base/common/async.js';
 import { Disposable, DisposableStore, IDisposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
-import { ISettableObservable, observableValue } from '../../../../../base/common/observable.js';
+import { autorunDelta, ISettableObservable, observableValue } from '../../../../../base/common/observable.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { Location } from '../../../../../editor/common/languages.js';
 import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
@@ -29,7 +29,7 @@ interface ConfigSource {
  * Discovers MCP servers based on various config sources.
  */
 export class ConfigMcpDiscovery extends Disposable implements IMcpDiscovery {
-	private readonly configSources: ConfigSource[] = [];
+	private configSources: ConfigSource[] = [];
 
 	constructor(
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
@@ -48,21 +48,35 @@ export class ConfigMcpDiscovery extends Disposable implements IMcpDiscovery {
 				path,
 				serverDefinitions: observableValue(this, []),
 				disposable: this._register(new MutableDisposable()),
-				getServerToLocationMapping: (uri) => this._getServerIdMapping(uri, path.section ? [path.section, 'servers'] : ['servers']),
+				getServerToLocationMapping: (uri) => this._getServerIdMapping(uri, path.section ? [...path.section, 'servers'] : ['servers']),
 			});
 		};
 
-		this._mcpConfigPathsService.paths.forEach(addPath);
-		this._register(this._mcpConfigPathsService.onDidAddPath(path => {
-			addPath(path);
-			this.sync();
-		}));
-
 		this._register(this._configurationService.onDidChangeConfiguration(e => {
 			if (e.affectsConfiguration(mcpConfigurationSection)) {
 				throttler.queue(() => this.sync());
 			}
 		}));
+
+		this._register(autorunDelta(this._mcpConfigPathsService.paths, ({ lastValue, newValue }) => {
+			for (const last of lastValue || []) {
+				if (!newValue.includes(last)) {
+					const idx = this.configSources.findIndex(src => src.path.id === last.id);
+					if (idx !== -1) {
+						this.configSources[idx].disposable.dispose();
+						this.configSources.splice(idx, 1);
+					}
+				}
+			}
+
+			for (const next of newValue) {
+				if (!lastValue || !lastValue.includes(next)) {
+					addPath(next);
+				}
+			}
+
+			this.sync();
+		}));
 	}
 
 	private async _getServerIdMapping(resource: URI, pathToServers: string[]): Promise<Map<string, Location>> {
@@ -87,8 +101,12 @@ export class ConfigMcpDiscovery extends Disposable implements IMcpDiscovery {
 		}));
 
 		for (const [index, src] of this.configSources.entries()) {
-			const collectionId = `mcp.config.${src.path.key}`;
-			let value = configurationKey[src.path.key];
+			const collectionId = `mcp.config.${src.path.id}`;
+			// inspect() will give the first workspace folder, and must be
+			// asked for explicitly for other folders.
+			let value = src.path.workspaceFolder
+				? this._configurationService.inspect<IMcpConfiguration>(mcpConfigurationSection, { resource: src.path.workspaceFolder.uri })[src.path.key]
+				: configurationKey[src.path.key];
 
 			// If we see there are MCP servers, migrate them automatically
 			if (value?.mcpServers) {
@@ -112,7 +130,9 @@ export class ConfigMcpDiscovery extends Disposable implements IMcpDiscovery {
 					envFile: value.envFile,
 					cwd: undefined,
 				},
+				roots: src.path.workspaceFolder ? [src.path.workspaceFolder.uri] : [],
 				variableReplacement: {
+					folder: src.path.workspaceFolder,
 					section: mcpConfigurationSection,
 					target: src.path.target,
 				},

src/vs/workbench/contrib/mcp/common/discovery/nativeMcpDiscoveryAbstract.ts

@@ -81,7 +81,7 @@ export abstract class FilesystemMpcDiscovery extends Disposable implements IMcpD
 				serverDefinitions: observableValue<readonly McpServerDefinition[]>(this, []),
 				presentation: {
 					origin: file,
-					order: adapter.order + (adapter.remoteAuthority ? McpCollectionSortOrder.RemotePenalty : 0),
+					order: adapter.order + (adapter.remoteAuthority ? McpCollectionSortOrder.RemoteBoost : 0),
 				},
 			} satisfies McpCollectionDefinition;
 

src/vs/workbench/contrib/mcp/common/mcpConfigPathsService.ts

@@ -3,63 +3,66 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Emitter, Event } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { Schemas } from '../../../../base/common/network.js';
+import { IObservable, ISettableObservable, observableValue } from '../../../../base/common/observable.js';
+import { isDefined } from '../../../../base/common/types.js';
 import { URI } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
 import { ConfigurationTarget } from '../../../../platform/configuration/common/configuration.js';
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILabelService } from '../../../../platform/label/common/label.js';
 import { IProductService } from '../../../../platform/product/common/productService.js';
 import { StorageScope } from '../../../../platform/storage/common/storage.js';
-import { IWorkspaceFolder } from '../../../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService, IWorkspaceFolder } from '../../../../platform/workspace/common/workspace.js';
 import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { FOLDER_SETTINGS_PATH, IPreferencesService } from '../../../services/preferences/common/preferences.js';
 import { IRemoteAgentService } from '../../../services/remote/common/remoteAgentService.js';
 import { mcpConfigurationSection } from './mcpConfiguration.js';
 import { McpCollectionSortOrder } from './mcpTypes.js';
 
 export interface IMcpConfigPath {
+	/** Short, unique ID for this config. */
+	id: string;
 	/** Configuration scope that maps to this path.  */
-	key: 'userLocalValue' | 'userRemoteValue' | 'workspaceValue';
+	key: 'userLocalValue' | 'userRemoteValue' | 'workspaceValue' | 'workspaceFolderValue';
 	/** Display name */
 	label: string;
 	/** Storage where associated data should be stored. */
 	scope: StorageScope;
 	/** Configuration target that correspond to this file */
 	target: ConfigurationTarget;
-	/** Associated workspace folder, for workspace folder values */
-	folder?: IWorkspaceFolder;
 	/** Order in which the configuration should be displayed */
 	order: number;
 	/** Config's remote authority */
 	remoteAuthority?: string;
 	/** Config file URI. */
 	uri: URI | undefined;
 	/** When MCP config is nested in a config file, the parent nested key. */
-	section?: string;
+	section?: string[];
+	/** Workspace folder, when the config refers to a workspace folder value. */
+	workspaceFolder?: IWorkspaceFolder;
 }
 
 export interface IMcpConfigPathsService {
 	_serviceBrand: undefined;
 
-	readonly onDidAddPath: Event<IMcpConfigPath>;
-	readonly paths: readonly IMcpConfigPath[];
+	readonly paths: IObservable<readonly IMcpConfigPath[]>;
 }
 
 export const IMcpConfigPathsService = createDecorator<IMcpConfigPathsService>('IMcpConfigPathsService');
 
 export class McpConfigPathsService extends Disposable implements IMcpConfigPathsService {
 	_serviceBrand: undefined;
 
-	private readonly _onDidAddPath = this._register(new Emitter<IMcpConfigPath>());
-	public readonly onDidAddPath = this._onDidAddPath.event;
+	private readonly _paths: ISettableObservable<readonly IMcpConfigPath[]>;
 
-	public readonly paths: IMcpConfigPath[] = [];
+	public get paths(): IObservable<readonly IMcpConfigPath[]> {
+		return this._paths;
+	}
 
 	constructor(
-
+		@IWorkspaceContextService workspaceContextService: IWorkspaceContextService,
 		@IProductService productService: IProductService,
 		@ILabelService labelService: ILabelService,
 		@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService,
@@ -68,44 +71,79 @@ export class McpConfigPathsService extends Disposable implements IMcpConfigPaths
 	) {
 		super();
 
-		this.paths.push(
+		const workspaceConfig = workspaceContextService.getWorkspace().configuration;
+		const initialPaths: (IMcpConfigPath | undefined | null)[] = [
 			{
+				id: 'usrlocal',
 				key: 'userLocalValue',
 				target: ConfigurationTarget.USER_LOCAL,
 				label: localize('mcp.configuration.userLocalValue', 'Global in {0}', productService.nameShort),
 				scope: StorageScope.PROFILE,
 				order: McpCollectionSortOrder.User,
 				uri: preferencesService.userSettingsResource,
-				section: mcpConfigurationSection,
+				section: [mcpConfigurationSection],
 			},
-			{
+			workspaceConfig && {
+				id: 'workspace',
 				key: 'workspaceValue',
 				target: ConfigurationTarget.WORKSPACE,
 				label: localize('mcp.configuration.workspaceValue', 'From your workspace'),
 				scope: StorageScope.WORKSPACE,
 				order: McpCollectionSortOrder.Workspace,
-				uri: preferencesService.workspaceSettingsResource ? URI.joinPath(preferencesService.workspaceSettingsResource, '../mcp.json') : undefined,
+				uri: workspaceConfig,
+				section: ['settings', mcpConfigurationSection],
 			},
-		);
+			...workspaceContextService.getWorkspace()
+				.folders
+				.map(wf => this._fromWorkspaceFolder(wf))
+		];
+
+		this._paths = observableValue('mcpConfigPaths', initialPaths.filter(isDefined));
 
 		remoteAgentService.getEnvironment().then((env) => {
 			const label = environmentService.remoteAuthority ? labelService.getHostLabel(Schemas.vscodeRemote, environmentService.remoteAuthority) : 'Remote';
 
-			this._addPath({
-				key: 'userRemoteValue',
-				target: ConfigurationTarget.USER_REMOTE,
-				label: localize('mcp.configuration.userRemoteValue', 'From {0}', label),
-				scope: StorageScope.PROFILE,
-				order: McpCollectionSortOrder.User + McpCollectionSortOrder.RemotePenalty,
-				uri: env?.settingsPath,
-				remoteAuthority: environmentService.remoteAuthority,
-				section: mcpConfigurationSection,
-			});
+			this._paths.set([
+				...this.paths.get(),
+				{
+					id: 'usrremote',
+					key: 'userRemoteValue',
+					target: ConfigurationTarget.USER_REMOTE,
+					label: localize('mcp.configuration.userRemoteValue', 'From {0}', label),
+					scope: StorageScope.PROFILE,
+					order: McpCollectionSortOrder.User + McpCollectionSortOrder.RemoteBoost,
+					uri: env?.settingsPath,
+					remoteAuthority: environmentService.remoteAuthority,
+					section: [mcpConfigurationSection],
+				}
+			], undefined);
 		});
+
+		this._register(workspaceContextService.onDidChangeWorkspaceFolders(e => {
+			const next = this._paths.get().slice();
+			for (const folder of e.added) {
+				next.push(this._fromWorkspaceFolder(folder));
+			}
+			for (const folder of e.removed) {
+				const idx = next.findIndex(c => c.workspaceFolder === folder);
+				if (idx !== -1) {
+					next.splice(idx, 1);
+				}
+			}
+			this._paths.set(next, undefined);
+		}));
 	}
 
-	private _addPath(path: IMcpConfigPath): void {
-		this.paths.push(path);
-		this._onDidAddPath.fire(path);
+	private _fromWorkspaceFolder(workspaceFolder: IWorkspaceFolder): IMcpConfigPath {
+		return {
+			id: `wf${workspaceFolder.index}`,
+			key: 'workspaceFolderValue',
+			target: ConfigurationTarget.WORKSPACE_FOLDER,
+			label: localize('mcp.configuration.workspaceFolter', 'From folder {0}', workspaceFolder.name),
+			scope: StorageScope.WORKSPACE,
+			order: McpCollectionSortOrder.WorkspaceFolder,
+			uri: URI.joinPath(workspaceFolder.uri, FOLDER_SETTINGS_PATH, '../mcp.json'),
+			workspaceFolder,
+		};
 	}
 }

src/vs/workbench/contrib/mcp/common/mcpServer.ts

@@ -8,6 +8,8 @@ import { CancellationToken, CancellationTokenSource } from '../../../../base/com
 import { Disposable, DisposableStore, IDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import { LRUCache } from '../../../../base/common/map.js';
 import { autorun, autorunWithStore, derived, disposableObservableValue, IObservable, ITransaction, observableFromEvent, ObservablePromise, observableValue, transaction } from '../../../../base/common/observable.js';
+import { basename } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
 import { ILogger, ILoggerService } from '../../../../platform/log/common/log.js';
 import { IStorageService, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
@@ -140,6 +142,7 @@ export class McpServer extends Disposable implements IMcpServer {
 	constructor(
 		public readonly collection: McpCollectionReference,
 		public readonly definition: McpDefinitionReference,
+		explicitRoots: URI[] | undefined,
 		private readonly _requiresExtensionActivation: boolean | undefined,
 		private readonly _toolCache: McpServerMetadataCache,
 		@IMcpRegistry private readonly _mcpRegistry: IMcpRegistry,
@@ -157,11 +160,13 @@ export class McpServer extends Disposable implements IMcpServer {
 		this._register(toDisposable(() => _loggerService.deregisterLogger(this._loggerId)));
 
 		// 1. Reflect workspaces into the MCP roots
-		const workspaces = observableFromEvent(
-			this,
-			workspacesService.onDidChangeWorkspaceFolders,
-			() => workspacesService.getWorkspace().folders,
-		);
+		const workspaces = explicitRoots
+			? observableValue(this, explicitRoots.map(uri => ({ uri, name: basename(uri) })))
+			: observableFromEvent(
+				this,
+				workspacesService.onDidChangeWorkspaceFolders,
+				() => workspacesService.getWorkspace().folders,
+			);
 
 		this._register(autorunWithStore(reader => {
 			const cnx = this._connection.read(reader)?.handler.read(reader);

src/vs/workbench/contrib/mcp/common/mcpService.ts

@@ -175,7 +175,14 @@ export class McpService extends Disposable implements IMcpService {
 		// Create any new servers that are needed.
 		for (const def of nextDefinitions) {
 			const store = new DisposableStore();
-			const object = this._instantiationService.createInstance(McpServer, def.collectionDefinition, def.serverDefinition, !!def.collectionDefinition.lazy, def.collectionDefinition.scope === StorageScope.WORKSPACE ? this.workspaceCache : this.userCache);
+			const object = this._instantiationService.createInstance(
+				McpServer,
+				def.collectionDefinition,
+				def.serverDefinition,
+				def.serverDefinition.roots,
+				!!def.collectionDefinition.lazy,
+				def.collectionDefinition.scope === StorageScope.WORKSPACE ? this.workspaceCache : this.userCache,
+			);
 			store.add(object);
 			this._syncTools(object, store);