目前国内还是很缺AI人才的，希望更多人能真正加入到AI行业，共同促进行业进步。想要系统学习AI知识的朋友可以看看我的教程 http://blog.csdn.net/jiangjunshow，教程通俗易懂，风趣幽默，从深度学习基础原理到各领域实战应用都有讲解。

前言

各位程序员小伙伴，咱们继续AI Agent的入门之旅！上一节聊完了Agent的“大脑”（决策模块），今天来扒一扒它的“记事本”——记忆模块。

你想啊，咱们写代码的时候，会临时记个变量名、接口参数（短期记忆），也会把常用的工具类、框架用法存在脑子里（长期记忆）。AI Agent也一样，要想不“失忆”，就得有靠谱的记忆系统。这一节咱们就用大白话讲清短期记忆和长期记忆的区别，还会给大家上ML.NET的实操代码，看完就能动手实现！

一、先搞懂：短期记忆vs长期记忆，到底差在哪？

咱们先拿程序员的日常类比，一看就懂：

特点	短期记忆（Short-Term Memory）	长期记忆（Long-Term Memory）
类比场景	写代码时记临时变量、函数参数	记住框架用法、经典算法思路
存储时长	会话内有效，关闭就丢	持久化存储，长期可用
容量大小	有限（类似缓存）	无限（依赖数据库/文件）
访问速度	快（内存中操作）	较慢（需读取存储介质）
核心作用	处理当前任务的临时信息	沉淀历史经验，支撑复杂决策

举个实际例子：你让Agent帮你写一个ML.NET的分类模型。它会先把你说的“分类任务”“数据源格式”记在短期记忆里，然后从长期记忆中调取“ML.NET分类算法选型”“数据预处理步骤”，最后结合两者生成代码——这就是记忆模块的协同工作！

二、实操环节：用ML.NET实现Agent的记忆模块

接下来上硬菜！咱们用C# + ML.NET写一个简单的Agent记忆模块，包含短期记忆（内存缓存）和长期记忆（文件存储）。

1. 先定义记忆模块的接口

首先明确短期记忆和长期记忆的核心功能，用接口来规范：

// 记忆项模型：存储记忆的内容和时间戳
public class MemoryItem
{
    // 记忆内容
    public string Content { get; set; }
    // 创建时间
    public DateTime CreateTime { get; set; }
    // 记忆类型（短期/长期）
    public MemoryType MemoryType { get; set; }
}

// 记忆类型枚举
public enum MemoryType
{
    ShortTerm,
    LongTerm
}

// 记忆模块接口
public interface IAgentMemory
{
    // 新增记忆
    void AddMemory(string content, MemoryType memoryType);
    // 检索记忆（支持关键词匹配）
    List<MemoryItem> SearchMemory(string keyword);
    // 清空短期记忆
    void ClearShortTermMemory();
}

2. 实现短期记忆：用ConcurrentDictionary做内存缓存

短期记忆要求快、临时存储，所以用ConcurrentDictionary（线程安全，适合多线程场景）来实现，简单直接：

// 短期记忆实现（内存缓存）
public class ShortTermMemory : IAgentMemory
{
    // 用ConcurrentDictionary存储，key是时间戳（保证唯一）
    private readonly ConcurrentDictionary<DateTime, MemoryItem> _shortTermMemories = new();

    public void AddMemory(string content, MemoryType memoryType)
    {
        // 短期记忆只处理ShortTerm类型
        if (memoryType != MemoryType.ShortTerm) return;
        
        var memoryItem = new MemoryItem
        {
            Content = content,
            CreateTime = DateTime.Now,
            MemoryType = memoryType
        };
        _shortTermMemories.TryAdd(memoryItem.CreateTime, memoryItem);
        Console.WriteLine($"短期记忆已添加：{content}");
    }

    public List<MemoryItem> SearchMemory(string keyword)
    {
        // 关键词模糊匹配，忽略大小写
        return _shortTermMemories.Values
            .Where(m => m.Content.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0)
            .OrderByDescending(m => m.CreateTime)
            .ToList();
    }

    public void ClearShortTermMemory()
    {
        _shortTermMemories.Clear();
        Console.WriteLine("短期记忆已清空");
    }
}

3. 实现长期记忆：用JSON文件持久化存储

长期记忆需要持久化，咱们用JSON文件来存储（简单易操作，不用装数据库），借助Newtonsoft.Json库序列化：

// 长期记忆实现（JSON文件存储）
public class LongTermMemory : IAgentMemory
{
    // 存储文件路径（当前目录下的agent_long_memory.json）
    private readonly string _filePath = Path.Combine(AppContext.BaseDirectory, "agent_long_memory.json");

    public void AddMemory(string content, MemoryType memoryType)
    {
        if (memoryType != MemoryType.LongTerm) return;
        
        var memoryItem = new MemoryItem
        {
            Content = content,
            CreateTime = DateTime.Now,
            MemoryType = memoryType
        };

        // 读取已有记忆
        var existingMemories = LoadMemoriesFromFile();
        existingMemories.Add(memoryItem);

        // 写入文件（格式化JSON，方便查看）
        File.WriteAllText(_filePath, JsonConvert.SerializeObject(existingMemories, Formatting.Indented));
        Console.WriteLine($"长期记忆已保存：{content}");
    }

