Skip to main content
Glama

Install in VS Code Claude plugin ChatGPT GitHub MCP Registry

ci PyPI npm License: Apache-2.0

Try it: one question, no key

curl -s -X POST https://emem.dev/v1/ask -H 'content-type: application/json' \
  -d '{"q":"What is the air quality in Delhi right now?"}' \
  | jq '{answer: (.answer | split("\n")[0]), limits: .direct_answer.limits, fact: .direct_answer.fact_cid, signed_facts: (.receipt.fact_cids | length)}'

What came back on 20 November 2026, in 2.3 s:

{
  "answer": "PM2.5 at Delhi: PM2.5 69.80 ug/m^3, on a reading dated 2026-11-20 (today).",
  "limits": [
    "Delhi covers more than one cell. This is the reading at the one cell the name resolves to, not a value over the whole place.",
    "CAMS is a model analysis on a coarse grid, not a street-level monitor."
  ],
  "fact": "olew2lwppg4uazm4sgiiv56qv4p4owphfon3ijqb3bvkqb35lyua",
  "signed_facts": 49
}

The answer names its source and says what it cannot tell you. Every fact behind it is signed, and the fact id resolves, for you or any other agent, to the same bytes.

The same for one farm field, from the latest clear Sentinel-2 pass:

curl -s -X POST https://emem.dev/v1/recall -H 'content-type: application/json' \
  -d '{"lat":30.745,"lng":75.605,"bands":["indices.ndvi"]}' \
  | jq '.facts[0] | {value, observed_at, scene: .derivation.args[2], surface: .surface_class.label, token: .memory_token}'

On 20 November that gave NDVI 0.169 from scene S2B_MSIL2A_20261117T054109_R005_T43REQ, with the pixel read as bare soil: a field between the rice harvest and the wheat.

Related MCP server: agent-memory

Web search and emem

Web search

emem

Returns

pages that mention the place

a measured value at the place

Source

whoever wrote the page

the sensor or model reading, named

Freshness

when it was crawled

read on demand from the latest pass or model run

Trust

rank

a signature, an append-only log, and a check anyone can run

For an agent

text to paraphrase

a value and a token to cite

When nothing is known

more pages

a signed absence that says where it looked

Connect your agent

claude mcp add --transport http emem https://emem.dev/mcp     # Claude Code

Any MCP host takes the same URL, https://emem.dev/mcp: Claude Desktop, ChatGPT, Cursor, VS Code, Cline and Gemini CLI. The Claude Code plugin adds nineteen skills on top: /plugin marketplace add Vortx-AI/emem, then /plugin install emem@emem. In code: pip install ememdev or npm i @vortxai/emem.

For agents. Connect to https://emem.dev/mcp. It advertises the 18 tools of the core loop in one page, about 75 KB of context, not the whole catalog: loading all 119 descriptors costs about 329 KB. For the lightest first contact, emem_tools returns the loop and a menu in about 13 KB, and tools/call dispatches every tool by name, with or without its emem_ prefix. To hand records on, prefer a bundle: emem_memory_bundle names up to 256 facts in 38 characters.

Then ask in plain words. Each prompt below runs one tool:

Ask your agent

What emem reads

Tool

"What is the air quality here right now?"

CAMS analysis: PM2.5, NO2 and ozone

emem_air

"Will it rain here this week?"

met.no forecast: temperature, cloud, rain and wind (ERA5 past hours through emem_recall)

emem_weather

"Is there open water here, and how often?"

JRC surface-water history since 1984 and Sentinel-1 radar, which sees water through cloud

emem_water

"Show the NDVI of this field through the last kharif season"

every clear Sentinel-2 pass in one call, each date with its pixel count (4.2 s for a 4.4 ha field, 13 dates)

emem_field_series

"Draw the field boundaries in this 1 km box"

Fields of The World outlines with net area and, if asked, the 10 m pixels each field holds

emem_field_boundaries

"Is this cocoa plot deforestation-free under the EUDR?"

the EU forest map and forest loss after 31 December 2020, one signed check per plot

emem_eudr_dds

"Was there tree-cover loss here since 2020?"

Hansen tree cover and year of loss, ESA WorldCover land class

emem_forest

"How steep is this slope? What is the soil?"

