每次 Tick 结束
      │
      ▼
┌─────────────────────┐
│   记忆写入（同步）    │
│  判断重要性 → 存库   │
│  （先不向量化）      │
└──────────┬──────────┘
           │ 后台任务
           ▼
┌─────────────────────┐
│   向量化（异步）     │
│  Gemini Embedding   │
│  → 写入 pgvector    │
└─────────────────────┘

下一次 Tick 开始
      │
      ▼
┌─────────────────────┐
│   记忆检索（同步）   │
│  当前观察 → Embedding│
│  → 余弦相似度检索    │
│  → 拼入 Prompt      │
└─────────────────────┘

type MemoryModel struct {
    NPCID      uint            // 这条记忆属于哪个 Agent
    Type       string          // "observation"（观察）/ "conversation"（对话）
    Content    string          // 记忆内容，自然语言文本
    Embedding  pgvector.Vector // 1536 维特征向量（pgvector 存储）
    Importance int             // 重要度评分，1-10 分
    Tick       int64           // 在第几次心跳产生
    IsCore     bool            // 是否是核心记忆（保留字段，用于未来扩展）
}

func RecordNPCActionMemory(npc *models.NPCModel, decision *llm_ser.NPCDecision, tick int64) {
    if decision.Action == "talk" {
        memory := models.MemoryModel{
            NPCID:      npc.ID,
            Type:       "conversation",
            Content:    fmt.Sprintf("我对大家说：%s", decision.Speak),
            Importance: 8,
            Tick:       tick,
        }
        // 注意：Omit("Embedding") —— 先不写向量，后台再处理
        global.DB.Omit("Embedding").Create(&memory)
    } else if decision.Action == "move" {
        memory := models.MemoryModel{
            NPCID:      npc.ID,
            Type:       "observation",
            Content:    fmt.Sprintf("我决定移动到 (%d, %d)", decision.TargetX, decision.TargetY),
            Importance: 4,
            Tick:       tick,
        }
        global.DB.Omit("Embedding").Create(&memory)
    }
    // stay 行为：直接忽略，不存储
}

func GetEmbeddings(texts []string) ([][]float32, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    cfg := global.Config.LLM.GetConfigByName(global.Config.LLM.EmbeddingModel)
    client := llm.GetOpenAIClient(cfg.ApiKey, cfg.BaseURL)

    req := openai.EmbeddingRequest{
        Input: texts,
        Model: openai.EmbeddingModel("gemini-embedding-001"),
    }

    res, err := client.CreateEmbeddings(ctx, req)
    // ...

    for _, item := range res.Data {
        val := item.Embedding
        // 强制截断到 1536 维，与数据库 vector(1536) 对齐
        if len(val) > 1536 {
            val = val[:1536]
        }
        embeddings = append(embeddings, val)
    }
    return embeddings, nil
}

func ChunkText(text string, chunkSize int, overlap int) []string {
    runes := []rune(text)  // 用 rune 处理中文，避免字节截断
    var chunks []string
    for i := 0; i < len(runes); {
        end := i + chunkSize
        if end > len(runes) {
            end = len(runes)
        }
        chunks = append(chunks, string(runes[i:end]))
        if end == len(runes) {
            break
        }
        i = end - overlap  // 重叠 overlap 个字符，防止语义被截断
    }
    return chunks
}

func RetrieveRelevantMemories(npcID uint, observation string) string {
    // 1. 把当前观察转化为向量
    embeddings, err := GetEmbeddings([]string{observation})
    if err != nil || len(embeddings) == 0 {
        return ""  // 降级：获取失败就不带记忆，但不中断主流程
    }

    vector := pgvector.NewVector(embeddings[0])

    // 2. 用余弦距离检索最相关的 5 条记忆
    var memories []models.MemoryModel
    global.DB.Where("npc_id = ? AND embedding IS NOT NULL", npcID).
        Order(clause.OrderBy{
            Expression: clause.Expr{
                SQL:  "embedding <=> ?",
                Vars: []any{vector},
            },
        }).
        Limit(5).
        Find(&memories)

    // 3. 拼成自然语言片段，插入 Prompt
    result := "\n【你脑海中浮现出以下相关记忆】：\n"
    for _, m := range memories {
        result += fmt.Sprintf("- %s\n", m.Content)
    }
    return result
}

【你脑海中浮现出以下相关记忆】：
- 我对大家说：市场附近好像在开庆典
- 我决定移动到 (15, 8)
- 我对大家说：今天天气不错，想去河边走走

embeddings, err := GetEmbeddings([]string{observation})
if err != nil || len(embeddings) == 0 {
    global.Log.Sugar().Errorf("获取观察向量失败: %v", err)
    return ""  // 降级：不带记忆继续，主流程不受影响
}