Steledger

Official5 toolsLive

by steledger · Python

Durable identity and memory for AI agents, anchored on the Emercoin blockchain.

MCP Server: com.steledger/gateway

The Model Context Protocol (MCP) server com.steledger/gateway provides durable identity and memory for AI agents. Its context is anchored on the Emercoin blockchain, as stated in the server description. This page summarizes the server’s described purpose, based on available repository metadata.

🛠️ Key Features

Durable identity for AI agents
Durable memory for AI agents
Anchored on the Emercoin blockchain

🚀 Use Cases

Storing and maintaining AI agent identity
Preserving AI agent memory across interactions
Running agent workflows tied to an Emercoin-backed anchor

⚡ Developer Benefits

Clear alignment with durable identity and memory needs
Blockchain anchoring defined as Emercoin

⚠️ Limitations

No tool count, topics, or README excerpt provided in the available data

Captured live from the server via tools/list.

node_status

Check that the chain node behind this service is healthy and fully synced: its version, block height, header height, peer connections and sync state. It is an Emercoin node. Read-only, no sign-in required, no parameters. `synced` is not a comparison of the two heights — it is true once the node's verification progress passes 0.9999, so it can still be false while `blocks` and `headers` already match. Trust that field, not the arithmetic. While it is false, a `read_record` may reflect an older state of the chain; writes still work, they simply confirm later. Also the way to make sense of expiry: `expires_in` on a record is denominated in blocks, and this tool reports the current height, so the two together are the only authoritative answer to when something lapses. A term is bought in days and charged at a flat 175 blocks each; the chain has been producing about 171 a day lately (8.4 min/block over the 103 days to 2026-09-22), so a term is close to its nominal length right now — but that rate drifts, which is why you should read the blocks rather than convert to days.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {},
  "title": "node_statusArguments"
}

read_record

Read one on-chain record by its full name — an agent's identity (`ai:gh:<github_id>`) or a memory (`ai:gh:<github_id>:mem:<hash>`) written by `register_identity` / `store_memory`. Records live in Emercoin's Name-Value Storage, so anyone can verify one in a public block explorer as well as here. Returns the confirmed on-chain record, or a `pending` one still in the mempool — the `status` field ('confirmed' | 'pending') distinguishes them. A name is only held for a limited term, so check `expired` (and `expires_in`, in blocks) before trusting a record: a lapsed name still reads back as 'confirmed' but can be re-registered by anyone. Read-only, no sign-in required; use `whoami` to find your own github_id. A name that has never been written is an error, not an empty record — handle the failure, do not test the fields for null. `name` is the full NVS name and is capped at 512 bytes by the chain.

Parameters1

name

string

required

Full NVS record name to read. Identity records are 'ai:gh:<github_id>' (e.g. 'ai:gh:3772563'); memory records are 'ai:gh:<github_id>:mem:<sha256-hex>'. Any existing NVS name works.

Raw schema

{
  "type": "object",
  "properties": {
    "name": {
      "description": "Full NVS record name to read. Identity records are 'ai:gh:<github_id>' (e.g. 'ai:gh:3772563'); memory records are 'ai:gh:<github_id>:mem:<sha256-hex>'. Any existing NVS name works.",
      "title": "Name",
      "type": "string"
    }
  },
  "required": [
    "name"
  ],
  "title": "read_recordArguments"
}

whoami

Report the current session's identity. Read-only, no sign-in required: an anonymous session gets `{authenticated: false}` with a hint (not an error), a signed-in one gets `{authenticated: true}` plus the GitHub-rooted id, login and tariff. Call it to confirm who you are before `register_identity` / `store_memory`; an anonymous caller must sign in (GitHub OAuth) first. `github_id` is the one field you usually need: every record name is built from it — `ai:gh:<github_id>` and `ai:gh:<github_id>:mem:<hash>` — so this is how you learn which names are yours to write and to read back. `tariff` is `free` for every account today; it governs the write rate limit, currently 10 writes per minute. Note what this tool does not do: it reports the session only, reading the token your client already holds without calling GitHub, and it proves nothing about control of an Emercoin address — that is what signing a challenge at login is for.

Parameters

No parameters.

Raw schema

{
  "type": "object",
  "properties": {},
  "title": "whoamiArguments"
}

register_identity

Create or rotate your on-chain identity record `ai:gh:<github_id>`, binding an Emercoin address to your GitHub identity. Requires a signed-in session (OAuth) and counts against the FREE-tier per-minute write limit. Run `whoami` first to confirm you are signed in; anchor memories under this identity afterwards with `store_memory`. Writes one NVS transaction paid by the gateway (you need no EMC); the record reads back as `pending` at once and `confirmed` after the next block (about 8 minutes on average lately). Idempotent — calling again rebinds the address, and `metadata` is replaced rather than merged. Limits worth knowing before you call: `metadata` is stored verbatim in the record value alongside your github id, login and address, and the whole value must stay under 20 KiB — the chain rejects more. Every 128 bytes of name plus value adds about 0.0001 EMC to the fee the gateway pays for you. The value is written to a public chain exactly as given and cannot be deleted, so put nothing private in it. `address` is not parsed or checked here — any string is accepted, because control is proven later by signing a challenge at login, so a typo surfaces then rather than now. Returns the record name and the transaction id.

Parameters2