Copernicus DEM slope and ruggedness, SoilGrids organic carbon and texture

emem_terrain, emem_soil

"How many buildings and roads are in this block?"

Overture buildings, places and road length

emem_recall

"Read this scanned lab report"

Tesseract OCR, with a receipt that binds the image, the text and the engine

emem_ocr

"Did this robot run what it says it ran?"

its signed execution trace, checked segment by segment

emem_trace_verify

"Check the numbers in my draft before I send it"

each cited token resolves, and its value is compared with your sentence

emem_guard_verdict

117 wired measurements from open sources, read on demand. The full list: emem.dev/tools.

Why the answers hold up

  • Every number traces to its source: the satellite scene, the band, the method and the registry version are in the record.

  • Nothing changes quietly: records go into an append-only log (RFC 6962) that two independent operators co-sign. When we find a fault we correct it in the open with a signed erratum.

  • Anyone can check it without us: each receipt verifies offline (pip install "ememdev[signing]", then verify_receipt_offline), or paste a token at emem.dev/verify.

  • Gaps are stated, not filled: where nothing qualifies, a signed absence says where emem looked and why. Cautions (cloud, a field too small for its pixels) travel with the value.

The long form, with what each record promises and how each promise is checked, is in docs/settlement.md.

Choose your path

You are

Start here

Trying it

the command above, or https://emem.dev/mcp in any MCP host. Reads need no key.

Building an agent or app

agent guide, OpenAPI, examples for LangChain, LlamaIndex, CrewAI, AutoGen, Agno and Mastra

A compliance or agri team

EUDR evidence, plot by plot, crop intelligence, or open an issue to talk to us

Running your own node

docker run -p 127.0.0.1:5051:5051 ghcr.io/vortx-ai/emem:latest, then docs/self-host.md; an air-gapped build is in emem-airgap

Numbers

119 MCP tools · 177 registered algorithms · 117 wired measurements from open sources, satellites and weather models to buildings and soil · a transparency log of 3.39 million entries co-signed by 2 independent operators · Apache-2.0, pure Rust, runs as one binary.

Who builds on it

  • eudr.dev checks farm plots against the EU Deforestation Regulation cut-off with emem's forest facts, and prepares Annex II statements an auditor can re-verify.

  • geo.qa runs a second node, whose transparency-log head emem co-signs.

Use it where you already work

In a chat

the emem app in ChatGPT (mention @emem), and emem in the Claude directory

In Claude Code

the plugin, the MCP server plus nineteen skills: /plugin marketplace add Vortx-AI/emem, then /plugin install emem@emem

In an IDE or MCP host

