feat(*): add RAG support

frontend/src/lib/convex/_generated/api.d.ts

@@ -10,11 +10,14 @@
 
 import type * as chats from "../chats.js";
 import type * as devicePairings from "../devicePairings.js";
+import type * as http from "../http.js";
 import type * as messages from "../messages.js";
 import type * as pairingRequests from "../pairingRequests.js";
 import type * as pendingGenerations from "../pendingGenerations.js";
 import type * as photoDrafts from "../photoDrafts.js";
 import type * as photoRequests from "../photoRequests.js";
+import type * as rag from "../rag.js";
+import type * as ragConnections from "../ragConnections.js";
 import type * as users from "../users.js";
 
 import type {
@@ -26,11 +29,14 @@ import type {
 declare const fullApi: ApiFromModules<{
   chats: typeof chats;
   devicePairings: typeof devicePairings;
+  http: typeof http;
   messages: typeof messages;
   pairingRequests: typeof pairingRequests;
   pendingGenerations: typeof pendingGenerations;
   photoDrafts: typeof photoDrafts;
   photoRequests: typeof photoRequests;
+  rag: typeof rag;
+  ragConnections: typeof ragConnections;
   users: typeof users;
 }>;
 
@@ -60,4 +66,401 @@ export declare const internal: FilterApi<
   FunctionReference<any, "internal">
 >;
 
-export declare const components: {};
+export declare const components: {
+  rag: {
+    chunks: {
+      insert: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          chunks: Array<{
+            content: { metadata?: Record<string, any>; text: string };
+            embedding: Array<number>;
+            searchableText?: string;
+          }>;
+          entryId: string;
+          startOrder: number;
+        },
+        { status: "pending" | "ready" | "replaced" }
+      >;
+      list: FunctionReference<
+        "query",
+        "internal",
+        {
+          entryId: string;
+          order: "desc" | "asc";
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            metadata?: Record<string, any>;
+            order: number;
+            state: "pending" | "ready" | "replaced";
+            text: string;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        }
+      >;
+      replaceChunksPage: FunctionReference<
+        "mutation",
+        "internal",
+        { entryId: string; startOrder: number },
+        { nextStartOrder: number; status: "pending" | "ready" | "replaced" }
+      >;
+    };
+    entries: {
+      add: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          allChunks?: Array<{
+            content: { metadata?: Record<string, any>; text: string };
+            embedding: Array<number>;
+            searchableText?: string;
+          }>;
+          entry: {
+            contentHash?: string;
+            filterValues: Array<{ name: string; value: any }>;
+            importance: number;
+            key?: string;
+            metadata?: Record<string, any>;
+            namespaceId: string;
+            title?: string;
+          };
+          onComplete?: string;
+        },
+        {
+          created: boolean;
+          entryId: string;
+          status: "pending" | "ready" | "replaced";
+        }
+      >;
+      addAsync: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          chunker: string;
+          entry: {
+            contentHash?: string;
+            filterValues: Array<{ name: string; value: any }>;
+            importance: number;
+            key?: string;
+            metadata?: Record<string, any>;
+            namespaceId: string;
+            title?: string;
+          };
+          onComplete?: string;
+        },
+        { created: boolean; entryId: string; status: "pending" | "ready" }
+      >;
+      deleteAsync: FunctionReference<
+        "mutation",
+        "internal",
+        { entryId: string; startOrder: number },
+        null
+      >;
+      deleteByKeyAsync: FunctionReference<
+        "mutation",
+        "internal",
+        { beforeVersion?: number; key: string; namespaceId: string },
+        null
+      >;
+      deleteByKeySync: FunctionReference<
+        "action",
+        "internal",
+        { key: string; namespaceId: string },
+        null
+      >;
+      deleteSync: FunctionReference<
+        "action",
+        "internal",
+        { entryId: string },
+        null
+      >;
+      findByContentHash: FunctionReference<
+        "query",
+        "internal",
+        {
+          contentHash: string;
+          dimension: number;
+          filterNames: Array<string>;
+          key: string;
+          modelId: string;
+          namespace: string;
+        },
+        {
+          contentHash?: string;
+          entryId: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          replacedAt?: number;
+          status: "pending" | "ready" | "replaced";
+          title?: string;
+        } | null
+      >;
+      get: FunctionReference<
+        "query",
+        "internal",
+        { entryId: string },
+        {
+          contentHash?: string;
+          entryId: string;
+          filterValues: Array<{ name: string; value: any }>;
+          importance: number;
+          key?: string;
+          metadata?: Record<string, any>;
+          replacedAt?: number;
+          status: "pending" | "ready" | "replaced";
+          title?: string;
+        } | null
+      >;
+      list: FunctionReference<
+        "query",
+        "internal",
+        {
+          namespaceId?: string;
+          order?: "desc" | "asc";
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+          status: "pending" | "ready" | "replaced";
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            contentHash?: string;
+            entryId: string;
+            filterValues: Array<{ name: string; value: any }>;
+            importance: number;
+            key?: string;
+            metadata?: Record<string, any>;
+            replacedAt?: number;
+            status: "pending" | "ready" | "replaced";
+            title?: string;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        }
+      >;
+      promoteToReady: FunctionReference<
+        "mutation",
+        "internal",
+        { entryId: string },
+        {
+          replacedEntry: {
+            contentHash?: string;
+            entryId: string;
+            filterValues: Array<{ name: string; value: any }>;
+            importance: number;
+            key?: string;
+            metadata?: Record<string, any>;
+            replacedAt?: number;
+            status: "pending" | "ready" | "replaced";
+            title?: string;
+          } | null;
+        }
+      >;
+    };
+    namespaces: {
+      deleteNamespace: FunctionReference<
+        "mutation",
+        "internal",
+        { namespaceId: string },
+        {
+          deletedNamespace: null | {
+            createdAt: number;
+            dimension: number;
+            filterNames: Array<string>;
+            modelId: string;
+            namespace: string;
+            namespaceId: string;
+            status: "pending" | "ready" | "replaced";
+            version: number;
+          };
+        }
+      >;
+      deleteNamespaceSync: FunctionReference<
+        "action",
+        "internal",
+        { namespaceId: string },
+        null
+      >;
+      get: FunctionReference<
+        "query",
+        "internal",
+        {
+          dimension: number;
+          filterNames: Array<string>;
+          modelId: string;
+          namespace: string;
+        },
+        null | {
+          createdAt: number;
+          dimension: number;
+          filterNames: Array<string>;
+          modelId: string;
+          namespace: string;
+          namespaceId: string;
+          status: "pending" | "ready" | "replaced";
+          version: number;
+        }
+      >;
+      getOrCreate: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          dimension: number;
+          filterNames: Array<string>;
+          modelId: string;
+          namespace: string;
+          onComplete?: string;
+          status: "pending" | "ready";
+        },
+        { namespaceId: string; status: "pending" | "ready" }
+      >;
+      list: FunctionReference<
+        "query",
+        "internal",
+        {
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+          status: "pending" | "ready" | "replaced";
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            createdAt: number;
+            dimension: number;
+            filterNames: Array<string>;
+            modelId: string;
+            namespace: string;
+            namespaceId: string;
+            status: "pending" | "ready" | "replaced";
+            version: number;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        }
+      >;
+      listNamespaceVersions: FunctionReference<
+        "query",
+        "internal",
+        {
+          namespace: string;
+          paginationOpts: {
+            cursor: string | null;
+            endCursor?: string | null;
+            id?: number;
+            maximumBytesRead?: number;
+            maximumRowsRead?: number;
+            numItems: number;
+          };
+        },
+        {
+          continueCursor: string;
+          isDone: boolean;
+          page: Array<{
+            createdAt: number;
+            dimension: number;
+            filterNames: Array<string>;
+            modelId: string;
+            namespace: string;
+            namespaceId: string;
+            status: "pending" | "ready" | "replaced";
+            version: number;
+          }>;
+          pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+          splitCursor?: string | null;
+        }
+      >;
+      lookup: FunctionReference<
+        "query",
+        "internal",
+        {
+          dimension: number;
+          filterNames: Array<string>;
+          modelId: string;
+          namespace: string;
+        },
+        null | string
+      >;
+      promoteToReady: FunctionReference<
+        "mutation",
+        "internal",
+        { namespaceId: string },
+        {
+          replacedNamespace: null | {
+            createdAt: number;
+            dimension: number;
+            filterNames: Array<string>;
+            modelId: string;
+            namespace: string;
+            namespaceId: string;
+            status: "pending" | "ready" | "replaced";
+            version: number;
+          };
+        }
+      >;
+    };
+    search: {
+      search: FunctionReference<
+        "action",
+        "internal",
+        {
+          chunkContext?: { after: number; before: number };
+          embedding: Array<number>;
+          filters: Array<{ name: string; value: any }>;
+          limit: number;
+          modelId: string;
+          namespace: string;
+          vectorScoreThreshold?: number;
+        },
+        {
+          entries: Array<{
+            contentHash?: string;
+            entryId: string;
+            filterValues: Array<{ name: string; value: any }>;
+            importance: number;
+            key?: string;
+            metadata?: Record<string, any>;
+            replacedAt?: number;
+            status: "pending" | "ready" | "replaced";
+            title?: string;
+          }>;
+          results: Array<{
+            content: Array<{ metadata?: Record<string, any>; text: string }>;
+            entryId: string;
+            order: number;
+            score: number;
+            startOrder: number;
+          }>;
+        }
+      >;
+    };
+  };
+};

frontend/src/lib/convex/chats.ts

@@ -80,7 +80,13 @@ export const getWithUser = query({
 				followUpPrompt: v.optional(v.string()),
 				model: v.string(),
 				followUpModel: v.optional(v.string()),
-				activeChatId: v.optional(v.id('chats'))
+				activeChatId: v.optional(v.id('chats')),
+				ragCollectionMode: v.optional(
+					v.object({
+						ragDatabaseId: v.id('ragDatabases'),
+						activeSince: v.number()
+					})
+				)
 			})
 		}),
 		v.null()

frontend/src/lib/convex/convex.config.ts

@@ -0,0 +1,7 @@
+import { defineApp } from 'convex/server';
+import rag from '@convex-dev/rag/convex.config';
+
+const app = defineApp();
+app.use(rag);
+
+export default app;

frontend/src/lib/convex/http.ts

@@ -0,0 +1,43 @@
+import { httpRouter } from 'convex/server';
+import { httpAction } from './_generated/server';
+import { api } from './_generated/api';
+import type { Id } from './_generated/dataModel';
+
+const http = httpRouter();
+
+http.route({
+	path: '/rag/search',
+	method: 'POST',
+	handler: httpAction(async (ctx, req) => {
+		const body = await req.json();
+		const { userId, dbNames, query, apiKey, limit } = body as {
+			userId: string;
+			dbNames: string[];
+			query: string;
+			apiKey: string;
+			limit?: number;
+		};
+
+		if (!userId || !dbNames || !query || !apiKey) {
+			return new Response(JSON.stringify({ error: 'Missing required fields' }), {
+				status: 400,
+				headers: { 'Content-Type': 'application/json' }
+			});
+		}
+
+		const result = await ctx.runAction(api.rag.searchMultiple, {
+			userId: userId as Id<'users'>,
+			dbNames,
+			apiKey,
+			query,
+			limit
+		});
+
+		return new Response(JSON.stringify(result), {
+			status: 200,
+			headers: { 'Content-Type': 'application/json' }
+		});
+	})
+});
+
+export default http;

frontend/src/lib/convex/rag.ts

@@ -0,0 +1,252 @@
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { RAG } from '@convex-dev/rag';
+import { v } from 'convex/values';
+import { api, components } from './_generated/api';
+import { action, mutation, query } from './_generated/server';
+
+function createRagInstance(apiKey: string) {
+	const google = createGoogleGenerativeAI({ apiKey });
+	return new RAG(components.rag, {
+		textEmbeddingModel: google.embedding('text-embedding-004'),
+		embeddingDimension: 768
+	});
+}
+
+function buildNamespace(userId: string, dbName: string): string {
+	return `user_${userId}/${dbName}`;
+}
+
+export const createDatabase = mutation({
+	args: { userId: v.id('users'), name: v.string() },
+	returns: v.id('ragDatabases'),
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query('ragDatabases')
+			.withIndex('by_user_id_and_name', (q) => q.eq('userId', args.userId).eq('name', args.name))
+			.unique();
+
+		if (existing) {
+			return existing._id;
+		}
+
+		return await ctx.db.insert('ragDatabases', {
+			userId: args.userId,
+			name: args.name,
+			createdAt: Date.now()
+		});
+	}
+});
+
+export const getDatabase = query({
+	args: { userId: v.id('users'), name: v.string() },
+	returns: v.union(
+		v.object({
+			_id: v.id('ragDatabases'),
+			_creationTime: v.number(),
+			userId: v.id('users'),
+			name: v.string(),
+			createdAt: v.number()
+		}),
+		v.null()
+	),
+	handler: async (ctx, args) => {
+		return await ctx.db
+			.query('ragDatabases')
+			.withIndex('by_user_id_and_name', (q) => q.eq('userId', args.userId).eq('name', args.name))
+			.unique();
+	}
+});
+
+export const getDatabaseById = query({
+	args: { ragDatabaseId: v.id('ragDatabases') },
+	returns: v.union(
+		v.object({
+			_id: v.id('ragDatabases'),
+			_creationTime: v.number(),
+			userId: v.id('users'),
+			name: v.string(),
+			createdAt: v.number()
+		}),
+		v.null()
+	),
+	handler: async (ctx, args) => {
+		return await ctx.db.get(args.ragDatabaseId);
+	}
+});
+
+export const listDatabases = query({
+	args: { userId: v.id('users') },
+	returns: v.array(
+		v.object({
+			_id: v.id('ragDatabases'),
+			_creationTime: v.number(),
+			userId: v.id('users'),
+			name: v.string(),
+			createdAt: v.number()
+		})
+	),
+	handler: async (ctx, args) => {
+		return await ctx.db
+			.query('ragDatabases')
+			.withIndex('by_user_id', (q) => q.eq('userId', args.userId))
+			.collect();
+	}
+});
+
+export const deleteDatabase = action({
+	args: { userId: v.id('users'), name: v.string(), apiKey: v.string() },
+	returns: v.boolean(),
+	handler: async (ctx, args) => {
+		const db = await ctx.runQuery(api.rag.getDatabase, {
+			userId: args.userId,
+			name: args.name
+		});
+
+		if (!db) {
+			return false;
+		}
+
+		const connections = await ctx.runQuery(api.ragConnections.getByRagDatabaseId, {
+			ragDatabaseId: db._id
+		});
+
+		for (const conn of connections) {
+			await ctx.runMutation(api.ragConnections.deleteConnection, {
+				connectionId: conn._id
+			});
+		}
+
+		await ctx.runMutation(api.rag.deleteDatabaseRecord, {
+			ragDatabaseId: db._id
+		});
+
+		return true;
+	}
+});
+
+export const deleteDatabaseRecord = mutation({
+	args: { ragDatabaseId: v.id('ragDatabases') },
+	returns: v.null(),
+	handler: async (ctx, args) => {
+		await ctx.db.delete(args.ragDatabaseId);
+		return null;
+	}
+});
+
+export const addContent = action({
+	args: {
+		userId: v.id('users'),
+		ragDatabaseId: v.id('ragDatabases'),
+		apiKey: v.string(),
+		text: v.string(),
+		key: v.optional(v.string())
+	},
+	returns: v.null(),
+	handler: async (ctx, args) => {
+		const db = await ctx.runQuery(api.rag.getDatabaseById, {
+			ragDatabaseId: args.ragDatabaseId
+		});
+
+		if (!db) {
+			throw new Error('RAG database not found');
+		}
+
+		const rag = createRagInstance(args.apiKey);
+		const namespace = buildNamespace(args.userId, db.name);
+
+		await rag.add(ctx, {
+			namespace,
+			text: args.text,
+			key: args.key
+		});
+
+		return null;
+	}
+});
+
+export const search = action({
+	args: {
+		userId: v.id('users'),
+		dbName: v.string(),
+		apiKey: v.string(),
+		query: v.string(),
+		limit: v.optional(v.number())
+	},
+	returns: v.object({
+		text: v.string(),
+		results: v.array(
+			v.object({
+				text: v.string(),
+				score: v.number()
+			})
+		)
+	}),
+	handler: async (ctx, args) => {
+		const rag = createRagInstance(args.apiKey);
+		const namespace = buildNamespace(args.userId, args.dbName);
+
+		const { results, text } = await rag.search(ctx, {
+			namespace,
+			query: args.query,
+			limit: args.limit ?? 5
+		});
+
+		return {
+			text: text ?? '',
+			results: results.map((r) => ({
+				text: r.content.map((c) => c.text).join('\n'),
+				score: r.score
+			}))
+		};
+	}
+});
+
+export const searchMultiple = action({
+	args: {
+		userId: v.id('users'),
+		dbNames: v.array(v.string()),
+		apiKey: v.string(),
+		query: v.string(),
+		limit: v.optional(v.number())
+	},
+	returns: v.object({
+		text: v.string(),
+		results: v.array(
+			v.object({
+				text: v.string(),
+				score: v.number(),
+				dbName: v.string()
+			})
+		)
+	}),
+	handler: async (ctx, args) => {
+		const rag = createRagInstance(args.apiKey);
+		const allResults: Array<{ text: string; score: number; dbName: string }> = [];
+
+		for (const dbName of args.dbNames) {
+			const namespace = buildNamespace(args.userId, dbName);
+			const { results } = await rag.search(ctx, {
+				namespace,
+				query: args.query,
+				limit: args.limit ?? 5
+			});
+
+			for (const r of results) {
+				allResults.push({
+					text: r.content.map((c) => c.text).join('\n'),
+					score: r.score,
+					dbName
+				});
+			}
+		}
+
+		allResults.sort((a, b) => b.score - a.score);
+		const topResults = allResults.slice(0, args.limit ?? 5);
+		const combinedText = topResults.map((r) => r.text).join('\n\n---\n\n');
+
+		return {
+			text: combinedText,
+			results: topResults
+		};
+	}
+});

