Spring AI Alibaba接入Mem0，给agent 赋予长期记忆

未来影子
262 阅读4分钟

[!TIP] Mem0 是专为现代 AI 代理设计的内存层。它充当持久内存层，代理可以使用它来：

  • 回忆过去的相关互动
  • 存储重要的用户偏好和事实背景
  • 从成功和失败中学习 它为 AI 代理提供记忆，以便他们可以在交互中记住、学习和进化。 官网：docs.mem0.ai/introductio…

本教程基于 spring ai alibaba 接入 mem0 示例 实战代码可见：github.com/GTyingzi/sp… 下的 advisor/advisor-memory-mem0 docker 启动配置项，可见 docker-compose/mem0

mem0 基础准备

在./spring-ai-tutorial/docker-compose/mem0 目录下

基础配置

  1. cp ./.env.example .en，更新 OPENAIAPIKEY、DEEPSEEKAPIKEY
OPENAIAPIKEY=xxx
DEEPSEEKAPIKEY=xxx

POSTGRESHOST=postgres
POSTGRESPORT=5432
POSTGRESDB=postgres
POSTGRESUSER=postgres
POSTGRESPASSWORD=postgres
POSTGRESCOLLECTIONNAME=memories

NEO4JURI=bolt://neo4j:7687
NEO4JUSERNAME=neo4j
NEO4JPASSWORD=mem0graph
  1. 配置 docker-compose.yaml 文件
name: mem0-dev

services:
  mem0:
    build:
      context: ..  # Set context to parent directory
      dockerfile: mem0/dev.Dockerfile
    ports:
      - "8888:8000"
    envfile:
      - .env
    networks:
      - mem0network
    volumes:
      - ./history:/app/history      # History db location. By default, it creates a history.db file on the server folder
      - .:/app                      # Server code. This allows to reload the app when the server code is updated
      - ../mem0:/app/packages/mem0  # Mem0 library. This allows to reload the app when the library code is updated
    dependson:
      postgres:
        condition: servicehealthy
      neo4j:
        condition: servicehealthy
    command: uvicorn main:app --host 0.0.0.0 --port 8000 --reload  # Enable auto-reload
    environment:
      - PYTHONDONTWRITEBYTECODE=1  # Prevents Python from writing .pyc files
      - PYTHONUNBUFFERED=1  # Ensures Python output is sent straight to terminal

  postgres:
      image: ankane/pgvector:v0.5.1
      restart: on-failure
      shmsize: "128mb" # Increase this if vacuuming fails with a "no space left on device" error
      networks:
        - mem0network
      environment:
        - POSTGRESUSER=postgres
        - POSTGRESPASSWORD=postgres
      healthcheck:
        test: ["CMD", "pgisready", "-q", "-d", "postgres", "-U", "postgres"]
        interval: 5s
        timeout: 5s
        retries: 5
      volumes:
        - postgresdb:/var/lib/postgresql/data
      ports:
        - "8432:5432"
  neo4j:
    image: neo4j:5.26.4
    networks:
      - mem0network
    healthcheck:
      test: wget bolt://neo4j:8687 || exit 1
      interval: 1s
      timeout: 10s
      retries: 20
      startperiod: 90s
    ports:
      - "8474:7474" # HTTP
      - "8687:7687" # Bolt
    volumes:
      - ./neo4j/data:/data  # 将 Neo4j 数据存储到 mem0 目录
      - ./neo4j/logs:/logs  # 将 Neo4j 日志存储到 mem0 目录
      - ./neo4j/import:/var/lib/neo4j/import  # 将 Neo4j 导入目录存储到 mem0 目录
    environment:
      - NEO4JAUTH=neo4j/mem0graph
      - NEO4JPLUGINS=["apoc"]  # Add this line to install APOC
      - NEO4Japocexportfileenabled=true
      - NEO4Japocimportfileenabled=true
      - NEO4Japocimportfileuseneo4jconfig=true

volumes:
  neo4jdata:
  postgresdb:

networks:
  mem0network:
    driver: bridge

启动 docker

docker compose up，可以发现控制台打印如下信息

此时 mem0-dev 下将有三个服务：neo4j、postgres、mem0

访问对应的 swagger：http://localhost:8888/docs

同时也可以看到 http://localhost:7474/控制台界面

Spring ai alibaba 接入 mem0

pom 文件

<dependencies>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-autoconfigure-model-chat-client</artifactId>
    </dependency>

    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-memory-mem0</artifactId>
        <version>1.0.0.4-SNAPSHOT</version>
    </dependency>
    
</dependencies>

1.0.0.4-SNAPSHOT 尚未发布，请自行下载 spring-ai-alibaba 仓库去下载源码

application.yml

server:
  port: 8080
  tomcat:
    connection-timeout: 60000

