TPT Neuron

A memory architecture for AI systems built on one principle: structure should be earned, not fixed. Storage, connectivity, and computation are shaped continuously by use, relevance, and salience rather than laid out in advance by a schema.

Full design rationale: spec.txt. Build status and phased checklist: TODO.md.

Architecture

Layer	Name	Crate / Service
1	Fragment Store	`crates/fragment-store`
2	Temporal Graph	`crates/temporal-graph`, `crates/retrieval-fusion`
3	Dynamic Connectivity Engine	`crates/connectivity-engine`
4	Consolidation Daemon	`services/consolidation-daemon` (Go + Temporal)
5	Policy DSL	`crates/policy-dsl`

Layers 1-3 run in a single process, services/memory-service, exposed over gRPC (proto/memory/v1/memory.proto). Layer 4 runs as a separate Go service that talks to memory-service exclusively over that same gRPC contract.

Repository layout

crates/            Rust workspace members — core types + Layers 1, 2, 3, 5
services/          memory-service (Rust, Layers 1-3) and consolidation-daemon (Go, Layer 4)
sdk/               Client libraries: rust, go, python, js
tptctl/            Inspection CLI
dashboard/         Consolidation audit web view
docker/            docker-compose stack: Neo4j, Qdrant, Temporal
config/            policy.policy — Layer 5's real pest-grammar policy file (Phase 3)
proto/             cross-language gRPC contract
tests/             fixtures + end-to-end tests
docs/adr/          architecture decision records

Local development

Prerequisites: Rust (see rust-toolchain.toml), Go 1.22+, Node 18+, and protoc (the Protocol Buffers compiler — required by tonic-build for memory-service, sdk/rust, and tptctl; not needed to build the other crates). Install protoc via your package manager (e.g. choco install protoc on Windows, apt install protobuf-compiler on Debian/Ubuntu, brew install protobuf on macOS).

cp .env.example .env
docker compose -f docker/docker-compose.yml up -d
./scripts/seed_phase0_dataset.sh
cargo build
tptctl fragments retrieve "heat transfer"

Note: cargo check -p core-model -p fragment-store -p temporal-graph -p retrieval-fusion -p connectivity-engine -p policy-dsl -p llm-client builds and passes its unit tests without protoc, since those crates have no gRPC codegen. The proto-dependent crates (memory-service, sdk/rust, tptctl) require protoc on PATH.

Use cases

TPT Neuron is designed against 10 concrete use cases spanning all five layers — see TODO.md for the full list, from long-running personal assistants (Layer 3 salience) to multi-tenant SaaS platforms (Layer 1 isolation) to compliance-grade healthcare documentation (Layer 2 + audit dashboard).

Status

Pre-prototype. See TODO.md for what's scaffolded vs. real.

tpt-neuron

Languages