frontend/src/lib/convex/ragConnections.ts

@@ -0,0 +1,102 @@
+import { v } from 'convex/values';
+import { mutation, query } from './_generated/server';
+
+export const connect = mutation({
+	args: {
+		userId: v.id('users'),
+		ragDatabaseId: v.id('ragDatabases'),
+		isGlobal: v.optional(v.boolean())
+	},
+	returns: v.id('ragConnections'),
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query('ragConnections')
+			.withIndex('by_user_id_and_rag_database_id', (q) =>
+				q.eq('userId', args.userId).eq('ragDatabaseId', args.ragDatabaseId)
+			)
+			.unique();
+
+		if (existing) {
+			return existing._id;
+		}
+
+		return await ctx.db.insert('ragConnections', {
+			userId: args.userId,
+			ragDatabaseId: args.ragDatabaseId,
+			isGlobal: args.isGlobal ?? true,
+			createdAt: Date.now()
+		});
+	}
+});
+
+export const disconnect = mutation({
+	args: {
+		userId: v.id('users'),
+		ragDatabaseId: v.id('ragDatabases')
+	},
+	returns: v.boolean(),
+	handler: async (ctx, args) => {
+		const existing = await ctx.db
+			.query('ragConnections')
+			.withIndex('by_user_id_and_rag_database_id', (q) =>
+				q.eq('userId', args.userId).eq('ragDatabaseId', args.ragDatabaseId)
+			)
+			.unique();
+
+		if (!existing) {
+			return false;
+		}
+
+		await ctx.db.delete(existing._id);
+		return true;
+	}
+});
+
+export const getActiveForUser = query({
+	args: { userId: v.id('users') },
+	returns: v.array(
+		v.object({
+			_id: v.id('ragConnections'),
+			_creationTime: v.number(),
+			userId: v.id('users'),
+			ragDatabaseId: v.id('ragDatabases'),
+			isGlobal: v.boolean(),
+			createdAt: v.number()
+		})
+	),
+	handler: async (ctx, args) => {
+		return await ctx.db
+			.query('ragConnections')
+			.withIndex('by_user_id', (q) => q.eq('userId', args.userId))
+			.collect();
+	}
+});
+
+export const getByRagDatabaseId = query({
+	args: { ragDatabaseId: v.id('ragDatabases') },
+	returns: v.array(
+		v.object({
+			_id: v.id('ragConnections'),
+			_creationTime: v.number(),
+			userId: v.id('users'),
+			ragDatabaseId: v.id('ragDatabases'),
+			isGlobal: v.boolean(),
+			createdAt: v.number()
+		})
+	),
+	handler: async (ctx, args) => {
+		return await ctx.db
+			.query('ragConnections')
+			.withIndex('by_rag_database_id', (q) => q.eq('ragDatabaseId', args.ragDatabaseId))
+			.collect();
+	}
+});
+
+export const deleteConnection = mutation({
+	args: { connectionId: v.id('ragConnections') },
+	returns: v.null(),
+	handler: async (ctx, args) => {
+		await ctx.db.delete(args.connectionId);
+		return null;
+	}
+});

