Mnemo

Verify every embedding
before it is used.

Trust and provenance for AI systems.

Attach identity to every embedding and verify it when it is used. Works with your existing system. Two calls to get started.

Start building See it in action

Use via API or run inside your infrastructure.

One SDK

Two calls. embed and verify.

Store-agnostic

The watermarked vector is a plain array of numbers. Store it anywhere that returns it unchanged. No native connectors.

Agent ready

Verify embedding provenance for $0.01 per check with no account required. Pay with x402 on Base or MPP on Tempo.

Drop-in

Works alongside your existing model and store.

01Where Mnemo sits

Between your embedding model and your system.

On insert, Mnemo attaches an identity to the embedding. On retrieval, your services confirm the embedding resolves to one your pipeline issued. Works with your existing system.

input

embed

store

retrieve

verify

Two integration points: embed() and verify(). Storage is optional. No vector database required.

02Use cases

If you generate embeddings, Mnemo applies.

RAG

Verified retrieval over your knowledge base.

Recommendations

Per-account vector_uids for product and user vectors.

Agents

Trust between agents and the data they read.

Content provenance

Identity at the embedding layer, under C2PA.

Semantic search

A registration check on retrieved results.

Fraud detection

Verified embeddings under fraud decisions.

Threat intelligence

Tenant-scoped verification for shared intel stores.

Regulated AI

Embedding-level evidence for review.

03Setup

Two calls. Works with your existing system.

Install the Python SDK. Wrap your embedding step with embed() and store the watermarked_vector it returns. Wrap your retrieval step with verify(). Your model and your storage stay where they are.

Mnemo is the embedding-vector provenance and verification API at trymnemo.com. The official Python distribution is mnemo-protocol, imported as mnemo_sdk, and the official GitHub organization is MnemoProtocol.

pip install mnemo-protocol

SDK docs · PyPI: mnemo-protocol · GitHub: MnemoProtocol/mnemo-sdk · OpenAPI

Start building See it in action

import os
from mnemo_sdk import MnemoClient

client = MnemoClient(api_key=os.environ["MNEMO_API_KEY"])

# on insert
vec = model.embed(doc)
r = client.embed(vec, model_id="text-embedding-3-small")
store.upsert(r.vector_uid, r.watermarked_vector)

# on retrieve
for hit in store.query(q, top_k=5):
    check = client.verify(hit.values)  # None if not verified
    if check is not None and check.verified:
        ctx.append(hit)

04Scope

What Mnemo does not do.

Does not detect prompt injection

Does not analyze model weights

Does not moderate content

Does not replace your system

Mnemo focuses on one layer: attaching identity to embeddings and verifying them when they are used.

Mnemo Verify checks whether a submitted vector resolves to an object registered to the caller's Mnemo account or namespace. verified=false is a safe outcome, not an error, and not proof that a vector is foreign. Verify does not establish the truth, authorship or ownership of the content behind a vector.

05In brief

What Mnemo is, and when to use it.

What it is: Mnemo is an HTTP API at https://api.trymnemo.com for embedding-vector provenance. Embed registers a vector to your account or namespace and returns a watermarked copy plus a vector_uid. Verify checks whether a vector resolves to one of your registered objects. Lineage reads the verified parents you named at embed time.
Provenance: In Mnemo, provenance means a vector resolves to a vector_uid that Mnemo issued at embed time and that is still attributable to the account or namespace that issued it. It is not similarity or proximity.
Problem it solves: A nearest-neighbour search can say a vector is close to something; it cannot say whether a vector you hold was issued by your own pipeline. Mnemo answers that narrower question for vectors you embedded through Mnemo, for example retrieved vectors before you use them, and records verified derivations between your own objects.
Use it when: You produce or store embeddings and later need to check whether a vector you hold was issued to your own account or namespace, or need to record and read a verified parent-to-child derivation.
Not for: Vectors never embedded through Mnemo (there is no retroactive coverage). Vectors issued to another account or namespace: verify cannot check another party's vectors. Similarity search or storage: Mnemo is not a vector database. Judging truth, authorship, ownership or the source model. Keeping data in an accountless namespace past its expiry: it is purged unless promoted. EEA, UK or Swiss personal data over accountless machine payments. There is no public MCP server; use the HTTP API.
Embed: POST /v1/embed takes your vector and a model_id (a label you declare). It returns vector_uid and watermarked_vector, a measurably perturbed watermarked copy of your input that carries the identity. Store and use that copy instead of the original.
Verify: Mnemo Verify checks whether a submitted vector resolves to an object registered to the caller's Mnemo account or namespace. POST /v1/verify returns verified, confidence, vector_uid (null when not verified) and policy_ok; decide on verified. verified=false is a normal, charged result: attribution could not be shown. It is not an error and not proof that the vector is foreign.
Lineage: Embed may name one parent you own (parent: vector_uid, relation, vector). Mnemo verifies the parent before it creates the child. GET /v1/lineage/{vector_uid} re-verifies every link on each read and returns the chain, or 409 when a link no longer verifies. Lineage records which parent you named; it does not say what the transformation did or whether it was faithful.
API key or no account: With an account, send X-API-Key: calls use the account's subscription plan or free trial and never use machine payments. When the plan has no verifications left, verify answers 402 insufficient_credits with no payment challenge. The Python SDK (pip install mnemo-protocol, import mnemo_sdk) covers embed and verify on this path. Without an account, an agent creates a short-lived namespace with POST /v1/agent/namespaces (up to 72 hours), sends its capability as X-Mnemo-Capability, embeds and reads lineage free, and pays $0.01 per verify with x402 on Base or MPP on Tempo, or funds a 500-verification burst for $5 (x402, Tempo or a card via Stripe).
Does not prove: That content is true, who authored or owns it, that a file or document is authentic, or which model produced a vector. Mnemo is not universal tamper detection.

Agent protocol (complete contract): /agent-protocol.md · Protocol repository: github.com/MnemoProtocol/mnemo-agent-protocol · OpenAPI 3.1: /openapi.json · llms.txt

Start verifying in minutes.

Create a workspace, register a service, issue a credential, and run your first verified embedding. Start with a 30-day free trial.

Start building See it in action

Questions? Read the FAQ →

Verify every embeddingbefore it is used.

Between your embedding model and your system.

If you generate embeddings, Mnemo applies.

Two calls. Works with your existing system.

What Mnemo does not do.

What Mnemo is, and when to use it.

Start verifying in minutes.

Verify every embedding
before it is used.