{"id":"io.github.Vortx-AI/emem","slug":"io-github-vortx-ai-emem","title":"emem, the verifiable memory protocol for the physical world","description":"Shared, verifiable memory for machines and AI. Encode where data lives; decode with any AI.","version":"2.4.5","publisher":{"kind":"github","id":"Vortx-AI","label":"@Vortx-AI on GitHub","url":"https://github.com/Vortx-AI"},"website":"https://emem.dev","repository":"https://github.com/Vortx-AI/emem","remotes":[{"type":"streamable-http","url":"https://emem.dev/mcp"}],"packages":[{"registryType":"oci","identifier":"ghcr.io/vortx-ai/emem:latest","runtimeHint":"docker","transport":{"type":"streamable-http","url":"http://localhost:5051/mcp"},"environmentVariables":[{"description":"PaaS port convention: the container entrypoint binds 0.0.0.0:$PORT when EMEM_BIND is not set explicitly. Falls back to 5051.","name":"PORT"},{"description":"Bind address for the HTTP server. When unset, the entrypoint derives it from PORT, falling back to 0.0.0.0:5051.","value":"0.0.0.0:5051","name":"EMEM_BIND"},{"description":"Path to the persistent data directory (sled cache + ed25519 identity). Mount a volume here; on managed platforms that mount /data, set EMEM_DATA=/data.","value":"/var/emem","name":"EMEM_DATA"},{"description":"Optional canonical origin for self-referencing URLs in MCP responses (e.g. https://emem.dev). When unset the server falls back to urn:emem.","name":"EMEM_PUBLIC_URL"},{"description":"Comma-separated hostnames for built-in Let's Encrypt ACME (TLS-ALPN-01). When set, the server binds 0.0.0.0:443 instead of EMEM_BIND.","name":"EMEM_TLS_DOMAINS"}]}],"published":"2026-11-07","updated":"2026-11-07","status":"online","auth":"","latency_ms":901,"checked":"2026-11-19","uptime":100,"checks":3,"tools":[{"name":"emem_entity","title":"Mint or get a canonical object identity","description":"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 resp","read_only":false},{"name":"emem_locate","title":"Resolve place to cell64 + band inventory","description":"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. ","read_only":true},{"name":"emem_recall","title":"Recall facts at a cell (auto-materializes on miss)","description":"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. Th","read_only":false},{"name":"emem_memory_token","title":"Compose a memory_token citation handle","description":"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).\n\nWhen to use: C","read_only":true},{"name":"emem_memory_token_resolve","title":"Dereference a memory_token in one round-trip","description":"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).\n\nWhen to use: Call this when you have a memory_token from","read_only":true},{"name":"emem_verify_receipt","title":"Server-side ed25519 receipt verifier","description":"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","read_only":true},{"name":"emem_memory_contradictions","title":"Scan for multi-attester disagreement","description":"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","read_only":true},{"name":"emem_guard_verdict","title":"Check whether the citations in a draft actually verify","description":"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).","read_only":true},{"name":"emem_tools","title":"What tools exist here, and when to reach for each","description":"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 SURFA","read_only":true},{"name":"emem_ask","title":"Ask a free-text question about a place","description":"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.\n\nWhen to use: Call this when the question is about a specific place and the answer must carry its evidence. Send th","read_only":false},{"name":"search","title":"Find signed facts for a place, as citable sources","description":"Search emem's signed corpus and get results as citations. Each entry is one signed fact. It has an `id` to dereference, a `title` with band, place and signed value, and a stable `url` that serves those bytes. The query can be a place or a question about one. ('NDVI near Mount Fuji': a topic word narrows the results and never removes all of them.) It can also be a cell64, an `emem:cell:` handle, or","read_only":false},{"name":"fetch","title":"Open one search result and read the signed record","description":"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, l","read_only":false},{"name":"emem_echo_verify","title":"Check a value against the fact it cites, before you publish it","description":"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 loo","read_only":true},{"name":"emem_memory_bundle","title":"Compose a signed multi-fact memory bundle","description":"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","read_only":false},{"name":"emem_entity_resolve","title":"Resolve a phrase (or emem:entity: token) to a canonical object","description":"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 plac","read_only":true},{"name":"emem_entity_link","title":"Attest that a phrasing/id denotes an existing object","description":"Record a signed, ATTRIBUTED claim that a label or an external id (GERS, OSM, Wikidata) names an existing object. With `stance: \"disputes\"`, record that it does not. This is a write to the shared space: it changes what other agents resolve. The responder stores it with your key, limits the rate for each key, and weighs it by how many INDEPENDENT keys agree. Every reader sees the binding of one key ","read_only":false},{"name":"emem_find_similar","title":"k-NN over the corpus by embedding","description":"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, defau","read_only":false},{"name":"emem_intent","title":"Intent-routed planner","description":"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.\n\ntype | needs | optional | answers\nwhere_is | description | | cell64 for a named place\nwhat_is_here | cell OR place | description | what i","read_only":false}],"server_info":{"name":"emem","version":"2.4.5"},"category":"memory","tags":["crypto","web-search"],"kind":"remote","source":"registry","submitted":{},"first_party":false,"domain_rank":null,"score":100,"indexable":true,"first_seen":"2026-04-28","stars":0,"badges":[],"sponsor":null,"page":"https://agentsindex.org/agents/io-github-vortx-ai-emem/"}