A shared space for agents and humans.
Typed Graph turns your Markdown and your code into one typed, checked graph, with an ontology that explains every type, link and block inside your documents. You write it in Obsidian or your editor. Your agent learns what each part means, then queries it from Claude Code, Cursor or any MCP client. Both see the same truth, in plain files.
Works with Obsidian · VS Code · Cursor · Windsurf · VSCodium · Claude Code · any MCP client
Install where you already work
Pick your tool. Each one takes about a minute, and they all read the same Markdown.
Claude Code
Install the CLI and let tg init wire hooks, instructions and skills for the agents you pick. npm package
npm i -g @typedgraph/cli tg init tg mcp
VS Code, Cursor, Windsurf
Typed backlinks and the graph for your Markdown and annotated code. On the VS Code Marketplace and on Open VSX.
code --install-extension \ pavlyshyn.typegraph-vscode
Obsidian
Typed, signed edges, openCypher query blocks and a graph view, in the community plugin directory as Typed Graph.
Settings → Community plugins → Browse → "Typed Graph"
See it work
Two short recordings, both made by script from real runs.
Why a shared space
One graph in plain Markdown, edited by people and read by agents, with a check that fails when it drifts.
Humans and agents, same files
You write implements:: [[Token expiry]] in Obsidian or an editor. The agent runs tg cypher or an MCP tool over the same file. No export, no sync, no second store.
Documented and reliable
tg check validates links, symbols, section rules and test-spec coverage, as a CI gate or an agent hook. The example vault is tested against the engine, so the manual cannot drift.
Memory an agent can query
Typed edges such as implements, contradicts and supersedes give an agent relationships to traverse, not a pile of text to re-read. Add vectors and cited GraphRAG when you want them.
An ontology that explains your documents to agents
A type says what a document is. It also says what goes inside it: the headings it has and the blocks it holds, such as a decision's options, a requirement's rules or a runbook's rollback, each described in plain words. Your agent reads what every part means before it writes one, and tg checks what it wrote.
You declare it once
# Types/Runbook.md
schema:
description: How to operate one part of the system
when something goes wrong.
sections:
Symptoms: {required: true, description: What an
on-call engineer sees first.}
elements:
step:
description: One action, in order, that an
engineer or an agent can run.
attributes:
risk: {values: [safe, disruptive], required: true}
elements:
check: {required: true, description: How to
tell that the step worked.}
rollback:
description: How to undo the steps.
required: true
many: false
The agent reads it, and the check holds it
$ tg ontology
Runbook (Types/Runbook.md)
How to operate one part of the system ...
sections:
## Symptoms (required) — What an on-call ...
elements:
<step> — One action, in order, that an ...
attributes:
risk (text, safe|disruptive, required)
elements:
<check> (required) — How to tell that ...
<rollback> (exactly one) — How to undo ...
$ tg ontology check
- lat.md/runbooks.md:28: <step> has no <check>:
How to tell that the step worked.
Every name explained
Types, properties, edges and blocks carry a description. tg ontology prints it for agents and people, and the SHACL export carries it to RDF tools.
The inside of a document, checked
A type declares its headings and the XML blocks its sections hold, nested with a clear scope. tg ontology check reports a missing or repeated block with its description. Anything undeclared stays prose.
Parts you can point at
Give a block an id and it becomes a node: link [[decisions#^redis]] from docs or code, and query every option your team ever rejected.
Write edges like you write notes
One line per edge, right where it belongs. Plain type:: [[Target]] lines from Graph Link Types keep working; add a sign and properties when you need them.
---
type: Person
role: research lead
---
knows:: [[Bob]] {since: 2020, label: "met at NeurIPS"}
works_at:: [[Acme]]
-distrusts:: [[Mallory]] {id: "alice-mallory"}
Ask it questions
A graph-query block runs openCypher and shows a graph or a table, live, as the vault changes.
```graph-query
MATCH (p:Person)-[c:contributes]->(proj:Project)
RETURN p.title AS person, proj.title AS project,
c.hours AS hours
ORDER BY hours DESC
```
Screenshots
Rendered by the plugin's own engine and renderer — the same ones you can poke at in the live demo.




Everything a graph needs
From a quick typed link to RAG-ready storage for agents.
Typed, signed edges
type:: [[X]], a - prefix for negative edges, properties in braces, stable or pinned ids.
Typed nodes & schemas
Frontmatter type gives labels; schema notes declare and describe properties, allowed edges, templates and looks.
Document elements
Types declare the headings and blocks inside a document, explained for agents; blocks with an id become nodes, and the shape is checked.
openCypher
MATCH, OPTIONAL MATCH, WITH, aggregation, variable-length paths — read-only, with clear errors.
Graph view
A full-pane explorer that follows the active note, expands neighbors and explains every style.
Edge property embeds
{{edge: Alice -knows-> Bob . since}} shows a value in prose and warns about unstable references.
LadybugDB mirror
An optional sidecar mirrors the graph into LadybugDB for full Cypher, verified against the built-in engine.
Vector search
Local Ollama embeddings over note chunks and edge sentences; combine hits with graph traversal.
GraphRAG & MCP
Cited retrieval over hits and their neighbors, served to agents through an MCP server.
For developers: tg
A command line that keeps design docs honest against the code, lets code point back at the docs with typed edges, and gives coding agents the result. It reads the same lat.md/ folders as lat.md and agrees with its check.
$ tg check
Scanned 39 .md, 87 .ts ...
All checks passed
$ tg search "how are tokens validated"
$ tg cypher "MATCH (c:CodeSymbol)-[:implements]->(s:Section)
RETURN s.title, count(c)"
$ tg init # pick your agents; it writes the setup
// @lat: [[auth#Token expiry]]
export function verifyToken(t: string) {}
// @tg: implements:: [[auth#Token expiry]] {since: 2}
// @tg: -contradicts:: [[design#Stateless sessions]]
function legacyCheck() {}
Check docs against code
Links, symbols, section rules, index files and test-spec coverage, as a CI gate or an agent hook. Same verdicts as lat.md.
Typed edges from code
@tg: comments add a type, a sign and properties to a link from a function to a design section.
Cypher over docs and code
Sections and code symbols are nodes in one graph: which sections have no implementation, which are implemented by most.
Search with no setup
Lexical ranking needs no model or key, so it runs in a fresh clone. Add Ollama or an OpenAI-compatible endpoint for hybrid search.
Agents and MCP
tg init installs instructions and six skills for nine coding agents, plus hooks for Claude Code; tg mcp serves ten tools. --dry-run shows the diff first.
Obsidian and export
The plugin opens lat.md links in place and draws code nodes. tg export and tg import move content between a vault and a lat.md folder.
npm install -g @typedgraph/cli
Bring your spec framework
tg traces requirements to the code that implements them, the tests that prove them and the docs that explain them, whichever framework you write them in. tg init asks which one you use, and installs it if you have none.
Capability specs, plus change proposals with deltas. Best for evolving an existing codebase.
tg init --spec openspec --install-spec # runs: openspec init --tools claude
// @tg: implements:: [[openspec:auth#Login]] // @tg: verifies:: [[openspec:auth#Login#Valid password]]
GitHub Spec Kit: one folder per feature, with user stories, FR-### requirements and acceptance scenarios. Best for building new features end to end.
tg init --spec speckit --install-spec # runs: specify init --here --force --integration claude # or: uvx --from specify-cli specify init …
// @tg: implements:: [[speckit:001-checkout#FR-001]] // @tg: verifies:: [[speckit:001-checkout#US1#Scenario 1]]
Kiro-style requirements with EARS acceptance criteria, shared by the Kiro IDE, cc-sdd and spec-workflow-mcp.
tg init --spec kiro --install-spec # runs: npx -y cc-sdd@latest --claude-skills # adds: .kiro/steering/tg.md
// @tg: implements:: [[kiro:reports#Requirement 2]] // @tg: verifies:: [[kiro:reports#Requirement 2#2.1]]
BMAD Method: agent personas write a PRD with FR-# items, then story files with acceptance criteria.
tg init --spec bmad --install-spec # runs: npx -y bmad-method@latest install …
// @tg: implements:: [[bmad:prd#FR-1]] // @tg: verifies:: [[bmad:epic-1#Story 1.2#AC1]]
Get Shit Done: one REQUIREMENTS.md with CATEGORY-NN ids and a roadmap in phases.
tg init --spec gsd # in a terminal it offers: npx -y get-shit-done-cc@latest
// @tg: implements:: [[gsd:requirements#AUTH-01]]
Architecture decision records in MADR, Nygard or log4brains format. Use them next to any of the others.
tg init --spec openspec,adr # writes: docs/adr/0001-record-architecture-decisions.md # docs/adr/template.md
// @tg: implements:: [[adr:0003]]
// @tg: -contradicts:: [[adr:0002]] {ticket: "PAY-7"}
How it fits together
Markdown stays the only source of truth. Everything else is derived and rebuildable.
core TypeScript
Edge parser, graph model, schemas, styles, openCypher engine, chunking. No Obsidian APIs.
plugin Obsidian
Query blocks, graph view, embeds, diagnostics. Works on desktop and mobile.
sidecar optional
Headless service over a read-only vault: REST, MCP, LadybugDB mirror, vectors.
tg CLI
One bundled binary on the same core: check, search, query, agent setup, export. No Obsidian needed.
Install
- From Obsidian: open Typed Graph in Obsidian and click Install, or go to Settings → Community plugins → Browse → search Typed Graph. It is listed in the community plugin directory.
- Beta builds, with BRAT: install the BRAT plugin, then Add beta plugin →
Volland/typedgraph. - Manually: download
main.js,manifest.jsonandstyles.cssfrom the latest release into<vault>/.obsidian/plugins/typed-graph/and enable it.
Without Obsidian: VS Code and its forks
The Typed Graph extension shows typed backlinks and the graph for the markdown and annotated code in a workspace. It is on the VS Code Marketplace and on Open VSX.
- VS Code: search TypeGraph in the Extensions view, or run
code --install-extension pavlyshyn.typegraph-vscode. - Cursor, Windsurf, VSCodium, Gitpod: search TypeGraph (Open VSX), or run
codium --install-extension pavlyshyn.typegraph-vscode.
For agents
With a CLI, tg mcp serves the graph to Claude Code (see the agents guide). With an Obsidian vault, run the sidecar next to your vault and give your agent the graph:
claude mcp add typed-graph \ -e OBSIGRAPH_VAULT=/path/to/vault \ -e OBSIGRAPH_DATA=/path/to/data \ -- node packages/sidecar/dist/server.mjs --stdio
Tools: cypher_query, vector_search, graphrag_retrieve. See the sidecar docs.
Learn more
Articles, a gallery of ready-made ontologies and a vault to explore.
Explainable blocks
An ontology for the inside of your documents: blocks an agent understands, code can point at and tg checks.
Declaring document elements
One shape, one reading: attributes, nesting and scope, and the normal form of TGS 0.5, with a checklist.
Bring your own spec framework
OpenSpec, Spec Kit, Kiro-style specs, BMAD, GSD and ADRs, traced to code and tests by one command.
A shared space for agents and humans
Why coding agents need the same documented, checked knowledge as people, in plain files.
Give Claude Code a memory in five minutes
Install tg, run tg init, write a typed link, and let the agent search, query and check.
Typed Graph and the alternatives
Next to lat.md, plain Obsidian and vector-only memory, including where each is better.
Your vault as a property graph
Typed, signed edges, schema notes, openCypher and styled graphs, in plain Markdown.
Your vault as RAG storage
LadybugDB, vector search over notes and edges, GraphRAG with citations, and MCP for agents.
Docs and code as one typed graph
The tg CLI: check design docs against code, typed edges from comments, Cypher over both, and agent hooks.
tg and lat.md compared
What is the same, what tg adds, where lat.md is stronger, and how to switch.
Ontology gallery
Download ready-made ontologies: Zettelkasten, books, requirements, prompts and agents, and an OKF catalog. Plain Markdown, and they combine.
Ontologies you can download, and combine
A shared core, multi-label notes and mixins: how several ontologies live in one graph.
Getting your vault OKF-ready
Four habits, a one-command export to Google's Open Knowledge Format, and reading any OKF bundle as a graph.
An ontology you can edit by hand
Typed Graph Schema: types and edge types in plain YAML notes, exchanged with RDF tools as SHACL.
One vocabulary for the whole team
The code ontology that tg init installs, and how developers, architects, product and agents use it.
Your codebase has two graphs
What to model, what to leave to the machine, and why specs are code now.
Why a typed graph for your codebase
Typed links between design and code, and why intent cannot be generated from the source.
A vault that teaches itself
A research-lab vault with the plugin preinstalled and a hands-on Cypher course.