frontend/src/lib/convex/schema.ts

@@ -10,7 +10,13 @@ export default defineSchema({
 		followUpPrompt: v.optional(v.string()),
 		model: v.string(),
 		followUpModel: v.optional(v.string()),
-		activeChatId: v.optional(v.id('chats'))
+		activeChatId: v.optional(v.id('chats')),
+		ragCollectionMode: v.optional(
+			v.object({
+				ragDatabaseId: v.id('ragDatabases'),
+				activeSince: v.number()
+			})
+		)
 	}).index('by_telegram_id', ['telegramId']),
 
 	chats: defineTable({
@@ -98,5 +104,23 @@ export default defineSchema({
 		base64: v.string(),
 		mediaType: v.string(),
 		createdAt: v.number()
-	}).index('by_chat_id_and_device_id', ['chatId', 'deviceId'])
+	}).index('by_chat_id_and_device_id', ['chatId', 'deviceId']),
+
+	ragDatabases: defineTable({
+		userId: v.id('users'),
+		name: v.string(),
+		createdAt: v.number()
+	})
+		.index('by_user_id', ['userId'])
+		.index('by_user_id_and_name', ['userId', 'name']),
+
+	ragConnections: defineTable({
+		userId: v.id('users'),
+		ragDatabaseId: v.id('ragDatabases'),
+		isGlobal: v.boolean(),
+		createdAt: v.number()
+	})
+		.index('by_user_id', ['userId'])
+		.index('by_user_id_and_rag_database_id', ['userId', 'ragDatabaseId'])
+		.index('by_rag_database_id', ['ragDatabaseId'])
 });

