runic-ogm

runic-ogm is a skill for Claude Code, Codex from jenreh/appkit. It costs 169 tokens per session (4,800 once invoked), scanned A, original, MIT.

A guide to runic.ogm, a Python object-graph mapper for property-graph databases such as Neo4j and FalkorDB. It lets typed Python classes represent graph nodes and relationships and provides sessions and query tools for working with them.

In plain words
What is it for?
Use it when defining graph nodes or edges, mapping fields, creating relationships, loading related data, building graph queries, traversing data, or performing database CRUD operations.
Why use it?
It reduces the need to write graph-database query language by hand for common modeling, relationship, and data-access tasks. It also documents supported drivers and the library’s query and repository APIs.

Skill for Claude CodeCodex

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add skills/jenreh/appkit/runic-ogm
Any agent
npx skills add jenreh/appkit --skill runic-ogm
Clone the repo
git clone --depth 1 https://github.com/jenreh/appkit

Made for: Claude Code, Codex.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for runic-ogm

README.md
[![agentmods](https://agentmods.dev/badge/skills/jenreh/appkit/runic-ogm.svg)](https://agentmods.dev/skills/jenreh/appkit/runic-ogm)
Your own site
<a href="https://agentmods.dev/skills/jenreh/appkit/runic-ogm"><img src="https://agentmods.dev/badge/skills/jenreh/appkit/runic-ogm.svg" alt="Measured on agentmods" height="20"></a>
Per session 169 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 4,800 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00169 $0.04800
Opus 5 $0.00084 $0.02400
Sonnet 5 $0.00034 $0.00960
Haiku 4.5 $0.00017 $0.00480

Measured 4d ago against content hash 39122533453f, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

runic-ogm scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 4d ago.

The scan reads SKILL.md. This mod also ships 6 executable files (examples/async_session.py, examples/mapping.py, examples/native_types.py, …), listed below but not scanned — reading those needs a real analyzer, not pattern matching.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

.claude/skills/runic-ogm/SKILL.md · 444 lines

How it starts

The opening of the file, as written. The whole thing — 444 lines — stays where its author put it; the contents beside it link to each section on GitHub.

runic.ogm — Graph OGM for Cypher Databases

runic.ogm is a lightweight, SQLModel-inspired OGM for property-graph databases. You declare nodes and edges as typed Python classes, then create, read, relate, and query them through a Session — without hand-writing Cypher. It targets FalkorDB first and also runs on Neo4j, Memgraph, ArcadeDB, and Apache AGE through a pluggable driver layer.

Three pillars, each with a runnable example and a reference:

Pillar What it covers Start here
Mapping Node/Edge classes, Field(), defaults, PK, indexes, native types examples/mapping.py
Relations Relation(), lazy/eager loading, edge models, relate(), polymorphism examples/relations.py
Query builder select(), filters, traversal, aggregation, search examples/query_builder.py

For the full API surface (every Field/Relation parameter, all Session, Repository, and QueryBuilder methods, drivers, exceptions) read references/api-reference.md. For task-oriented recipes and gotchas read references/cookbook.md.

The snippets below omit the # type: ignore / # noqa comments the repo's own examples carry. Those exist only because Field()/Relation() return Any and the descriptor comparison operators (User.age > 18) confuse some type checkers. The code is correct as written; add the ignores only if your checker complains.


Quick start

All runic.ogm imports come from runic.ogm directly. Session, Repository, select, and their methods (add, commit, flush, scalars, relate, unrelate, query, count, all_rows, etc.) are runic.ogm-native API — not from SQLAlchemy or any other ORM. Never import from runic.ogm.orm.* — the package root re-exports everything.

from runic.ogm import (
    Field, Node, Edge, Relation,
    Session, AsyncSession,
    Repository,
    select,
    count, avg, sum_,
)
from runic.ogm.driver.factory import create_driver

class User(Node, labels=["User"]):
    id: str = Field(primary_key=True)
    name: str
    email: str = Field(unique=True)
    active: bool = True

driver = create_driver("falkordb", host="localhost", port=6379, graph="app")

with Session(driver) as session:
    session.add(User(id="u1", name="Alice", email="[email protected]"))
    session.commit()

    alice = session.get(User, "u1")     # read by primary key
    alice.name = "Alice B."             # mutation marks the entity dirty
    session.commit()                    # flushes the SET automatically

driver.close()

Read the full file on GitHub · 444 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 4d ago First seen · 444 lines · 169 tokens per session scan A 39122533453f

Subscribe to this mod's changes

runic-ogm is a skill published in the GitHub repository jenreh/appkit (4 stars, last pushed 4d ago), licensed MIT. It adds 169 tokens to every session and 4,800 once invoked, about $0.0008 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.

Related

Other skills, from other repositories

adding-personhog-rpc

Guide for adding a new RPC to personhog-replica and personhog-router. Covers eligibility checks, proto definition, code generation for Python and Node.js clients, Rust implementation (storage trait, postgres queries, service handler, router wiring), and index compatibility validation. Use when adding a new gRPC…

PostHog/posthog · 88 tokens

geopipe-agent

Use when building AI-driven GIS data pipelines with YAML-defined steps — format conversion, spatial validation, QC reporting, PostGIS loading, WMS publishing. GeoPipe Agent: YAML-driven GIS ETL pipeline agent with quality control.

znlgis/opengis-skills · 50 tokens

cairo-contract-authoring

Cairo smart-contract authoring on Starknet. Trigger on "write a contract", "create a contract", "implement this in Cairo", "add storage/events/interface", "compose components". Guides structure, security patterns, and component wiring.

keep-starknet-strange/starknet-agentic · 54 tokens

bitcoin-libraries-bdk-python

Python bindings for BDK. Same API as Rust BDK exposed via UniFFI.

claude-dev-suite/claude-dev-suite · 58 tokens

bitcoin-libraries-bitcoinlib-py

High-level wallet library by 1200WD. Aims to be a complete solution for Python Bitcoin (and altcoin) wallets.

claude-dev-suite/claude-dev-suite · 54 tokens

algorand-python

Develops Algorand smart contracts in Python using PuyaPy — covers syntax, decorators, storage, transactions, types, testing with pytest, deployment, AlgoKit Utils, ARC-4/ARC-56 standards, and error troubleshooting. Use when writing algopy contracts, using @arc4.abimethod decorators, working with GlobalState or BoxMap…

algorand-devrel/algorand-agent-skills · 103 tokens