snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/server/services/ai-search/service.ts

@@ -0,0 +1,434 @@
+import {
+	AI_LICENSE_MODULE,
+	AI_SEARCH_PAGE_SIZE,
+	buildIntelligentSearchPipelineFilters,
+	generateOpenAICompatibleSearchAnswer,
+	listOpenAICompatibleModels,
+	MAX_SEARCH_ANSWER_MESSAGES,
+	MAX_SEARCH_ANSWER_TEXT_LENGTH,
+	MAX_SEARCH_FILTER_VALUES,
+	normalizeIntelligentSearchCandidates,
+	searchIntelligentPipeline,
+	type IntelligentSearchFilters,
+	type IntelligentSearchPipelineConfig,
+	type OpenAICompatibleProviderConfig,
+	type SearchAnswerMessage,
+} from '@rocket.chat/ai-search';
+import type {
+	AISearchAnswerMessage,
+	AISearchAnswerResult,
+	AISearchFilters,
+	AISearchModelOption,
+	AISearchResult,
+	AISearchStatus,
+	IAISearchService,
+} from '@rocket.chat/core-services';
+import { License, ServiceClass } from '@rocket.chat/core-services';
+import { isBannedSubscription, type IMessage, type IRoom, type IUser } from '@rocket.chat/core-typings';
+import { Logger } from '@rocket.chat/logger';
+import { Messages, Rooms, Subscriptions, Users } from '@rocket.chat/models';
+import { serverFetch, type ExtendedFetchOptions } from '@rocket.chat/server-fetch';
+
+import { settings } from '../../settings';
+
+const logger = new Logger('AISearchService');
+
+const fetchWithSsrfValidation = (url: string, options: Omit<ExtendedFetchOptions, 'allowList' | 'ignoreSsrfValidation'>) =>
+	serverFetch(url, {
+		...options,
+		ignoreSsrfValidation: false,
+		allowList: settings.get<string>('SSRF_Allowlist'),
+	});
+
+const asString = (value: unknown): string => {
+	if (typeof value === 'string') {
+		return value;
+	}
+	if (typeof value === 'number' || typeof value === 'boolean') {
+		return String(value);
+	}
+	return '';
+};
+
+const toDate = (value?: string | Date): Date | undefined => {
+	if (!value) {
+		return undefined;
+	}
+
+	const date = value instanceof Date ? value : new Date(value);
+	return Number.isNaN(date.getTime()) ? undefined : date;
+};
+
+const limitFilterValues = (values: string[] | undefined): string[] | undefined => {
+	if (!values) {
+		return undefined;
+	}
+
+	const limitedValues: string[] = [];
+	for (const value of values) {
+		if (value) {
+			limitedValues.push(value);
+			if (limitedValues.length === MAX_SEARCH_FILTER_VALUES) {
+				break;
+			}
+		}
+	}
+	return limitedValues;
+};
+
+const normalizeFilters = (filters: AISearchFilters = {}): IntelligentSearchFilters => ({
+	rid: filters.rid,
+	rids: limitFilterValues(filters.rids),
+	roomNames: limitFilterValues(filters.roomNames),
+	fromUsername: filters.fromUsername,
+	fromUsernames: limitFilterValues(filters.fromUsernames),
+	startDate: toDate(filters.startDate),
+	endDate: toDate(filters.endDate),
+});
+
+type OpenAICompatibleProviderSettings = Pick<OpenAICompatibleProviderConfig, 'baseUrl' | 'apiKey'> & {
+	model?: string;
+};
+
+export class AISearchService extends ServiceClass implements IAISearchService {
+	protected name = 'ai-search';
+
+	private getPipelineConfig(): IntelligentSearchPipelineConfig | undefined {
+		const baseUrl = settings.get<string>('AI_Intelligent_Search_Pipeline_Base_URL');
+		const pipelineId = settings.get<string>('AI_Intelligent_Search_Pipeline_ID');
+		const apiKey = settings.get<string>('AI_Intelligent_Search_API_Key');
+		const apiKeySecret = settings.get<string>('AI_Intelligent_Search_API_Key_Secret');
+		const queryTemplate = settings.get<string>('AI_Intelligent_Search_Query_Template');
+		const minimumSimilarityPercent = settings.get<number>('AI_Intelligent_Search_Min_Similarity_Percent');
+
+		const normalizedBaseUrl = asString(baseUrl);
+		const normalizedPipelineId = asString(pipelineId);
+		const normalizedApiKey = asString(apiKey);
+		const normalizedApiKeySecret = asString(apiKeySecret);
+
+		if (!normalizedBaseUrl || !normalizedPipelineId || !normalizedApiKey || !normalizedApiKeySecret) {
+			return undefined;
+		}
+
+		return {
+			baseUrl: normalizedBaseUrl,
+			pipelineId: normalizedPipelineId,
+			apiKey: normalizedApiKey,
+			apiKeySecret: normalizedApiKeySecret,
+			queryTemplate: asString(queryTemplate),
+			minimumSimilarityPercent: Number(minimumSimilarityPercent || 0),
+		};
+	}
+
+	private getAnswerProviderSettings(): OpenAICompatibleProviderSettings | undefined {
+		const baseUrl = settings.get<string>('AI_LLM_OpenAI_Base_URL');
+		const apiKey = settings.get<string>('AI_LLM_OpenAI_API_Key');
+		const model = settings.get<string>('AI_LLM_OpenAI_Model');
+
+		const normalizedBaseUrl = asString(baseUrl);
+		const normalizedApiKey = asString(apiKey);
+		const normalizedModel = asString(model);
+
+		if (!normalizedBaseUrl || !normalizedApiKey) {
+			return undefined;
+		}
+
+		return {
+			baseUrl: normalizedBaseUrl,
+			apiKey: normalizedApiKey,
+			model: normalizedModel,
+		};
+	}
+
+	private getAnswerProviderConfig(): OpenAICompatibleProviderConfig | undefined {
+		const provider = this.getAnswerProviderSettings();
+		if (!provider?.model) {
+			return undefined;
+		}
+
+		return {
+			name: 'OpenAI compatible',
+			baseUrl: provider.baseUrl,
+			apiKey: provider.apiKey,
+			model: provider.model,
+		};
+	}
+
+	async status(): Promise<AISearchStatus> {
+		const hasIntelligentSearchLicense = await License.hasModule(AI_LICENSE_MODULE);
+		const intelligentSearchEnabled = settings.get<boolean>('AI_Intelligent_Search_Enabled');
+		const answerGenerationEnabled = settings.get<boolean>('AI_Intelligent_Search_Answer_Enabled');
+		const pipelineConfig = this.getPipelineConfig();
+		const answerProviderConfig = this.getAnswerProviderConfig();
+
+		return {
+			hasIntelligentSearchLicense,
+			intelligentSearchEnabled: intelligentSearchEnabled === true,
+			intelligentSearchConfigured: Boolean(pipelineConfig),
+			answerGenerationConfigured: answerGenerationEnabled === true && Boolean(answerProviderConfig) && Boolean(pipelineConfig),
+		};
+	}
+
+	private async getRoomMap(roomIds: string[]): Promise<Map<string, Pick<IRoom, '_id' | 't' | 'name' | 'fname'>>> {
+		if (!roomIds.length) {
+			return new Map();
+		}
+
+		const rooms = await Rooms.findByIds([...new Set(roomIds)], {
+			projection: { _id: 1, t: 1, name: 1, fname: 1 },
+		}).toArray();
+
+		return new Map(rooms.map((room) => [room._id, room]));
+	}
+
+	private async getUserSubscribedRoomIdsForPipeline(userId: string): Promise<string[]> {
+		const roomIds = await Subscriptions.findByUserId(userId, {
+			projection: { rid: 1, status: 1 },
+		})
+			.map((subscription) => (isBannedSubscription(subscription) ? undefined : subscription.rid))
+			.toArray();
+
+		return roomIds.filter((rid): rid is string => Boolean(rid));
+	}
+
+	private async getSubscribedRoomIdSet(userId: string, roomIds: string[]): Promise<Set<string>> {
+		const uniqueRoomIdSet = new Set<string>();
+		for (const roomId of roomIds) {
+			if (roomId) {
+				uniqueRoomIdSet.add(roomId);
+			}
+		}
+		const uniqueRoomIds = [...uniqueRoomIdSet];
+		if (!uniqueRoomIds.length) {
+			return new Set();
+		}
+
+		const subscriptions = await Subscriptions.findByUserIdAndRoomIds(userId, uniqueRoomIds, {
+			projection: { rid: 1, status: 1 },
+		}).toArray();
+
+		const subscribedRoomIds = new Set<string>();
+		for (const subscription of subscriptions) {
+			if (!isBannedSubscription(subscription)) {
+				subscribedRoomIds.add(subscription.rid);
+			}
+		}
+		return subscribedRoomIds;
+	}
+
+	private async normalizeIntelligentResults(
+		rawSearchResults: unknown,
+		userId: string,
+		limit = AI_SEARCH_PAGE_SIZE,
+	): Promise<AISearchResult[]> {
+		const candidates = normalizeIntelligentSearchCandidates(rawSearchResults, [], limit, logger);
+		const msgIdSet = new Set<string>();
+		for (const { msgId } of candidates) {
+			if (msgId) {
+				msgIdSet.add(msgId);
+			}
+		}
+		const msgIds = [...msgIdSet];
+		let messageMap = new Map<string, Pick<IMessage, '_id' | 'rid' | 'msg' | 'ts' | 'u'>>();
+
+		if (msgIds.length > 0) {
+			messageMap = new Map(
+				await Messages.findVisibleByIds(msgIds, {
+					projection: { _id: 1, rid: 1, msg: 1, ts: 1, u: 1 },
+				})
+					.map((message) => [String(message._id), message] as const)
+					.toArray(),
+			);
+			logger.debug({ msg: 'AI search messages fetched from DB', requested: msgIds.length, found: messageMap.size });
+		}
+
+		const resultRoomIds = Array.from(messageMap.values(), ({ rid }) => rid);
+		const [rooms, subscribedRoomIds] = await Promise.all([
+			this.getRoomMap(resultRoomIds),
+			this.getSubscribedRoomIdSet(userId, resultRoomIds),
+		]);
+
+		const normalizedResults: AISearchResult[] = [];
+		for (const result of candidates) {
+			// candidates without a visible database message could surface stale pipeline text
+			const dbMessage = result.msgId ? messageMap.get(result.msgId) : undefined;
+			if (!dbMessage) {
+				logger.debug({ msg: 'AI search result filtered: message not visible', msgId: result.msgId });
+				continue;
+			}
+
+			const { rid } = dbMessage;
+			if (!rid || !subscribedRoomIds.has(rid)) {
+				continue;
+			}
+
+			const room = rooms.get(rid);
+			normalizedResults.push({
+				_id: result.msgId || result._id,
+				rid,
+				msgId: result.msgId,
+				text: dbMessage.msg || '',
+				ts: dbMessage.ts?.toISOString(),
+				u: dbMessage.u ? { username: dbMessage.u.username, name: dbMessage.u.name } : undefined,
+				...(Number.isFinite(result.score) && { score: result.score }),
+				...(room && { room }),
+			});
+			if (normalizedResults.length === limit) {
+				break;
+			}
+		}
+
+		return normalizedResults;
+	}
+
+	private async getUserClassifications(userId: string): Promise<string[]> {
+		const user = await Users.findOneById<Pick<IUser, 'roles'>>(userId, { projection: { roles: 1 } });
+		return Array.from(new Set(['user', ...(user?.roles || [])]));
+	}
+
+	private async getSubscribedRoomIds(userId: string, roomIds: string[]): Promise<string[]> {
+		return [...(await this.getSubscribedRoomIdSet(userId, roomIds))];
+	}
+
+	private async getSubscribedRoomIdsByName(userId: string, roomNames: string[] = []): Promise<string[]> {
+		if (!roomNames.length) {
+			return [];
+		}
+
+		const rooms = await Promise.all(
+			Array.from(new Set(roomNames)).map((roomName) => Rooms.findOneByNameOrFname(roomName, { projection: { _id: 1 } })),
+		);
+
+		const roomIds = rooms.reduce<string[]>((roomIds, room) => {
+			if (typeof room?._id === 'string') {
+				roomIds.push(room._id);
+			}
+
+			return roomIds;
+		}, []);
+
+		return this.getSubscribedRoomIds(userId, roomIds);
+	}
+
+	async search({
+		query,
+		userId,
+		filters: rawFilters,
+		limit = AI_SEARCH_PAGE_SIZE,
+	}: {
+		query: string;
+		userId: string;
+		filters?: AISearchFilters;
+		limit?: number;
+	}): Promise<AISearchResult[]> {
+		const hasIntelligentSearchLicense = await License.hasModule(AI_LICENSE_MODULE);
+		const intelligentSearchEnabled = settings.get<boolean>('AI_Intelligent_Search_Enabled');
+		const config = this.getPipelineConfig();
+
+		if (!hasIntelligentSearchLicense || intelligentSearchEnabled !== true || !config) {
+			logger.debug({
+				msg: 'AI search skipped: unavailable',
+				hasIntelligentSearchLicense,
+				intelligentSearchEnabled: intelligentSearchEnabled === true,
+				intelligentSearchConfigured: Boolean(config),
+			});
+			return [];
+		}
+
+		const filters = normalizeFilters(rawFilters);
+		const requestedRoomIds = [...new Set([...(filters.rids || []), ...(filters.rid ? [filters.rid] : [])])];
+		const roomNameIds = await this.getSubscribedRoomIdsByName(userId, filters.roomNames);
+		const scopedRoomIds = [...new Set([...requestedRoomIds, ...roomNameIds])];
+
+		// a room filter that resolves to no subscribed rooms must not fall through to the unscoped path
+		if (filters.roomNames?.length && !scopedRoomIds.length) {
+			logger.debug({ msg: 'AI search skipped: room name filters did not resolve to subscribed rooms' });
+			return [];
+		}
+		const [pipelineRoomIds, classifications] = await Promise.all([
+			scopedRoomIds.length ? this.getSubscribedRoomIds(userId, scopedRoomIds) : this.getUserSubscribedRoomIdsForPipeline(userId),
+			this.getUserClassifications(userId),
+		]);
+
+		if (!pipelineRoomIds.length) {
+			logger.debug({ msg: 'AI search skipped: user has no room subscriptions' });
+			return [];
+		}
+
+		const pipelineFilters = buildIntelligentSearchPipelineFilters(pipelineRoomIds, {
+			...filters,
+			rids: [...(filters.rids || []), ...roomNameIds],
+		});
+
+		if (!pipelineFilters) {
+			logger.debug({ msg: 'AI search skipped: no subscribed rooms for filters', rid: filters.rid });
+			return [];
+		}
+
+		const json = await searchIntelligentPipeline({
+			query,
+			config,
+			classifications,
+			pipelineFilters,
+			limit,
+			fetch: fetchWithSsrfValidation,
+			logger,
+		});
+
+		return this.normalizeIntelligentResults(json, userId, limit);
+	}
+
+	async answer({ query, messages }: { query: string; messages: AISearchAnswerMessage[] }): Promise<AISearchAnswerResult> {
+		const hasIntelligentSearchLicense = await License.hasModule(AI_LICENSE_MODULE);
+		const intelligentSearchEnabled = settings.get<boolean>('AI_Intelligent_Search_Enabled');
+		const answerGenerationEnabled = settings.get<boolean>('AI_Intelligent_Search_Answer_Enabled');
+		const pipelineConfig = this.getPipelineConfig();
+		const provider = this.getAnswerProviderConfig();
+		const systemPromptSetting = settings.get<string>('AI_Intelligent_Search_Answer_System_Prompt');
+
+		if (!hasIntelligentSearchLicense || intelligentSearchEnabled !== true || answerGenerationEnabled !== true || !pipelineConfig) {
+			throw new Error('error-ai-not-enabled');
+		}
+
+		if (!provider) {
+			throw new Error('error-ai-provider-not-configured');
+		}
+
+		const systemPrompt = asString(systemPromptSetting);
+
+		const sanitizedMessages: SearchAnswerMessage[] = messages.map(({ text, username, roomName, ts, score }) => ({
+			text,
+			username,
+			roomName,
+			ts,
+			score,
+		}));
+
+		return generateOpenAICompatibleSearchAnswer({
+			query,
+			messages: sanitizedMessages,
+			provider,
+			systemPrompt,
+			fetch: fetchWithSsrfValidation,
+			logger,
+			maxMessages: MAX_SEARCH_ANSWER_MESSAGES,
+			maxTextLength: MAX_SEARCH_ANSWER_TEXT_LENGTH,
+		});
+	}
+
+	async models(): Promise<AISearchModelOption[]> {
+		if (!(await License.hasModule(AI_LICENSE_MODULE))) {
+			return [];
+		}
+
+		const provider = this.getAnswerProviderSettings();
+		const selectedModel = settings.get<string>('AI_LLM_OpenAI_Model');
+
+		return listOpenAICompatibleModels({
+			provider,
+			selectedModel: asString(selectedModel),
+			fetch: fetchWithSsrfValidation,
+			logger,
+		});
+	}
+}