Orrery is a knowledge graph that adapts to its corpus. Every document gets immediate entity extraction from a general-purpose spec, so the graph is queryable from the first upload. When a domain accumulates enough content, Orrery investigates it and builds a custom extraction spec for that domain. Feed it more of something, and it learns to see that something in finer detail. Agents get an API. Humans get a galaxy.
Install
Orrery is open source and runs fully locally if you want it to.
On an Apple silicon Mac, the fastest path is Noospheric, the Tauri-built desktop app: one signed, notarized, auto-updating download that bundles the whole pipeline (orchestrator, worker, and frontend) with no Docker and no dev toolchain. First launch does a one-time runtime setup (~500 MB), then asks for an LLM backend: an Anthropic API key, a custom gateway, or local Ollama.
Everywhere else, Docker:
git clone https://github.com/2389-research/Noospheric-Orrery.git
cd Noospheric-Orrery
cp .env.example .env
docker compose up
Point it at Anthropic’s API, AWS Bedrock, or a local Ollama install. The README has the details.
What it does
Adaptive extraction. Documents are classified into a hierarchical domain taxonomy that builds itself incrementally. When a domain hits critical mass, a refinement pass determines what specialized entities would give better insight into that area than the general superset does. Our finance domain learned compliance standards, funding stages, and the specific SaaS services we pay for; a software-architecture domain went the other direction, below architecture into individual fields, functions, and error conditions.
Refinement that runs on small models. The mechanism descends from Simmer: a two-stage feedback loop where the first stage builds a golden dataset of the right entities for a domain and the second hones an extraction prompt against it. Splitting the stages made the problem tractable for small models. A refinement run takes 10-20 minutes at around $0.50, and works well enough on ~30B-parameter local models that our live instance, several thousand documents and 100+ GitHub repos, runs entirely on them.
A maintained graph, not a one-shot build. Workers spin up when the system is idle to scan for normalization candidates, spacing and capitalization variants first, conservative about merging higher-order concepts. Agents and users file GitHub-style issues against nodes, and a separate pipeline picks them up, compares the claims, and adjudicates. Quality effort concentrates on the parts of the graph actually being used.
Two interfaces, one substrate. Agents get standard graph operations over an API: semantic and lexical search, node traversal, local neighborhood exploration. Humans get the galaxy, where domains are regions of space laid out semantically and documents and entities are stars. The layout is anchored around domains, gravitational-well style, so the graph grows without ever losing its landmarks. As agents query the graph, their activity lights up the nodes they touch, and you watch the cascade ripple across the galaxy.
How it works
The useful work happens when documents arrive, not when questions are asked. Ingestion extracts entities, links documents, and builds structure once, so every downstream agent and teammate inherits those connections instead of re-deriving them per query. Domain classification decides when a conceptual domain has enough content to trigger refinement, and refined specs then drive extraction for new documents in their domain.
The galaxy is a projection of the graph, not the graph itself. The same substrate could render as a wiki; you pick the projection that serves the audience in front of it.
Requirements
- Desktop app: an Apple silicon Mac
- Docker path: Docker and Docker Compose
- An LLM backend: an Anthropic API key, AWS Bedrock, or a local Ollama install