场景1：连续对话
你：帮我写个用户登录功能
AI：好的，这是代码...
你：加上密码强度检查
AI：什么密码强度检查？你在说什么？

场景2：跨会话工作
昨天：你叫张三，在开发电商平台
今天：继续昨天的项目
AI：什么项目？你是谁？

// src/memory/mod.rs
pub trait Memory: Send + Sync {
    /// 存储记忆
    async fn store(&self, entry: MemoryEntry) -> Result<()>;
    
    /// 检索记忆
    async fn recall(&self, query: &str, limit: usize) -> Result<Vec<MemoryEntry>>;
    
    /// 删除记忆
    async fn forget(&self, id: &str) -> Result<()>;
}

/// 记忆条目
pub struct MemoryEntry {
    pub id: String,
    pub content: String,
    pub embedding: Option<Vec<f32>>,  // 向量表示
    pub metadata: Metadata,
    pub created_at: DateTime<Utc>,
}

pub struct Metadata {
    pub source: String,       // telegram, discord, cli...
    pub user_id: Option<String>,
    pub session_id: Option<String>,
    pub category: Category,   // conversation, fact, tool_result...
}

pub enum Category {
    Conversation,  // 对话历史
    Fact,          // 事实知识
    ToolResult,    // 工具执行结果
    Preference,    // 用户偏好
}

// src/memory/chunking.rs
pub struct TextChunker {
    max_chunk_size: usize,
    overlap: usize,
}

impl TextChunker {
    pub fn chunk(&self, text: &str) -> Vec<Chunk> {
        // 策略1：按段落分块（优先）
        let paragraphs: Vec<&str> = text.split("\n\n").collect();
        
        let mut chunks = Vec::new();
        let mut current_chunk = String::new();
        
        for para in paragraphs {
            if current_chunk.len() + para.len() > self.max_chunk_size 
                && !current_chunk.is_empty() {
                // 保存当前块
                chunks.push(Chunk {
                    content: current_chunk.clone(),
                    start_pos: chunks.len() * self.max_chunk_size,
                });
                
                // 重叠保留上下文
                let overlap_text = self.get_overlap(&current_chunk);
                current_chunk = overlap_text;
            }
            
            current_chunk.push_str(para);
            current_chunk.push('\n');
        }
        
        // 最后一块
        if !current_chunk.is_empty() {
            chunks.push(Chunk {
                content: current_chunk,
                start_pos: chunks.len() * self.max_chunk_size,
            });
        }
        
        chunks
    }
    
    fn get_overlap(&self, text: &str) -> String {
        // 取最后 overlap 个字符作为重叠
        text.chars()
            .rev()
            .take(self.overlap)
            .collect::<String>()
            .chars()
            .rev()
            .collect()
    }
}

pub struct Chunk {
    pub content: String,
    pub start_pos: usize,
}

// src/memory/embedding.rs
pub struct EmbeddingService {
    provider: Arc<dyn EmbeddingProvider>,
    cache: Arc<RwLock<LruCache<String, Vec<f32>>>>,
}

#[async_trait]
pub trait EmbeddingProvider: Send + Sync {
    async fn embed(&self, text: &str) -> Result<Vec<f32>>;
}

impl EmbeddingService {
    pub async fn get_embedding(&self, text: &str) -> Result<Vec<f32>> {
        // 1. 生成缓存键（文本的哈希）
        let cache_key = blake3::hash(text.as_bytes()).to_string();
        
        // 2. 检查缓存
        {
            let cache = self.cache.read().await;
            if let Some(embedding) = cache.get(&cache_key) {
                trace!("嵌入缓存命中");
                return Ok(embedding.clone());
            }
        }
        
        // 3. 调用嵌入服务
        trace!("调用嵌入服务...");
        let embedding = self.provider.embed(text).await?;
        
        // 4. 写入缓存
        {
            let mut cache = self.cache.write().await;
            cache.put(cache_key, embedding.clone());
        }
        
        Ok(embedding)
    }
}

// src/memory/sqlite.rs
pub struct SqliteMemory {
    pool: SqlitePool,
}