Claude Desktop, Cursor, Cline, VS Code and Copilot, Gemini CLI (gemini extensions install https://github.com/Vortx-AI/emem), all on one endpoint, https://emem.dev/mcp

In a workflow tool

the verified Dify plugin

In code

the Python and TypeScript clients, REST (OpenAPI), and examples for LangChain, LlamaIndex, CrewAI, AutoGen, Agno and Mastra

Agent to agent

A2A: read the agent card, send a task, verify the signed result

Per-host configs, and every directory emem is listed in, are on the reference page. Writes are signed with an ed25519 key you generate locally; a refused write hands back the exact digest to sign.

Run it yourself

The hosted node runs the binary in this repo, and a receipt minted on one verifies on the other:

docker run -p 127.0.0.1:5051:5051 ghcr.io/vortx-ai/emem:latest

Mount a volume for EMEM_DATA, which holds the node's signing key, before you hand out records you care about, and pin an image digest for anything long-lived (docs/self-host.md).

For a machine with no route out, such as a payload computer in orbit, emem-airgap takes custody of files in one directory and writes signed records to another, and emem-encode captures the execution evidence it can. Each record says which of the two guarantees it carries. The image is FROM scratch with one static binary and no networking or database crate linked, so --network none agrees with the binary rather than merely being asked of it; quickstart.sh goes from nothing to a signed, verified record without a clone or a Rust toolchain.

Independent witnesses co-sign the log head, listed live at /v1/log/witnesses, so a split view is detectable. Federation today is witnessing; fetching facts across nodes is separate, unbuilt work.

What the checks do not prove

  • A signature says who, never that it is true. A receipt proves what one responder signed. Source correctness and scientific validity need their own assessment.

  • A token points at bytes held somewhere. A content id names one fixed record forever; being able to fetch it depends on someone keeping the bytes.

  • A place name resolves to one 10 m cell. Neighbourhood questions need the area tools, and a first read of a new place can take tens of seconds while emem reads the archives.

  • Time series are sparse. At one warm cell geo.qa measured 38 NDVI readings over three years, about 12.7 a year: enough for a direction, not for a full phenology curve.

  • One responder signs, not a network. A receipt never claims consensus.

  • Notes are public and permanent. Encoding a file never uploads it; publishing a note does. Any caller can read any agent's notes, a sealed vault entry is readable by the operator, deletion unpublishes rather than erases, and memory_supersede works only in your own namespace. Encrypt client-side for anything private (PRIVACY.md).

Version 2.4.6, a patch on the 2.4.0 minor. The receipt preimage last changed in 2.0.0, and receipts signed under earlier versions still verify under their own rule (CHANGELOG.md). Next: docs/roadmap.md.

Learn more

When you want to

Go

the long form: what a record promises, A2A and the channel, the agent card, security, every limit

docs/emem-in-depth.md

why it matters: robot fleets, satellite tasking, agent swarms, compaction

emem in depth, what breaks without it

see it work in ten minutes

tutorial, agent walkthroughs

follow one request end to end, with live consoles

emem.dev/how-it-works

wire your agent in

agent guide, skills, connect a client

put it on a machine

machines that ask emem where they are, emem-airgap, federation

check the trust model, formally

whitepaper, protocol, formal model, security, verifier spec

read the full API

/openapi.json, /mcp/full, all tools, the wire spec

use it for evals, and what is unmeasured

benchmarks with methods, how emem compares, roadmap

Citation

Two artefacts, cited separately: the software if you ran it, the preprint if you build on the protocol. GitHub's Cite this repository button reads CITATION.cff, which carries both.

@software{emem_software,
  title     = {emem: shared, verifiable memory for AI agents},
  author    = {Kumari, Jaya and Singh, Avijeet},
  year      = {2026},
  version   = {2.4.6},
  url       = {https://github.com/Vortx-AI/emem},
  license   = {Apache-2.0},
  publisher = {Vortx AI Private Limited}
}

@misc{emem2026,
  title     = {emem: A research on Content-Addressed, Verifiable Earth-Memory
               Protocol for AI Agents over Foundation-Model Embeddings},
  author    = {Kumari, Jaya and Singh, Avijeet},
  year      = {2026},
  doi       = {10.5281/zenodo.20706893},
  publisher = {Zenodo}
}

The preprint is open (CC-BY-4.0) and not yet peer-reviewed.

Contributing and license

Issues and pull requests welcome: CONTRIBUTING.md, SECURITY.md. Pure Rust, Apache-2.0 (LICENSE, NOTICE). Default data sources are open, with no API keys and no lock-in. A shared memory is worth more the more agents read and write it; if yours use emem, a star helps other builders find it.

Content address

Every section above this one is a unit of one signed tree: emem:tree:omu3zfjzvpb65jn6f44ux452ey, root cjijxfeat7eftjkitxi4inilopfwhaj5l6v3nz4pveelydnd2mka, published under the key k572x7go. A single section is emem:tree:omu3zfjzvpb65jn6f44ux452ey#row=<i>, so another agent can cite one part of this file and anyone can prove it was in the file as published:

curl -s "https://emem.dev/memories/by_attester/k572x7go/readme/tree-20261120d.md" > index.md
curl -s "https://emem.dev/v1/tree/omu3zfjzvpb65jn6f44ux452ey?row=3" > row.json
python3 tools/verifiers/emem-tokenise-files/tree_proof.py check row.json index.md README.md

index.md is the signed note at /memories/by_attester/k572x7go/readme/tree-20261120d.md. python3 scripts/readme_tree_check.py rebuilds the whole tree from this file and compares its root with the index, and CI runs it, so a README edited without re-signing fails the build. The tree changes whenever the README does, and this section is left out of it because it names the tree.

Available Tools

18 tools
emem_askAsk a free-text question about a placeAInspect

Answer a free-text question about a real-world location in one call. Signed satellite, elevation, water and built-up receipts support the answer. The tool sends the place and the question through the locate, recall and algorithm chain on the server, and returns one packaged envelope.

When to use: Call this when the question is about a specific place and the answer must carry its evidence. Send the question as q, with place, cell or lat+lng. Over MCP a point answer is a projection. It has answer, direct_answer (verdict, band, rule, date, limits), receipt (cite receipt.fact_cids), place_resolved, routed_to, context and spatial_trace. It has model_answer if you sent model, and _projection, which names what the projection removed. research_nearby holds pointers to signed research conclusions; read them with emem_inferences. POST /v1/ask has more, such as caveats and reasoning. A past date never gets the newest reading. Send context.context_id as context_id to continue a thread. For how X changed, use emem_intent did_change or emem_diff.

Example arguments: {"q":"is this neighbourhood flood-prone for a flat purchase","place":"Ashok Nagar, Ranchi"}

Inputs: q (required), lat, lng, cell, +9 more. Returns: cell, _means, answer, schema, +2 more

emem_echo_verifyCheck a value against the fact it cites, before you publish itA
Read-onlyIdempotent
Inspect

Grade a value that you will emit against the signed fact that your citation cites. The tool returns matches. When the value does not match, it also returns the drift between your value and the value in emem. This step catches a transcription error that would otherwise be a silent wrong number. A model can resolve a fact correctly and still type 0.2411 for 0.241103. No other step in the loop sees this. Memory algebra: the verify operation (https://emem.dev/docs/model.html).

When to use: Call this immediately before you publish, log or pass on a value from an emem fact. Treat a false matches as a stop, not a warning. Use value_verbatim from resolve: quote that exact decimal string, then echo-verify the text you emitted. For a due-diligence or compliance record, this gives a signed check for each citation. Then you can state every cited value was echo-verified. The tool also accepts a bare cid, so a damaged citation still gets a grade.

Example arguments: {"token":"emem:fact:defi.zb572.xoso.zb1ec:4qj3l4mgh7ch5kvxmkqspjdl6y42oqhm42khh3gostccpixkbz5q","claimed_value":"-0.0522"}

Inputs: token (required), claimed_value (required), strict. Returns: drift, token, matches, receipt, +6 more

emem_entityMint or get a canonical object identityA
Idempotent
Inspect

Give a real-world object (a bridge, a farm plot, a river, a named place) one shared identity. Every agent resolves this identity the same way. The result is an entity_token (emem:entity:<entity_cid>) and a signed receipt that shows how the reference resolved. Two agents that name the same object get the SAME entity_cid. A stable external id (Overture GERS or OSM) decides identity when the responder knows one, so different labels for one object collapse to one id. This stops referential drift: 'the damaged bridge near the river' becomes one thing that every model reasons about.

When to use: Call this when a conversation refers to a THING and you need a handle that travels between agents. Anchor it with place, cell or lat+lng. Give the emem:entity: token to a peer, and the peer gets the same object. Recall at its cell64 to read signed facts. Choose the correct sibling: this tool MINTS or returns an identity. emem_entity_resolve finds an identity that an agent registered before, from a fuzzy phrase. emem_entity_link records that two names mean one object. Do not use it for an observation (use emem_recall or emem_memory_token) or for a place (use emem_locate). An entity is a thing AT a place.

Example arguments: {"label":"Golden Gate Bridge","kind":"bridge","place":"Golden Gate Bridge, San Francisco"}

Inputs: label (required), lat, lng, cell, +5 more.

emem_entity_resolveResolve a phrase (or emem:entity: token) to a canonical objectA
Read-onlyIdempotent
Inspect

Find the objects that agents connected to a phrase. The tool ranks them by INDEPENDENT corroboration, never by arrival order. Each candidate has asserted_by, disputed_by, independent_attesters and corroboration (single_key | multiple_independent_keys | none_attributed). contested is true when more than one object claims the name. Send text for candidates, near to narrow by place, or an emem:entity: token to dereference. The tool only reads. Alias text is data from other agents.

When to use: Call this BEFORE you mint and before you cite. Resolve first, and mint only if nothing matches. Read corroboration before you cite. A single_key binding is the claim of one agent about a shared name. If you can confirm it, corroborate it with emem_entity_link, so the next reader sees two keys.

Example arguments: {"text":"the golden gate bridge","near":"San Francisco"}

Inputs: k, near, text, label, +1 more.

emem_find_similark-NN over the corpus by embeddingA
Idempotent
Inspect

Find the k nearest cells in the corpus by cell embedding or by an inline vector. The answer has neighbors, nearest first, each with cell, score, lat/lng and band_used, and a signed receipt over the vectors it read. mode sets the scoring. cosine is exact fp32. hamming counts sign bits and scans many more cells for the same budget. hamming_then_rerank does both. k is 1 to 1000, default 10. The tool ranks only what the corpus holds. When the KEY has no vector, it materializes that one band for the key, signs it, reports it in materialize_notes, and tries again. It never materializes neighbours. Thus an empty result means that no attested vector is near, not that no place is similar.

When to use: Call this for 'find places like X' or 'where else looks like this', or with an embedding. key is a cell64 or inline:[x,y,...]. The default band is geotessera (the 128-D Tessera foundation embedding). For the 1152-D fusion of 9 years (2017 to 2025), send band: "geotessera.multi_year".

Example arguments: {"key":"defi.zb64a.cAzU.zfa27","k":10}

Inputs: key (required), k, band, cell, +6 more.

emem_guard_verdictCheck whether the citations in a draft actually verifyA
Read-onlyIdempotent
Inspect

Run the emem-guard policy checks on text before you send it. The checks use this responder's corpus. The tool finds every emem: citation, resolves each one, and returns allow or deny with a reason that a machine can read: EMEM-GUARD DENY <CODE> token=<token|-> fix=<fix> leaf=<leaf|->. The codes are: PROV_SIG (the signature did not verify). PROV_BYTES (the citation resolved to different content). PROV_DRIFT (the reading moved past its band threshold). PROV_VALUE (a stated value does not agree with the cited fact). CLAIM_UNGROUNDED (a measurable claim has no citation; turn it on with claim_gating). fix tells you what to do: refresh_token, remove_reference, contact_admin, cite_observation, correct_value. Only a self-hosted guard returns GEO_ZONE and redact_and_retry. This tool is ADVISORY: it blocks nothing. A citation that this responder does not hold is never a denial, because it can be a citation from another responder. Memory algebra: the verify operation (https://emem.dev/docs/model.html).

When to use: Call it on your draft before you assert something, or on a tool result before you reason on it. Then you can fix a citation that does not resolve. With claim_gating: true, it also names measurable claims with no citation, and the band that answers each. For a payload from another framework (CloudEvent, OPA input, OpenAI moderations body, a tool call from another server), send it unchanged and name its shape. The default reader reads only texts, and a check that read nothing answers allow. To ENFORCE the policy, use emem_guard_selfhost. It returns the procedure for your own node.

Example arguments: {"texts":["Lusail ground sits at 2.6 m per emem:fact:defi.zb521.jawI.gOze:f3yr3urkrfwamlemwadulgth2qpw645vi6l6fhtuu4dy5o7onahq"]}

Inputs: agent, shape, texts, claim_gating. Returns: fix, code, claim, action, +6 more

emem_intentIntent-routed plannerAInspect

State what you want in one typed object and get the answer. You do not choose a primitive. type selects the intent AND the other fields that the tool reads. Send only the fields in its row. The plan runs in the same call: you get results, not a list of calls.

type | needs | optional | answers where_is | description | | cell64 for a named place what_is_here | cell OR place | description | what is attested at a location is_like | a, b | | cosine similarity of two cells did_change | cell, band, window | | delta for one band over [start,end] tslots find_like | key | k, filter | nearest cells by embedding confirm | claim, cell | | verdict and the signed facts behind it ask | description | place/cell/lat+lng | free-text question, packaged answer area_over_time | geometry, bbox OR areas; start_date, end_date | index, max_scenes | index of an area for each overpass, with spread and anomaly

An unknown or missing type returns a needs_intent_type envelope with the valid values. It is not a hard error.

When to use: Call this when the question matches one of the eight rows and you prefer to state the goal. Otherwise call the primitive. A band at a cell is emem_recall. A region is emem_recall_polygon. A free-text question about a place is emem_ask (type:"ask" sends it there). window takes tslots, not dates: get them from emem_trajectory. areas puts up to 6 areas on one chart. You can call a tool that this text names but your list does not show, by name, through tools/call.

Example arguments: {"type":"did_change","cell":"defi.zb64a.cAzU.zfa27","band":"indices.ndvi","window":[20245,20620]}

Inputs: type (required), a, b, k, +17 more.

emem_locateResolve place to cell64 + band inventoryA
Read-onlyIdempotent
Inspect

Get the canonical address (cell64) of a real-world place. Every agent resolves a place to the same cell64, so two models refer to the same ground. The answer also lists, by topic, the bands and algorithms that you can recall there. For an OBJECT identity (a bridge, a plot) instead of a cell, use emem_entity. Send lat+lng as numbers, or a free-text place. When both arrive, the coordinates win. q, query and name are other names for place. The answer lists keys that this schema does not declare in _unrecognised_arguments, so a typo is visible.

When to use: Call this when the next step needs the cell64 of a named place, or the bands that exist there. data_at_this_cell lists every band you can recall, by topic (live_bands_by_topic), the recipes that use them (algorithms_for_topic), and the bands with no materializer here. It has research_nearby when vouched research agents signed conclusions inside the place. Read those with emem_inferences before you recompute them. For one packaged answer in one call, use emem_ask.

Example arguments: {"place":"Mount Everest"}

Inputs: q, lat, lng, name, +2 more. Returns: next, cell64, status, selected, +3 more

emem_memory_bundleCompose a signed multi-fact memory bundleA
Idempotent
Inspect

Combine N (cell, band, tslot?) triples into ONE signed envelope. Each triple goes through the standard recall path, which materializes on a miss. The tool puts the resulting fact_cids in a content-addressed envelope, and the responder signs the full receipt. The bundle_token is emem:bundle:<bundle_cid>: one string that cites the full set. Memory algebra: the merge operation (https://emem.dev/docs/model.html).

When to use: Call this when you must cite several (place, band, date) facts as one handle. You can verify the bundle offline with /v1/verify_receipt. The receipt covers all the cited fact_cids and cells. Use this instead of N calls to emem_memory_token when the citation is one thing. An example is "the EUDR baseline for these 8 plots at 2020-12-31". The limit is 256 triples for each call. The answer gives members and resolved, so you can see a bundle that resolved only in part.

Example arguments: {"triples":[{"cell":"defi.zb4d9.pefa.zf619","band":"copdem30m.elevation_mean"},{"cell":"defi.zb493.xoso.zcb6a","band":"indices.ndvi"}],"purpose":"audit baseline 2026"}

Inputs: scope, purpose, triples, fact_cids.

emem_memory_contradictionsScan for multi-attester disagreementA
Read-onlyIdempotent
Inspect

Find where the corpus DISAGREES with itself (algebra: competing evidence). Two or more independent sources can sign different values for the same place, band and time. This tool returns that disagreement with a severity from 0 to 1 and a citation for each disputed fact. It does not pick one value and hide the conflict. It tells you when not to trust a single answer. Read the SCOPE before you quote a zero. By default it counts two kinds: two DIFFERENT attesters that disagree, and one responder that answers from two upstreams. disagreement_scope names the kind.

When to use: Call this before you rely on a number: 'do the sources agree on X', 'audit this claim'. Use cell_prefix for a region and band for one band family. min_severity removes small differences. Severity depends on the band kind: for a scalar, the spread over the band's range. For a vector, 1 minus the mean cosine. For a category, 1 minus the share of the mode. On a single-responder node, add include_same_attester_sources: true. There, the most likely disagreement is one signer that answers from two providers. Each record names its disagreement_scope. The receipt cites every disputed cid. To measure a pair, use emem_diff. To read the disagrees_with edge, use emem_edges_recall.

Example arguments: {"cell_prefix":"damO","band":"indices.ndvi","min_severity":0.2}

Inputs: band, cell, limit, cell64, +5 more.

emem_memory_tokenCompose a memory_token citation handleA
Read-onlyIdempotent
Inspect

Make a citation handle, emem:fact:<cell64>:<fact_cid> (or :<state_cid>). Any agent or LLM resolves it to the same signed object, byte for byte. Give this one string to another agent instead of a new description of the fact. The tool checks that both parts are not empty and do not contain the : separator. Memory algebra: the cite operation (https://emem.dev/docs/model.html).

When to use: Call this when you need one string that cites a place and an attested fact across messages, agents or tools. Use emem_echo_verify before you publish the value. FOR MANY FACTS, USE emem_memory_bundle. This is a measured result. A token is 83 to 84 characters and 51 LLM tokens. The value it cites is 11 characters and 5.4 tokens on average. Thus N tokens use about 9.5 times the context of the N numbers. A bundle is 38 characters for any N up to 256, and it resolves in one round trip. It costs less than tokens from N=1, and less than the plain values from N=5. Use one token to cite ONE fact that you must verify later.

Example arguments: {"cell":"defi.zb493.xoso.zcb6a","fact_cid":"cxjiu7l54ujzrpnekp24n4534yojpue4mprddbvevnqtti3lh5bq"}

Inputs: cell (required), fact_cid (required), band, observed_on. Returns: cell, docs, grammar, fact_cid, +2 more

emem_memory_token_resolveDereference a memory_token in one round-tripA
Read-onlyIdempotent
Inspect

Read a emem:fact:<cell64>:<fact_cid> citation handle and return the reading that it cites. value, unit, band and kind are at the TOP level of the answer, beside the full signed fact body. You do not split the token or call GET /v1/facts/<cid> yourself. Memory algebra: the resolve operation (https://emem.dev/docs/model.html).

When to use: Call this when you have a memory_token from another agent or an earlier turn and need the value. For a scalar, quote value_verbatim, the exact decimal string that the responder signed. A null value or unit means the fact has none (an absence, or an index with no unit). It does not mean a missing field. A cid that this responder does not hold returns a typed 404. Then try /v1/fetch, or resolve at a mirror.

Example arguments: {"token":"emem:fact:defi.zb493.xoso.zcb6a:cxjiu7l54ujzrpnekp24n4534yojpue4mprddbvevnqtti3lh5bq"}

Inputs: token (required). Returns: band, cell, kind, unit, +6 more

emem_recallRecall facts at a cell (auto-materializes on miss)A
Idempotent
Inspect

Read the signed facts at a canonical address (cell64). When a band has no fact yet but has a registered materializer, the responder fetches it. A fact_cid names one signed attestation, so you can cite a fact and verify it again. Resolve the cid anywhere and you get the same bytes. A fact_cid is NOT a fingerprint of the observation. The digest includes the responder's key and the time it signed. Thus two responders that measure the same thing make different fact_cids, and a cid resolves only at the responder that signed it. For identity across responders, use emem_entity. Send deterministic:true (or a provenance class list) to keep only facts that you can compute from the cited raw source. In the memory algebra this is ensure(cell, bands), not get: you state what must exist.

When to use: Call this after emem_locate, or with a cell64 or a place name. It returns every Primary fact at that (cell, band, tslot). A band can have no fact but have a materializer. Then the responder fetches the upstream value, signs it, stores it and returns it in the same call. The first call is slow; later calls use the cache. Thus any wired band recalls at any cell on Earth: send bands: [<band>]. materialize_notes lists what the call fetched. Empty notes mean no materializer here.

Example arguments: {"cell":"defi.zb64a.cAzU.zfa27","bands":["weather.temperature_2m","copdem30m.elevation_mean"]}

Inputs: cell (required), lat, lng, band, +10 more. Returns: facts, receipt, fact_order, current_by_band, +2 more

emem_toolsWhat tools exist here, and when to reach for eachA
Read-onlyIdempotent
Inspect

The map of emem's tools, and the one tool that finds all the others. It gives the working loop in order (name, ground, cite, resolve, verify, check for drift). Then it groups every other tool by the question it answers, each with a one-line trigger. Send name for the full schema of one tool and an example that runs. IF YOU SEE A LIST OF 18 TOOLS, IT IS A CURATED SUBSET OF 119, NOT THE FULL SURFACE. Hosts remove _meta, so this text repeats the count. A host that calls only listed tools refuses the rest: connect /mcp/full and follow nextCursor, or use listed_route.

When to use: Call this FIRST when you do not know which tool answers the question. Also call it when your list does not have a capability. A tool that is not in your list can still be on the server. q searches by topic (ndvi, flood, verify). name returns one exact schema. With no arguments, you get the full map. /mcp/full registers the full catalog. emem_ask answers in one call without a choice of primitive.

Example arguments: {"q":"ndvi"}

Inputs: q, name, tier, shape, +2 more.

emem_verify_receiptServer-side ed25519 receipt verifierA
Read-onlyIdempotent
Inspect

Verify a signed receipt on the server. The tool builds the canonical preimage again, under the rule that the receipt's preimage_version names. It checks the ed25519 signature with the embedded key. It returns {valid, reason, failure_detail, signature_valid, merkle_proof_valid, signer_pubkey_b32, preimage_blake3_hex}. A receipt verifies BYTE FOR BYTE OR NOT AT ALL. Version 2 binds the inclusion proof, so a change of any kind makes the signature fail: a dropped field, a renamed field, a summary. Use this tool when the browser page /verify is not available. Also use it to audit a receipt from a third party.

When to use: Send the receipt EXACTLY as the read tool returned it, complete and unchanged. Two omissions cause a false forgery, not a 400. Do not drop merkle_proof. Do not drop preimage_version. Without it the value is 0, which selects the v0 rule, and the signature reads as invalid. The signature and the key can be byte arrays, or sig_b32 and responder_pubkey_b32. The tool accepts no other names. When a field changed after signing, the answer is reason: receipt_reshaped_after_signing and names the field. To require a specific signer, set pubkey_b32. A bad signature returns 200 with valid: false, never a 4xx. The example (from emem_tools) is a real receipt over two Trafalgar Square facts. Unchanged, it is valid. Change one byte, and it is not.

Example arguments: 1602 bytes, too long to inline in a listing. Call emem_tools with {"name": "emem_verify_receipt"} for it whole and runnable; it is not shortened here because a truncated example is not one.

Inputs: receipt (required), facts, pubkey_b32, current_responder_epoch.

fetchOpen one search result and read the signed recordA
Idempotent
Inspect

Dereference an id from search. You get the reading in one line, then the signed body, the URL that serves those bytes, and metadata: cell, band, signing time and key. The id can be an emem:fact: citation, a bare fact_cid, or an emem:cell: handle for a full cell. The value is the exact decimal string that the responder signed, never a new format. A fact handle writes nothing. A cell handle, like emem_recall, MATERIALIZES a missing band on a cold cell: it fetches, signs and stores it. The flags follow that path: readOnlyHint false.

When to use: Call this on each result that you will cite, before you quote the number. Quote the one-line reading. The body lets a reader check it, and emem_echo_verify grades what you emit against it. When a body is too large, the answer says so and gives the URL that serves it complete.

Example arguments: {"id":"emem:fact:defi.zb493.xoso.zcb6a:cxjiu7l54ujzrpnekp24n4534yojpue4mprddbvevnqtti3lh5bq"}

Inputs: id (required). Returns: id, url, text, title, +1 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 18 tools

    Disambiguation3/5

    The core lifecycle tools are distinct, but several boundaries overlap: emem_ask, search, fetch and emem_recall all retrieve signed facts, while fetch and emem_memory_token_resolve both dereference fact citations. emem_intent and emem_tools are meta-wrappers that can route to the same operations, so descriptions help but do not eliminate misselection risk.

    Naming Consistency4/5

    Most tools use a predictable emem_ snake_case prefix, and the names are readable despite mixing noun- and verb-oriented forms. The two unprefixed tools, search and fetch, are clear exceptions that slightly break the pattern.

    Tool Count3/5

    Eighteen tools is heavy for a listed MCP surface, especially when it includes both primitive operations and multiple high-level wrappers such as emem_ask, emem_intent and emem_tools. The breadth is justified by the domain, but the set feels borderline over-scoped rather than tightly curated.

    Completeness3/5

    The citation lifecycle is well covered: locate, recall, mint tokens, bundle, resolve, verify and guard. However, the listed surface omits several primitives explicitly referenced by the descriptions, such as trajectory, polygon recall, diff, edges and inferences, so agents may hit dead ends unless they can access /mcp/full.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers