Mnemom

by mnemom

367 downloads

Not rated

GitHub

About

Trust ratings for AI agents and websites. Look up an agent's reputation, scan a site's AI-trust-readiness, and verify signed scorecards in-band — reads are zero-auth. From Mnemom, the trust layer for the agent internet.

Details

Author: mnemom
Downloads: 367
Categories: Other, Security

- 15 curated tools across reputation, scanning, identity, and orientation groups
- Ed25519‑signed scorecards verifiable in‑band or with the published JWKS
- Zero‑auth reads – no key or login needed for lookups
- OAuth 2.0 with Dynamic Client Registration + PKCE for writes
- Website trust readiness scanning via the scan_trust tool
- Agent identity claiming and alignment card publishing

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Mnemom

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

From the repository

Connect a compliant MCP client (Claude, ChatGPT, etc.) to the Streamable‑HTTP endpoint https://api.mnemom.ai/mcp?profile=directory. Reads are anonymous and require no authentication; write operations (claiming an agent, publishing an alignment card) require OAuth 2.0 with Dynamic Client Registration + PKCE or an X-Mnemom-Api-Key header.

`claim_agent`

Claim a verifiable identity — bind an agent to your organization so its trust and accountability record is provably yours. No human in the loop.

`get_agent`

Look up an agent's public identity and trust state by ID — the accountable record other agents and humans can rely on.

`get_reputation`

Look up an AI agent's published Trust Rating — Mnemom's portable reliability signal for autonomous software, computed from the agent's own verified activity record. Returns the rating plus the technical factors behind it. Free, public, read-only: every registered agent's rating is published by standard (the `visibility` field is the reputation-publication axis, distinct from identity-record visibility).

`get_reputation_badge`

Get an embeddable Trust Rating badge for an agent — returns the badge image URL plus ready-to-paste Markdown and HTML snippets for a README or agent card.

`get_started`

Zero-auth, no-args orientation: who Mnemom is, the surface map, how to authenticate and what it unlocks, and the value tools to try right now (headlining scan_trust + the reputation reads).

`list_agents`

List your agents — List all agents owned by the authenticated user. Supports pagination.

`preview_compose_alignment_by_agent`

Preview composed alignment (dry run) — Composes the cascade against a hypothetical body at the agent layer and returns conflicts + the composed view. No DB writes. Used by the dashboard editor for live conflict markers.

`preview_compose_protection_by_agent`

Preview composed protection (dry run) — Composes the cascade against a hypothetical body at the agent layer and returns conflicts + the composed view. No DB writes. Used by the dashboard editor for live conflict markers.

`put_alignment_by_agent`

Publish or replace the alignment manifest — Accepts YAML (`text/yaml`, `application/yaml`) or JSON. Body is the full `UnifiedAlignmentCard`; server-side composition merges it across the platform → org → team → agent cascade and writes the canonical composed card. Requires `Idempotency-Key`. Honor...

`put_protection_by_agent`

Publish or replace the protection manifest — Accepts YAML (`text/yaml`, `application/yaml`) or JSON. Body is the full `UnifiedProtectionCard`; server-side composition merges it across the platform → org → team → agent cascade and writes the canonical composed card. Requires `Idempotency-Key`. Hon...

`report_recipe_fn_fp`

Submit a false-positive / false-negative correction for one of Mnemom's automated detection rules (a 'recipe') — technical feedback that improves detection accuracy, like filing a bug report against a spam filter.

`scan_trust`

Scan a website's agent-trust-readiness and return a signed scorecard (Trust, plus an Access axis on newer rubrics). Zero-auth. Results are CACHED for up to 24h — check `cached` and `scannedAt` on the result; pass `fresh: true` to force a re-scan (rate-limited). Proxies to the SSRF-locked isittrustready scanner; the Ed25519 signature + permalink are preserved verbatim. Rubric + docs: https://www.isittrustready.ai/rubric and https://docs.mnemom.ai/.

`search_reputation_directory`

Resolve an agent name or id-prefix to a real agent_id over the PUBLIC reputation directory (only agents whose reputation visibility is public). Zero-auth. The arriving-agent entry point: discover a concrete agent_id, then call get_reputation / verify_reputation on it.

`verify_reputation`

Attest an agent's Trust Rating — returns a Merkle-root + hash-chain attestation (hash_chain_valid) proving the rating derives from an unbroken, append-only checkpoint chain, plus a pointer to the signed integrity certificate. This is a chain-integrity attestation, NOT an in-band Ed25519 signature check (that parity is verify_scan, for website scorecards).

`verify_scan`

Verify a website scan scorecard's Ed25519 signature IN-BAND (verify, don't trust). Pass a `scan` (a scorecard from scan_trust) or a `url` to re-scan; returns {verified, key_id, canonicalization} checked against the public key at mnemom://iitr/jwks. Zero-auth. Spec + rubric: https://www.isittrustready.ai/rubric and https://docs.mnemom.ai/.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mnemom": {
            "mnemom": {
                "command": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://api.mnemom.ai/mcp?profile=directory"
                ]
            }
        }
    }
}

McpServers

{
    "mnemom": {
        "command": "npx",
        "args": [
            "-y",
            "mcp-remote",
            "https://api.mnemom.ai/mcp?profile=directory"
        ]
    }
}

Mnemom — Trust Ratings for AI Agents (MCP server)

Canonical home for the Mnemom Model Context Protocol (MCP) server — trust
infrastructure for the agent internet. Look up a verifiable Trust Rating for
an AI agent, scan a website's AI-trust-readiness, verify signed
scorecards in‑band, claim an agent identity, and publish an alignment card.

This repo is the public, canonical source of truth for the server's connection
details and manifest. The server implementation runs on Mnemom's platform; this
repo is its metadata + documentation home.

- Website: https://www.mnemom.ai · for agents: https://www.mnemom.ai/for-agents
- Docs: https://docs.mnemom.ai
- Rubric (isittrustready): https://www.isittrustready.ai/rubric
- Official MCP registry: io.github.mnemom/mnemom
- Maintainer: support@mnemom.ai

Connect

Streamable‑HTTP MCP endpoint (curated directory profile, 15 tools):

https://api.mnemom.ai/mcp?profile=directory

The full manifest is in server.json.

In Claude / ChatGPT / any MCP client

Add a custom connector pointing at the URL above. Reads are anonymous — you
can list tools and call the reputation, search, scan, verify, and get‑started
tools with no account. Writes (claiming an agent, publishing an alignment
card) require authentication.

Authentication

- Reads: zero‑auth. No key, no login.
- Writes: OAuth 2.0 with Dynamic Client Registration (RFC 7591) + PKCE.
Discovery follows RFC 9728 — an unauthenticated write returns 401 with a
WWW‑Authenticate header pointing at the Protected Resource Metadata, so a
compliant client can self‑configure:
- Protected Resource Metadata: https://api.mnemom.ai/.well-known/oauth-protected-resource/mcp
- Authorization Server Metadata: https://api.mnemom.ai/.well-known/oauth-authorization-server
- An X-Mnemom-Api-Key header is accepted as an alternative to OAuth.

What's in the directory profile

A curated 15‑tool surface, grouped:

- Reputation — get_reputation, get_reputation_badge, get_risk_history,
search_reputation_directory, verify_reputation, list_agents, get_agent
- Website trust scanning — scan_trust, verify_scan
- Identity & declarations — claim_agent, preview_compose_alignment_by_agent,
put_alignment_by_agent, report_recipe_fn_fp
- Orientation — get_started

The default endpoint (/mcp, no profile) exposes the full power‑user tool
surface; ?profile=directory is the curated face used for directory listings.

Verify, don't trust

Scan scorecards are Ed25519‑signed. Verify any scorecard in‑band with the
verify_scan tool, or check the signature yourself against the published key:

- Scanner JWKS: mnemom://iitr/jwks (also at the isittrustready surface)
- The scorecard carries a self‑describing verification block (algorithm, key
id, canonicalization rule) so a holder can reconstruct and check the signature.

Links

| | |
|---|---|
| Website | https://www.mnemom.ai |
| For agents | https://www.mnemom.ai/for-agents |
| Documentation | https://docs.mnemom.ai |
| Trust‑readiness rubric | https://www.isittrustready.ai/rubric |
| Contact | support@mnemom.ai |

---

© Mnemom. The server implementation is operated by Mnemom; this repository is its
public manifest and documentation home.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

claim_agent

get_agent

get_reputation

get_reputation_badge

get_started

list_agents

preview_compose_alignment_by_agent

preview_compose_protection_by_agent

put_alignment_by_agent

put_protection_by_agent

report_recipe_fn_fp

scan_trust

search_reputation_directory

verify_reputation

verify_scan

Claude Desktop / Cursor

McpServers

Mnemom — Trust Ratings for AI Agents (MCP server)

Connect

In Claude / ChatGPT / any MCP client

Authentication

What's in the directory profile

Verify, don't trust

Links

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀

`claim_agent`

`get_agent`

`get_reputation`

`get_reputation_badge`

`get_started`

`list_agents`

`preview_compose_alignment_by_agent`

`preview_compose_protection_by_agent`

`put_alignment_by_agent`

`put_protection_by_agent`

`report_recipe_fn_fp`

`scan_trust`

`search_reputation_directory`

`verify_reputation`

`verify_scan`