@lobehub/lobehub 2.0.0-next.341 → 2.0.0-next.343

package/src/server/routers/lambda/userMemories/search.ts

@@ -1,117 +0,0 @@
-import { type LobeChatDatabase } from '@lobechat/database';
-import { type z } from 'zod';
-
-import { DEFAULT_FILE_EMBEDDING_MODEL_ITEM } from '@/const/settings/knowledge';
-import { type UserMemoryModel } from '@/database/models/userMemory';
-import { getServerDefaultFilesConfig } from '@/server/globalConfig';
-import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
-import { type SearchMemoryResult, searchMemorySchema } from '@/types/userMemory';
-
-import { EMBEDDING_VECTOR_DIMENSION, memoryProcedure, router } from './shared';
-
-type MemorySearchContext = {
-  memoryModel: UserMemoryModel;
-  serverDB: LobeChatDatabase;
-  userId: string;
-};
-
-type MemorySearchResult = Awaited<ReturnType<UserMemoryModel['searchWithEmbedding']>>;
-
-const EMPTY_SEARCH_RESULT: SearchMemoryResult = {
-  contexts: [],
-  experiences: [],
-  preferences: [],
-};
-
-const mapMemorySearchResult = (layeredResults: MemorySearchResult): SearchMemoryResult => {
-  return {
-    contexts: layeredResults.contexts.map((context) => ({
-      accessedAt: context.accessedAt,
-      associatedObjects: context.associatedObjects,
-      associatedSubjects: context.associatedSubjects,
-      createdAt: context.createdAt,
-      currentStatus: context.currentStatus,
-      description: context.description,
-      id: context.id,
-      metadata: context.metadata,
-      scoreImpact: context.scoreImpact,
-      scoreUrgency: context.scoreUrgency,
-      tags: context.tags,
-      title: context.title,
-      type: context.type,
-      updatedAt: context.updatedAt,
-      userMemoryIds: Array.isArray(context.userMemoryIds)
-        ? (context.userMemoryIds as string[])
-        : null,
-    })),
-    experiences: layeredResults.experiences.map((experience) => ({
-      accessedAt: experience.accessedAt,
-      action: experience.action,
-      createdAt: experience.createdAt,
-      id: experience.id,
-      keyLearning: experience.keyLearning,
-      metadata: experience.metadata,
-      possibleOutcome: experience.possibleOutcome,
-      reasoning: experience.reasoning,
-      scoreConfidence: experience.scoreConfidence,
-      situation: experience.situation,
-      tags: experience.tags,
-      type: experience.type,
-      updatedAt: experience.updatedAt,
-      userMemoryId: experience.userMemoryId,
-    })),
-    preferences: layeredResults.preferences.map((preference) => ({
-      accessedAt: preference.accessedAt,
-      conclusionDirectives: preference.conclusionDirectives,
-      createdAt: preference.createdAt,
-      id: preference.id,
-      metadata: preference.metadata,
-      scorePriority: preference.scorePriority,
-      suggestions: preference.suggestions,
-      tags: preference.tags,
-      type: preference.type,
-      updatedAt: preference.updatedAt,
-      userMemoryId: preference.userMemoryId,
-    })),
-  } satisfies SearchMemoryResult;
-};
-
-export const searchUserMemories = async (
-  ctx: MemorySearchContext,
-  input: z.infer<typeof searchMemorySchema>,
-): Promise<SearchMemoryResult> => {
-  const { provider, model: embeddingModel } =
-    getServerDefaultFilesConfig().embeddingModel || DEFAULT_FILE_EMBEDDING_MODEL_ITEM;
-  // Read user's provider config from database
-  const agentRuntime = await initModelRuntimeFromDB(ctx.serverDB, ctx.userId, provider);
-
-  const queryEmbeddings = await agentRuntime.embeddings({
-    dimensions: EMBEDDING_VECTOR_DIMENSION,
-    input: input.query,
-    model: embeddingModel,
-  });
-
-  const limits = {
-    contexts: input.topK?.contexts,
-    experiences: input.topK?.experiences,
-    preferences: input.topK?.preferences,
-  };
-
-  const layeredResults = await ctx.memoryModel.searchWithEmbedding({
-    embedding: queryEmbeddings?.[0],
-    limits,
-  });
-
-  return mapMemorySearchResult(layeredResults);
-};
-
-export const searchRouter = router({
-  searchMemory: memoryProcedure.input(searchMemorySchema).query(async ({ input, ctx }) => {
-    try {
-      return await searchUserMemories(ctx, input);
-    } catch (error) {
-      console.error('Failed to retrieve memories:', error);
-      return EMPTY_SEARCH_RESULT;
-    }
-  }),
-});