impl SqliteMemory {
    pub async fn new(path: &Path) -> Result<Self> {
        let pool = SqlitePool::connect(&format!(
            "sqlite:{}", path.display()
        )).await?;
        
        // 初始化表结构
        sqlx::query(
            r#"
            CREATE TABLE IF NOT EXISTS memories (
                id TEXT PRIMARY KEY,
                content TEXT NOT NULL,
                embedding BLOB,  -- 二进制存储向量
                category TEXT,
                source TEXT,
                user_id TEXT,
                session_id TEXT,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
            );
            
            -- FTS5 全文搜索虚拟表
            CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
                content,
                content='memories',
                content_rowid='rowid'
            );
            
            -- 触发器：自动同步 FTS 索引
            CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
                INSERT INTO memories_fts(rowid, content) 
                VALUES (new.rowid, new.content);
            END;
            
            CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
                INSERT INTO memories_fts(memories_fts, rowid, content) 
                VALUES ('delete', old.rowid, old.content);
            END;
            "#
        ).execute(&pool).await?;
        
        Ok(Self { pool })
    }
    
    pub async fn store(&self, entry: MemoryEntry) -> Result<()> {
        let id = uuid::Uuid::new_v4().to_string();
        
        // 序列化向量为二进制
        let embedding_blob = entry.embedding.as_ref()
            .map(|e| serialize_embedding(e));
        
        sqlx::query(
            r#"
            INSERT INTO memories 
            (id, content, embedding, category, source, user_id, session_id)
            VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
            "#
        )
        .bind(&id)
        .bind(&entry.content)
        .bind(embedding_blob.as_deref())
        .bind(format!("{:?}", entry.metadata.category))
        .bind(&entry.metadata.source)
        .bind(&entry.metadata.user_id)
        .bind(&entry.metadata.session_id)
        .execute(&self.pool)
        .await?;
        
        Ok(())
    }
}

fn serialize_embedding(embedding: &[f32]) -> Vec<u8> {
    // f32 转字节数组
    embedding.iter()
        .flat_map(|f| f.to_le_bytes())
        .collect()
}

fn deserialize_embedding(bytes: &[u8]) -> Vec<f32> {
    bytes.chunks_exact(4)
        .map(|chunk| {
            let mut arr = [0u8; 4];
            arr.copy_from_slice(chunk);
            f32::from_le_bytes(arr)
        })
        .collect()
}

// src/memory/vector_search.rs
pub struct VectorSearch {
    pool: SqlitePool,
}

impl VectorSearch {
    /// 使用余弦相似度搜索
    pub async fn search(
        &self, 
        query_embedding: &[f32], 
        limit: usize
    ) -> Result<Vec<SearchResult>> {
        // SQLite 没有原生向量索引，需要手动计算
        // 生产环境建议使用 pgvector 或专门的向量数据库
        
        let rows = sqlx::query_as::<_, MemoryRow>(
            "SELECT id, content, embedding, created_at FROM memories WHERE embedding IS NOT NULL"
        )
        .fetch_all(&self.pool)
        .await?;
        
        let mut results: Vec<SearchResult> = rows
            .into_iter()
            .filter_map(|row| {
                let embedding = row.embedding?;
                let similarity = cosine_similarity(query_embedding, &embedding);
                
                // 过滤低相似度结果
                if similarity < 0.5 {
                    return None;
                }
                
                Some(SearchResult {
                    id: row.id,
                    content: row.content,
                    similarity,
                    created_at: row.created_at,
                })
            })
            .collect();
        
        // 按相似度排序
        results.sort_by(|a, b| {
            b.similarity.partial_cmp(&a.similarity).unwrap()
        });
        
        results.truncate(limit);
        Ok(results)
    }
}

/// 余弦相似度计算
fn cosine_similarity(a: &[f32], b: &[f32]) -> f32 {
    let dot_product: f32 = a.iter().zip(b.iter()).map(|(x, y)| x * y).sum();
    let norm_a: f32 = a.iter().map(|x| x * x).sum::<f32>().sqrt();
    let norm_b: f32 = b.iter().map(|x| x * x).sum::<f32>().sqrt();
    
    dot_product / (norm_a * norm_b + 1e-8)  // 避免除零
}

// src/memory/keyword_search.rs
impl SqliteMemory {
    pub async fn keyword_search(
        &self,
        query: &str,
        limit: usize,
    ) -> Result<Vec<SearchResult>> {
        // 使用 FTS5 的 BM25 评分
        let rows = sqlx::query_as::<_, MemoryRow>(
            r#"
            SELECT m.id, m.content, m.created_at,
                   rank as score
            FROM memories_fts fts
            JOIN memories m ON m.rowid = fts.rowid
            WHERE memories_fts MATCH ?1
            ORDER BY rank
            LIMIT ?2
            "#
        )
        .bind(query)
        .bind(limit as i64)
        .fetch_all(&self.pool)
        .await?;
        
        Ok(rows.into_iter().map(|r| SearchResult {
            id: r.id,
            content: r.content,
            score: r.score,
            created_at: r.created_at,
        }).collect())
    }
}

