Skip to main content
Glama
Obsideo MCP server

Obsideo MCP server

by Regan-Milne

Obsideo MCP server

Give any MCP-capable agent (Claude Desktop, Claude Code, Cursor, Cline, ...) durable storage that is encrypted on your machine before it is uploaded and that you can independently prove is still held. Zero setup: the first put/get/ls auto-creates a free no-email trial account (100 MB, proof-of-work instead of identity), so storage just works with nothing to configure. Want more? Self-serve signup from inside the conversation upgrades to 8 GB free, no card, no CAPTCHA, no expiry; 16 GB after the account holder answers eight questions in the Drive web app.

Obsideo is S3-compatible object storage where every stored object is replicated to 3 providers and challenged with chunk-level merkle proofs on a continuous cycle; providers are paid only for proofs they pass. 8 GB free with an email, no card; 16 GB after eight questions in the Drive web app. Paid plans are 200 GB blocks at $5/month each by card (Stripe), started from the upgrade tool and paid on Stripe's own page; the plan never changes size without the human's agreement.

Privacy posture (read this first)

  • This server runs on YOUR machine. Obsideo never hosts it. Credentials, the account signing key, and the encryption key live in ~/.obsideo/ and are sent nowhere except the endpoints they authenticate against.

  • The account signing key is generated locally; only the public half is ever sent. Keep ~/.obsideo/signing.pem private. Re-running signup rotates credentials and the keypair with no overlap, so do not re-run casually.

  • Encrypted by default. put encrypts client-side (AES-256-GCM) with a locally generated, user-held key before anything leaves the machine, so the platform stores ciphertext it is architecturally incapable of reading. Pass encrypt: false only when another tool must read the stored bytes directly (S3 interop).

Back up your key

The encryption key is generated on your machine when the account is created and written to ~/.obsideo/mcp.json. Obsideo does not have a copy and cannot recover it. If that file is lost, every encrypted object is permanently unreadable, no matter how many providers still hold it and how many proofs it passes. Replication protects against providers losing your bytes; it does not protect against you losing your key. Call backup_keys with a destination right after signup and keep the archive somewhere you would still have after losing this machine. Encrypted objects are readable only with this key: there is no sharing of encrypted objects between people or machines today, so treat an account as one person's.

~/.obsideo/roots.json is written alongside it: the merkle root of each object as committed at upload time. It holds no secrets, and it is what lets verify prove providers hold your bytes without re-uploading them. Encryption uses a fresh IV per upload, so ciphertext cannot be recomputed from a plaintext file later; this record is what keeps the strong proof available for encrypted objects. Losing it costs you strength of proof, not data. If it is damaged, the server moves it aside unchanged and says so in the next result, rather than overwriting it.

Related MCP server: serac

Install

Claude Desktop, one click: download obsideo-mcp.mcpb from the latest release, then Settings -> Extensions and drag the file in. No Node or npm setup needed.

Everything else, via npx:

{
  "mcpServers": {
    "obsideo": {
      "command": "npx",
      "args": ["-y", "obsideo-mcp"]
    }
  }
}

(Claude Desktop: claude_desktop_config.json. Claude Code: claude mcp add obsideo -- npx -y obsideo-mcp. Cursor/Cline: their MCP settings, same command.)

Hermes Agent: paste https://obsideo.io/agent-storage to your Hermes and say "set this up". That page is a runbook the agent executes: install, first store, first proof, then the free tier (8 GB) with your email. The install it runs is one command on any OS (Node 18 or newer is required for npx):

hermes mcp add obsideo --command npx --args -y obsideo-mcp

It writes the server into Hermes's own config, connects, lists the 13 tools and asks which to enable (leave out rm if you would rather the agent had no delete tool). Then /reload-mcp in a running session, or start a new one. The tools appear as mcp_obsideo_put, mcp_obsideo_get, mcp_obsideo_verify and so on. Manual alternative: the same mcpServers block as above, under the mcp_servers: key of Hermes's config.yaml. First thing to try: ask Hermes to store its own MEMORY.md on obsideo, then to verify it.

Tools

Tool

What it does

trial

Create an instant no-email account (100 MB, ~7 days, proof-of-work, no human needed). Usually unnecessary: storage tools auto-create one on first use

signup_start

Email a 6-digit code (8 GB free; real inboxes only, refusals are labeled). With a trial configured this claims it in place: same account, keys and data, quota rises

signup_verify

Complete signup or the claim. A new account generates the signing keypair locally and stores credentials; a claim changes nothing but the quota

put

Store a file or inline content, encrypted client-side by default (encrypt: false opts out). Auto-creates a trial account if none is configured

get

Retrieve an object (auto-decrypts with the local key)

ls

List objects, optionally by prefix

rm

Delete an object

verify

Prove the network still holds an object, without downloading it

usage

Storage used vs quota, plus the plan line

backup_keys

Copy credentials, signing key, encryption key and upload commitments to a destination you give it (a .tar.gz path or a folder). No default: without a destination it refuses. Obsideo has no copy of the key

plan

Free tier or paid blocks, status, period end, any offer waiting for the human

upgrade