spring:
  ai:
    dashscope:
      api-key: ${AIDASHSCOPEAPIKEY}
    alibaba:
      mem0:
        client:
          base-url: http://127.0.0.1:8888
          timeout-seconds: 120
        server:
          version: v0.1.116
          vector-store:
            provider: pgvector
            config:
              host: ${POSTGRESHOST:postgres}
              port: ${POSTGRESPORT:5432}
              dbname: ${POSTGRESDB:postgres}
              user: ${POSTGRESUSER:postgres}
              password: ${POSTGRESPASSWORD:postgres}
              collection-name: ${POSTGRESCOLLECTIONNAME:memories}
          graph-store:
            provider: neo4j
            config:
              url: ${NEO4JURI:bolt://neo4j:7687}
              username: ${NEO4JUSERNAME:neo4j}
              password: ${NEO4JPASSWORD:mem0graph}
          llm:
            provider: deepseek
            config:
              api-key: ${DEEPSEEKAPIKEY}
              temperature: 0.2
              model: deepseek-chat # qwen现在因为json结构问题不可用了，改为使用官方支持的DeepSeek
          #        openai-base-url: https://dashscope.aliyuncs.com/compatible-mode/v1
          embedder:
            provider: openai
            config:
              api-key: ${AIDASHSCOPEAPIKEY}
              model: text-embedding-v4
              openai-base-url: https://dashscope.aliyuncs.com/compatible-mode/v1
          custom-fact-extraction-prompt: classpath:/prompts/customfactextractionprompt.st

Mem0MemoryController

package com.spring.ai.tutorial.advisor.memory.controller;

import com.alibaba.cloud.ai.memory.mem0.advisor.Mem0ChatMemoryAdvisor;
import com.alibaba.cloud.ai.memory.mem0.core.Mem0ServiceClient;
import com.alibaba.cloud.ai.memory.mem0.model.Mem0ServerRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;

import static com.alibaba.cloud.ai.memory.mem0.advisor.Mem0ChatMemoryAdvisor.USERID;


/**
 * @author morain.miao
 * @date 2025/06/23 11:54
 * @description mem0的一些应用
 */
@RestController
@RequestMapping("/advisor/memory/mem0")
public class Mem0MemoryController {
    private static final Logger logger = LoggerFactory.getLogger(Mem0MemoryController.class);

    private final ChatClient chatClient;
    private final VectorStore store;
    private final Mem0ServiceClient mem0ServiceClient;

    public Mem0MemoryController(ChatClient.Builder builder, VectorStore store, Mem0ServiceClient mem0ServiceClient) {
        this.store = store;
        this.mem0ServiceClient = mem0ServiceClient;
        this.chatClient = builder
                .defaultAdvisors(
                        Mem0ChatMemoryAdvisor.builder(store).build()
                )
                .build();
    }

    @GetMapping("/call")
    public String call(@RequestParam(value = "query", defaultValue = "你好，我是万能的喵，我爱玩三角洲行动") String message,
                       @RequestParam(value = "userid", defaultValue = "miao") String userId
    ) {
        return chatClient.prompt(message)
                .advisors(
                        a -> a.params(Map.of(USERID, userId))
                )
                .call().content();
    }

    @GetMapping("/messages")
    public List<Document> messages(
            @RequestParam(value = "query", defaultValue = "我的爱好是什么？") String query,
            @RequestParam(value = "userid", defaultValue = "miao") String userId) {
        Mem0ServerRequest.SearchRequest searchRequest = Mem0ServerRequest.SearchRequest.builder().query(query).userId(userId).build();
        return store.similaritySearch(searchRequest);
    }

    @GetMapping("/test")
    public void test(){
        //用户和agent的长期记忆
        mem0ServiceClient.addMemory(
                Mem0ServerRequest.MemoryCreate.builder()
                        .agentId("agent2")
                        .userId("test2")
                        .messages(List.of(
                                new Mem0ServerRequest.Message("user", "I'm travelling to San Francisco"),
                                new Mem0ServerRequest.Message("assistant", "That's great! I'm going to Dubai next month."))
                        )
                        .build());
        logger.info("用户和agent的长期记忆保存成功");
        // 获取用户和agent的长期记忆
        List<Document> documents = store.similaritySearch(Mem0ServerRequest.SearchRequest.builder().userId("test2").agentId("agent2").build());
        logger.info("agent的长期记忆: {}", documents);
    }
}

效果

调用 call 接口，将记忆存储至 mem0 中（ps：该接口目前响应速度很慢，长达 1 分钟待后续优化）

调用 messages，取出存在 mem0 的记忆

同时进入 docker 容器中，看到 mem0 服务的日志记录

相关数据后续还会在该目录展示

往期资料

Spring AI + Spring Ai Aliabba系统化学习资料

本教程将采用2025年5月20日正式的GA版，给出如下内容

  1. 核心功能模块的快速上手教程
  2. 核心功能模块的源码级解读
  3. Spring ai alibaba增强的快速上手教程 + 源码级解读

版本：

  • JDK21
  • SpringBoot3.4.5
  • SpringAI 1.0.1
  • SpringAI Alibaba 1.0.3+

免费渠道：

  1. 为Spring Ai Alibaba开源社区解决解决有效的issue or 提供有价值的PR，可免费获取上述教程
  2. 往届微信推文

收费服务：收费69.9元

  1. 飞书在线云文档
  2. Spring AI会员群教程代码答疑

学习交流圈

你好，我是影子，曾先后在🐻、新能源、老铁就职，兼任Spring AI Alibaba开源社区的Committer。

目前新建了一个交流群，一个人走得快，一群人走得远，另外，本人长期维护一套飞书云文档笔记，涵盖后端、大数据系统化的面试资料，可私信免费获取

avatar
文章
阅读
粉丝