// src/memory/hybrid_search.rs
pub struct HybridSearcher {
    vector_weight: f32,
    keyword_weight: f32,
    k: f32,  // RRF 常数
}

impl HybridSearcher {
    pub fn new(vector_weight: f32, keyword_weight: f32) -> Self {
        Self {
            vector_weight,
            keyword_weight,
            k: 60.0,  // 平滑常数
        }
    }
    
    pub fn merge(
        &self,
        vector_results: Vec<SearchResult>,
        keyword_results: Vec<SearchResult>,
        limit: usize,
    ) -> Vec<SearchResult> {
        let mut scores: HashMap<String, f32> = HashMap::new();
        
        // 向量分数（RRF）
        for (rank, result) in vector_results.iter().enumerate() {
            let rrf_score = self.vector_weight * (1.0 / (self.k + rank as f32));
            *scores.entry(result.id.clone()).or_insert(0.0) += rrf_score;
        }
        
        // 关键词分数（RRF）
        for (rank, result) in keyword_results.iter().enumerate() {
            let rrf_score = self.keyword_weight * (1.0 / (self.k + rank as f32));
            *scores.entry(result.id.clone()).or_insert(0.0) += rrf_score;
        }
        
        // 合并结果
        let mut merged: Vec<_> = scores.into_iter()
            .map(|(id, score)| {
                // 找到原始内容
                let content = vector_results.iter()
                    .chain(keyword_results.iter())
                    .find(|r| r.id == id)
                    .map(|r| r.content.clone())
                    .unwrap_or_default();
                    
                SearchResult { id, content, score }
            })
            .collect();
        
        // 按分数排序
        merged.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap());
        merged.truncate(limit);
        
        merged
    }
}

score = Σ (weight_i / (k + rank_i))

其中：
- weight_i: 第 i 个搜索方法的权重
- rank_i: 结果在第 i 个方法中的排名（从0开始）
- k = 60: 平滑常数，防止高排名差异过大

// src/memory/importance.rs
pub struct ImportanceScorer;

impl ImportanceScorer {
    /// 评估记忆重要度
    pub fn score(entry: &MemoryEntry) -> f32 {
        let mut score = 0.0;
        
        // 1. 内容长度（适中长度得分高）
        let len = entry.content.len();
        if len > 50 && len < 1000 {
            score += 0.2;
        }
        
        // 2. 包含关键词
        let important_keywords = ["bug", "error", "fix", "solution", "config"];
        for kw in &important_keywords {
            if entry.content.to_lowercase().contains(kw) {
                score += 0.1;
            }
        }
        
        // 3. 用户确认（如果用户说"记住这个"）
        if entry.content.contains("记住") || entry.content.contains("save this") {
            score += 0.3;
        }
        
        // 4. 工具执行结果
        if matches!(entry.metadata.category, Category::ToolResult) {
            score += 0.2;
        }
        
        // 5. 时间衰减（越新越重要）
        let days_old = entry.created_at.signed_duration_since(Utc::now()).num_days();
        score += (1.0 / (1.0 + days_old as f32)) * 0.2;
        
        score.min(1.0)
    }
}

[memory]
# 存储后端
backend = "sqlite"  # sqlite | postgres | lucid | markdown | none

# 自动保存
auto_save = true

# 嵌入服务
embedding_provider = "openai"  # openai | local | none

# 混合搜索权重
vector_weight = 0.7
keyword_weight = 0.3

# 检索限制
recall_limit = 5          # 默认召回数量
similarity_threshold = 0.5  # 最小相似度

# 清理策略
max_memory_age_days = 90   # 自动清理超过90天的记忆
max_memories_total = 10000 # 最多保留1万条

[memory]
backend = "sqlite"
auto_save = true
embedding_provider = "none"  # 关闭嵌入，节省成本

[memory]
backend = "sqlite"
auto_save = true
embedding_provider = "openai"
vector_weight = 0.7
keyword_weight = 0.3

[memory]
backend = "markdown"  # 纯文本存储
auto_save = true
embedding_provider = "none"