Trusty

Website: trustytools.dev

Unified Rust workspace consolidating the entire trusty-* AI tooling ecosystem. It combines code search, memory, analysis, orchestration, review, audit, and operator interfaces in one Cargo workspace. The live package inventory comes from cargo metadata; the human-readable map is docs/reference/crate-map.md.

Three Flagship MCP Servers

trusty-search — Hybrid Code Search

Machine-wide code search daemon with hybrid BM25 + vector + knowledge-graph fusion, fused via Reciprocal Rank Fusion. One install per machine, unlimited named project indexes.

What you get:

• Sub-10ms p50 warm query latency on 100k-chunk indexes
• Intelligent query routing (Definition / Usage / Conceptual / BugDebt intent detection)
• Knowledge graph expansion with caller/callee chains
• Branch-aware search (boost results from your current feature branch)
• Auto-tuned memory tiers (5 tiers from 8 GB to 64+ GB RAM)
• Embedded Svelte 5 admin UI
• OpenRouter-backed chat with auto-injected search context

Quick start:

cargo install trusty-search
trusty-search start
trusty-search index ~/Projects/myproj --name myproj
trusty-search query "fn authenticate" --index myproj

MCP tools: search, search_lexical, search_semantic, search_kg, search_all, search_similar, grep, typeahead, get_call_chain, index_file, remove_file, list_indexes, create_index, delete_index, reindex, index_status, list_chunks, search_health, chat, upgrade, console_metrics

See crates/trusty-search/README.md for full documentation.

---

trusty-memory — Memory Palace Storage Engine

Long-term memory storage with semantic search, persistent embedding index, and embedded Svelte UI. Store development context, notes, snippets, and retrieve them via natural language.

What you get:

• Pure-Rust HNSW vector index (hnsw_rs) persisted in redb + fastembed embeddings
• Semantic search over all stored memories
• Collection organization (notes, snippets, code patterns, decisions)
• Svelte UI for browsing and editing
• MCP server for Claude Code integration
• MIT license (memory preservation is for everyone)

Quick start:

cargo run -p trusty-memory -- serve
# Or via MCP stdio:
# Add to ~/.claude/claude_desktop_config.json:
# "trusty-memory": {
#   "command": "cargo",
#   "args": ["run", "-p", "trusty-memory", "--", "serve"]
# }

MCP tools: memory_remember, memory_recall, memory_recall_deep, memory_recall_all, memory_note, memory_list, memory_forget, list_prompt_facts, remove_prompt_fact, get_prompt_context

See crates/trusty-memory/README.md for full documentation.

---

trusty-analyze — Code Analysis Sidecar

Static code-analysis sidecar for trusty-search: cyclomatic and cognitive complexity, code smells, quality grading, git temporal decay, concept clustering, SCIP protobuf ingest, and a (subject, predicate, object) facts store backed by redb. It reads its chunk corpus from trusty-search over HTTP, serves daemon RPC over a Unix socket, and exposes MCP over stdio.

What you get:

• Cyclomatic + cognitive complexity per chunk / file / index
• Configurable code-smell categories with named thresholds
• A–F quality grade aggregation
• Git blame–driven temporal decay scoring (stale high-complexity code)
• k-means concept clustering (BoW or neural embeddings)
• Facts store: typed knowledge triples with provenance, persisted in redb
• SCIP protobuf ingest for LSP-quality symbol data
• Optional ONNX-backed NER over doc comments (feature-gated: --features ner)
• Tree-sitter adapters for Rust, TypeScript, JavaScript, Python, Java, Go, Ruby, PHP, C, C++, C#, Kotlin, Swift, Scala
• Unix-socket JSON-RPC + MCP parity (every method has a tool equivalent)

Quick start:

# 1. trusty-search must be running first — it is a hard runtime dependency
cargo run -p trusty-search -- start

# 2. start the analyze sidecar
cargo run -p trusty-analyze -- --search-url http://127.0.0.1:7878 start

# 3. analyze a named index
cargo run -p trusty-analyze -- analyze <index-id> --top-k 20

MCP tools: analyzer_health, complexity_hotspots, find_smells, analyze_quality, list_facts, upsert_fact, delete_fact, ingest_scip, cluster_concepts

See crates/trusty-analyze/README.md for full documentation.

---

Workspace Package Index

This is an orientation map, not a second package registry. For package names, versions, publishability, and targets, use cargo metadata --no-deps --format-version 1; for direct links from every package to its manifest, source, and documentation, use the crate map.

Core Daemons / MCP Servers

Crate	Description	License
trusty-search	Hybrid code search (BM25 + vector + KG) + MCP server	MIT
trusty-memory	Memory palace UI + MCP frontend (storage engine lives in trusty-common's memory-core feature)	MIT
trusty-analyze	Code-analysis sidecar daemon (complexity, smells, facts) + MCP server	MIT
trusty-review	LLM-backed review pipeline with search and static-analysis context	MIT
trusty-console	Web console for the local trusty service fleet	MIT
trusty-channels	Native Slack and Telegram MCP servers	MIT

Shared Libraries

Crate	Description
trusty-common	Tracing, daemon helpers, OpenRouter chat client, shared utilities
trusty-embedderd	fastembed wrapper — all-MiniLM-L6-v2 INT8 quantised, 384-dim output
trusty-gworkspace	Google Workspace client (Calendar, Tasks, Drive)
trusty-cto-db	SQLite schema + rusqlite bindings for ops data
tc-services	Service adapters (CTO DB, Granola, GWorkspace)
trusty-mcp	Shared JSON-RPC 2.0 and MCP protocol primitives
trusty-progress	Shared terminal progress and status rendering
trusty-code-tui	Shared interactive terminal UI seam

MPM Platform (Multi-agent Platform Manager)

Crate	Description
trusty-mpm	Core platform with embedded CLI, daemon, and MCP server
trusty-mpm-gui	Desktop GUI (Tauri)
trusty-code	Coding harness (tcode)
trusty-code-gui	Desktop shell for tcode

Supporting Tools & Agents

Crate	Description
trusty-installer	Install/upgrade orchestrator (bins: trusty-installer, tctl alias; ADR-0013)
trusty-audit	Auditor handoff client and CLI
trusty-kb	Deterministic personal knowledge-base store + MCP server
trusty-publish-guard	Internal release parity checker
trusty-sld-lint	Spec-linked documentation linter
trusty-embedderd-py	Optional Python/MPS embedding sidecar launcher

Analytics & Orchestration

Crate	Description
tga (trusty-git-analytics directory)	Developer productivity analytics from git history
trusty-agents	Agent orchestration platform
trusty-agents-common	Shared types and utilities for agent framework
trusty-agents-ui	Nested Tauri desktop client for trusty-agents
trusty-audit-ui	Nested Tauri desktop client for trusty-audit

Architecture

┌───────────────────────────────────────────────────────────────┐
│ User surfaces: tm · tcode · tagent · taudit · tga · GUIs    │
└──────────────────────────────┬────────────────────────────────┘
                               │
┌──────────────────────────────▼────────────────────────────────┐
│ Services: search · memory · analyze · review · console       │
│           channels · gworkspace                              │
└──────────────────────────────┬────────────────────────────────┘
                               │
┌──────────────────────────────▼────────────────────────────────┐
│ Shared foundations: common · mcp · embedderd · progress      │
│                     cto-db · tc-services · kb                │
└───────────────────────────────────────────────────────────────┘

This is a role view, not a dependency graph. Cargo manifests are authoritative for compile-time edges; runtime edges are documented in the crate map and the relevant crate README.

Getting Started

New to trusty-tools?

• Engineers: Start with Install and Run trusty-mpm (tm) on Your Laptop for the quickest path to a working session.
• Migrating from claude-mpm: Read claude-mpm vs trusty-mpm — Differences & Install to understand what changed and how to migrate.
• Developers: Consult Build & Test Commands below.

---

Installation

One-liner: curl | sh Bootstrap Installer

Install the full trusty-tools platform with one command (no Rust toolchain required):

curl -sSf https://raw.githubusercontent.com/bobmatnyc/trusty-tools/main/install.sh | sh

This downloads the prebuilt trusty-installer binary (SHA-256 verified), installs it to ~/.local/bin, and runs trusty-installer install to set up the rest of the platform (search, memory, analyze, review, console). The tctl transitional alias is also installed, so existing muscle-memory commands (tctl install, tctl status, etc.) continue to work.

Non-interactive (CI / scripted):

curl -sSf https://raw.githubusercontent.com/bobmatnyc/trusty-tools/main/install.sh | sh -s -- -y

Options (environment variables):

Variable	Effect
TRUSTY_VERSION	Pin a specific version (e.g. 0.2.0)
TRUSTY_INSTALL_DIR	Override the install directory (default ~/.local/bin)
TRUSTY_YES=1	Skip all prompts (same as -y)
TRUSTY_FORCE=1	Re-download even if already installed (same as --force)
TRUSTY_NO_MODIFY_PATH=1	Don't modify your shell PATH

Supported platforms: macOS (Apple Silicon), Linux x86_64, and Linux arm64 (aarch64-unknown-linux-gnu). macOS Intel is not supported — build from source with cargo install trusty-installer.

Security: The installer is served over HTTPS and every downloaded binary is SHA-256 verified against its published checksum. The installer script itself is not signed — review it before running if you require higher assurance: https://github.com/bobmatnyc/trusty-tools/blob/main/install.sh

---

With tctl (the control plane)

tctl — the trusty-installer binary the bootstrap script above puts on your PATH — is the recommended route for its managed application set: trusty-search, trusty-memory, trusty-analyze, trusty-review, trusty-console, trusty-mpm, and tga. It installs them, upgrades them together, knows which run as daemons, and can update its own control-plane binary. The live set is defined in stable_set.rs.

tctl install                       # the full managed set
tctl install trusty-search         # one member
tctl install trusty-search --dry-run
tctl status                        # what is installed, and which daemons are up

Homebrew below is the alternative when you want one binary and nothing else.

With Homebrew

Installs individual trusty-* binaries via package manager. First, add the tap:

brew tap bobmatnyc/trusty

Then install any published binary you need:

brew install trusty-analyze
brew install trusty-audit
brew install trusty-code
brew install trusty-console
brew install trusty-git-analytics
brew install trusty-installer
brew install trusty-memory
brew install trusty-mpm
brew install trusty-review
brew install trusty-search

Or combine into a single command:

brew install bobmatnyc/trusty/trusty-search \
             bobmatnyc/trusty/trusty-memory \
             bobmatnyc/trusty/trusty-analyze \
             bobmatnyc/trusty/trusty-review \
             bobmatnyc/trusty/trusty-mpm \
             bobmatnyc/trusty/trusty-git-analytics

From Source with Cargo

If you prefer to build from the latest source or need a crate not distributed via Homebrew:

git clone https://github.com/bobmatnyc/trusty-tools
cd trusty-tools

# Build all crates
cargo build --release

# Run all tests
cargo test

# Install the CLI tools
cargo install --path crates/trusty-search --locked
# More tools available via: cargo install --path crates/<crate>

Build & Test Commands

cargo build                                          # all crates, debug
cargo check -p <crate-name>                          # fastest crate-scoped check
cargo test -p <crate-name> --no-fail-fast           # every target in one crate
cargo clippy -p <crate-name> --all-targets -- -D warnings
cargo fmt --check

See CLAUDE.md for feature-gated crates and the risk-based test ladder. A bare workspace test is a hardening gate, not the normal inner loop.

Workspace Info

Single source of truth: Every crate is co-located under crates/ with one workspace root and one Cargo.lock, so a change spanning several of them is one commit.

MSRV: Rust 1.94+ (required by the aws-config / aws-sdk-bedrockruntime dependencies)

License: the workspace package default is MIT. Each package manifest remains authoritative, including nested private UI packages that may not inherit the workspace field.

Where to start:

• I want to search code: Read crates/trusty-search/README.md
• I want persistent memory: Read crates/trusty-memory/README.md
• I want multi-session orchestration: Read crates/trusty-mpm/README.md
• I want the agent harness: Read crates/trusty-agents/README.md