frontend/src/lib/convex/users.ts

@@ -16,7 +16,13 @@ export const getById = query({
 			followUpPrompt: v.optional(v.string()),
 			model: v.string(),
 			followUpModel: v.optional(v.string()),
-			activeChatId: v.optional(v.id('chats'))
+			activeChatId: v.optional(v.id('chats')),
+			ragCollectionMode: v.optional(
+				v.object({
+					ragDatabaseId: v.id('ragDatabases'),
+					activeSince: v.number()
+				})
+			)
 		}),
 		v.null()
 	),
@@ -38,7 +44,13 @@ export const getByTelegramId = query({
 			followUpPrompt: v.optional(v.string()),
 			model: v.string(),
 			followUpModel: v.optional(v.string()),
-			activeChatId: v.optional(v.id('chats'))
+			activeChatId: v.optional(v.id('chats')),
+			ragCollectionMode: v.optional(
+				v.object({
+					ragDatabaseId: v.id('ragDatabases'),
+					activeSince: v.number()
+				})
+			)
 		}),
 		v.null()
 	),
@@ -127,3 +139,41 @@ export const setActiveChat = mutation({
 		return null;
 	}
 });
+
+export const startRagCollectionMode = mutation({
+	args: { userId: v.id('users'), ragDatabaseId: v.id('ragDatabases') },
+	returns: v.null(),
+	handler: async (ctx, args) => {
+		await ctx.db.patch(args.userId, {
+			ragCollectionMode: {
+				ragDatabaseId: args.ragDatabaseId,
+				activeSince: Date.now()
+			}
+		});
+		return null;
+	}
+});
+
+export const stopRagCollectionMode = mutation({
+	args: { userId: v.id('users') },
+	returns: v.null(),
+	handler: async (ctx, args) => {
+		await ctx.db.patch(args.userId, { ragCollectionMode: undefined });
+		return null;
+	}
+});
+
+export const getRagCollectionMode = query({
+	args: { userId: v.id('users') },
+	returns: v.union(
+		v.object({
+			ragDatabaseId: v.id('ragDatabases'),
+			activeSince: v.number()
+		}),
+		v.null()
+	),
+	handler: async (ctx, args) => {
+		const user = await ctx.db.get(args.userId);
+		return user?.ragCollectionMode ?? null;
+	}
+});