1
function createMemoryVectorId(input: {
2
  memoryId: string
3
  revision: number
4
}) {
5
  return `${input.memoryId}:r${input.revision}`
6
}

01
interface MemoryIndexMessage {
02
  memoryId: string
03
  expectedRevision: number
04
  operation: 'upsert' | 'delete'
05
}
06

07
await env.AGENT_MEMORY_INDEX_QUEUE.send({
08
  memoryId: memory.id,
09
  expectedRevision: memory.revision,
10
  operation: 'upsert',
11
} satisfies MemoryIndexMessage)

01
interface AgentMemory {
02
  type: string
03
  content: string
04
  agentName: string
05
}
06

07
function buildMemoryEmbeddingText(memory: AgentMemory) {
08
  return [
09
    `记忆类型：${memory.type}`,
10
    `相关 Agent：${memory.agentName}`,
11
    `记忆内容：${memory.content}`,
12
  ].join('\n')
13
}

01
import { OpenAIEmbeddings } from '@langchain/openai'
02

03
const embeddings = new OpenAIEmbeddings({
04
  model: 'text-embedding-3-small',
05
})
06

07
interface IndexAgentMemoryInput {
08
  memory: {
09
    id: string
10
    revision: number
11
    userId: string
12
    agentId: string
13
    type: string
14
    content: string
15
    importance: number
16
    active: boolean
17
    agentName: string
18
  }
19
  index: VectorizeIndex
20
}
21

22
export async function indexAgentMemory(
23
  input: IndexAgentMemoryInput,
24
) {
25
  const { memory, index } = input
26
  const vectorId = `${memory.id}:r${memory.revision}`
27
  const vector = await embeddings.embedQuery(
28
    buildMemoryEmbeddingText(memory),
29
  )
30

31
  await index.upsert([
32
    {
33
      id: vectorId,
34
      values: vector,
35
      namespace: memory.userId,
36
      metadata: {
37
        memoryId: memory.id,
38
        memoryRevision: memory.revision,
39
        userId: memory.userId,
40
        agentId: memory.agentId,
41
        type: memory.type,
42
        importance: memory.importance,
43
        active: memory.active,
44
      },
45
    },
46
  ])
47

48
  return vectorId
49
}

01
import * as z from 'zod'
02
import { ChatOpenAI } from '@langchain/openai'
03

04
const memoryQuerySchema = z.object({
05
  shouldRetrieve: z.boolean(),
06
  query: z.string(),
07
  memoryTypes: z.array(
08
    z.enum(['偏好', '边界', '关系目标', '对话风格']),
09
  ),
10
})
11

12
const queryModel = new ChatOpenAI({
13
  model: 'gpt-4.1-mini',
14
  temperature: 0,
15
}).withStructuredOutput(memoryQuerySchema, {
16
  name: 'build_memory_query',
17
})
18

19
export async function buildMemoryQuery(input: {
20
  recentMessages: Array<{
21
    role: 'user' | 'assistant'
22
    content: string
23
  }>
24
  userText: string
25
}) {
26
  return queryModel.invoke([
27
    {
28
      role: 'system',
29
      content: `判断回答当前消息是否需要回忆长期信息。
30
需要时，生成一条独立、完整的记忆检索语句。
31
只能使用输入中已有事实，不要虚构用户偏好。
32
普通寒暄或完全由当前消息即可回答时，shouldRetrieve=false。`,
33
    },
34
    {
35
      role: 'user',
36
      content: JSON.stringify(input),
37
    },
38
  ])
39
}

01
import { OpenAIEmbeddings } from '@langchain/openai'
02

03
const embeddings = new OpenAIEmbeddings({
04
  model: 'text-embedding-3-small',
05
})
06

07
export async function searchMemoryVectors(input: {
08
  index: VectorizeIndex
09
  userId: string
10
  agentId: string
11
  query: string
12
}) {
13
  const queryVector = await embeddings.embedQuery(input.query)
14

15
  return input.index.query(queryVector, {
16
    topK: 24,
17
    namespace: input.userId,
18
    filter: {
19
      userId: { $eq: input.userId },
20
      agentId: { $eq: input.agentId },
21
      active: { $eq: true },
22
    },
23
    returnMetadata: 'all',
24
  })
25
}

1
finalScore =
2
  vectorScore * 0.6 +
3
  importance * 0.3 +
4
  recency * 0.1

01
interface MemoryCandidate {
02
  id: string
03
  semanticScore: number
04
  importance: number
05
  updatedAtMs: number
06
}
07

