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

技巧

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

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

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

mem0 基础准备

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

基础配置

1. 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. 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:uvicornmain:app--host0.0.0.0--port8000--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:wgetbolt://neo4j:8687||exit1
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;

importstatic 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")
publicclassMem0MemoryController {
privatestaticfinalLoggerlogger= LoggerFactory.getLogger(Mem0MemoryController.class);

privatefinal ChatClient chatClient;
privatefinal VectorStore store;
privatefinal Mem0ServiceClient mem0ServiceClient;

publicMem0MemoryController(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.SearchRequestsearchRequest= Mem0ServerRequest.SearchRequest.builder().query(query).userId(userId).build();
return store.similaritySearch(searchRequest);
    }

@GetMapping("/test")
publicvoidtest(){
//用户和Agent的长期记忆
        mem0ServiceClient.addMemory(
                Mem0ServerRequest.MemoryCreate.builder()
                        .agentId("agent2")
                        .userId("test2")
                        .messages(List.of(
newMem0ServerRequest.Message("user", "I'm travelling to San Francisco"),
newMem0ServerRequest.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 服务的日志记录

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