out = new ArrayList<>();
+ String[] lines = data.split("[\\n\\r]+");
+ for (String raw : lines) {
+ if (raw == null) continue;
+ String s = raw.trim();
+ if (s.isEmpty()) continue;
+
+ // Simple Chinese patterns: "用户喜欢X" / "我喜欢X" / "用户偏好X"
+ Triple t = parseChinesePreference(s);
+ if (t != null) {
+ out.add(t);
+ continue;
+ }
+
+ // English fallback: "User likes X"
+ Triple e = parseEnglishPreference(s);
+ if (e != null) {
+ out.add(e);
+ }
+ }
+ return out;
+ }
+
+ private static Triple parseChinesePreference(String s) {
+ String subject = null;
+ String rest = null;
+
+ // normalize punctuation
+ String x = s.replace("：", ":").replace("，", ",").replace("。", ".").trim();
+
+ if (x.startsWith("用户")) {
+ subject = "用户";
+ rest = x.substring(2);
+ } else if (x.startsWith("我")) {
+ subject = "我";
+ rest = x.substring(1);
+ } else {
+ // unknown subject, skip
+ return null;
+ }
+
+ if (rest == null) return null;
+ rest = rest.trim();
+
+ String rel;
+ int idx;
+ if ((idx = rest.indexOf("喜欢")) >= 0) {
+ rel = "喜欢";
+ } else if ((idx = rest.indexOf("偏好")) >= 0) {
+ rel = "偏好";
+ } else if ((idx = rest.indexOf("讨厌")) >= 0) {
+ rel = "讨厌";
+ } else {
+ return null;
+ }
+
+ String obj = rest.substring(idx + rel.length()).trim();
+ if (obj.isEmpty()) {
+ return null;
+ }
+ return new Triple(subject, rel, obj);
+ }
+
+ private static Triple parseEnglishPreference(String s) {
+ String x = s.trim();
+ String lower = x.toLowerCase(Locale.ROOT);
+ if (!lower.startsWith("user ")) {
+ return null;
+ }
+ // e.g. "User likes coffee"
+ int idx = lower.indexOf(" likes ");
+ String rel = "likes";
+ if (idx < 0) {
+ idx = lower.indexOf(" prefers ");
+ rel = "prefers";
+ }
+ if (idx < 0) {
+ return null;
+ }
+ String obj = x.substring(idx + (" " + rel + " ").length()).trim();
+ if (obj.isEmpty()) return null;
+ return new Triple("User", rel, obj);
+ }
+}
+
diff --git a/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseConstants.java b/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseConstants.java
index c0dc60b..90dd753 100644
--- a/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseConstants.java
+++ b/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseConstants.java
@@ -7,5 +7,20 @@
*/
public final class OceanBaseConstants {
private OceanBaseConstants() {}
+
+ // Graph storage table names
+ public static final String TABLE_GRAPH_ENTITIES = "graph_entities";
+ public static final String TABLE_GRAPH_RELATIONSHIPS = "graph_relationships";
+
+ // Vector config defaults
+ public static final String DEFAULT_OCEANBASE_VECTOR_METRIC_TYPE = "l2";
+ public static final String DEFAULT_VIDX_NAME = "vidx";
+ public static final String DEFAULT_INDEX_TYPE = "HNSW";
+
+ // Graph search defaults
+ public static final double DEFAULT_SIMILARITY_THRESHOLD = 0.7;
+ public static final int DEFAULT_SEARCH_LIMIT = 100;
+ public static final int DEFAULT_BM25_TOP_N = 15;
+ public static final int DEFAULT_MAX_HOPS = 3;
}
diff --git a/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseGraphStore.java b/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseGraphStore.java
index 9b02d1e..ad663e1 100644
--- a/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseGraphStore.java
+++ b/src/main/java/com/oceanbase/powermem/sdk/storage/oceanbase/OceanBaseGraphStore.java
@@ -1,15 +1,1168 @@
package com.oceanbase.powermem.sdk.storage.oceanbase;
+import com.oceanbase.powermem.sdk.exception.ApiException;
+import com.oceanbase.powermem.sdk.integrations.embeddings.Embedder;
+import com.oceanbase.powermem.sdk.integrations.llm.LLM;
+import com.oceanbase.powermem.sdk.integrations.llm.LlmResponse;
+import com.oceanbase.powermem.sdk.json.JacksonJsonCodec;
+import com.oceanbase.powermem.sdk.json.JsonCodec;
+import com.oceanbase.powermem.sdk.model.Message;
+import com.oceanbase.powermem.sdk.prompts.graph.GraphPrompts;
+import com.oceanbase.powermem.sdk.prompts.graph.GraphToolsPrompts;
import com.oceanbase.powermem.sdk.storage.base.GraphStore;
+import com.oceanbase.powermem.sdk.util.Bm25;
+import com.oceanbase.powermem.sdk.util.LlmJsonUtils;
+import com.oceanbase.powermem.sdk.util.SnowflakeIdGenerator;
+import com.oceanbase.powermem.sdk.util.TextTokenizer;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
/**
- * OceanBase graph store implementation (Java migration target).
+ * OceanBase graph store implementation (Python parity).
*
- * Used to store entities/relations and support graph-based retrieval (multi-hop, relation queries).
+ * Python reference: {@code src/powermem/storage/oceanbase/oceanbase_graph.py}
*
- * Python reference: {@code src/powermem/storage/oceanbase/oceanbase_graph.py} and
- * {@code src/powermem/storage/oceanbase/oceanbase_graph.py}.
+ * Implements:
+ * - entities + relationships tables (graph_entities / graph_relationships)
+ * - LLM tools based extraction (extract_entities + establish_relationships + delete_graph_memory)
+ * - ANN-style entity resolution via VECTOR distance (best-effort) with embedding_json brute-force fallback
+ * - BM25 rerank of candidate relationships
+ * - multi-hop expansion
*/
public class OceanBaseGraphStore implements GraphStore {
+ private static final Logger LOG = Logger.getLogger(OceanBaseGraphStore.class.getName());
+
+ private final com.oceanbase.powermem.sdk.config.GraphStoreConfig config;
+ private final Embedder embedder;
+ private final LLM llm;
+ private final JsonCodec json = new JacksonJsonCodec();
+ private final SnowflakeIdGenerator idGenerator = SnowflakeIdGenerator.defaultGenerator();
+
+ private volatile boolean initialized;
+ private volatile boolean hasVectorColumn;
+
+ public OceanBaseGraphStore(com.oceanbase.powermem.sdk.config.GraphStoreConfig config) {
+ this(config, null, null);
+ }
+
+ public OceanBaseGraphStore(com.oceanbase.powermem.sdk.config.GraphStoreConfig config, Embedder embedder, LLM llm) {
+ this.config = config;
+ this.embedder = embedder;
+ this.llm = llm;
+ ensureInitialized();
+ }
+
+ @Override
+ public Map add(String data, Map filters) {
+ if (data == null || data.isBlank()) {
+ return Collections.emptyMap();
+ }
+ ensureInitialized();
+ Map scope = normalizeScope(filters);
+
+ Map entityTypeMap = extractEntitiesWithTypes(data, scope);
+ List toAdd = extractRelations(data, entityTypeMap, scope);
+ if (toAdd.isEmpty()) {
+ return Map.of("deleted_entities", Collections.emptyList(), "added_entities", Collections.emptyList());
+ }
+
+ // Neighborhood search then delete decision (Python parity).
+ List> neighborhood = searchGraphNeighborhood(entityTypeMap.keySet(), scope, safeSearchLimit());
+ String existingMemories = formatMemoriesForPrompt(neighborhood);
+ List toDelete = decideDeletions(existingMemories, data, scope);
+
+ List> deleted = deleteRelations(toDelete, scope);
+ List> added = addEntitiesAndRelationships(toAdd, entityTypeMap, scope);
+
+ Map out = new HashMap<>();
+ out.put("deleted_entities", deleted);
+ out.put("added_entities", added);
+ return out;
+ }
+
+ @Override
+ public List> search(String query, Map filters, int limit) {
+ ensureInitialized();
+ Map scope = normalizeScope(filters);
+ int top = limit > 0 ? limit : safeBm25TopN();
+
+ Map seed = extractEntitiesWithTypes(query, scope);
+ List> candidates = multiHopNeighborhood(seed.keySet(), scope, safeMaxHops(), safeSearchLimit());
+ if (candidates.isEmpty()) {
+ return Collections.emptyList();
+ }
+
+ List> reranked = bm25Rerank(query, candidates, top);
+ // Ensure Python search shape: destination key.
+ List> out = new ArrayList<>();
+ for (Map r : reranked) {
+ if (r == null) continue;
+ Map m = new HashMap<>();
+ m.put("source", r.get("source"));
+ m.put("relationship", r.get("relationship"));
+ Object dst = r.get("destination");
+ if (dst == null) dst = r.get("target");
+ m.put("destination", dst);
+ out.add(m);
+ }
+ return out;
+ }
+
+ @Override
+ public void deleteAll(Map filters) {
+ ensureInitialized();
+ Map scope = normalizeScope(filters);
+ try (Connection c = openConnection()) {
+ Set entityIds = new HashSet<>();
+
+ StringBuilder where = new StringBuilder(" WHERE user_id = ?");
+ List args = new ArrayList<>();
+ args.add(String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) {
+ where.append(" AND agent_id = ?");
+ args.add(asNullableString(scope.get("agent_id")));
+ }
+ if (asNullableString(scope.get("run_id")) != null) {
+ where.append(" AND run_id = ?");
+ args.add(asNullableString(scope.get("run_id")));
+ }
+
+ String q = "SELECT source_entity_id, destination_entity_id FROM " + relationshipsTable() + where;
+ try (PreparedStatement ps = c.prepareStatement(q)) {
+ for (int i = 0; i < args.size(); i++) ps.setString(i + 1, String.valueOf(args.get(i)));
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) {
+ entityIds.add(rs.getLong(1));
+ entityIds.add(rs.getLong(2));
+ }
+ }
+ }
+
+ try (PreparedStatement ps = c.prepareStatement("DELETE FROM " + relationshipsTable() + where)) {
+ for (int i = 0; i < args.size(); i++) ps.setString(i + 1, String.valueOf(args.get(i)));
+ ps.executeUpdate();
+ }
+
+ if (!entityIds.isEmpty()) {
+ String in = placeholders(entityIds.size());
+ String delEnt = "DELETE FROM " + entitiesTable() + " WHERE user_id = ?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND agent_id = ?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND run_id = ?" : "")
+ + " AND id IN (" + in + ")";
+ try (PreparedStatement ps = c.prepareStatement(delEnt)) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ for (Long id : entityIds) ps.setLong(p++, id);
+ ps.executeUpdate();
+ }
+ }
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "OceanBaseGraphStore.deleteAll failed: " + ex.getMessage(), ex);
+ }
+ }
+
+ @Override
+ public List> getAll(Map filters, int limit) {
+ ensureInitialized();
+ Map scope = normalizeScope(filters);
+ int top = limit > 0 ? limit : safeSearchLimit();
+
+ String sql = "SELECT se.name AS source, r.relationship_type AS relationship, de.name AS target "
+ + "FROM " + relationshipsTable() + " r "
+ + "JOIN " + entitiesTable() + " se ON se.id = r.source_entity_id "
+ + "JOIN " + entitiesTable() + " de ON de.id = r.destination_entity_id "
+ + "WHERE r.user_id = ?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND r.agent_id = ?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND r.run_id = ?" : "")
+ + " ORDER BY r.updated_at DESC LIMIT " + top;
+
+ List> out = new ArrayList<>();
+ try (Connection c = openConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) {
+ Map m = new HashMap<>();
+ m.put("source", rs.getString("source"));
+ m.put("relationship", rs.getString("relationship"));
+ m.put("target", rs.getString("target"));
+ out.add(m);
+ }
+ }
+ } catch (Exception ex) {
+ throw new ApiException("OceanBaseGraphStore.getAll failed: " + ex.getMessage(), ex);
+ }
+ return out;
+ }
+
+ @Override
+ public void reset() {
+ ensureInitialized();
+ try (Connection c = openConnection(); Statement st = c.createStatement()) {
+ st.execute("TRUNCATE TABLE " + relationshipsTable());
+ st.execute("TRUNCATE TABLE " + entitiesTable());
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "OceanBaseGraphStore.reset failed: " + ex.getMessage(), ex);
+ }
+ }
+
+ // ---------------- init/schema ----------------
+
+ private synchronized void ensureInitialized() {
+ if (initialized) return;
+ try (Connection c = openConnection(); Statement st = c.createStatement()) {
+ String ent = entitiesTable();
+ String rel = relationshipsTable();
+
+ st.execute("CREATE TABLE IF NOT EXISTS " + ent + " (\n" +
+ " id BIGINT PRIMARY KEY,\n" +
+ " user_id VARCHAR(128) NOT NULL,\n" +
+ " agent_id VARCHAR(128) NULL,\n" +
+ " run_id VARCHAR(128) NULL,\n" +
+ " name VARCHAR(512) NOT NULL,\n" +
+ " entity_type VARCHAR(128) NULL,\n" +
+ " embedding_json LONGTEXT NULL,\n" +
+ " created_at TIMESTAMP NULL,\n" +
+ " updated_at TIMESTAMP NULL\n" +
+ ")");
+
+ st.execute("CREATE TABLE IF NOT EXISTS " + rel + " (\n" +
+ " id BIGINT PRIMARY KEY,\n" +
+ " user_id VARCHAR(128) NOT NULL,\n" +
+ " agent_id VARCHAR(128) NULL,\n" +
+ " run_id VARCHAR(128) NULL,\n" +
+ " source_entity_id BIGINT NOT NULL,\n" +
+ " relationship_type VARCHAR(255) NOT NULL,\n" +
+ " destination_entity_id BIGINT NOT NULL,\n" +
+ " created_at TIMESTAMP NULL,\n" +
+ " updated_at TIMESTAMP NULL\n" +
+ ")");
+
+ try {
+ st.execute("CREATE INDEX IF NOT EXISTS idx_" + ent + "_scope ON " + ent + " (user_id, agent_id, run_id)");
+ st.execute("CREATE INDEX IF NOT EXISTS idx_" + rel + "_scope ON " + rel + " (user_id, agent_id, run_id)");
+ st.execute("CREATE INDEX IF NOT EXISTS idx_" + rel + "_src ON " + rel + " (source_entity_id)");
+ st.execute("CREATE INDEX IF NOT EXISTS idx_" + rel + "_dst ON " + rel + " (destination_entity_id)");
+ } catch (Exception ignored) {}
+
+ int dims = config == null ? 0 : config.getEmbeddingModelDims();
+ if (dims > 0) {
+ try {
+ try (PreparedStatement ps = c.prepareStatement("ALTER TABLE " + ent + " ADD COLUMN embedding VECTOR(" + dims + ")")) {
+ ps.execute();
+ }
+ } catch (Exception ignored) {}
+ try (PreparedStatement ps = c.prepareStatement(
+ "SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME=? AND COLUMN_NAME='embedding'")) {
+ ps.setString(1, ent);
+ try (ResultSet rs = ps.executeQuery()) {
+ hasVectorColumn = rs.next();
+ }
+ } catch (Exception ignored) {
+ hasVectorColumn = false;
+ }
+
+ if (hasVectorColumn) {
+ Integer existingDims = tryGetVectorDims(c, ent, "embedding");
+ if (existingDims != null && existingDims > 0 && existingDims != dims) {
+ throw new RuntimeException("Vector dimension mismatch: existing VECTOR(" + existingDims + "), requested dims=" + dims);
+ }
+ String indexType = config.getIndexType() == null ? OceanBaseConstants.DEFAULT_INDEX_TYPE : config.getIndexType().trim().toUpperCase(Locale.ROOT);
+ String metricType = config.getMetricType() == null ? OceanBaseConstants.DEFAULT_OCEANBASE_VECTOR_METRIC_TYPE : config.getMetricType().trim().toLowerCase(Locale.ROOT);
+ String vidx = config.getVectorIndexName() == null || config.getVectorIndexName().isBlank()
+ ? OceanBaseConstants.DEFAULT_VIDX_NAME
+ : config.getVectorIndexName().trim();
+ String ddl = "CREATE VECTOR INDEX " + vidx + " ON " + ent + " (embedding) USING " + indexType
+ + " WITH (metric_type='" + metricType + "')";
+ try (PreparedStatement ps = c.prepareStatement(ddl)) {
+ ps.execute();
+ } catch (Exception ignored) {}
+ }
+ }
+ } catch (Exception ex) {
+ throw new ApiException("Failed to initialize OceanBaseGraphStore: " + ex.getMessage(), ex);
+ }
+ initialized = true;
+ }
+
+ private static Integer tryGetVectorDims(Connection c, String table, String col) {
+ try (PreparedStatement ps = c.prepareStatement(
+ "SELECT COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME=? AND COLUMN_NAME=?")) {
+ ps.setString(1, table);
+ ps.setString(2, col);
+ try (ResultSet rs = ps.executeQuery()) {
+ if (!rs.next()) return null;
+ String t = rs.getString(1);
+ if (t == null) return null;
+ String s = t.trim().toLowerCase(Locale.ROOT);
+ int l = s.indexOf('(');
+ int r = s.indexOf(')', l + 1);
+ if (l < 0 || r <= l) return null;
+ return Integer.parseInt(s.substring(l + 1, r).trim());
+ }
+ } catch (Exception ignored) {
+ return null;
+ }
+ }
+
+ // ---------------- extraction (LLM tools + fallbacks) ----------------
+
+ private Map extractEntitiesWithTypes(String text, Map scope) {
+ if (llm != null) {
+ try {
+ String system = "You are a smart assistant who understands entities and their types in a given text. "
+ + "If user message contains self reference such as 'I', 'me', 'my' etc. "
+ + "then use " + String.valueOf(scope.get("user_id")) + " as the source entity. "
+ + "Extract all the entities from the text. "
+ + "***DO NOT*** answer the question itself if the given text is a question.";
+ List msgs = List.of(
+ new Message("system", system),
+ new Message("user", text == null ? "" : text)
+ );
+ LlmResponse resp = llm.generateResponseWithTools(
+ msgs,
+ null,
+ List.of(GraphToolsPrompts.extractEntitiesTool(false)),
+ GraphToolsPrompts.toolChoiceFunction("extract_entities")
+ );
+ Map parsed = parseExtractEntities(resp);
+ if (!parsed.isEmpty()) return normalizeEntityTypeMap(parsed);
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "Graph extract_entities failed; fallback. cause=" + ex.getMessage(), ex);
+ }
+ }
+ // heuristic fallback
+ Map out = new HashMap<>();
+ for (RelationTriple t : heuristicTriples(text)) {
+ out.put(t.source, "entity");
+ out.put(t.destination, "entity");
+ }
+ // If still empty (e.g., a pure query), fall back to token-based entities so search can work offline.
+ if (out.isEmpty() && text != null && !text.isBlank()) {
+ for (String tok : TextTokenizer.tokenize(text)) {
+ if (tok == null || tok.isBlank()) continue;
+ // skip ultra-short noise tokens
+ if (tok.length() <= 1) continue;
+ out.put(normalizeName(tok), "entity");
+ }
+ }
+ return normalizeEntityTypeMap(out);
+ }
+
+ private List extractRelations(String text, Map entityTypeMap, Map scope) {
+ if (llm != null && text != null && !text.isBlank() && entityTypeMap != null && !entityTypeMap.isEmpty()) {
+ try {
+ String userIdentity = "user_id: " + scope.get("user_id")
+ + (asNullableString(scope.get("agent_id")) != null ? ", agent_id: " + scope.get("agent_id") : "")
+ + (asNullableString(scope.get("run_id")) != null ? ", run_id: " + scope.get("run_id") : "");
+ String custom = config == null ? null : (config.getCustomExtractRelationsPrompt() != null ? config.getCustomExtractRelationsPrompt() : config.getCustomPrompt());
+ String system = GraphPrompts.extractRelationsSystemPrompt(userIdentity, custom);
+ String userMsg = "List of entities: " + entityTypeMap.keySet() + ". \n\nText: " + text;
+ List msgs = List.of(
+ new Message("system", system),
+ new Message("user", userMsg)
+ );
+ LlmResponse resp = llm.generateResponseWithTools(
+ msgs,
+ null,
+ List.of(GraphToolsPrompts.establishRelationsTool(false)),
+ null
+ );
+ List parsed = parseEstablishRelations(resp);
+ if (!parsed.isEmpty()) return normalizeRelationTriples(parsed);
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "Graph establish_relationships failed; fallback. cause=" + ex.getMessage(), ex);
+ }
+ }
+ return normalizeRelationTriples(heuristicTriples(text));
+ }
+
+ private List decideDeletions(String existingMemories, String newText, Map scope) {
+ if (llm == null) return Collections.emptyList();
+ try {
+ String custom = config == null ? null : config.getCustomDeleteRelationsPrompt();
+ String system = GraphPrompts.deleteRelationsSystemPrompt(String.valueOf(scope.get("user_id")), custom);
+ String user = GraphPrompts.deleteRelationsUserPrompt(existingMemories, newText);
+ List msgs = List.of(new Message("system", system), new Message("user", user));
+ LlmResponse resp = llm.generateResponseWithTools(
+ msgs,
+ null,
+ List.of(GraphToolsPrompts.deleteGraphMemoryTool(false)),
+ null
+ );
+ return normalizeRelationTriples(parseDeleteGraphMemory(resp));
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "Graph delete decision failed; ignore deletes. cause=" + ex.getMessage(), ex);
+ return Collections.emptyList();
+ }
+ }
+
+ // ---------------- entity/relationship operations ----------------
+
+ private List> deleteRelations(List toDelete, Map scope) {
+ if (toDelete == null || toDelete.isEmpty()) return Collections.emptyList();
+ List> out = new ArrayList<>();
+ for (RelationTriple t : toDelete) {
+ int n = deleteRelationByNames(t, scope);
+ out.add(Map.of("deleted_count", n));
+ }
+ return out;
+ }
+
+ private int deleteRelationByNames(RelationTriple t, Map scope) {
+ if (t == null) return 0;
+ try (Connection c = openConnection()) {
+ List srcIds = findEntityIdsByName(c, t.source, scope);
+ List dstIds = findEntityIdsByName(c, t.destination, scope);
+ if (srcIds.isEmpty() || dstIds.isEmpty()) return 0;
+
+ String relTable = relationshipsTable();
+ StringBuilder sql = new StringBuilder("DELETE FROM ").append(relTable)
+ .append(" WHERE relationship_type = ? AND user_id = ?");
+ List args = new ArrayList<>();
+ args.add(t.relationship);
+ args.add(String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) {
+ sql.append(" AND agent_id = ?");
+ args.add(asNullableString(scope.get("agent_id")));
+ }
+ if (asNullableString(scope.get("run_id")) != null) {
+ sql.append(" AND run_id = ?");
+ args.add(asNullableString(scope.get("run_id")));
+ }
+
+ sql.append(" AND source_entity_id IN (").append(placeholders(srcIds.size())).append(")");
+ sql.append(" AND destination_entity_id IN (").append(placeholders(dstIds.size())).append(")");
+
+ try (PreparedStatement ps = c.prepareStatement(sql.toString())) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(args.get(0)));
+ ps.setString(p++, String.valueOf(args.get(1)));
+ for (int i = 2; i < args.size(); i++) ps.setString(p++, String.valueOf(args.get(i)));
+ for (Long id : srcIds) ps.setLong(p++, id);
+ for (Long id : dstIds) ps.setLong(p++, id);
+ return ps.executeUpdate();
+ }
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "deleteRelation failed: " + ex.getMessage(), ex);
+ return 0;
+ }
+ }
+
+ private List> addEntitiesAndRelationships(List triples, Map entityTypeMap, Map scope) {
+ if (triples == null || triples.isEmpty()) return Collections.emptyList();
+ if (embedder == null) throw new ApiException("OceanBaseGraphStore requires an embedder");
+
+ List> out = new ArrayList<>();
+ for (RelationTriple t : triples) {
+ long srcId = getOrCreateEntity(t.source, entityTypeMap.getOrDefault(t.source, "entity"), scope);
+ long dstId = getOrCreateEntity(t.destination, entityTypeMap.getOrDefault(t.destination, "entity"), scope);
+ Map rel = createRelationshipIfNotExists(srcId, dstId, t.relationship, scope);
+ if (rel != null && !rel.isEmpty()) out.add(rel);
+ }
+ return out;
+ }
+
+ private long getOrCreateEntity(String name, String type, Map scope) {
+ String n = normalizeName(name);
+ float[] vec = embedder.embed(n, "search");
+ EntityRow hit = searchSimilarEntity(vec, scope, similarityThreshold(), 1);
+ if (hit != null) return hit.id;
+ return createEntity(n, type, vec, scope);
+ }
+
+ private long createEntity(String name, String type, float[] embedding, Map scope) {
+ long id = parseLongOrZero(idGenerator.nextId());
+ Instant now = Instant.now();
+ String embeddingJson = json.toJson(embedding == null ? new float[0] : embedding);
+
+ List cols = new ArrayList<>();
+ cols.add("id");
+ cols.add("user_id");
+ cols.add("agent_id");
+ cols.add("run_id");
+ cols.add("name");
+ cols.add("entity_type");
+ cols.add("embedding_json");
+ cols.add("created_at");
+ cols.add("updated_at");
+ if (hasVectorColumn) cols.add("embedding");
+
+ StringBuilder sql = new StringBuilder("INSERT INTO ").append(entitiesTable()).append(" (");
+ for (int i = 0; i < cols.size(); i++) {
+ if (i > 0) sql.append(", ");
+ sql.append(cols.get(i));
+ }
+ sql.append(") VALUES (");
+ for (int i = 0; i < cols.size(); i++) {
+ if (i > 0) sql.append(", ");
+ sql.append("?");
+ }
+ sql.append(")");
+
+ try (Connection c = openConnection(); PreparedStatement ps = c.prepareStatement(sql.toString())) {
+ int p = 1;
+ ps.setLong(p++, id);
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ ps.setString(p++, asNullableString(scope.get("agent_id")));
+ ps.setString(p++, asNullableString(scope.get("run_id")));
+ ps.setString(p++, name);
+ ps.setString(p++, type);
+ ps.setString(p++, embeddingJson);
+ ps.setTimestamp(p++, java.sql.Timestamp.from(now));
+ ps.setTimestamp(p++, java.sql.Timestamp.from(now));
+ if (hasVectorColumn) ps.setString(p, embeddingJson);
+ ps.executeUpdate();
+ return id;
+ } catch (Exception ex) {
+ throw new ApiException("createEntity failed: " + ex.getMessage(), ex);
+ }
+ }
+
+ private Map createRelationshipIfNotExists(long srcId, long dstId, String relType, Map scope) {
+ long id = parseLongOrZero(idGenerator.nextId());
+ Instant now = Instant.now();
+
+ try (Connection c = openConnection()) {
+ String exists = "SELECT 1 FROM " + relationshipsTable() + " WHERE user_id=?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND agent_id=?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND run_id=?" : "")
+ + " AND source_entity_id=? AND destination_entity_id=? AND relationship_type=? LIMIT 1";
+ try (PreparedStatement ps = c.prepareStatement(exists)) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ ps.setLong(p++, srcId);
+ ps.setLong(p++, dstId);
+ ps.setString(p, relType);
+ try (ResultSet rs = ps.executeQuery()) {
+ if (rs.next()) return Collections.emptyMap();
+ }
+ }
+
+ String insert = "INSERT INTO " + relationshipsTable()
+ + " (id, user_id, agent_id, run_id, source_entity_id, relationship_type, destination_entity_id, created_at, updated_at) "
+ + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+ try (PreparedStatement ps = c.prepareStatement(insert)) {
+ int p = 1;
+ ps.setLong(p++, id);
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ ps.setString(p++, asNullableString(scope.get("agent_id")));
+ ps.setString(p++, asNullableString(scope.get("run_id")));
+ ps.setLong(p++, srcId);
+ ps.setString(p++, relType);
+ ps.setLong(p++, dstId);
+ ps.setTimestamp(p++, java.sql.Timestamp.from(now));
+ ps.setTimestamp(p, java.sql.Timestamp.from(now));
+ ps.executeUpdate();
+ }
+
+ Map out = new HashMap<>();
+ out.put("source", getEntityNameById(c, srcId));
+ out.put("relationship", relType);
+ out.put("target", getEntityNameById(c, dstId));
+ return out;
+ } catch (Exception ex) {
+ throw new ApiException("createRelationship failed: " + ex.getMessage(), ex);
+ }
+ }
+
+ private String getEntityNameById(Connection c, long id) throws Exception {
+ try (PreparedStatement ps = c.prepareStatement("SELECT name FROM " + entitiesTable() + " WHERE id=? LIMIT 1")) {
+ ps.setLong(1, id);
+ try (ResultSet rs = ps.executeQuery()) {
+ if (rs.next()) return rs.getString(1);
+ }
+ }
+ return null;
+ }
+
+ private List findEntityIdsByName(Connection c, String name, Map scope) throws Exception {
+ String sql = "SELECT id FROM " + entitiesTable() + " WHERE user_id=?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND agent_id=?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND run_id=?" : "")
+ + " AND name=? LIMIT " + safeSearchLimit();
+ List out = new ArrayList<>();
+ try (PreparedStatement ps = c.prepareStatement(sql)) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ ps.setString(p, name);
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) out.add(rs.getLong(1));
+ }
+ }
+ return out;
+ }
+
+ // ---------------- ANN lookup ----------------
+
+ private EntityRow searchSimilarEntity(float[] queryEmbedding, Map scope, double threshold, int limit) {
+ if (queryEmbedding == null || queryEmbedding.length == 0) return null;
+ int k = Math.max(1, limit);
+
+ if (hasVectorColumn) {
+ String metricType = config.getMetricType() == null ? OceanBaseConstants.DEFAULT_OCEANBASE_VECTOR_METRIC_TYPE : config.getMetricType().trim().toLowerCase(Locale.ROOT);
+ String distFunc = "l2_distance";
+ if ("cosine".equals(metricType)) distFunc = "cosine_distance";
+ if ("inner_product".equals(metricType) || "ip".equals(metricType)) distFunc = "inner_product";
+
+ String sql = "SELECT id, name, entity_type, " + distFunc + "(embedding, ?) AS d FROM " + entitiesTable()
+ + " WHERE user_id=?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND agent_id=?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND run_id=?" : "")
+ + " ORDER BY d ASC LIMIT " + k;
+ try (Connection c = openConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+ int p = 1;
+ ps.setString(p++, json.toJson(queryEmbedding));
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ try (ResultSet rs = ps.executeQuery()) {
+ if (rs.next()) {
+ double d = rs.getDouble("d");
+ if (threshold > 0 && d >= threshold) return null;
+ return new EntityRow(rs.getLong("id"), rs.getString("name"), rs.getString("entity_type"), d);
+ }
+ }
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "Graph SQL distance failed; fallback to brute-force. cause=" + ex.getMessage(), ex);
+ }
+ }
+
+ // Brute-force fallback via embedding_json
+ try (Connection c = openConnection()) {
+ String sql = "SELECT id, name, entity_type, embedding_json FROM " + entitiesTable()
+ + " WHERE user_id=?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND agent_id=?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND run_id=?" : "")
+ + " LIMIT " + safeSearchLimit();
+ try (PreparedStatement ps = c.prepareStatement(sql)) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ EntityRow best = null;
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) {
+ float[] vec = json.fromJson(rs.getString("embedding_json"), float[].class);
+ if (vec == null || vec.length == 0) continue;
+ double d = l2Distance(queryEmbedding, vec);
+ if (threshold > 0 && d >= threshold) continue;
+ if (best == null || d < best.distance) {
+ best = new EntityRow(rs.getLong("id"), rs.getString("name"), rs.getString("entity_type"), d);
+ }
+ }
+ }
+ return best;
+ }
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "Graph brute-force entity search failed: " + ex.getMessage(), ex);
+ return null;
+ }
+ }
+
+ private static double l2Distance(float[] a, float[] b) {
+ if (a == null || b == null) return Double.POSITIVE_INFINITY;
+ int n = Math.min(a.length, b.length);
+ double s = 0.0;
+ for (int i = 0; i < n; i++) {
+ double d = (double) a[i] - (double) b[i];
+ s += d * d;
+ }
+ return Math.sqrt(s);
+ }
+
+ // ---------------- neighborhood + BM25 + multi-hop ----------------
+
+ private List> searchGraphNeighborhood(Set seedNames, Map scope, int limit) {
+ if (seedNames == null || seedNames.isEmpty() || embedder == null) return Collections.emptyList();
+ Set ids = new HashSet<>();
+ for (String n : seedNames) {
+ if (n == null || n.isBlank()) continue;
+ float[] vec = embedder.embed(n, "search");
+ EntityRow hit = searchSimilarEntity(vec, scope, similarityThreshold(), 1);
+ if (hit != null) ids.add(hit.id);
+ }
+ if (ids.isEmpty()) return Collections.emptyList();
+ return fetchRelationsByEntityIds(ids, scope, limit);
+ }
+
+ private List> multiHopNeighborhood(Set seedNames, Map scope, int maxHops, int limit) {
+ if (seedNames == null || seedNames.isEmpty() || embedder == null) return Collections.emptyList();
+ int hops = Math.max(1, maxHops);
+ int cap = Math.max(1, limit);
+
+ Set frontier = new HashSet<>();
+ Set visitedNodes = new HashSet<>();
+ for (String s : seedNames) {
+ if (s == null || s.isBlank()) continue;
+ float[] vec = embedder.embed(s, "search");
+ EntityRow hit = searchSimilarEntity(vec, scope, similarityThreshold(), 1);
+ if (hit != null) {
+ frontier.add(hit.id);
+ visitedNodes.add(hit.id);
+ }
+ }
+ if (frontier.isEmpty()) return Collections.emptyList();
+
+ List> edges = new ArrayList<>();
+ Set dedup = new HashSet<>();
+
+ for (int hop = 0; hop < hops && !frontier.isEmpty() && edges.size() < cap; hop++) {
+ List> batch = fetchRelationsByEntityIds(frontier, scope, cap - edges.size());
+ Set next = new HashSet<>();
+ for (Map e : batch) {
+ if (e == null) continue;
+ String key = String.valueOf(e.get("source")) + "|" + String.valueOf(e.get("relationship")) + "|" + String.valueOf(e.get("destination"));
+ if (dedup.add(key)) edges.add(e);
+ // Prefer id-based traversal for parity (avoid name->id roundtrip).
+ Object sid = e.get("_src_id");
+ Object did = e.get("_dst_id");
+ if (sid instanceof Number) next.add(((Number) sid).longValue());
+ if (did instanceof Number) next.add(((Number) did).longValue());
+ }
+ next.removeAll(visitedNodes);
+ visitedNodes.addAll(next);
+ frontier = next;
+ }
+ return edges;
+ }
+
+ private List> fetchRelationsByEntityIds(Set ids, Map scope, int limit) {
+ if (ids == null || ids.isEmpty()) return Collections.emptyList();
+ int top = Math.max(1, limit);
+ String in = placeholders(ids.size());
+ String sql = "SELECT r.source_entity_id AS src_id, r.destination_entity_id AS dst_id, "
+ + "se.name AS source, r.relationship_type AS relationship, de.name AS destination "
+ + "FROM " + relationshipsTable() + " r "
+ + "JOIN " + entitiesTable() + " se ON se.id = r.source_entity_id "
+ + "JOIN " + entitiesTable() + " de ON de.id = r.destination_entity_id "
+ + "WHERE r.user_id=?"
+ + (asNullableString(scope.get("agent_id")) != null ? " AND r.agent_id=?" : "")
+ + (asNullableString(scope.get("run_id")) != null ? " AND r.run_id=?" : "")
+ + " AND (r.source_entity_id IN (" + in + ") OR r.destination_entity_id IN (" + in + "))"
+ + " ORDER BY r.updated_at DESC LIMIT " + top;
+
+ List> out = new ArrayList<>();
+ try (Connection c = openConnection(); PreparedStatement ps = c.prepareStatement(sql)) {
+ int p = 1;
+ ps.setString(p++, String.valueOf(scope.get("user_id")));
+ if (asNullableString(scope.get("agent_id")) != null) ps.setString(p++, asNullableString(scope.get("agent_id")));
+ if (asNullableString(scope.get("run_id")) != null) ps.setString(p++, asNullableString(scope.get("run_id")));
+ for (Long id : ids) ps.setLong(p++, id);
+ for (Long id : ids) ps.setLong(p++, id);
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) {
+ Map m = new HashMap<>();
+ m.put("_src_id", rs.getLong("src_id"));
+ m.put("_dst_id", rs.getLong("dst_id"));
+ m.put("source", rs.getString("source"));
+ m.put("relationship", rs.getString("relationship"));
+ m.put("destination", rs.getString("destination"));
+ out.add(m);
+ }
+ }
+ } catch (Exception ex) {
+ LOG.log(Level.WARNING, "fetchRelationsByEntityIds failed: " + ex.getMessage(), ex);
+ }
+ return out;
+ }
+
+ private List> bm25Rerank(String query, List> candidates, int topN) {
+ if (candidates == null || candidates.isEmpty()) return Collections.emptyList();
+ int top = Math.max(1, topN);
+
+ List> corpus = new ArrayList<>();
+ for (Map r : candidates) {
+ String combined = String.valueOf(r.get("source")) + " " + String.valueOf(r.get("relationship")) + " " + String.valueOf(r.get("destination"));
+ corpus.add(TextTokenizer.tokenize(combined));
+ }
+ Bm25 bm25 = new Bm25(corpus);
+ double[] scores = bm25.getScores(TextTokenizer.tokenize(query == null ? "" : query));
+
+ List idx = new ArrayList<>();
+ for (int i = 0; i < candidates.size(); i++) idx.add(i);
+ idx.sort((a, b) -> Double.compare(scores[b], scores[a]));
+
+ List> out = new ArrayList<>();
+ for (int i : idx) {
+ out.add(candidates.get(i));
+ if (out.size() >= top) break;
+ }
+ return out;
+ }
+
+ private static String formatMemoriesForPrompt(List> rels) {
+ if (rels == null || rels.isEmpty()) return "";
+ StringBuilder sb = new StringBuilder();
+ for (Map r : rels) {
+ if (r == null) continue;
+ if (sb.length() > 0) sb.append("\n");
+ sb.append(String.valueOf(r.get("source"))).append(" -- ")
+ .append(String.valueOf(r.get("relationship"))).append(" -- ")
+ .append(String.valueOf(r.get("destination")));
+ }
+ return sb.toString();
+ }
+
+ // ---------------- tool parsing helpers ----------------
+
+ private Map parseExtractEntities(LlmResponse resp) {
+ Map out = new HashMap<>();
+ for (Map tc : extractToolCalls(resp)) {
+ String name = toolCallName(tc);
+ if (!"extract_entities".equals(name)) continue;
+ Map args = toolCallArguments(tc);
+ Object ents = args.get("entities");
+ if (ents instanceof List) {
+ for (Object e : (List) ents) {
+ if (!(e instanceof Map)) continue;
+ Map em = (Map) e;
+ Object en = em.get("entity");
+ Object et = em.get("entity_type");
+ if (en == null) continue;
+ out.put(normalizeName(String.valueOf(en)), et == null ? "entity" : normalizeName(String.valueOf(et)));
+ }
+ }
+ }
+ return out;
+ }
+
+ private List parseEstablishRelations(LlmResponse resp) {
+ List out = new ArrayList<>();
+ for (Map tc : extractToolCalls(resp)) {
+ String name = toolCallName(tc);
+ if (!"establish_relationships".equals(name) && !"establish_relations".equals(name)) continue;
+ Map args = toolCallArguments(tc);
+ Object ents = args.get("entities");
+ if (ents instanceof List) {
+ for (Object e : (List) ents) {
+ if (!(e instanceof Map)) continue;
+ Map em = (Map) e;
+ String src = normalizeName(String.valueOf(em.get("source")));
+ String rel = normalizeName(String.valueOf(em.get("relationship")));
+ String dst = normalizeName(String.valueOf(em.get("destination")));
+ if (!src.isBlank() && !rel.isBlank() && !dst.isBlank()) out.add(new RelationTriple(src, rel, dst));
+ }
+ }
+ }
+ return out;
+ }
+
+ private List parseDeleteGraphMemory(LlmResponse resp) {
+ List out = new ArrayList<>();
+ for (Map tc : extractToolCalls(resp)) {
+ String name = toolCallName(tc);
+ if (!"delete_graph_memory".equals(name)) continue;
+ Map args = toolCallArguments(tc);
+ String src = normalizeName(String.valueOf(args.get("source")));
+ String rel = normalizeName(String.valueOf(args.get("relationship")));
+ String dst = normalizeName(String.valueOf(args.get("destination")));
+ if (!src.isBlank() && !rel.isBlank() && !dst.isBlank()) out.add(new RelationTriple(src, rel, dst));
+ }
+ return out;
+ }
+
+ private List> extractToolCalls(LlmResponse resp) {
+ if (resp == null) return Collections.emptyList();
+ if (resp.getToolCalls() != null && !resp.getToolCalls().isEmpty()) return resp.getToolCalls();
+ Map m = LlmJsonUtils.parseJsonObjectLoose(resp.getContent());
+ Object tc = m.get("tool_calls");
+ if (tc instanceof List) {
+ List> out = new ArrayList<>();
+ for (Object o : (List) tc) {
+ if (o instanceof Map) {
+ @SuppressWarnings("unchecked")
+ Map mm = (Map) o;
+ out.add(mm);
+ }
+ }
+ return out;
+ }
+ return Collections.emptyList();
+ }
+
+ private static String toolCallName(Map tc) {
+ if (tc == null) return null;
+ Object fn = tc.get("function");
+ if (fn instanceof Map) {
+ Object n = ((Map) fn).get("name");
+ return n == null ? null : String.valueOf(n);
+ }
+ Object n = tc.get("name");
+ return n == null ? null : String.valueOf(n);
+ }
+
+ private static Map toolCallArguments(Map tc) {
+ if (tc == null) return Collections.emptyMap();
+ Object fn = tc.get("function");
+ Object args = null;
+ if (fn instanceof Map) args = ((Map) fn).get("arguments");
+ if (args == null) args = tc.get("arguments");
+ if (args instanceof Map) {
+ @SuppressWarnings("unchecked")
+ Map m = (Map) args;
+ return m;
+ }
+ if (args instanceof String) return LlmJsonUtils.parseJsonObjectLoose((String) args);
+ return Collections.emptyMap();
+ }
+
+ // ---------------- fallbacks / normalization ----------------
+
+ private static Map normalizeEntityTypeMap(Map m) {
+ Map out = new HashMap<>();
+ if (m == null) return out;
+ for (Map.Entry e : m.entrySet()) {
+ if (e.getKey() == null) continue;
+ String k = normalizeName(e.getKey());
+ if (k.isBlank()) continue;
+ String v = e.getValue() == null ? "entity" : normalizeName(e.getValue());
+ if (v.isBlank()) v = "entity";
+ out.put(k, v);
+ }
+ return out;
+ }
+
+ private static List normalizeRelationTriples(List in) {
+ if (in == null || in.isEmpty()) return Collections.emptyList();
+ List out = new ArrayList<>();
+ for (RelationTriple t : in) {
+ if (t == null) continue;
+ String s = normalizeName(t.source);
+ String r = normalizeName(t.relationship);
+ String d = normalizeName(t.destination);
+ if (s.isBlank() || r.isBlank() || d.isBlank()) continue;
+ out.add(new RelationTriple(s, r, d));
+ }
+ return out;
+ }
+
+ private static String normalizeName(String s) {
+ if (s == null) return "";
+ return s.toLowerCase(Locale.ROOT).replace(" ", "_").trim();
+ }
+
+ private static List heuristicTriples(String data) {
+ if (data == null || data.isBlank()) return Collections.emptyList();
+ List out = new ArrayList<>();
+ String[] lines = data.split("[\\n\\r]+");
+ for (String raw : lines) {
+ if (raw == null) continue;
+ String s = raw.trim();
+ if (s.isEmpty()) continue;
+ // Allow explicit triple format: source -- relationship -- destination
+ RelationTriple explicit = parseExplicitTriple(s);
+ if (explicit != null) {
+ out.add(explicit);
+ continue;
+ }
+ RelationTriple t = parseChinesePreference(s);
+ if (t != null) {
+ out.add(t);
+ continue;
+ }
+ RelationTriple e = parseEnglishPreference(s);
+ if (e != null) out.add(e);
+ }
+ return out;
+ }
+
+ private static RelationTriple parseExplicitTriple(String s) {
+ if (s == null) return null;
+ String x = s.trim();
+ if (!x.contains("--")) return null;
+ String[] parts = x.split("\\s*--\\s*");
+ if (parts.length < 3) return null;
+ String src = normalizeName(parts[0]);
+ String rel = normalizeName(parts[1]);
+ String dst = normalizeName(parts[2]);
+ if (src.isBlank() || rel.isBlank() || dst.isBlank()) return null;
+ return new RelationTriple(src, rel, dst);
+ }
+
+ private static RelationTriple parseChinesePreference(String s) {
+ String x = s.replace("：", ":").replace("，", ",").replace("。", ".").trim();
+ String subject;
+ String rest;
+ if (x.startsWith("用户")) {
+ subject = "用户";
+ rest = x.substring(2);
+ } else if (x.startsWith("我")) {
+ subject = "我";
+ rest = x.substring(1);
+ } else {
+ return null;
+ }
+ rest = rest.trim();
+ String rel;
+ int idx;
+ if ((idx = rest.indexOf("喜欢")) >= 0) rel = "喜欢";
+ else if ((idx = rest.indexOf("偏好")) >= 0) rel = "偏好";
+ else if ((idx = rest.indexOf("讨厌")) >= 0) rel = "讨厌";
+ else return null;
+ String obj = rest.substring(idx + rel.length()).trim();
+ if (obj.isEmpty()) return null;
+ return new RelationTriple(normalizeName(subject), normalizeName(rel), normalizeName(obj));
+ }
+
+ private static RelationTriple parseEnglishPreference(String s) {
+ String x = s.trim();
+ String lower = x.toLowerCase(Locale.ROOT);
+ if (!lower.startsWith("user ")) return null;
+ int idx = lower.indexOf(" likes ");
+ String rel = "likes";
+ if (idx < 0) {
+ idx = lower.indexOf(" prefers ");
+ rel = "prefers";
+ }
+ if (idx < 0) return null;
+ String obj = x.substring(idx + (" " + rel + " ").length()).trim();
+ if (obj.isEmpty()) return null;
+ return new RelationTriple("user", normalizeName(rel), normalizeName(obj));
+ }
+
+ // ---------------- config helpers ----------------
+
+ private int safeSearchLimit() {
+ int v = config == null ? 0 : config.getSearchLimit();
+ return v > 0 ? v : OceanBaseConstants.DEFAULT_SEARCH_LIMIT;
+ }
+
+ private int safeBm25TopN() {
+ int v = config == null ? 0 : config.getBm25TopN();
+ return v > 0 ? v : OceanBaseConstants.DEFAULT_BM25_TOP_N;
+ }
+
+ private int safeMaxHops() {
+ int v = config == null ? 0 : config.getMaxHops();
+ return v > 0 ? v : OceanBaseConstants.DEFAULT_MAX_HOPS;
+ }
+
+ private double similarityThreshold() {
+ double v = config == null ? 0.0 : config.getSimilarityThreshold();
+ return v > 0.0 ? v : OceanBaseConstants.DEFAULT_SIMILARITY_THRESHOLD;
+ }
+
+ // ---------------- connection + SQL helpers ----------------
+
+ private String entitiesTable() {
+ String tn = config == null ? null : config.getEntitiesTable();
+ if (tn == null || tn.isBlank()) tn = OceanBaseConstants.TABLE_GRAPH_ENTITIES;
+ String safe = tn.trim();
+ if (!safe.matches("[A-Za-z0-9_]+")) safe = OceanBaseConstants.TABLE_GRAPH_ENTITIES;
+ return safe;
+ }
+
+ private String relationshipsTable() {
+ String tn = config == null ? null : config.getRelationshipsTable();
+ if (tn == null || tn.isBlank()) tn = OceanBaseConstants.TABLE_GRAPH_RELATIONSHIPS;
+ String safe = tn.trim();
+ if (!safe.matches("[A-Za-z0-9_]+")) safe = OceanBaseConstants.TABLE_GRAPH_RELATIONSHIPS;
+ return safe;
+ }
+
+ private String jdbcUrl() {
+ String host = config.getHost() == null || config.getHost().isBlank() ? "127.0.0.1" : config.getHost();
+ int port = config.getPort() > 0 ? config.getPort() : 2881;
+ String db = config.getDatabase() == null || config.getDatabase().isBlank() ? "ai_work" : config.getDatabase();
+ int timeout = Math.max(1, config.getTimeoutSeconds());
+ return "jdbc:mysql://" + host + ":" + port + "/" + db
+ + "?useUnicode=true&characterEncoding=UTF-8"
+ + "&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC"
+ + "&connectTimeout=" + (timeout * 1000)
+ + "&socketTimeout=" + (timeout * 1000);
+ }
+
+ private Connection openConnection() throws Exception {
+ String user = config.getUser();
+ String pass = config.getPassword();
+ if (user == null || user.isBlank()) {
+ throw new ApiException("OceanBase user is required (graph_store.user)");
+ }
+ if (pass == null) pass = "";
+ return DriverManager.getConnection(jdbcUrl(), user, pass);
+ }
+
+ private static Map normalizeScope(Map filters) {
+ Map f = filters == null ? new HashMap<>() : new HashMap<>(filters);
+ Object uid = f.get("user_id");
+ if (uid == null || String.valueOf(uid).isBlank()) {
+ f.put("user_id", "user"); // Python parity default
+ }
+ return f;
+ }
+
+ private static String asNullableString(Object v) {
+ if (v == null) return null;
+ String s = String.valueOf(v);
+ return s.isBlank() ? null : s;
+ }
+
+ private static long parseLongOrZero(String s) {
+ try {
+ return Long.parseLong(s);
+ } catch (Exception ex) {
+ return 0L;
+ }
+ }
+
+ private static String placeholders(int n) {
+ if (n <= 0) return "";
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < n; i++) {
+ if (i > 0) sb.append(",");
+ sb.append("?");
+ }
+ return sb.toString();
+ }
+
+ // ---------------- data types ----------------
+
+ private static final class RelationTriple {
+ final String source;
+ final String relationship;
+ final String destination;
+ RelationTriple(String source, String relationship, String destination) {
+ this.source = source;
+ this.relationship = relationship;
+ this.destination = destination;
+ }
+ }
+
+ private static final class EntityRow {
+ final long id;
+ final String name;
+ final String entityType;
+ final double distance;
+ EntityRow(long id, String name, String entityType, double distance) {
+ this.id = id;
+ this.name = name;
+ this.entityType = entityType;
+ this.distance = distance;
+ }
+ }
}
diff --git a/src/main/java/com/oceanbase/powermem/sdk/util/Bm25.java b/src/main/java/com/oceanbase/powermem/sdk/util/Bm25.java
new file mode 100644
index 0000000..16527b3
--- /dev/null
+++ b/src/main/java/com/oceanbase/powermem/sdk/util/Bm25.java
@@ -0,0 +1,82 @@
+package com.oceanbase.powermem.sdk.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Minimal BM25 scorer (Okapi BM25).
+ *
+ * Used for graph triple reranking (Python parity: rank_bm25.BM25Okapi).
+ */
+public final class Bm25 {
+ private final double k1;
+ private final double b;
+ private final List> corpus;
+ private final Map docFreq = new HashMap<>();
+ private final List> termFreqs = new ArrayList<>();
+ private final double avgDocLen;
+
+ public Bm25(List> tokenizedCorpus) {
+ this(tokenizedCorpus, 1.5, 0.75);
+ }
+
+ public Bm25(List> tokenizedCorpus, double k1, double b) {
+ this.k1 = k1;
+ this.b = b;
+ this.corpus = tokenizedCorpus == null ? new ArrayList<>() : tokenizedCorpus;
+
+ long totalLen = 0;
+ for (List doc : this.corpus) {
+ Map tf = new HashMap<>();
+ if (doc != null) {
+ totalLen += doc.size();
+ for (String t : doc) {
+ if (t == null || t.isBlank()) continue;
+ tf.put(t, tf.getOrDefault(t, 0) + 1);
+ }
+ }
+ termFreqs.add(tf);
+ for (String term : tf.keySet()) {
+ docFreq.put(term, docFreq.getOrDefault(term, 0) + 1);
+ }
+ }
+ this.avgDocLen = this.corpus.isEmpty() ? 0.0 : (double) totalLen / (double) this.corpus.size();
+ }
+
+ public double[] getScores(List queryTokens) {
+ int nDocs = corpus.size();
+ double[] scores = new double[nDocs];
+ if (nDocs == 0) {
+ return scores;
+ }
+ if (queryTokens == null || queryTokens.isEmpty()) {
+ return scores;
+ }
+
+ for (int i = 0; i < nDocs; i++) {
+ List doc = corpus.get(i);
+ Map tf = termFreqs.get(i);
+ int docLen = doc == null ? 0 : doc.size();
+ double denomNorm = (1.0 - b) + b * (avgDocLen > 0 ? ((double) docLen / avgDocLen) : 1.0);
+
+ double s = 0.0;
+ for (String q : queryTokens) {
+ if (q == null || q.isBlank()) continue;
+ Integer df = docFreq.get(q);
+ if (df == null || df == 0) continue;
+ // IDF with smoothing (Okapi)
+ double idf = Math.log(1.0 + (nDocs - df + 0.5) / (df + 0.5));
+ int f = tf.getOrDefault(q, 0);
+ if (f == 0) continue;
+ double numer = f * (k1 + 1.0);
+ double denom = f + k1 * denomNorm;
+ s += idf * (numer / denom);
+ }
+ scores[i] = s;
+ }
+ return scores;
+ }
+}
+
diff --git a/src/main/java/com/oceanbase/powermem/sdk/util/TextTokenizer.java b/src/main/java/com/oceanbase/powermem/sdk/util/TextTokenizer.java
new file mode 100644
index 0000000..7dfdc74
--- /dev/null
+++ b/src/main/java/com/oceanbase/powermem/sdk/util/TextTokenizer.java
@@ -0,0 +1,62 @@
+package com.oceanbase.powermem.sdk.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Minimal tokenizer used for BM25 in graph store.
+ *
+ * Python parity: jieba is used when available; here we use a lightweight heuristic:
+ * - ASCII words: split by non-alphanumerics
+ * - CJK: treat each CJK character as a token
+ * - Also keep numeric tokens
+ */
+public final class TextTokenizer {
+ private TextTokenizer() {}
+
+ public static List tokenize(String text) {
+ List out = new ArrayList<>();
+ if (text == null || text.isBlank()) {
+ return out;
+ }
+ String s = text.toLowerCase(Locale.ROOT);
+
+ StringBuilder ascii = new StringBuilder();
+ for (int i = 0; i < s.length(); i++) {
+ char c = s.charAt(i);
+ if (isCjk(c)) {
+ flushAscii(ascii, out);
+ out.add(String.valueOf(c));
+ } else if (Character.isLetterOrDigit(c)) {
+ ascii.append(c);
+ } else {
+ flushAscii(ascii, out);
+ }
+ }
+ flushAscii(ascii, out);
+ return out;
+ }
+
+ private static void flushAscii(StringBuilder sb, List out) {
+ if (sb.length() == 0) return;
+ String tok = sb.toString();
+ sb.setLength(0);
+ if (!tok.isBlank()) {
+ out.add(tok);
+ }
+ }
+
+ private static boolean isCjk(char c) {
+ Character.UnicodeBlock b = Character.UnicodeBlock.of(c);
+ return b == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
+ || b == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
+ || b == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
+ || b == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
+ || b == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
+ || b == Character.UnicodeBlock.HIRAGANA
+ || b == Character.UnicodeBlock.KATAKANA
+ || b == Character.UnicodeBlock.HANGUL_SYLLABLES;
+ }
+}
+
diff --git a/src/test/java/com/oceanbase/powermem/GraphStoreConfigOverrideTest.java b/src/test/java/com/oceanbase/powermem/GraphStoreConfigOverrideTest.java
new file mode 100644
index 0000000..2b98db6
--- /dev/null
+++ b/src/test/java/com/oceanbase/powermem/GraphStoreConfigOverrideTest.java
@@ -0,0 +1,61 @@
+package com.oceanbase.powermem;
+
+import com.oceanbase.powermem.sdk.config.MemoryConfig;
+import com.oceanbase.powermem.sdk.config.ConfigLoader;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Offline test for graph_store.llm/embedder override parsing.
+ *
+ * We primarily validate that ConfigLoader wires the nested config objects and does not affect
+ * the top-level llm/embedder config.
+ */
+public class GraphStoreConfigOverrideTest {
+
+ @Test
+ void testGraphStoreNestedLlmAndEmbedder_areParsed() {
+ java.util.Map m = new java.util.HashMap<>();
+ m.put("GRAPH_STORE_ENABLED", "true");
+ m.put("GRAPH_STORE_PROVIDER", "oceanbase");
+
+ m.put("LLM_PROVIDER", "mock");
+ m.put("EMBEDDING_PROVIDER", "mock");
+
+ m.put("GRAPH_STORE_LLM_PROVIDER", "openai");
+ m.put("GRAPH_STORE_LLM_API_KEY", "k1");
+ m.put("GRAPH_STORE_LLM_MODEL", "gpt-4o-mini");
+ m.put("GRAPH_STORE_LLM_BASE_URL", "https://example.com/v1");
+
+ m.put("GRAPH_STORE_EMBEDDING_PROVIDER", "qwen");
+ m.put("GRAPH_STORE_EMBEDDING_API_KEY", "k2");
+ m.put("GRAPH_STORE_EMBEDDING_MODEL", "text-embedding-v4");
+ m.put("GRAPH_STORE_EMBEDDING_DIMS", "1536");
+ m.put("GRAPH_STORE_EMBEDDING_BASE_URL", "https://dashscope.aliyuncs.com/compatible-mode/v1");
+
+ MemoryConfig cfg = ConfigLoader.fromMap(m);
+
+ assertNotNull(cfg.getGraphStore());
+ assertTrue(cfg.getGraphStore().isEnabled());
+
+ // top-level remains mock
+ assertEquals("mock", cfg.getLlm().getProvider());
+ assertEquals("mock", cfg.getEmbedder().getProvider());
+
+ // graph_store overrides
+ assertNotNull(cfg.getGraphStore().getLlm());
+ assertEquals("openai", cfg.getGraphStore().getLlm().getProvider());
+ assertEquals("k1", cfg.getGraphStore().getLlm().getApiKey());
+ assertEquals("gpt-4o-mini", cfg.getGraphStore().getLlm().getModel());
+ assertEquals("https://example.com/v1", cfg.getGraphStore().getLlm().getBaseUrl());
+
+ assertNotNull(cfg.getGraphStore().getEmbedder());
+ assertEquals("qwen", cfg.getGraphStore().getEmbedder().getProvider());
+ assertEquals("k2", cfg.getGraphStore().getEmbedder().getApiKey());
+ assertEquals("text-embedding-v4", cfg.getGraphStore().getEmbedder().getModel());
+ assertEquals(1536, cfg.getGraphStore().getEmbedder().getEmbeddingDims());
+ assertEquals("https://dashscope.aliyuncs.com/compatible-mode/v1", cfg.getGraphStore().getEmbedder().getBaseUrl());
+ }
+}
+
diff --git a/src/test/java/com/oceanbase/powermem/MemoryE2eTest.java b/src/test/java/com/oceanbase/powermem/MemoryE2eTest.java
index b7de54f..135089b 100644
--- a/src/test/java/com/oceanbase/powermem/MemoryE2eTest.java
+++ b/src/test/java/com/oceanbase/powermem/MemoryE2eTest.java
@@ -45,6 +45,32 @@ private static Memory newMemoryWithTempSqlite(Path dbPath) {
return new Memory(cfg);
}
+ private static Memory newMemoryWithTempSqliteAndInMemoryGraph(Path dbPath) {
+ MemoryConfig cfg = new MemoryConfig();
+ VectorStoreConfig vs = VectorStoreConfig.sqlite(dbPath.toString());
+ vs.setCollectionName("memories");
+ cfg.setVectorStore(vs);
+
+ // offline deterministic
+ EmbedderConfig emb = new EmbedderConfig();
+ emb.setProvider("mock");
+ cfg.setEmbedder(emb);
+
+ LlmConfig llm = new LlmConfig();
+ llm.setProvider("mock");
+ cfg.setLlm(llm);
+
+ // enable intelligent memory plugin (ebbinghaus lifecycle hooks)
+ cfg.getIntelligentMemory().setEnabled(true);
+ cfg.getIntelligentMemory().setDecayEnabled(true);
+
+ // enable graph store (in-memory)
+ cfg.getGraphStore().setEnabled(true);
+ cfg.getGraphStore().setProvider("memory");
+
+ return new Memory(cfg);
+ }
+
@Test
void testCrudAndSearch_withMetadataAndFilters(@TempDir Path tmp) {
Memory mem = newMemoryWithTempSqlite(tmp.resolve("powermem_test.db"));
@@ -247,5 +273,50 @@ void testCrudAndSearch_withAgentIdOnly_userIdOptional(@TempDir Path tmp) {
assertNotNull(delResp);
assertTrue(delResp.isDeleted());
}
+
+ @Test
+ void testGraphStoreRelations_areReturnedWhenEnabled(@TempDir Path tmp) {
+ Memory mem = newMemoryWithTempSqliteAndInMemoryGraph(tmp.resolve("powermem_graph.db"));
+
+ String userId = null; // Python parity: user_id optional; graph uses default "user"
+ String agentId = "a_graph";
+ String runId = "r_graph";
+
+ DeleteAllMemoriesRequest delAll = new DeleteAllMemoriesRequest();
+ delAll.setUserId(userId);
+ delAll.setAgentId(agentId);
+ delAll.setRunId(runId);
+ mem.deleteAll(delAll);
+
+ AddMemoryRequest add = new AddMemoryRequest();
+ add.setUserId(userId);
+ add.setAgentId(agentId);
+ add.setRunId(runId);
+ add.setInfer(false);
+ add.setText("用户喜欢简洁的中文回答");
+ var addResp = mem.add(add);
+ assertNotNull(addResp);
+ assertNotNull(addResp.getResults());
+ assertEquals(1, addResp.getResults().size());
+ assertNotNull(addResp.getRelations(), "relations should be present when graph store is enabled");
+
+ @SuppressWarnings("unchecked")
+ Map rel = (Map) addResp.getRelations();
+ assertTrue(rel.containsKey("added_entities"));
+
+ // Search should return relations list (source/relationship/destination)
+ SearchMemoriesRequest search = SearchMemoriesRequest.ofQuery("喜欢 简洁");
+ search.setUserId(userId);
+ search.setAgentId(agentId);
+ search.setRunId(runId);
+ var searchResp = mem.search(search);
+ assertNotNull(searchResp);
+ assertNotNull(searchResp.getRelations(), "search.relations should be present when graph store is enabled");
+
+ @SuppressWarnings("unchecked")
+ List> graphHits = (List>) searchResp.getRelations();
+ assertFalse(graphHits.isEmpty());
+ assertEquals("用户", String.valueOf(graphHits.get(0).get("source")));
+ }
}
diff --git a/src/test/java/com/oceanbase/powermem/OceanBaseGraphStoreIT.java b/src/test/java/com/oceanbase/powermem/OceanBaseGraphStoreIT.java
new file mode 100644
index 0000000..2c5f4db
--- /dev/null
+++ b/src/test/java/com/oceanbase/powermem/OceanBaseGraphStoreIT.java
@@ -0,0 +1,96 @@
+package com.oceanbase.powermem;
+
+import com.oceanbase.powermem.sdk.config.EmbedderConfig;
+import com.oceanbase.powermem.sdk.config.MemoryConfig;
+import com.oceanbase.powermem.sdk.config.VectorStoreConfig;
+import com.oceanbase.powermem.sdk.core.Memory;
+import com.oceanbase.powermem.sdk.model.AddMemoryRequest;
+import com.oceanbase.powermem.sdk.model.DeleteAllMemoriesRequest;
+import com.oceanbase.powermem.sdk.model.SearchMemoriesRequest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * OceanBaseGraphStore integration test.
+ *
+ * Runs only when required OceanBase env vars are set.
+ */
+@EnabledIfEnvironmentVariable(named = "OCEANBASE_HOST", matches = ".+")
+@EnabledIfEnvironmentVariable(named = "OCEANBASE_USER", matches = ".+")
+@EnabledIfEnvironmentVariable(named = "OCEANBASE_DATABASE", matches = ".+")
+public class OceanBaseGraphStoreIT {
+
+ @Test
+ void testGraphRelations_addAndSearch(@TempDir Path tmp) {
+ String host = System.getenv("OCEANBASE_HOST");
+ String user = System.getenv("OCEANBASE_USER");
+ String password = System.getenv().getOrDefault("OCEANBASE_PASSWORD", "");
+ String db = System.getenv("OCEANBASE_DATABASE");
+ int port = 2881;
+ try {
+ String p = System.getenv("OCEANBASE_PORT");
+ if (p != null && !p.isBlank()) port = Integer.parseInt(p);
+ } catch (Exception ignored) {}
+
+ // Vector store can stay local (SQLite). Graph store uses OceanBase.
+ MemoryConfig cfg = new MemoryConfig();
+ VectorStoreConfig vs = VectorStoreConfig.sqlite(tmp.resolve("powermem_graph_it.db").toString());
+ vs.setCollectionName("memories_graph_it");
+ cfg.setVectorStore(vs);
+
+ EmbedderConfig emb = new EmbedderConfig();
+ emb.setProvider("mock");
+ cfg.setEmbedder(emb);
+ cfg.getLlm().setProvider("mock");
+
+ cfg.getGraphStore().setEnabled(true);
+ cfg.getGraphStore().setProvider("oceanbase");
+ cfg.getGraphStore().setHost(host);
+ cfg.getGraphStore().setPort(port);
+ cfg.getGraphStore().setUser(user);
+ cfg.getGraphStore().setPassword(password);
+ cfg.getGraphStore().setDatabase(db);
+ cfg.getGraphStore().setEntitiesTable("graph_entities_java_it");
+ cfg.getGraphStore().setRelationshipsTable("graph_relationships_java_it");
+ cfg.getGraphStore().setTimeoutSeconds(10);
+
+ Memory mem = new Memory(cfg);
+
+ String userId = null; // Python parity: optional
+ String agentId = "it_agent_graph";
+ String runId = "it_run_graph";
+
+ DeleteAllMemoriesRequest delAll = new DeleteAllMemoriesRequest();
+ delAll.setUserId(userId);
+ delAll.setAgentId(agentId);
+ delAll.setRunId(runId);
+ mem.deleteAll(delAll);
+
+ AddMemoryRequest add = new AddMemoryRequest();
+ add.setUserId(userId);
+ add.setAgentId(agentId);
+ add.setRunId(runId);
+ add.setInfer(false);
+ add.setText("user -- likes -- coffee\ncoffee -- is_a -- beverage");
+ var addResp = mem.add(add);
+ assertNotNull(addResp);
+ assertNotNull(addResp.getRelations());
+
+ // Multi-hop: user -> coffee -> beverage
+ SearchMemoriesRequest search = SearchMemoriesRequest.ofQuery("user beverage");
+ search.setUserId(userId);
+ search.setAgentId(agentId);
+ search.setRunId(runId);
+ var sr = mem.search(search);
+ assertNotNull(sr);
+ assertNotNull(sr.getRelations());
+ assertTrue(sr.getRelations() instanceof java.util.List);
+ assertFalse(((java.util.List) sr.getRelations()).isEmpty());
+ }
+}
+