MCP server

emem, the verifiable memory protocol for the physical world

io.github.Vortx-AI/emem

Checked 25 Oct 2026, 20:29 UTC · Connected to it and listed its tools

Shared, verifiable memory for machines and AI. Encode where data lives; decode with any AI.

Website Source

At a glance

Type

MCP server

Publisher

Not verified

Status

Working at last check

Tools

18

Token cost

About 15,363 tokens per request

Sets up in

Claude Code, Claude Desktop, Codex, Gemini CLI, Cursor, VS Code, Antigravity, ChatGPT, OpenAI API, Grok

Last checked

25 Oct 2026, 20:29 UTC

Connect it to your agent

Add to CursorAdd to VS CodeVS Code Insiders

Opens the app, which shows the server and asks you to confirm. For other apps, copy the setup below.

Claude Code

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

Claude Desktop

Settings → Connectors → Add custom connector, and paste the URL.

Codex (config.toml)

[mcp_servers.emem]
url = "https://emem.dev/mcp"

Gemini CLI

{"mcpServers":{"emem":{"httpUrl":"https://emem.dev/mcp"}}}

Cursor

{"mcpServers":{"emem":{"url":"https://emem.dev/mcp"}}}

VS Code

{"servers":{"emem":{"type":"http","url":"https://emem.dev/mcp"}}}

Antigravity

agy mcp add emem https://emem.dev/mcp

ChatGPT

Settings → Apps & Connectors → Advanced settings: turn on Developer mode, then Create a connector and paste the URL. Which plans can do this varies.

OpenAI API (Responses tools)

{"type":"mcp","server_label":"emem","server_url":"https://emem.dev/mcp","require_approval":"always"}

Grok (xAI API tools)

{"type":"mcp","server_label":"emem","server_url":"https://emem.dev/mcp"}

Tools

• emem_ask ~1148 tokens
  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: C
• emem_echo_verify ~765 tokens
  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
• emem_entity ~866 tokens
  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
• emem_entity_link ~580 tokens
  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 e
• emem_entity_resolve ~436 tokens
  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
• emem_find_similar ~983 tokens
  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 a
• emem_guard_verdict ~1089 tokens
  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 ar
• emem_intent ~1991 tokens
  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 whe
• emem_locate ~554 tokens
  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 eme
• emem_memory_bundle ~785 tokens
  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:<bundl
• emem_memory_contradictions ~986 tokens
  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 an
• emem_memory_token ~645 tokens
  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 `:`
• emem_memory_token_resolve ~322 tokens
  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` ope
• emem_recall ~1598 tokens
  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
• emem_tools ~1037 tokens
  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
• emem_verify_receipt ~882 tokens
  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,
• fetch ~347 tokens
  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
• search ~349 tokens
  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 nar

Browse

• GitHub tools
• Hiring and jobs
• GitHub and code hosting
• Speech to text
• Searching your documents (RAG)

Related MCP servers

• emem, shared verifiable memory (MCP server)
  Verifiable memory for AI agents, checkable offline
• Physical Capability Cloud
  Discover, hire, and verify real-world physical capability through MCP.
• TestGraph
  Shared semantic graph for AI reviews, classification and structured memory across AI assistants.
• Innovalyxx Sovereign Edge
  Verified cyber-physical AI tools. 25 MCP tools, x402-payable on Base.
• Googleapis
  Provides capabilities that let LLM agents perform a range of infrastructure management tasks.
• Apex Edge — x402-paid machine services
  x402-paid MCP tools: utils, audit screens, corpus search, inference. USDC Base+Solana.
• Agent Cloud Tools
  Free no-signup cloud tools for AI agents: file transfer, static site hosting, memory, handoff.
• Senlay Physical Context
  Physical-world evidence and operability checks with provenance and explicit data gaps.

Badge for your README

[![AptLynx](https://aptlynx.net/badge/io.github.Vortx-AI/emem.svg)](https://aptlynx.net/servers/io.github.Vortx-AI/emem)

Listing text is written by the maker; AptLynx lists tools and does not vouch for them. Find another tool · Browse by topic · For agents