riz/mcp-memory
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: eradicate deprecated tools (sticky_notes, pinned_files, context_workspaces, pr_checklist, preferences) and dead code

Browse Source
This commit is contained in:
Riz Ashraf committed 2026-10-07 11:12:42 +01:00
1 parent d80915635f
commit 79209da711
31 files changed
+1230 -3920
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

server/src/handlers/graph.rs
+122 -95
View File
@@ -459,14 +459,15 @@ impl McpTool for ReadGraphHandler {
let offset = req.offset.unwrap_or(0);
let data = state.read_graph(|full| -> crate::error::Result<String> {
let mut result_json = if limit.is_some() || req.offset.is_some() {
let filtered_entities: Vec<(&String, &crate::models::Entity)> = full
.entities
.iter()
.filter(|(_, v)| req.namespace.as_ref().map_or(true, |ns| &v.namespace == ns))
.collect();
let filtered_entities: Vec<(&String, &crate::models::Entity)> = full
.entities
.iter()
.filter(|(_, v)| req.namespace.as_ref().map_or(true, |ns| &v.namespace == ns))
.collect();
let total_count = filtered_entities.len();
let total_count = filtered_entities.len();
let (entities_map, relations_vec, meta_json) = if limit.is_some() || req.offset.is_some() {
let effective_limit = limit.unwrap_or(50);
let paged_entities: std::collections::HashMap<&String, &crate::models::Entity> = filtered_entities
.into_iter()
@@ -485,45 +486,94 @@ impl McpTool for ReadGraphHandler {
})
.collect();
serde_json::to_string(&serde_json::json!({
"entities": paged_entities,
"relations": relevant_relations,
let meta = serde_json::json!({
"total_count": total_count,
"offset": offset,
"limit": effective_limit,
"has_more": has_more,
}))?
} else if let Some(ns) = req.namespace {
let mut filtered = BorrowedGraph::default();
for (k, v) in &full.entities {
if v.namespace == ns {
filtered.entities.insert(k, v);
}
}
for r in &full.relations {
if r.namespace == ns {
filtered.relations.push(r);
}
}
serde_json::to_string(&filtered)?
});
(paged_entities, relevant_relations, Some(meta))
} else {
serde_json::to_string(full)?
let ent_map: std::collections::HashMap<&String, &crate::models::Entity> =
filtered_entities.into_iter().collect();
let rel_vec: Vec<&crate::models::Relation> = full
.relations
.iter()
.filter(|r| req.namespace.as_ref().map_or(true, |ns| &r.namespace == ns))
.collect();
(ent_map, rel_vec, None)
};
let serialized = if let Some(meta) = &meta_json {
serde_json::json!({
"entities": entities_map,
"relations": relations_vec,
"total_count": meta["total_count"],
"offset": meta["offset"],
"limit": meta["limit"],
"has_more": meta["has_more"],
})
} else {
serde_json::json!({
"entities": entities_map,
"relations": relations_vec,
})
};
let mut result_json = serde_json::to_string(&serialized)?;
if let Some(max_tok) = max_tokens {
let max_chars = max_tok * 4;
if result_json.len() > max_chars {
let valid_boundary = result_json.floor_char_boundary(max_chars);
result_json.truncate(valid_boundary);
result_json.push_str("\n... [TRUNCATED_TO_MAX_TOKENS. Use search_nodes, pagination (limit, offset), or get_subgraph for targeted discovery]");
let total_ent = entities_map.len();
let total_rel = relations_vec.len();
let frac = (max_chars as f64) / (result_json.len() as f64);
let mut keep_count = (total_ent as f64 * frac * 0.85).max(1.0) as usize;
let ent_vec: Vec<_> = entities_map.into_iter().collect();
while keep_count > 0 {
let sliced_ent: std::collections::HashMap<_, _> = ent_vec.iter().take(keep_count).cloned().collect();
let sliced_rel: Vec<_> = relations_vec.iter().filter(|r| sliced_ent.contains_key(&r.from) && sliced_ent.contains_key(&r.to)).copied().collect();
let mut truncated_val = serde_json::json!({
"entities": sliced_ent,
"relations": sliced_rel,
"_meta": {
"truncated": true,
"total_entities": total_ent,
"returned_entities": sliced_ent.len(),
"total_relations": total_rel,
"returned_relations": sliced_rel.len(),
"note": "Output structurally truncated to fit within max_tokens. Use pagination (limit, offset), search_nodes, or get_subgraph for targeted discovery."
}
});
if let Some(meta) = &meta_json {
if let Some(obj) = truncated_val.as_object_mut() {
obj.insert("total_count".to_string(), meta["total_count"].clone());
obj.insert("offset".to_string(), meta["offset"].clone());
obj.insert("limit".to_string(), meta["limit"].clone());
obj.insert("has_more".to_string(), serde_json::Value::Bool(true));
}
}
if let Ok(trunc_str) = serde_json::to_string(&truncated_val) {
if trunc_str.len() <= max_chars || keep_count == 1 {
result_json = trunc_str;
break;
}
}
keep_count = keep_count.saturating_sub(keep_count / 3 + 1);
}
}
}
Ok(result_json)
})?;
Ok(data)
}
}
pub struct SearchNodesHandler;
#[async_trait]
@@ -910,36 +960,49 @@ impl McpTool for GetSubgraphHandler {
let depth = req.depth.unwrap_or(2);
let format = req.format.unwrap_or(SubgraphFormat::Json);
if format == SubgraphFormat::MarkdownTree {
let (sub_entities, sub_relations) = state.read_graph(|g| {
let mut visited = std::collections::HashSet::new();
let mut queue = std::collections::VecDeque::new();
queue.push_back((root.clone(), 0));
visited.insert(root.clone());
let (matched_entities, matched_relations) = state.read_graph(|full| {
let mut adj: std::collections::HashMap<&str, Vec<&str>> =
std::collections::HashMap::with_capacity(full.relations.len() * 2);
for r in &full.relations {
adj.entry(r.from.as_str()).or_default().push(r.to.as_str());
adj.entry(r.to.as_str()).or_default().push(r.from.as_str());
}
while let Some((curr, d)) = queue.pop_front() {
if d >= depth {
continue;
}
for r in &g.relations {
if r.from == curr && !visited.contains(&r.to) {
visited.insert(r.to.clone());
queue.push_back((r.to.clone(), d + 1));
} else if r.to == curr && !visited.contains(&r.from) {
visited.insert(r.from.clone());
queue.push_back((r.from.clone(), d + 1));
let mut visited = std::collections::HashSet::new();
let mut queue = std::collections::VecDeque::new();
queue.push_back((root.as_str(), 0));
visited.insert(root.clone());
while let Some((curr, d)) = queue.pop_front() {
if d < depth {
if let Some(neighbors) = adj.get(curr) {
for &next in neighbors {
if visited.insert(next.to_string()) {
queue.push_back((next, d + 1));
}
}
}
}
}
let ent: Vec<_> = g.entities.values().filter(|e| visited.contains(&e.name)).cloned().collect();
let rel: Vec<_> = g.relations.iter().filter(|r| visited.contains(&r.from) && visited.contains(&r.to)).cloned().collect();
(ent, rel)
});
let ent: std::collections::HashMap<String, crate::models::Entity> = visited
.iter()
.filter_map(|name| full.entities.get(name).map(|e| (name.clone(), e.clone())))
.collect();
let rel: Vec<crate::models::Relation> = full
.relations
.iter()
.filter(|r| visited.contains(&r.from) && visited.contains(&r.to))
.cloned()
.collect();
(ent, rel)
});
if format == SubgraphFormat::MarkdownTree {
let mut markdown = format!("# Subgraph Topology for `{}`\n\n", root);
markdown.push_str("## Entities\n");
for e in &sub_entities {
for e in matched_entities.values() {
markdown.push_str(&format!("- **{}** (`{}`)\n", e.name, e.entity_type));
for obs in &e.observations {
markdown.push_str(&format!(" - {}\n", obs));
@@ -947,56 +1010,20 @@ impl McpTool for GetSubgraphHandler {
}
markdown.push_str("\n## Relations\n");
for r in &sub_relations {
for r in &matched_relations {
markdown.push_str(&format!("- `{}` --[{}]--> `{}`\n", r.from, r.relation_type, r.to));
}
return Ok(markdown);
}
let data = state.read_graph(|full| {
let mut visited_nodes: std::collections::HashSet<String> = std::collections::HashSet::new();
let mut matched_entities = std::collections::HashMap::new();
let mut matched_relations = Vec::new();
let result = serde_json::json!({
"root_node": root,
"depth": depth,
"entities": matched_entities,
"relations": matched_relations,
});
let mut queue = std::collections::VecDeque::new();
queue.push_back((root.clone(), 0));
visited_nodes.insert(root.clone());
while let Some((curr, current_depth)) = queue.pop_front() {
if let Some(entity) = full.entities.get(&curr) {
matched_entities.insert(curr.clone(), entity.clone());
}
if current_depth < depth {
for rel in &full.relations {
if rel.from == curr {
matched_relations.push(rel.clone());
if !visited_nodes.contains(&rel.to) {
visited_nodes.insert(rel.to.clone());
queue.push_back((rel.to.clone(), current_depth + 1));
}
} else if rel.to == curr {
matched_relations.push(rel.clone());
if !visited_nodes.contains(&rel.from) {
visited_nodes.insert(rel.from.clone());
queue.push_back((rel.from.clone(), current_depth + 1));
}
}
}
}
}
let result = serde_json::json!({
"root_node": root,
"depth": depth,
"entities": matched_entities,
"relations": matched_relations,
});
Ok::<String, crate::error::AppError>(serde_json::to_string_pretty(&result)?)
})?;
Ok(data)
Ok(serde_json::to_string_pretty(&result)?)
}
}