SynCore

MCP server for AI-native development - Built in 2 weeks, solo, with $15 AI assistance budget.

Unified interface for memory, vectors, code analysis, and knowledge graphs. 65+ tools accessible via single MCP connection.

Built in Rust. Production-tested with Claude Code.

What This Actually Does

SynCore is an MCP (Model Context Protocol) server exposing 65 tools for:

• Persistent Memory - Key-value storage (SQLite + Sled cache)
• Dual-Domain Vector Search - Separate embedding models for code vs. text
  • CODE domain: BGE-small-en-v1.5 (optimized for semantic code search)
  • GENERAL domain: all-MiniLM-L6-v2 (optimized for documents/tasks)
• Code Intelligence - Tree-sitter parsing for Rust, JavaScript, Python, JSON, TOML, Bash
• Knowledge Graphs - Neo4j integration with Cypher queries
• Task Management - Task tracking with parent/child relationships
• Agent Coordination - Message bus for multi-agent workflows
• Application Mapping - File dependency tracking and change history
• Sequential Reasoning - Multi-step thought recording
• Project Analysis - LLM-free codebase intelligence (hotspots, dead code, cycles, refactoring)

Current State (November 2025)

What Works Reliably

Core Tools (Tested Daily):

• memory_store / memory_query - Key-value storage, ~1ms latency
• vector_insert / vector_search - Semantic search, 10-50ms latency
• code_index / code_search - Code semantic search
• code_index_directory - Batch index with incremental support (skips unchanged files)
• parser_analyze - Tree-sitter AST extraction with optional persistence
• parser_search - Ripgrep code pattern search
• graph_query / graph_insert - Neo4j Cypher queries
• code_graph_sync_neo4j - Sync SQLite entities to Neo4j
• code_graph_fusion_query - Tri-mode (simple/attention/reasoning) search

Graph Features:

• 7 edge types: CONTAINS, CALLS, USES, IMPORTS, MODULE_CHILD, INHERITS, REFERENCES
• Multi-hop diffusion with PageRank
• Temporal metadata enrichment (git history + mtime)

Project Analysis Engine (PHASE 6):

• project_file_report - Detailed file analysis (entities, relationships, metrics)
• project_hotspots - Find complexity hotspots (fan-in/out, LOC, entity count)
• project_dead_code - Detect unused entities
• project_cycles - Find circular dependencies
• project_unused_imports - Find unused imports
• project_module_map - Module dependency map
• project_refactor_suggestions - Heuristic refactoring suggestions

Meta-Tools (Aggregate PAE Data):

• project_architecture_overview - Project-wide summary: entity counts, dependency stats, complexity metrics
• project_complexity_dashboard - Top hotspots, worst cycles, complexity rankings
• project_improvement_roadmap - Prioritized improvements with effort/impact matrix
• project_refactor_action_plan - Actionable refactor plan (high-risk hotspots, dead code, cycle breaks)

Incremental Indexing (NEW - PHASE 5):

• SHA256 + mtime change detection
• Skips unchanged files (0 entities returned = skipped)
• Detects new, modified, deleted files
• Idempotent (safe to run repeatedly)

What's Experimental

• IntelliTask AI features - Requires Ollama running locally, quality depends on model
• Sequential reasoning - sequential_cycle requires Ollama
• Agent message bus - Works but not heavily tested in production
• RAGGraph multi-hop - Works but scoring may need tuning

Honest Limitations

• Single-node only - No distributed mode
• No authentication - Designed for local use
• Neo4j required for graph features - Some tools fail silently without it
• Ollama required for AI features - IntelliTask, sequential_cycle need it
• ~500MB RAM after startup - Two HuggingFace embedding models loaded (BGE + MiniLM)
• Graph features partially tested - Neo4j sync works but entity population needs validation

Quick Start

Build

cd syncore
cargo build --release

Produces two binaries:

• target/release/syncore_mcp_stdio (~55 MB) - MCP server for Claude Code
• target/release/syncore_graph_cli (~33 MB) - CLI for graph operations

Configure Claude Code

Add to ~/.config/claude/mcp_settings.json:

{
  "syncore": {
    "command": "/path/to/syncore/target/release/syncore_mcp_stdio",
    "args": [],
    "env": {
      "DB_PATH": "/path/to/syncore.db",
      "NEO4J_URI": "bolt://127.0.0.1:7687",
      "NEO4J_USER": "neo4j",
      "NEO4J_PASS": "your_password"
    }
  }
}

Environment Variables

All Tools (42 in memory_suite + 23 standalone)

Memory Suite (42 commands via memory_suite)

Basic Memory (5 commands):

Semantic Search (8 commands - APEX 1.9-M):

Vector Operations (2 commands):

Task Management (15 commands):

Sequential Reasoning (4 commands):

Agent Coordination (8 commands):

Standalone MCP Tools

Code Suite (11 commands):

Graph Suite (5 commands):

Mapping Suite (8 commands):

Debug Suite (10 commands):

REFRAG Suite (3 commands - APEX 1.8):

Architecture Notes

Dual-Domain Embeddings

SynCore uses two separate vector stores with specialized models:

CODE Domain (syncore_code.index):

• Model: BGE-small-en-v1.5 (384 dims)
• Purpose: Semantic code search
• Why: Trained on code+text, understands programming semantics
• Routed: Code entities, functions, classes

GENERAL Domain (syncore_general.index):

• Model: all-MiniLM-L6-v2 (384 dims)
• Purpose: Documents, tasks, notes
• Why: Optimized for natural language understanding
• Routed: Memory, documents, reasoning steps

This prevents "domain pollution" where code embeddings contaminate document search and vice versa.

Graph-BERT Integration Point

The codebase includes a GraphEmbeddingStrategy trait for future integration of Graph-BERT or other GNN models to combine CODE embeddings with graph structural features. Currently uses deterministic feature injection.

Performance

Tested on Ryzen 7, 32GB RAM:

Note: HNSW indexing reduces search to 1-10ms after warmup, but initial queries use linear scan.

Requirements

Required:

• Rust 1.70+
• ~4GB disk for build artifacts
• ~500MB RAM after embedding model loads

Optional:

• Neo4j 5.x (for graph features - graph_*, code_graph_*, raggraph_*)
• Ollama (for AI features - intellitask_generate/subtasks/prioritize/next, sequential_cycle)

CLI Tool

syncore_graph_cli provides command-line graph operations:

# Sync SQLite entities to Neo4j
NEO4J_URI="bolt://127.0.0.1:7687" NEO4J_USER="neo4j" NEO4J_PASS="password" \
  ./target/release/syncore_graph_cli sync

# Validate graph integrity
./target/release/syncore_graph_cli validate

# Show graph statistics
./target/release/syncore_graph_cli stats

License

GPL-3.0

Technical Highlights (Engineer-Grounded)

What makes this interesting:

1. Dual-domain embeddings - Separate BGE/MiniLM models with automatic routing (rare in MCP servers)
2. Multi-modal storage - SQLite + Sled + Neo4j + HNSW in single coherent API
3. Incremental indexing - SHA256+mtime change detection, idempotent re-runs
4. Code graph fusion - Tri-mode search (simple/attention/reasoning) with temporal scoring
5. Graph-BERT seam - Extensibility point for GNN integration via trait abstraction
6. Zero-dependency project analysis - Complexity metrics without LLM calls

What's not production-ready:

• Neo4j entity queries return empty (sync works but population logic needs debugging)
• Graph-BERT is architectural placeholder (uses deterministic feature injection)
• No streaming for large result sets
• Limited integration test coverage
• Single-node architecture (no replication/sharding)

Development context:

• 2 weeks, solo developer, $15 budget
• 100% AI-assisted code generation (Claude Code + free tier models)
• 7866 lines of Rust across 250 files
• Daily production use with Claude Code CLI

Acknowledgments

Built with rmcp, neo4rs, rusqlite, tree-sitter, fastembed, tokio, sled, hnsw_rs.

Core embedding models: BGE-small-en-v1.5 (BAAI), all-MiniLM-L6-v2 (sentence-transformers).