address	string	required	Emercoin address to bind to your GitHub identity, e.g. 'EVfAn...'. It is the anchor for later signature login — you must control its key (control is proven when you sign a challenge at login, not here).
metadata	any	optional	Optional JSON object stored verbatim in the identity record, e.g. {"agent": "my-bot", "url": "https://..."}. Omit if unused.

Raw schema

{
  "type": "object",
  "properties": {
    "address": {
      "description": "Emercoin address to bind to your GitHub identity, e.g. 'EVfAn...'. It is the anchor for later signature login — you must control its key (control is proven when you sign a challenge at login, not here).",
      "title": "Address",
      "type": "string"
    },
    "metadata": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional JSON object stored verbatim in the identity record, e.g. {\"agent\": \"my-bot\", \"url\": \"https://...\"}. Omit if unused.",
      "title": "Metadata"
    }
  },
  "required": [
    "address"
  ],
  "title": "register_identityArguments"
}

store_memory

Anchor a memory/artifact on-chain as the NVS record `ai:gh:<github_id>:mem:<content_hash>` — a tamper-evident fingerprint others can verify later. Requires a signed-in session (OAuth) and counts against the FREE-tier per-minute write limit. Writes one NVS transaction paid by the gateway; reads back `pending` at once, `confirmed` after the next block (about 8 minutes on average lately). Not idempotent — each distinct hash is a new record. Register your identity first — nothing enforces it, the write succeeds either way, but a memory under an unregistered id anchors to nobody and proves correspondingly little. Limits worth knowing before you call: `content_hash` becomes part of the record *name*, `ai:gh:<github_id>:mem:<hash>`, and NVS names are capped at 512 bytes — a hex digest is the intended shape. It is stored exactly as given and never verified: nothing checks that it is the hash of anything, so a wrong or truncated digest anchors happily and proves nothing. `metadata` goes verbatim into the record value, which must stay under 20 KiB, is public and permanent. Returns the record name and the transaction id.

Parameters2

content_hash	string	required	Hash of the artifact/memory, e.g. a SHA-256 hex digest. It becomes the record's ':mem:<hash>' suffix; the content itself stays off-chain (e.g. IPFS) — only this fingerprint is anchored.
metadata	any	optional	Optional JSON object stored with the record (note, source, tags, …). Omit if unused.

Raw schema

{
  "type": "object",
  "properties": {
    "content_hash": {
      "description": "Hash of the artifact/memory, e.g. a SHA-256 hex digest. It becomes the record's ':mem:<hash>' suffix; the content itself stays off-chain (e.g. IPFS) — only this fingerprint is anchored.",
      "title": "Content Hash",
      "type": "string"
    },
    "metadata": {
      "anyOf": [
        {
          "additionalProperties": true,
          "type": "object"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional JSON object stored with the record (note, source, tags, …). Omit if unused.",
      "title": "Metadata"
    }
  },
  "required": [
    "content_hash"
  ],
  "title": "store_memoryArguments"
}

mcp_server/README.md2 KBView on GitHub

Steledger — MCP server

Thin MCP client over the edge gateway HTTP API. Lets an AI agent use the Emercoin chain as its identity + memory layer. (The edge is the agent-facing IAM layer; it delegates chain ops to the node adapter — see docs/ARCHITECTURE.md.)

Tools

Tool	Auth	Maps to
`node_status()`	no	`GET /status`
`login()`	no	`POST /auth/github/device/start` (device flow; show code to user)
`login_poll(session_id)`	no	`POST /auth/github/device/poll` (finish; caches JWT)
`login_with_token(github_token)`	no	`POST /auth/login` (dev/CI fallback)
`register_identity(address, metadata?)`	yes	`POST /nvs/identity`
`store_memory(content_hash, metadata?)`	yes	`POST /nvs/mem`
`store_memory_batch(records)`	yes	`POST /nvs/mem/batch` (atomic, one tx)
`read_record(name)`	no	`GET /nvs/{name}`

Config (env)

GATEWAY_URL — edge gateway base URL (default http://localhost:8000)
GATEWAY_JWT — optional pre-issued token; otherwise use the login tool

Run (stdio transport)

bash

pip install -r requirements.txt
GATEWAY_URL=http://localhost:8000 python server.py

Claude Code MCP config example

json

{
  "mcpServers": {
    "steledger": {
      "command": "python",
      "args": ["/path/to/mcp_server/server.py"],
      "env": { "GATEWAY_URL": "http://localhost:8000" }
    }
  }
}

Install

Tools (5)

node_statusread_recordwhoamiregister_identitystore_memory

Configuration

Environment variables

GATEWAY_URLdefault https://api.steledger.com

Base URL of the edge gateway the MCP server talks to

Add to VS Code Add to Cursor

claude_desktop_config.json

json

{
  "mcpServers": {
    "gateway": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/steledger/mcp:latest"
      ],
      "env": {
        "GATEWAY_URL": "https://api.steledger.com"
      }
    }
  }
}

MCP Server: com.steledger/gateway

🛠️ Key Features

🚀 Use Cases

⚡ Developer Benefits

⚠️ Limitations

node_status

read_record

whoami

register_identity

store_memory

Steledger — MCP server

Tools

Config (env)

Run (stdio transport)

Claude Code MCP config example

Install

Configuration

Related servers