Stripe checkout link for N x 200 GB blocks. Charges nothing; the human pays on Stripe's page. Never changes an existing plan

portal

Stripe portal link: cancel, change card, invoices

Paying, and what an agent is allowed to do

upgrade returns a link. That is all it does. The human opens it, sees the exact monthly amount, and pays or closes the tab; the quota rises after payment. An existing plan is never resized from this server: near the top of a tier Obsideo emails an agree link, and the human's click is the only thing that changes the bill. portal returns the Stripe portal link for cancelling, changing the card and downloading invoices. Cancelling keeps everything stored and readable; the account returns to its free quota at the end of the paid period.

verify

Challenges every provider holding the object directly, on one randomly chosen chunk each, and compares each answer on this machine against a merkle root. For objects this server uploaded, that is the root recorded locally at upload time, so a pass means the provider holds your bytes rather than agreeing with the others. Objects uploaded elsewhere can be checked against a file you pass as local_path. With neither, it falls back to the coordinator's root and says so.

The coordinator still chooses which providers to ask and where to reach them, issues the challenge tokens, and lists the public keys that providers' signatures are checked against. The result states which of these it relied on. When a provider fails the proof or cannot be challenged, the result says so first and speaks only for the providers that passed.

What it is good for

App file storage, automated backups (databases, snapshots, state), agent artifacts and memory that must survive sessions and machines, provable offsite copies. Not a CDN, not a queryable database, not sub-millisecond storage; Obsideo stores objects and backup artifacts.

Full integration contract (per-step postconditions, error table): obsideo.io/agents.md

Transport

From 0.7.0, put / get / ls / rm talk to the coordinator and to the storage providers it names, the same path verify has always used. There is no S3 gateway hop and no wait for freshly minted credentials to propagate: the account's coordinator API key is valid the moment signup returns, so the first put after signup works at once (measured 0.8 s on production). Configs that predate the coordinator key, or OBSIDEO_TRANSPORT=s3, keep using the S3 gateway with the SigV4 keypair; nothing about stored objects changes between the two, and the same S3 credentials still work with rclone, boto3 and any other S3 client.

Verified

Every tool in this server is exercised end to end against production before release: a freshly minted trial, then an encrypted put / byte-exact get / ls / rm over the direct transport (test/e2e_prod.mjs, which identifies itself so it is excluded from funnel measurement), plus labeled-error passthrough from the signup service. Unit tests run the transport against mock coordinator and provider servers (npm test).

License

PolyForm Shield 1.0.0 from version 0.6.2 (see LICENSE). In plain terms: you may use, read, audit, modify and redistribute this server for any purpose except building a product or service that competes with Obsideo. That keeps the client auditable, which the product depends on, without handing the work to a competitor. Versions 0.6.1 and earlier remain under MIT as published. The storage provider node (obsideo-provider) is and stays MIT.

Privacy Policy

This extension runs entirely on your machine. Credentials, your account signing key, and any client-side encryption key are stored locally in ~/.obsideo/mcp.json and are never sent to or hosted by Obsideo. Conversation content from your AI assistant is not collected; only the tool calls you make (for example an upload) reach the storage service.

Full policy: https://obsideo.io/privacy/

Available Tools

13 tools
backup_keysBack up the credentials and encryption keyA
Idempotent

Copy everything needed to recover this account's data (credentials, account signing key, encryption key, upload commitments) to a destination: one you are already authorized to use for backups, or one your human names. Obsideo holds no copy of the encryption key: if the local file is lost, encrypted objects are unrecoverable no matter how many providers hold them. Until this has been run, the only copy is on this machine, so it is worth running once after the account is created and again after any signup that rotates keys. A .tar.gz path produces one archive; a directory path produces plain copies. With no destination it refuses rather than choosing one.

Inputs: destination.

getRetrieve an objectA
Destructive

Retrieve an object. Encrypted objects (the default for anything stored through this server) are decrypted automatically with the local key; retrieval from a machine without that key will fail, which is the intended property. Small text objects return inline; pass local_path for anything else. WRITES TO DISK: passing local_path writes the bytes to that path and overwrites any existing file there, so treat it as a write operation and confirm the path with your human first.

Inputs: key (required), local_path.

lsList stored objectsB
Read-only

List stored objects (size TAB key), optionally under a prefix.

Inputs: prefix.

planShow the paid planA
Read-only

Show the account's plan: free tier or paid blocks (200 GB per block, $5/month each), status, period end, and any upgrade offer waiting for the human's agreement. Never changes anything and never contacts Stripe.

Inputs: no named parameters.

portalGet the billing portal linkA
Idempotent

Get the Stripe Customer Portal link for a paid plan: cancel, change card, download invoices. For the human to open. Cancelling keeps everything stored and readable; the account returns to its free quota at the end of the paid period.

Inputs: no named parameters.

putStore an objectA
Destructive