    public List<MemoryItem> SearchMemory(string keyword)
    {
        var allMemories = LoadMemoriesFromFile();
        return allMemories
            .Where(m => m.Content.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0)
            .OrderByDescending(m => m.CreateTime)
            .ToList();
    }

    public void ClearShortTermMemory()
    {
        // 长期记忆不支持清空（实际项目可根据需求添加）
        Console.WriteLine("长期记忆不支持清空操作");
    }

    // 从文件加载记忆
    private List<MemoryItem> LoadMemoriesFromFile()
    {
        if (!File.Exists(_filePath))
        {
            return new List<MemoryItem>();
        }

        var jsonContent = File.ReadAllText(_filePath);
        return JsonConvert.DeserializeObject<List<MemoryItem>>(jsonContent) ?? new List<MemoryItem>();
    }
}

4. 整合记忆模块：Agent的“记忆管家”

最后写一个统一的记忆管家类，让Agent能同时使用短期和长期记忆：

// 记忆管家：整合短期和长期记忆
public class AgentMemoryManager
{
    private readonly IAgentMemory _shortTermMemory;
    private readonly IAgentMemory _longTermMemory;

    public AgentMemoryManager()
    {
        _shortTermMemory = new ShortTermMemory();
        _longTermMemory = new LongTermMemory();
    }

    // 新增记忆（自动区分类型）
    public void AddMemory(string content, MemoryType memoryType)
    {
        if (memoryType == MemoryType.ShortTerm)
        {
            _shortTermMemory.AddMemory(content, memoryType);
        }
        else
        {
            _longTermMemory.AddMemory(content, memoryType);
        }
    }

    // 检索所有记忆（短期+长期）
    public List<MemoryItem> SearchAllMemory(string keyword)
    {
        var shortTermResults = _shortTermMemory.SearchMemory(keyword);
        var longTermResults = _longTermMemory.SearchMemory(keyword);
        // 合并结果，按时间戳排序（最新的在前）
        return shortTermResults.Concat(longTermResults)
            .OrderByDescending(m => m.CreateTime)
            .ToList();
    }

    // 清空短期记忆
    public void ClearShortTermMemory()
    {
        _shortTermMemory.ClearShortTermMemory();
    }
}

5. 测试一下：看看Agent会不会“记东西”

写个Main方法测试一下，体验效果：

class Program
{
    static void Main(string[] args)
    {
        // 创建记忆管家
        var memoryManager = new AgentMemoryManager();

        // 1. 添加一些记忆
        Console.WriteLine("=== 第一步：添加记忆 ===");
        memoryManager.AddMemory("用户需要用ML.NET做鸢尾花分类", MemoryType.ShortTerm);
        memoryManager.AddMemory("ML.NET的分类算法有SVM、决策树、逻辑回归", MemoryType.LongTerm);
        memoryManager.AddMemory("用户提供的数据源路径是D:/data/iris.csv", MemoryType.ShortTerm);
        memoryManager.AddMemory("数据预处理需要先处理缺失值和标准化", MemoryType.LongTerm);

        // 2. 检索记忆
        Console.WriteLine("\n=== 第二步：检索包含'ML.NET'的记忆 ===");
        var mlNetMemories = memoryManager.SearchAllMemory("ML.NET");
        foreach (var memory in mlNetMemories)
        {
            Console.WriteLine($"[{memory.MemoryType}] {memory.CreateTime:yyyy-MM-dd HH:mm:ss}：{memory.Content}");
        }

        // 3. 清空短期记忆
        Console.WriteLine("\n=== 第三步：清空短期记忆 ===");
        memoryManager.ClearShortTermMemory();

        // 4. 再次检索
        Console.WriteLine("\n=== 第四步：再次检索包含'ML.NET'的记忆 ===");
        var remainingMemories = memoryManager.SearchAllMemory("ML.NET");
        foreach (var memory in remainingMemories)
        {
            Console.WriteLine($"[{memory.MemoryType}] {memory.CreateTime:yyyy-MM-dd HH:mm:ss}：{memory.Content}");
        }
    }
}

运行结果大家可以自己试一下，会发现：清空短期记忆后，“用户需要用ML.NET做鸢尾花分类”“数据源路径”这些临时信息没了，但“ML.NET分类算法”“数据预处理步骤”这些长期记忆还在——这就是短/长期记忆的核心区别！

三、实际项目中的优化技巧

咱们这个示例是最小实现，实际开发中还可以做这些优化：

1. 短期记忆加过期时间：比如设置30分钟过期，自动清理没用的临时信息，避免内存溢出；
2. 长期记忆用数据库：如果记忆量大，用SQL Server、MongoDB替代JSON文件，查询更快、支持更复杂的检索；
3. 添加记忆权重：重要的信息权重高，检索时优先返回；
4. 支持向量检索（Vector Search）：把记忆转换成向量存储，用余弦相似度匹配，比如用户问“怎么用ML.NET做分类”，能匹配到“ML.NET的分类算法有SVM、决策树”这种相关记忆，比关键词匹配更智能。

小结

今天咱们搞懂了Agent记忆模块的核心：短期记忆管临时，长期记忆管沉淀，两者配合才能让Agent“越用越聪明”。还通过ML.NET实现了一个简单但可用的记忆系统，代码直接复制就能跑通。

下一节咱们聊聊Agent的“手脚”——工具调用模块，看看Agent是怎么调用API、操作文件、甚至调用其他AI模型的，敬请期待！