INSTALL · THE SERVER

The shared graph, on your own server.

The client keeps each person's memory local. The server is what turns many personal memories into one team memory over the wire — a self-hosted service that every teammate's TeamGraph binds to, so a problem solved once on any machine is answered everywhere.

teamgraph-server · docker compose
# Postgres + pgvector, the embedding sidecar, and the server
$make compose-up
# migrations run at boot; then the API is live
$curl localhost:8088/v1/healthz
  {"status":"ok","service":"teamgraph-server"}
One stack, one API — every teammate binds to the same graph.
WHAT IT IS

The authoritative team graph.

A headless HTTP service that hosts a team's shared graph. Clients push what they learn and pull what the team learned; the server applies the same conflict-free merge the client does — only here it is the one convergent copy everyone syncs against.

Push & pull

Clients send their change sets and read back everything new since their last sync, through a gap-free, resumable cursor.

sync surface

Authoritative merge

The CRDT rules run server-side: content-hash identity, last-writer-wins state by a hybrid logical clock, max edge weight, union authors and sources.

strong eventual consistency

Query the whole team

Semantic match, search and explore run over the shared graph, so recall draws on everything the team has pooled, not just one machine.

retrieval

Tenant isolation

Every team is isolated at the database level with row-level security, and scoped bearer tokens gate read, write and admin access.

multi-team
HOW IT WORKS

A small stack you run yourself.

The server is a Go HTTP API backed by Postgres with pgvector for similarity search, and a local embedding sidecar so vectors are produced by a model you pin — never sent to a third party.

Go HTTP APIA frozen OpenAPI contract: sync, query, nodes and admin endpoints.
Postgres + pgvectorThe graph and its embeddings, with an HNSW index for fast recall.
Embedding sidecarA local model produces vectors; a team pins one embedding space.
One Docker Compose stack brings up Postgres, the sidecar and the server, and applies database migrations at boot — make compose-up and it's live on your network.
WHY YOU'D WANT IT

This is what makes it
team memory.

On its own, the client is local-first — its memory lives in a SQLite file on one machine. The server is the piece that makes sharing real: one convergent graph the whole team binds to, with the same privacy guarantees intact.

Solved once, answered everywhere Private notes never sync Work offline, reconcile later Self-hosted, your data
How the team graph converges
gitSELF-HOSTED

teamgraph-server

gitlab.com/adam.allard/teamgraph-server

The Go service, its Postgres schema and migrations, the OpenAPI contract and the Docker Compose stack. Clone it, read the architecture, and run your own.

Project statusBinding the client to a remote shared graph and syncing over the wire is the active work toward 1.0. The server is open and runnable today; expect its surface to settle as the two sides lock together.
STAND UP A TEAM GRAPH

Run the server. Point your team at it.

Self-host the shared graph, hand out scoped tokens, and let a fix on one laptop answer everywhere.