Store a local file or inline content as an object. ENCRYPTED BY DEFAULT: the bytes are encrypted client-side with AES-256-GCM using a locally generated, user-held key before they leave the machine, so the platform stores ciphertext it cannot read. The key lives only in the local config file and Obsideo has no copy: if the user loses it the data is unrecoverable, so tell them to back it up. Pass encrypt=false only when another tool must read the stored bytes directly (S3 interop); that stores plaintext. Zero-byte objects are rejected. Objects are replicated to 3 providers and verified on a continuous cryptographic challenge cycle. The first call on a fresh machine also creates the account and can take 20 to 50 seconds; progress is reported while it runs. Encrypted objects are readable only with this machine's key: there is no cross-user sharing of encrypted objects.

Inputs: key (required), content, encrypt, local_path.

rmDelete an objectC
DestructiveIdempotent

Delete an object by key.

Inputs: key (required).

signup_startStart Obsideo signup (or claim the trial)A

Start Obsideo signup: emails a 6-digit verification code (8 GB free, no card, no expiry; 16 GB after the account holder answers eight questions in the Drive web app). If a no-email trial is configured on this machine, this CLAIMS it in place: same account, bucket, keys and data, only the quota rises. Otherwise it creates a new account for the email. Use a real inbox you or your human can read; documentation placeholders and disposable domains are refused with labeled errors. Then call signup_verify.

Inputs: email (required), source, abandon_trial.

signup_verifyComplete Obsideo signupA

Complete signup with the emailed code. When claiming a trial, nothing but the quota and the identity changes (credentials stay valid, no propagation wait). For a new account, generates the Ed25519 account signing keypair locally (only the public half is sent) and stores S3 credentials in ~/.obsideo/mcp.json; re-running that path rotates credentials and keypair with no overlap, so do not re-run to retry.

Inputs: code (required), email (required).

trialCreate an instant trial account (no email)A
Destructive

Create a free Obsideo account with no email and no human in the loop: a small proof-of-work and a ~10 second wait in place of identity. Returns a real account on the production network (100 MB, about 7 days, RF=3 replication, continuous possession proofs) and saves credentials locally. You usually do NOT need to call this: the first put/get/ls/usage auto-creates a trial if no account is configured. Call it to provision explicitly. To keep data beyond the trial, claim it with an email via signup_start (same account and data, quota rises to 8 GB free with no card and no expiry; 16 GB after the account holder answers eight questions in the Drive web app). Takes about 15 to 30 seconds (proof of work plus a 10 second issuance window); progress is reported while it runs.

Inputs: source, replace.

upgradeGet a checkout link for a paid planA
Idempotent

Get a Stripe-hosted checkout link for a paid plan of N x 200 GB blocks at $5/month per block. This tool charges NOTHING and changes nothing: the human opens the link and pays on Stripe's page, and the quota rises after payment. Call it only when the human has asked for more space, and hand the link back to them; do not open or submit it yourself. If the account already has a paid plan this returns the plan instead (plan size is never changed from here; only the human's click on Obsideo's emailed agree link does that).

Inputs: blocks.

usageShow storage usageA
Read-only

Show account storage usage versus quota.

Inputs: no named parameters.

verifyProve an object is really stored (client-side)A
Read-only

Independently verify that the network still holds an object, without downloading it. Challenges each provider directly and compares every answer, on this machine, against a merkle root. For objects stored through this server, that root is the one this machine recorded at upload time, if the local record still has it. Pass local_path (your copy of the stored file) to compare against a root computed from that file instead. If neither is available, it falls back to the coordinator's recorded root and says so. The coordinator chooses which providers to ask, where to reach them, and the public keys their signatures are checked against, and issues the challenge tokens. Each provider is challenged on one randomly chosen chunk. Returns how many providers proved possession right now, how many of those answers were signed, and whether any returned bad data.

Inputs: key (required), local_path.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 13 tools

    Disambiguation4/5

    Core object operations (put/get/ls/rm) and verification/backup tools are clearly distinct, and account lifecycle tools separate cleanly along trial vs email signup vs code verification. The only soft overlaps are portal vs upgrade (both mint Stripe links) and plan vs usage (both report account state), and the descriptions do enough to disambiguate them.

    Naming Consistency3/5

    The set mixes terse Unix-style verbs (put, get, ls, rm) with noun-first compounds (signup_start, signup_verify) and noun-only names (plan, portal, usage, trial). Also inconsistent within the same family: signup_start puts the verb second while backup_keys puts it first, so there is no single predictable pattern.

    Tool Count5/5

    13 tools is well inside the sensible range and each one maps to a distinct need: object CRUD, integrity verification, key backup, trial/email signup, usage/plan visibility, and billing links. Nothing looks like a redundant wrapper or an orphan tool.

    Completeness4/5

    Object lifecycle (store, list, retrieve, delete), integrity verification, disaster-recovery backup, and account/quota/billing flows are all covered, so agents won't hit dead ends on core workflows. Gaps are minor: no metadata/stat or copy/move operation, no account deletion or credential-rotation tool exposed outside re-running signup, and no batch operations.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Sovereign E2E cloud storage for AI agents. MCP-native, zero-knowledge, RGPD-compliant, built in France.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Agent-native object storage MCP server with per-agent DID isolation and x402 pay-per-byte metering in real Base USDC, enabling autonomous agents to store and retrieve objects with hot, warm, or cold retention classes.
      MIT