@lota-sdk/core 0.4.8 → 0.4.10

package/src/services/memory/memory.service.ts

@@ -0,0 +1,674 @@
+import { Context, Schema, Effect, Layer } from 'effect'
+
+import { aiLogger } from '../../config/logger'
+import type { Memory } from '../../db/memory'
+import { isUniqueIndexConflict } from '../../db/memory-store.helpers'
+import type {
+  AddOptions,
+  ExtractedFact,
+  MemoryListScalar,
+  MemoryRecord,
+  MemorySearchResult,
+  MemoryType,
+  RelationType,
+} from '../../db/memory-types'
+import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../../effect/services'
+import { withOrgMemoryLockEffect } from '../../redis/org-memory-lock'
+import type { HelperModelRuntime } from '../../runtime/helper-model'
+import { HelperModelTag } from '../../runtime/helper-model'
+import { ORG_SCOPE_PREFIX, agentScopeId, scopeId } from '../../runtime/memory/memory-scope'
+import {
+  countScopedRetrievalCandidates,
+  executeScopedRetrieval,
+  scopedRetrievalToMap,
+} from '../../runtime/retrieval-adapters'
+import type { ResolvedLotaRuntimeConfig } from '../../runtime/runtime-config'
+import { clampImportance, compactWhitespace } from '../../utils/string'
+import { BackgroundWorkService } from '../background-work.service'
+import type { MemoryServiceError } from './memory-errors'
+import { tryMemoryPromise as memoryTryPromise } from './memory-errors'
+import type { MemoryRerankOutput } from './memory-rerank'
+import { formatMemoryResults, formatRerankedResults, getCandidateLimit } from './memory-utils'
+export type { MemoryRerankOutput } from './memory-rerank'
+import {
+  buildConversationMessages,
+  isRoutableAgentName,
+  resolveAgentScopeNames,
+  shouldSkipExtractedFacts,
+} from './memory-conversation'
+import { getOrgMemory, makeOrgMemoryCache } from './memory-org-memory'
+import type { OrgMemoryCache } from './memory-org-memory'
+import { getTopMemoriesSection } from './memory-preseeded'
+import { rerankCandidates, rerankCandidatesMultiScope } from './memory-rerank'
+import type { makeRerankService } from './rerank.service'
+import { RerankServiceTag } from './rerank.service'
+
+const ORG_MEMORY_TYPE = 'fact'
+const MAX_MEMORY_RESULTS_PER_SCOPE = 10
+const ONBOARDING_MEMORY_MAX_FACTS = 16
+const ONBOARDING_MEMORY_EXTRACTION_PROMPT =
+  'Onboarding mode is active. Extract multiple concrete startup facts from user-provided context: company mission, product capabilities, customer segments, pricing, traction, go-to-market plans, roadmap, team composition, technical stack, risks, and referenced URLs. Prefer one fact per concrete claim.'
+const DIRECT_MEMORY_ASSESSMENT_PROMPT =
+  'The user is submitting a direct memory candidate. Keep the wording faithful. Return one fact only when the statement is durable enough for memory; otherwise return no facts.'
+
+class InvalidAgentNameError extends Schema.TaggedErrorClass<InvalidAgentNameError>()('InvalidAgentNameError', {
+  agentName: Schema.String,
+}) {}
+
+type EffectSuccess<T> = T extends Effect.Effect<infer A, infer _E, infer _R> ? A : Awaited<T>
+
+function searchMemoriesEffect({
+  runtimeConfig,
+  helperModelRuntime,
+  resolveReranker,
+  query,
+  memory,
+  scopeId,
+  memoryType,
+  fastMode = true,
+}: {
+  runtimeConfig: ResolvedLotaRuntimeConfig
+  helperModelRuntime: HelperModelRuntime
+  resolveReranker: () => ReturnType<typeof makeRerankService>
+  query: string
+  memory: Memory
+  scopeId: string
+  memoryType: MemoryType
+  fastMode?: boolean
+}): Effect.Effect<string, MemoryServiceError> {
+  return Effect.gen(function* () {
+    const limit = runtimeConfig.memory.searchK
+    const candidateLimit = fastMode ? limit : getCandidateLimit(limit)
+    const candidates = yield* memoryTryPromise('Failed to search memory candidates.', () =>
+      memory.searchCandidates(query, {
+        scopeId,
+        limit: candidateLimit,
+        memoryType,
+        fastMode,
+        includeNeighborContext: !fastMode,
+      }),
+    )
+
+    aiLogger.debug`Memory search candidates (scopeId: ${scopeId}, candidates: ${candidates.length})`
+
+    if (candidates.length === 0) {
+      return 'No stored memories.'
+    }
+
+    if (fastMode || candidates.length <= limit) {
+      aiLogger.debug`Skipping reranking (candidates: ${candidates.length} <= limit: ${limit})`
+      return formatMemoryResults(candidates.slice(0, limit))
+    }
+
+    const reranked = yield* rerankCandidates(
+      runtimeConfig,
+      helperModelRuntime,
+      query,
+      candidates,
+      limit,
+      resolveReranker(),
+    )
+    return formatRerankedResults(reranked, candidates, limit)
+  })
+}
+
+function applyPreparedScopeUpdatesEffect(params: {
+  orgId: string
+  orgMemory: Memory
+  preparedUpdates: EffectSuccess<ReturnType<Memory['prepareFactsToScopes']>>
+  acquireLock?: boolean
+}) {
+  return Effect.gen(function* () {
+    if (params.preparedUpdates.length === 0) {
+      return
+    }
+
+    if (params.acquireLock === false) {
+      yield* memoryTryPromise('Failed to apply prepared memory scope updates.', () =>
+        params.orgMemory.applyPreparedScopeUpdates(params.preparedUpdates),
+      )
+      return
+    }
+
+    yield* withOrgMemoryLockEffect(params.orgId, () =>
+      memoryTryPromise('Failed to apply prepared memory scope updates.', () =>
+        params.orgMemory.applyPreparedScopeUpdates(params.preparedUpdates),
+      ),
+    )
+  })
+}
+
+function formatBatchedResults(
+  reranked: MemoryRerankOutput | null,
+  candidatesByScopeTag: Map<string, MemorySearchResult[]>,
+  limit: number,
+  agentName?: string,
+): string {
+  if (reranked && reranked.sections.length > 0) {
+    const allCandidates = Array.from(candidatesByScopeTag.values()).flat()
+    return formatRerankedResults(reranked, allCandidates, limit)
+  }
+
+  const sections: string[] = []
+
+  if (agentName) {
+    const agentCandidates = candidatesByScopeTag.get(`agent:${agentName}`) ?? []
+    if (agentCandidates.length > 0) {
+      sections.push(`Agent memory (${agentName}):\n${formatMemoryResults(agentCandidates.slice(0, limit))}`)
+    } else {
+      sections.push(`Agent memory (${agentName}):\nNo stored memories.`)
+    }
+  }
+
+  const orgCandidates = candidatesByScopeTag.get('org') ?? []
+  if (orgCandidates.length > 0) {
+    sections.push(
+      `${agentName ? 'Global org memory' : 'Organization memory'}:\n${formatMemoryResults(orgCandidates.slice(0, limit))}`,
+    )
+  } else {
+    sections.push(`${agentName ? 'Global org memory' : 'Organization memory'}:\nNo stored memories.`)
+  }
+
+  return sections.join('\n\n')
+}
+
+interface MemoryServiceDeps {
+  runtimeConfig: ResolvedLotaRuntimeConfig
+  rerankService: ReturnType<typeof makeRerankService>
+  helperModelRuntime: HelperModelRuntime
+  orgMemoryCache: OrgMemoryCache
+}
+
+export function createMemoryService(deps: MemoryServiceDeps) {
+  const { runtimeConfig, helperModelRuntime, orgMemoryCache } = deps
+  const resolveRerankService = () => deps.rerankService
+  const service = {
+    searchOrganizationMemories: Effect.fn('MemoryService.searchOrganizationMemories')(function* (
+      orgId: string,
+      query: string,
+    ) {
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      aiLogger.debug`Organization memory search requested (orgId: ${orgId}, scopeId: ${orgScopeId}, queryLength: ${query.length})`
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const results = yield* searchMemoriesEffect({
+        runtimeConfig,
+        helperModelRuntime,
+        resolveReranker: resolveRerankService,
+        query,
+        memory,
+        scopeId: orgScopeId,
+        memoryType: ORG_MEMORY_TYPE,
+      })
+      aiLogger.debug`Organization memory search completed (resultLength: ${results.length}, preview: ${results.slice(0, 100)})`
+      return results
+    }),
+
+    getStaleMemories(orgId: string) {
+      return Effect.gen(function* () {
+        const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+        const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+        return yield* memoryTryPromise('Failed to load stale memories.', () => memory.getStaleMemories(orgScopeId))
+      }).pipe(
+        Effect.withSpan('MemoryService.getStaleMemories'),
+        Effect.map((stale) => {
+          if (stale.length === 0) return ''
+          const items = stale.map((m) => `- [NEEDS REVIEW] ${m.content}`).join('\n')
+          return `Memories flagged for review (parent fact was superseded):\n${items}`
+        }),
+        Effect.catch((error) => {
+          aiLogger.error`Failed to get stale memories: ${error.cause}`
+          return Effect.succeed('')
+        }),
+      )
+    },
+
+    searchOrganizationMemoriesRaw: Effect.fn('MemoryService.searchOrganizationMemoriesRaw')(function* (
+      orgId: string,
+      query: string,
+      options?: { fastMode?: boolean; limit?: number },
+    ) {
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      aiLogger.debug`searchOrganizationMemoriesRaw - orgId: "${orgId}", scopeId: "${orgScopeId}"`
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const fastMode = options?.fastMode ?? true
+      const searchK = runtimeConfig.memory.searchK
+      const limit = options?.limit ?? (fastMode ? Math.min(searchK, 4) : searchK)
+      const candidates = yield* memoryTryPromise('Failed to search organization memories.', () =>
+        memory.searchCandidates(query, {
+          scopeId: orgScopeId,
+          limit,
+          memoryType: ORG_MEMORY_TYPE,
+          fastMode,
+          includeNeighborContext: !fastMode,
+        }),
+      )
+      aiLogger.debug`Organization memory search (raw) completed (candidates: ${candidates.length})`
+      return formatMemoryResults(candidates)
+    }),
+
+    searchAgentMemories: Effect.fn('MemoryService.searchAgentMemories')(function* (
+      orgId: string,
+      agentName: string,
+      query: string,
+    ) {
+      if (!isRoutableAgentName(agentName)) {
+        aiLogger.debug`Agent memory search skipped - invalid agentName: ${agentName}`
+        return 'No stored memories.'
+      }
+
+      const scoped = yield* agentScopeId(orgId, agentName)
+      aiLogger.debug`Agent memory search requested (orgId: ${orgId}, agentName: ${agentName}, scopeId: ${scoped}, queryLength: ${query.length})`
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const results = yield* searchMemoriesEffect({
+        runtimeConfig,
+        helperModelRuntime,
+        resolveReranker: resolveRerankService,
+        query,
+        memory,
+        scopeId: scoped,
+        memoryType: ORG_MEMORY_TYPE,
+      })
+      aiLogger.debug`Agent memory search completed (agentName: ${agentName}, resultLength: ${results.length}, preview: ${results.slice(0, 100)})`
+      return results
+    }),
+
+    listOrganizationMemoryRecords: Effect.fn('MemoryService.listOrganizationMemoryRecords')(function* (params: {
+      orgId: string
+      limit?: number
+      memoryType?: MemoryType
+      metadataEquals?: Record<string, MemoryListScalar>
+      metadataNotEquals?: Record<string, MemoryListScalar>
+      sort?: 'createdAtAsc' | 'createdAtDesc'
+    }) {
+      const { orgId, ...listOptions } = params
+      const orgMemory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      return yield* memoryTryPromise('Failed to list organization memory records.', () =>
+        orgMemory.list({ scopeId: orgScopeId, ...listOptions }),
+      )
+    }),
+
+    getTopMemories(params: { orgId: string; agentName?: string; limit?: number }) {
+      return getTopMemoriesSection({
+        orgMemoryCache,
+        orgId: params.orgId,
+        agentName: params.agentName,
+        limit: params.limit,
+      })
+    },
+
+    searchAllMemoriesBatched: Effect.fn('MemoryService.searchAllMemoriesBatched')(function* ({
+      orgId,
+      agentName,
+      query,
+      fastMode = true,
+      allowMultiScopeRerank = true,
+    }: {
+      orgId: string
+      agentName?: string
+      query: string
+      fastMode?: boolean
+      allowMultiScopeRerank?: boolean
+    }) {
+      const limit = Math.min(runtimeConfig.memory.searchK, MAX_MEMORY_RESULTS_PER_SCOPE)
+      const candidateLimit = fastMode ? limit : getCandidateLimit(limit)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      const orgMemory = yield* getOrgMemory(orgMemoryCache, orgId)
+
+      const retrievalTasks = [
+        {
+          scopeTag: 'org',
+          retrieve: () =>
+            orgMemory.searchCandidates(query, {
+              scopeId: orgScopeId,
+              limit: candidateLimit,
+              memoryType: ORG_MEMORY_TYPE,
+              fastMode,
+              includeNeighborContext: !fastMode,
+            }),
+        },
+      ]
+
+      if (isRoutableAgentName(agentName)) {
+        const agentScoped = yield* agentScopeId(orgId, agentName)
+        retrievalTasks.push({
+          scopeTag: `agent:${agentName}`,
+          retrieve: () =>
+            orgMemory.searchCandidates(query, {
+              scopeId: agentScoped,
+              limit: candidateLimit,
+              memoryType: ORG_MEMORY_TYPE,
+              fastMode,
+              includeNeighborContext: !fastMode,
+            }),
+        })
+      }
+
+      const results = yield* memoryTryPromise('Failed to execute scoped memory retrieval.', () =>
+        executeScopedRetrieval(retrievalTasks),
+      )
+      const totalCandidates = countScopedRetrievalCandidates(results)
+      aiLogger.debug`Batched memory search candidates (scopes: ${results.length}, total: ${totalCandidates})`
+
+      if (totalCandidates === 0) {
+        return 'No stored memories.'
+      }
+
+      const candidatesByScopeTag = scopedRetrievalToMap(results)
+      if (fastMode || !allowMultiScopeRerank) {
+        return formatBatchedResults(null, candidatesByScopeTag, limit, agentName)
+      }
+
+      const reranked = yield* rerankCandidatesMultiScope(
+        runtimeConfig,
+        helperModelRuntime,
+        query,
+        results,
+        limit,
+        resolveRerankService(),
+      )
+      return formatBatchedResults(reranked, candidatesByScopeTag, limit, agentName)
+    }),
+
+    createOrganizationMemory({
+      orgId,
+      content,
+      memoryType,
+      metadata,
+      importance,
+      durability,
+    }: {
+      orgId: string
+      content: string
+      memoryType: MemoryType
+      metadata?: Record<string, unknown>
+      importance?: number
+      durability?: MemoryRecord['durability']
+    }) {
+      return Effect.gen(function* () {
+        const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+        const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+        return yield* memoryTryPromise('Failed to create organization memory.', () =>
+          memory.insert(content, {
+            scopeId: orgScopeId,
+            memoryType,
+            importance: importance ?? 1,
+            durability,
+            metadata: { orgId, ...metadata },
+          }),
+        )
+      }).pipe(
+        Effect.withSpan('MemoryService.createOrganizationMemory'),
+        Effect.tap(() =>
+          Effect.gen(function* () {
+            const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+            aiLogger.debug`createOrganizationMemory - orgId: "${orgId}", scopeId: "${orgScopeId}", content preview: "${content.slice(0, 50)}"`
+          }),
+        ),
+        Effect.catch((error) => {
+          if (isUniqueIndexConflict(error, 'memoryHashIdx')) {
+            aiLogger.debug`Organization memory already exists (hash conflict)`
+            return Effect.succeed('')
+          }
+          return Effect.fail(error)
+        }),
+      )
+    },
+
+    addOrganizationMemoryRelation: Effect.fn('MemoryService.addOrganizationMemoryRelation')(function* ({
+      orgId,
+      fromMemoryId,
+      toMemoryId,
+      relationType,
+      confidence,
+    }: {
+      orgId: string
+      fromMemoryId: string
+      toMemoryId: string
+      relationType: RelationType
+      confidence?: number
+    }) {
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      return yield* memoryTryPromise('Failed to add organization memory relation.', () =>
+        memory.addRelation(fromMemoryId, toMemoryId, relationType, confidence),
+      )
+    }),
+
+    createAgentMemory({
+      orgId,
+      agentName,
+      content,
+      memoryType,
+      metadata,
+      importance,
+    }: {
+      orgId: string
+      agentName: string
+      content: string
+      memoryType: MemoryType
+      metadata?: Record<string, unknown>
+      importance?: number
+    }) {
+      if (!isRoutableAgentName(agentName)) {
+        return Effect.fail(new InvalidAgentNameError({ agentName }))
+      }
+
+      return Effect.gen(function* () {
+        const scoped = yield* agentScopeId(orgId, agentName)
+        const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+        return yield* memoryTryPromise('Failed to create agent memory.', () =>
+          memory.insert(content, {
+            scopeId: scoped,
+            memoryType,
+            importance: importance ?? 1,
+            metadata: { orgId, agentName, memoryScope: 'agent', ...metadata },
+          }),
+        )
+      }).pipe(
+        Effect.withSpan('MemoryService.createAgentMemory'),
+        Effect.catch((error) => {
+          if (isUniqueIndexConflict(error, 'memoryHashIdx')) {
+            aiLogger.debug`Agent memory already exists (hash conflict)`
+            return Effect.succeed('')
+          }
+          return Effect.fail(error)
+        }),
+      )
+    },
+
+    assessMemoryCandidate: Effect.fn('MemoryService.assessMemoryCandidate')(function* (params: {
+      orgId: string
+      content: string
+    }) {
+      const trimmed = compactWhitespace(params.content)
+      if (!trimmed) return null
+
+      const memory = yield* getOrgMemory(orgMemoryCache, params.orgId)
+      const facts = yield* memoryTryPromise('Failed to assess direct memory candidate.', () =>
+        memory.extractFactsFromMessages([{ role: 'user', content: trimmed }], {
+          maxFacts: 1,
+          customPrompt: DIRECT_MEMORY_ASSESSMENT_PROMPT,
+        }),
+      )
+      if (facts.length === 0) return null
+      const fact = facts[0]
+
+      return {
+        classification: fact.classification,
+        durability: fact.durability,
+        importance: clampImportance(fact.importance),
+        rationale: fact.rationale,
+      }
+    }),
+
+    updateOrganizationMemoryById: Effect.fn('MemoryService.updateOrganizationMemoryById')(function* ({
+      orgId,
+      memoryId,
+      content,
+    }: {
+      orgId: string
+      memoryId: string
+      content: string
+    }) {
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      return yield* memoryTryPromise('Failed to update organization memory.', () =>
+        memory.updateMemory(memoryId, content),
+      )
+    }),
+
+    addExtractedFactsToScopes: Effect.fn('MemoryService.addExtractedFactsToScopes')(function* (params: {
+      orgId: string
+      facts: ExtractedFact[]
+      source: string
+      sourceMetadata?: Record<string, unknown>
+      agentNames?: string[]
+      acquireLock?: boolean
+    }) {
+      if (params.facts.length === 0) return
+
+      const orgMemory = yield* getOrgMemory(orgMemoryCache, params.orgId)
+      const orgScopeIdValue = yield* scopeId(ORG_SCOPE_PREFIX, params.orgId)
+      const scopes: AddOptions[] = [
+        {
+          scopeId: orgScopeIdValue,
+          memoryType: ORG_MEMORY_TYPE,
+          metadata: { orgId: params.orgId, source: params.source, ...params.sourceMetadata },
+        },
+      ]
+
+      for (const scopedAgentName of resolveAgentScopeNames(undefined, params.agentNames ?? [])) {
+        const agentScopedValue = yield* agentScopeId(params.orgId, scopedAgentName)
+        scopes.push({
+          scopeId: agentScopedValue,
+          memoryType: ORG_MEMORY_TYPE,
+          metadata: {
+            orgId: params.orgId,
+            source: params.source,
+            ...params.sourceMetadata,
+            agentName: scopedAgentName,
+            memoryScope: 'agent',
+          },
+        })
+      }
+
+      const preparedUpdates = yield* memoryTryPromise('Failed to prepare extracted facts for memory scopes.', () =>
+        orgMemory.prepareFactsToScopes(params.facts, scopes),
+      )
+      yield* applyPreparedScopeUpdatesEffect({
+        orgId: params.orgId,
+        orgMemory,
+        preparedUpdates,
+        acquireLock: params.acquireLock,
+      })
+    }),
+
+    addConversationMemories: Effect.fn('MemoryService.addConversationMemories')(function* ({
+      orgId,
+      input,
+      output,
+      sourceId,
+      source = 'chat',
+      sourceMetadata,
+      onboardStatus,
+      agentName,
+      historyMessages = [],
+      memoryBlock,
+      attachmentContext,
+      agentNames = [],
+    }: {
+      orgId: string
+      input: string
+      output: string
+      sourceId?: string
+      source?: string
+      sourceMetadata?: Record<string, unknown>
+      onboardStatus?: string
+      agentName?: string
+      historyMessages?: Array<{ role: 'user' | 'agent'; content: string; agentName?: string }>
+      memoryBlock?: string
+      attachmentContext?: string
+      agentNames?: string[]
+    }) {
+      const { messages, normalizedInput, sanitizedOutput } = buildConversationMessages({
+        input,
+        output,
+        historyMessages,
+        memoryBlock,
+        attachmentContext,
+      })
+
+      if (!normalizedInput || !sanitizedOutput || messages.length === 0) {
+        aiLogger.debug`Skipping memory add - empty input or output`
+        return
+      }
+
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      aiLogger.debug`addConversationMemories - orgId: "${orgId}", scopeId: "${orgScopeId}", sourceId: ${sourceId ?? 'none'}`
+
+      const onboardingActive = onboardStatus !== undefined && onboardStatus !== 'completed'
+      const extractionConfig = onboardingActive
+        ? { maxFacts: ONBOARDING_MEMORY_MAX_FACTS, customPrompt: ONBOARDING_MEMORY_EXTRACTION_PROMPT }
+        : undefined
+      const orgMemory = yield* getOrgMemory(orgMemoryCache, orgId)
+
+      const scopes: AddOptions[] = [
+        {
+          scopeId: orgScopeId,
+          memoryType: ORG_MEMORY_TYPE,
+          metadata: { orgId, source, ...(sourceId ? { sourceId } : {}), ...sourceMetadata },
+        },
+      ]
+
+      for (const scopedAgentName of resolveAgentScopeNames(agentName, agentNames)) {
+        const agentId = yield* agentScopeId(orgId, scopedAgentName)
+        scopes.push({
+          scopeId: agentId,
+          memoryType: ORG_MEMORY_TYPE,
+          metadata: {
+            orgId,
+            agentName: scopedAgentName,
+            memoryScope: 'agent',
+            source,
+            ...(sourceId ? { sourceId } : {}),
+            ...sourceMetadata,
+          },
+        })
+      }
+
+      const extractedFacts = yield* memoryTryPromise('Failed to extract conversation memories.', () =>
+        orgMemory.extractFactsFromMessages(messages, extractionConfig),
+      )
+      if (shouldSkipExtractedFacts(extractedFacts)) {
+        aiLogger.debug`Skipping transient conversation memory`
+        return
+      }
+
+      const preparedUpdates = yield* memoryTryPromise('Failed to prepare conversation memories for scopes.', () =>
+        orgMemory.prepareFactsToScopes(extractedFacts, scopes),
+      )
+      yield* applyPreparedScopeUpdatesEffect({ orgId, orgMemory, preparedUpdates })
+      if (preparedUpdates.length > 0) {
+        aiLogger.debug`Conversation memories added to ${scopes.length} scope(s) from ${messages.length} message(s)`
+      }
+    }),
+  }
+
+  return service
+}
+
+export class MemoryServiceTag extends Context.Service<MemoryServiceTag, ReturnType<typeof createMemoryService>>()(
+  '@lota-sdk/core/MemoryService',
+) {}
+
+export const MemoryServiceLive = Layer.effect(
+  MemoryServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const runtimeConfig = yield* RuntimeConfigServiceTag
+    const rerankService = yield* RerankServiceTag
+    const helperModelRuntime = yield* HelperModelTag
+    const background = yield* BackgroundWorkService
+    const orgMemoryCache = yield* makeOrgMemoryCache({ db, runtimeConfig, helperModelRuntime, background })
+    return createMemoryService({ runtimeConfig, rerankService, helperModelRuntime, orgMemoryCache })
+  }),
+)