package/src/server/routers/lambda/userMemories/shared.ts

@@ -1,63 +0,0 @@
-import { type LobeChatDatabase } from '@lobechat/database';
-import { type SQL, and } from 'drizzle-orm';
-
-import { DEFAULT_FILE_EMBEDDING_MODEL_ITEM } from '@/const/settings/knowledge';
-import { UserMemoryModel } from '@/database/models/userMemory';
-import { authedProcedure } from '@/libs/trpc/lambda';
-import { keyVaults, serverDatabase } from '@/libs/trpc/lambda/middleware';
-import { getServerDefaultFilesConfig } from '@/server/globalConfig';
-import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
-
-export const EMBEDDING_VECTOR_DIMENSION = 1024;
-
-export const memoryProcedure = authedProcedure
-  .use(serverDatabase)
-  .use(keyVaults)
-  .use(async (opts) => {
-    const { ctx } = opts;
-    return opts.next({
-      ctx: {
-        memoryModel: new UserMemoryModel(ctx.serverDB, ctx.userId),
-      },
-    });
-  });
-
-export const getEmbeddingRuntime = async (serverDB: LobeChatDatabase, userId: string) => {
-  const { provider, model: embeddingModel } =
-    getServerDefaultFilesConfig().embeddingModel || DEFAULT_FILE_EMBEDDING_MODEL_ITEM;
-  // Read user's provider config from database
-  const agentRuntime = await initModelRuntimeFromDB(serverDB, userId, provider);
-
-  return { agentRuntime, embeddingModel };
-};
-
-export const createEmbedder = (agentRuntime: any, embeddingModel: string) => {
-  return async (value?: string | null): Promise<number[] | undefined> => {
-    if (!value || value.trim().length === 0) return undefined;
-
-    const embeddings = await agentRuntime.embeddings({
-      dimensions: EMBEDDING_VECTOR_DIMENSION,
-      input: value,
-      model: embeddingModel,
-    });
-
-    return embeddings?.[0];
-  };
-};
-
-export const combineConditions = (conditions: Array<SQL | undefined>): SQL | undefined => {
-  const filtered = conditions.filter((condition): condition is SQL => condition !== undefined);
-  if (filtered.length === 0) return undefined;
-  if (filtered.length === 1) return filtered[0];
-
-  return and(...filtered);
-};
-
-export const normalizeEmbeddable = (value?: string | null): string | undefined => {
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-
-  return trimmed.length > 0 ? trimmed : undefined;
-};
-
-export { router } from '@/libs/trpc/lambda';

package/src/server/routers/lambda/userMemories/tools.ts

