Files
memoryweave/go/internal/api/routes/graph.go
T
xiaowei 2a350cf781 fix(distill): max_tokens 800→1200 — Agnes推理token预算不足
Agnes 2.0-flash是推理模型,推理token占大量预算。
800仍不够→JSON截断(parse error: unexpected end of JSON input)。
1200确保推理+正文都够用。
2026-08-20 01:13:06 +08:00

191 lines
5.9 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 织忆 MemoryWeave — 知识图谱 API
package routes
import (
"encoding/json"
"net/http"
"strings"
"unicode"
"github.com/xiaoxue/memoryweave/internal/governance"
)
type GraphAPI struct {
Graph governance.GraphStore
}
func NewGraphAPI(g governance.GraphStore) *GraphAPI {
return &GraphAPI{Graph: g}
}
// GET /api/v1/graph/stats
func (ga *GraphAPI) Stats(w http.ResponseWriter, r *http.Request) {
nodeCount, edgeCount, density := ga.Graph.Stats()
respond(w, 200, map[string]interface{}{
"node_count": nodeCount,
"edge_count": edgeCount,
"density": density,
})
}
// POST /api/v1/graph/query
// 设计文档 §2.5.4: match 格式兼容; 同时保留 entity+relation 简洁格式
func (ga *GraphAPI) Query(w http.ResponseWriter, r *http.Request) {
var req struct {
Entity string `json:"entity"`
Relation string `json:"relation"`
Namespace string `json:"namespace"`
// 设计文档兼容格式: {"match": {"type": "entity", "label": "..."}}
Match *struct {
Type string `json:"type"`
Label string `json:"label"`
} `json:"match"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, 400, "invalid body")
return
}
// 兼容设计文档 match 格式
if req.Match != nil && req.Entity == "" {
// match.type 过滤 node type, match.label 做 name 模糊搜索
var nodes []map[string]interface{}
if req.Match.Label != "" {
nodes = ga.Graph.SearchNodes(req.Match.Label, req.Namespace)
} else if req.Match.Type != "" {
nodes = ga.Graph.ListNodesByType(req.Match.Type, req.Namespace)
} else {
nodes = ga.Graph.ListNodes(req.Namespace)
}
respond(w, 200, map[string]interface{}{"nodes": nodes, "count": len(nodes)})
return
}
// 默认跨 namespace 搜索(空 = 匹配所有,§2.5.6)
results := ga.Graph.Query(NormalizeEntity(req.Entity), req.Relation, req.Namespace)
respond(w, 200, map[string]interface{}{"results": results, "count": len(results)})
}
// POST /api/v1/graph/navigate
// 支持三种模式:
// 1. 单实体 BFS: {"entity": "...", "max_hops": 2}
// 2. 双向 BFS: {"source": "...", "target": "...", "max_hops": 3}
// 3. 关系过滤 BFS: {"entity": "...", "max_hops": 2, "relation_filter": ["related_to", "uses"]}(E1.5)
// 返回新增 grouped_by_relation 字段,按关系类型分组,便于阅读
func (ga *GraphAPI) Navigate(w http.ResponseWriter, r *http.Request) {
var req struct {
Entity string `json:"entity"`
Source string `json:"source"`
Target string `json:"target"`
MaxHops int `json:"max_hops"`
Namespace string `json:"namespace"`
RelationFilter []string `json:"relation_filter"` // E1.5: 关系类型白名单
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
respondError(w, 400, "invalid body")
return
}
if req.MaxHops <= 0 {
req.MaxHops = 2
}
// 模式 2: 双向 BFS(source + target)
if req.Source != "" && req.Target != "" {
source := NormalizeEntity(req.Source)
target := NormalizeEntity(req.Target)
paths, err := ga.Graph.NavigateBiDir(source, target, req.MaxHops, req.Namespace, req.RelationFilter)
if err != nil {
respondError(w, 500, "navigate failed: "+err.Error())
return
}
respond(w, 200, map[string]interface{}{
"paths": paths, "source": req.Source, "target": req.Target,
"bidirectional": true, "count": len(paths),
"relation_filter": req.RelationFilter,
})
return
}
// 模式 1: 单实体 BFS(兼容旧格式)
if req.Entity == "" {
respondError(w, 400, "entity (or source+target) required")
return
}
entity := NormalizeEntity(req.Entity)
paths, err := ga.Graph.Navigate(entity, req.MaxHops, req.Namespace, req.RelationFilter)
if err != nil {
respondError(w, 500, "navigate failed: "+err.Error())
return
}
// 新增:按 relation 分组,更直观
grouped := make(map[string][]map[string]interface{})
for _, p := range paths {
rel := p["relation"].(string)
if rel == "" {
rel = "_unknown"
}
grouped[rel] = append(grouped[rel], map[string]interface{}{
"from": stripPrefix(p["from"].(string)),
"to": stripPrefix(p["to"].(string)),
"weight": p["weight"],
"hop": p["hop"],
})
}
// 新增:相关实体建议(从 path 提取去重的 to 节点,跳过 ep_ 开头的)
suggestions := []string{}
seen := make(map[string]bool)
for _, p := range paths {
to := stripPrefix(p["to"].(string))
if !seen[to] && !strings.HasPrefix(p["to"].(string), "ep_") {
seen[to] = true
suggestions = append(suggestions, to)
}
}
if len(suggestions) > 20 {
suggestions = suggestions[:20]
}
respond(w, 200, map[string]interface{}{
"paths": paths,
"grouped_by_relation": grouped,
"entity": req.Entity,
"normalized_entity": entity,
"count": len(paths),
"relation_count": len(grouped),
"suggestions": suggestions,
"relation_filter": req.RelationFilter,
})
}
// stripPrefix 去掉节点 ID 的 n_ 前缀,用于可读展示
func stripPrefix(id string) string {
return strings.TrimPrefix(id, "n_")
}
// NormalizeEntity 规整实体名:去特殊字符 + n_前缀,保留中文和 Unicode 字符
func NormalizeEntity(entity string) string {
if strings.HasPrefix(entity, "n_") {
entity = entity[2:]
}
// 过滤特殊字符,保留 Unicode 字母、数字、下划线、中横线
clean := strings.Map(func(r rune) rune {
if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' || r == '-' || r == ' ' {
return r
}
// 保留中文和其他 Unicode 字母(如韩文、日文等)
if unicode.IsLetter(r) {
return r
}
return '_'
}, strings.ToLower(strings.TrimSpace(entity)))
// 合并连续下划线
for strings.Contains(clean, "__") {
clean = strings.ReplaceAll(clean, "__", "_")
}
clean = strings.Trim(clean, "_ ")
if clean == "" {
return "n_unknown"
}
return "n_" + clean
}