08
function addRanking(
09
  scores: Map<string, number>,
10
  ranking: MemoryCandidate[],
11
  weight: number,
12
  k = 60,
13
) {
14
  ranking.forEach((memory, index) => {
15
    const current = scores.get(memory.id) ?? 0
16
    scores.set(
17
      memory.id,
18
      current + weight / (k + index + 1),
19
    )
20
  })
21
}
22

23
export function rankMemoryCandidates(
24
  candidates: MemoryCandidate[],
25
) {
26
  const scores = new Map<string, number>()
27

28
  addRanking(
29
    scores,
30
    [...candidates].sort(
31
      (a, b) => b.semanticScore - a.semanticScore,
32
    ),
33
    0.65,
34
  )
35
  addRanking(
36
    scores,
37
    [...candidates].sort(
38
      (a, b) => b.importance - a.importance,
39
    ),
40
    0.25,
41
  )
42
  addRanking(
43
    scores,
44
    [...candidates].sort(
45
      (a, b) => b.updatedAtMs - a.updatedAtMs,
46
    ),
47
    0.1,
48
  )
49

50
  return [...candidates]
51
    .sort((a, b) => {
52
      return (scores.get(b.id) ?? 0)
53
        - (scores.get(a.id) ?? 0)
54
    })
55
    .slice(0, 6)
56
}

01
import * as z from 'zod'
02
import { StateSchema } from '@langchain/langgraph'
03

04
const recalledMemorySchema = z.object({
05
  id: z.string(),
06
  type: z.string(),
07
  content: z.string(),
08
  importance: z.number(),
09
})
10

11
export const MemoryRagState = new StateSchema({
12
  userId: z.string(),
13
  agentId: z.string(),
14
  userText: z.string(),
15
  retrievalQuery: z.string().default(''),
16
  shouldRetrieve: z.boolean().default(false),
17
  candidates: z
18
    .array(recalledMemorySchema)
19
    .default(() => []),
20
  selectedMemories: z
21
    .array(recalledMemorySchema)
22
    .default(() => []),
23
  memoryContext: z.string().default(''),
24
  retrievalStatus: z.enum([
25
    'skipped',
26
    'passed',
27
    'insufficient',
28
    'unavailable',
29
  ]).default('skipped'),
30
})

01
import {
02
  END,
03
  START,
04
  StateGraph,
05
} from '@langchain/langgraph'
06
import { MemoryRagState } from './memory-rag-state'
07
import {
08
  decideMemoryRetrieval,
09
  retrieveMemoryCandidates,
10
  validateAndRankMemories,
11
  buildMemoryContext,
12
  skipMemoryRetrieval,
13
} from './memory-rag-nodes'
14

15
export const memoryRagGraph = new StateGraph(
16
  MemoryRagState,
17
)
18
  .addNode(
19
    'decide_memory_retrieval',
20
    decideMemoryRetrieval,
21
  )
22
  .addNode(
23
    'retrieve_memory_candidates',
24
    retrieveMemoryCandidates,
25
  )
26
  .addNode(
27
    'validate_and_rank_memories',
28
    validateAndRankMemories,
29
  )
30
  .addNode(
31
    'build_memory_context',
32
    buildMemoryContext,
33
  )
34
  .addNode(
35
    'skip_memory_retrieval',
36
    skipMemoryRetrieval,
37
  )
38
  .addEdge(START, 'decide_memory_retrieval')
39
  .addConditionalEdges(
40
    'decide_memory_retrieval',
41
    (state) => {
42
      return state.shouldRetrieve
43
        ? 'retrieve_memory_candidates'
44
        : 'skip_memory_retrieval'
45
    },
46
  )
47
  .addEdge(
48
    'retrieve_memory_candidates',
49
    'validate_and_rank_memories',
50
  )
51
  .addEdge(
52
    'validate_and_rank_memories',
53
    'build_memory_context',
54
  )
55
  .addEdge('build_memory_context', END)
56
  .addEdge('skip_memory_retrieval', END)
57
  .compile()

01
interface SelectedMemory {
02
  id: string
03
  type: string
04
  content: string
05
}
06

07
export function formatMemoryContext(
08
  memories: SelectedMemory[],
09
) {
10
  if (memories.length === 0) {
11
    return '本轮没有可用的长期记忆。'
12
  }
13

14
  return memories
15
    .map((memory, index) => {
16
      return [
17
        `<memory id="M${index + 1}">`,
18
        `类型：${memory.type}`,
19
        memory.content,
20
        '</memory>',
21
      ].join('\n')
22
    })
23
    .join('\n\n')
24
}

01
interface MemoryRetrievalService {
02
  retrieve(input: {
03
    userId: string
04
    agentId: string
05
    query: string
06
    limit: number
07
  }): Promise<Array<{
08
    id: string
09
    type: string
10
    content: string
11
  }>>
12
}