@@ -1,410 +0,0 @@
-import {
-  AddIdentityActionSchema,
-  ContextMemoryItemSchema,
-  ExperienceMemoryItemSchema,
-  PreferenceMemoryItemSchema,
-  RemoveIdentityActionSchema,
-  UpdateIdentityActionSchema,
-} from '@lobechat/memory-user-memory';
-import { LayersEnum } from '@lobechat/types';
-
-import {
-  type IdentityEntryBasePayload,
-  type IdentityEntryPayload,
-  UserMemoryModel,
-} from '@/database/models/userMemory';
-import { searchMemorySchema } from '@/types/userMemory';
-
-import { searchUserMemories } from './search';
-import { createEmbedder, getEmbeddingRuntime, memoryProcedure, router } from './shared';
-
-export const toolsRouter = router({
-  addContextMemory: memoryProcedure
-    .input(ContextMemoryItemSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const contextDescriptionEmbedding = await embed(input.withContext.description);
-
-        const { context, memory } = await ctx.memoryModel.createContextMemory({
-          context: {
-            associatedObjects:
-              UserMemoryModel.parseAssociatedObjects(input.withContext.associatedObjects) ?? null,
-            associatedSubjects:
-              UserMemoryModel.parseAssociatedSubjects(input.withContext.associatedSubjects) ?? null,
-            currentStatus: input.withContext.currentStatus ?? null,
-            description: input.withContext.description ?? null,
-            descriptionVector: contextDescriptionEmbedding ?? null,
-            metadata: {},
-            scoreImpact: input.withContext.scoreImpact ?? null,
-            scoreUrgency: input.withContext.scoreUrgency ?? null,
-            tags: input.tags ?? [],
-            title: input.withContext.title ?? null,
-            type: input.withContext.type ?? null,
-          },
-          details: input.details || '',
-          detailsEmbedding,
-          memoryCategory: input.memoryCategory,
-          memoryLayer: LayersEnum.Context,
-          memoryType: input.memoryType,
-          summary: input.summary,
-          summaryEmbedding,
-          title: input.title,
-        });
-
-        return {
-          contextId: context.id,
-          memoryId: memory.id,
-          message: 'Memory saved successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save memory:', error);
-        return {
-          message: `Failed to save memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  addExperienceMemory: memoryProcedure
-    .input(ExperienceMemoryItemSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const situationVector = await embed(input.withExperience.situation);
-        const actionVector = await embed(input.withExperience.action);
-        const keyLearningVector = await embed(input.withExperience.keyLearning);
-
-        const { experience, memory } = await ctx.memoryModel.createExperienceMemory({
-          details: input.details || '',
-          detailsEmbedding,
-          experience: {
-            action: input.withExperience.action ?? null,
-            actionVector: actionVector ?? null,
-            keyLearning: input.withExperience.keyLearning ?? null,
-            keyLearningVector: keyLearningVector ?? null,
-            metadata: {},
-            possibleOutcome: input.withExperience.possibleOutcome ?? null,
-            reasoning: input.withExperience.reasoning ?? null,
-            scoreConfidence: input.withExperience.scoreConfidence ?? null,
-            situation: input.withExperience.situation ?? null,
-            situationVector: situationVector ?? null,
-            tags: input.tags ?? [],
-            type: input.memoryType,
-          },
-          memoryCategory: input.memoryCategory,
-          memoryLayer: LayersEnum.Experience,
-          memoryType: input.memoryType,
-          summary: input.summary,
-          summaryEmbedding,
-          title: input.title,
-        });
-
-        return {
-          experienceId: experience.id,
-          memoryId: memory.id,
-          message: 'Memory saved successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save memory:', error);
-        return {
-          message: `Failed to save memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  addIdentityMemory: memoryProcedure
-    .input(AddIdentityActionSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const descriptionEmbedding = await embed(input.withIdentity.description);
-
-        const identityMetadata: Record<string, unknown> = {};
-        if (
-          input.withIdentity.scoreConfidence !== null &&
-          input.withIdentity.scoreConfidence !== undefined
-        ) {
-          identityMetadata.scoreConfidence = input.withIdentity.scoreConfidence;
-        }
-        if (
-          input.withIdentity.sourceEvidence !== null &&
-          input.withIdentity.sourceEvidence !== undefined
-        ) {
-          identityMetadata.sourceEvidence = input.withIdentity.sourceEvidence;
-        }
-
-        const { identityId, userMemoryId } = await ctx.memoryModel.addIdentityEntry({
-          base: {
-            details: input.details,
-            detailsVector1024: detailsEmbedding ?? null,
-            memoryCategory: input.memoryCategory,
-            memoryLayer: LayersEnum.Identity,
-            memoryType: input.memoryType,
-            metadata: Object.keys(identityMetadata).length > 0 ? identityMetadata : undefined,
-            summary: input.summary,
-            summaryVector1024: summaryEmbedding ?? null,
-            tags: input.tags,
-            title: input.title,
-          },
-          identity: {
-            description: input.withIdentity.description,
-            descriptionVector: descriptionEmbedding ?? null,
-            episodicDate: input.withIdentity.episodicDate,
-            metadata: Object.keys(identityMetadata).length > 0 ? identityMetadata : undefined,
-            relationship: input.withIdentity.relationship,
-            role: input.withIdentity.role,
-            tags: input.tags,
-            type: input.withIdentity.type,
-          },
-        });
-
-        return {
-          identityId,
-          memoryId: userMemoryId,
-          message: 'Identity memory saved successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save identity memory:', error);
-        return {
-          message: `Failed to save identity memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  addPreferenceMemory: memoryProcedure
-    .input(PreferenceMemoryItemSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        const summaryEmbedding = await embed(input.summary);
-        const detailsEmbedding = await embed(input.details);
-        const conclusionVector = await embed(input.withPreference.conclusionDirectives);
-
-        const suggestionsText =
-          input.withPreference?.suggestions?.length && input.withPreference?.suggestions?.length > 0
-            ? input.withPreference?.suggestions?.join('\n')
-            : null;
-
-        const metadata = {
-          appContext: input.withPreference.appContext,
-          extractedScopes: input.withPreference.extractedScopes,
-          originContext: input.withPreference.originContext,
-        } satisfies Record<string, unknown>;
-
-        const { memory, preference } = await ctx.memoryModel.createPreferenceMemory({
-          details: input.details || '',
-          detailsEmbedding,
-          memoryCategory: input.memoryCategory,
-          memoryLayer: LayersEnum.Preference,
-          memoryType: input.memoryType,
-          preference: {
-            conclusionDirectives: input.withPreference.conclusionDirectives || '',
-            conclusionDirectivesVector: conclusionVector ?? null,
-            metadata,
-            scorePriority: input.withPreference.scorePriority ?? null,
-            suggestions: suggestionsText,
-            tags: input.tags,
-            type: input.memoryType,
-          },
-          summary: input.summary,
-          summaryEmbedding,
-          title: input.title,
-        });
-
-        return {
-          memoryId: memory.id,
-          message: 'Memory saved successfully',
-          preferenceId: preference.id,
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to save memory:', error);
-        return {
-          message: `Failed to save memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  removeIdentityMemory: memoryProcedure
-    .input(RemoveIdentityActionSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const removed = await ctx.memoryModel.removeIdentityEntry(input.id);
-
-        if (!removed) {
-          return {
-            message: 'Identity memory not found',
-            success: false,
-          };
-        }
-
-        return {
-          identityId: input.id,
-          message: 'Identity memory removed successfully',
-          reason: input.reason,
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to remove identity memory:', error);
-        return {
-          message: `Failed to remove identity memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-
-  searchMemory: memoryProcedure.input(searchMemorySchema).query(async ({ input, ctx }) => {
-    try {
-      return await searchUserMemories(ctx, input);
-    } catch (error) {
-      console.error('Failed to retrieve memories:', error);
-      return { contexts: [], experiences: [], preferences: [] };
-    }
-  }),
-
-  updateIdentityMemory: memoryProcedure
-    .input(UpdateIdentityActionSchema)
-    .mutation(async ({ input, ctx }) => {
-      try {
-        const { agentRuntime, embeddingModel } = await getEmbeddingRuntime(
-          ctx.serverDB,
-          ctx.userId,
-        );
-        const embed = createEmbedder(agentRuntime, embeddingModel);
-
-        let summaryVector1024: number[] | null | undefined;
-        if (input.set.summary !== undefined) {
-          const vector = await embed(input.set.summary);
-          summaryVector1024 = vector ?? null;
-        }
-
-        let detailsVector1024: number[] | null | undefined;
-        if (input.set.details !== undefined) {
-          const vector = await embed(input.set.details);
-          detailsVector1024 = vector ?? null;
-        }
-
-        let descriptionVector: number[] | null | undefined;
-        if (input.set.withIdentity.description !== undefined) {
-          const vector = await embed(input.set.withIdentity.description);
-          descriptionVector = vector ?? null;
-        }
-
-        const metadataUpdates: Record<string, unknown> = {};
-        if (Object.hasOwn(input.set.withIdentity, 'scoreConfidence')) {
-          metadataUpdates.scoreConfidence = input.set.withIdentity.scoreConfidence ?? null;
-        }
-        if (Object.hasOwn(input.set.withIdentity, 'sourceEvidence')) {
-          metadataUpdates.sourceEvidence = input.set.withIdentity.sourceEvidence ?? null;
-        }
-
-        const identityPayload: Partial<IdentityEntryPayload> = {};
-        if (input.set.withIdentity.description !== undefined) {
-          identityPayload.description = input.set.withIdentity.description;
-          identityPayload.descriptionVector = descriptionVector;
-        }
-        if (input.set.withIdentity.episodicDate !== undefined) {
-          identityPayload.episodicDate = input.set.withIdentity.episodicDate;
-        }
-        if (input.set.withIdentity.relationship !== undefined) {
-          identityPayload.relationship = input.set.withIdentity.relationship;
-        }
-        if (input.set.withIdentity.role !== undefined) {
-          identityPayload.role = input.set.withIdentity.role;
-        }
-        if (input.set.tags !== undefined) {
-          identityPayload.tags = input.set.tags;
-        }
-        if (input.set.withIdentity.type !== undefined) {
-          identityPayload.type = input.set.withIdentity.type;
-        }
-        if (Object.keys(metadataUpdates).length > 0) {
-          identityPayload.metadata = metadataUpdates;
-        }
-
-        const basePayload: Partial<IdentityEntryBasePayload> = {};
-        if (input.set.details !== undefined) {
-          basePayload.details = input.set.details;
-          basePayload.detailsVector1024 = detailsVector1024;
-        }
-        if (input.set.memoryCategory !== undefined) {
-          basePayload.memoryCategory = input.set.memoryCategory;
-        }
-        if (input.set.memoryType !== undefined) {
-          basePayload.memoryType = input.set.memoryType;
-        }
-        if (input.set.summary !== undefined) {
-          basePayload.summary = input.set.summary;
-          basePayload.summaryVector1024 = summaryVector1024;
-        }
-        if (input.set.tags !== undefined) {
-          basePayload.tags = input.set.tags;
-        }
-        if (input.set.title !== undefined) {
-          basePayload.title = input.set.title;
-        }
-        if (Object.keys(metadataUpdates).length > 0) {
-          basePayload.metadata = metadataUpdates;
-        }
-
-        const updated = await ctx.memoryModel.updateIdentityEntry({
-          base: Object.keys(basePayload).length > 0 ? basePayload : undefined,
-          identity: Object.keys(identityPayload).length > 0 ? identityPayload : undefined,
-          identityId: input.id,
-          mergeStrategy: input.mergeStrategy,
-        });
-
-        if (!updated) {
-          return {
-            message: 'Identity memory not found',
-            success: false,
-          };
-        }
-
-        return {
-          identityId: input.id,
-          message: 'Identity memory updated successfully',
-          success: true,
-        };
-      } catch (error) {
-        console.error('Failed to update identity memory:', error);
-        return {
-          message: `Failed to update identity memory: ${(error as Error).message}`,
-          success: false,
-        };
-      }
-    }),
-});