Obsideo MCP server
One line: Obsideo MCP server gives an agent durable, client-side-encrypted object storage on a 3-provider network, with provable possession checks plus account, quota, and billing management.
Store objects —
puta local file or inline content, encrypted client-side (AES-256-GCM) by default;encrypt: falsefor plaintext S3 interop.Retrieve objects —
getan object, auto-decrypted with the local key, returned inline or written to a local path (overwrites).List objects —
ls, optionally filtered by key prefix.Delete objects —
rmby key.Prove storage —
verifychallenges each provider on a random chunk and checks answers locally against the upload-time merkle root, without downloading the object.Instant no-email account —
trialprovisions a 100 MB, ~7-day account via proof-of-work (auto-created on first use anyway).Upgrade to a real account —
signup_start+signup_verifyemail a 6-digit code for 8 GB free, claiming an existing trial in place (same keys/data, higher quota).Check usage —
usageshows storage consumed vs quota.Check plan —
planshows free tier or paid blocks, status, period end, pending offers (read-only, no Stripe contact).Request paid capacity —
upgradereturns a Stripe checkout link for N x 200 GB blocks at $5/mo each; charges nothing, human pays.Manage billing —
portalreturns a Stripe portal link to cancel, change card, or download invoices.Back up keys —
backup_keysarchives credentials, signing key, encryption key, and upload commitments to a destination you supply (no default; refuses without one), since Obsideo holds no copy of the encryption key.
Provides tools for upgrading storage plans via Stripe checkout (upgrade) and managing subscriptions via the Stripe customer portal (portal), enabling payment for additional storage blocks and handling billing, cancellation, and invoices.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Obsideo MCP server store my database backup in Obsideo"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.pemprivate. Re-running signup rotates credentials and the keypair with no overlap, so do not re-run casually.Encrypted by default.
putencrypts 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. Passencrypt: falseonly 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-mcpIt 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 |
| 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 |
| 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 |
| Complete signup or the claim. A new account generates the signing keypair locally and stores credentials; a claim changes nothing but the quota |
| Store a file or inline content, encrypted client-side by default ( |
| Retrieve an object (auto-decrypts with the local key) |
| List objects, optionally by prefix |
| Delete an object |
| Prove the network still holds an object, without downloading it |
| Storage used vs quota, plus the plan line |
| 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 |
| Free tier or paid blocks, status, period end, any offer waiting for the human |
| Stripe checkout link for N x 200 GB blocks. Charges nothing; the human pays on Stripe's page. Never changes an existing plan |
| 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 toolsbackup_keysBack up the credentials and encryption keyAIdempotent
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 objectADestructive
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 objectsBRead-only
List stored objects (size TAB key), optionally under a prefix.
Inputs: prefix.
planShow the paid planARead-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 linkAIdempotent
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 objectADestructive
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 objectCDestructiveIdempotent
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)ADestructive
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 planAIdempotent
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 usageARead-only
Show account storage usage versus quota.
Inputs: no named parameters.
verifyProve an object is really stored (client-side)ARead-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
Scored across 13 tools
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.
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.
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.
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
Related MCP Connectors
Private, permanent encrypted storage for AI agents. Paid per call in USDC via x402.
MCP-native Trust Infrastructure for AI Agents. Persistent encrypted memory with Trust Quotient.
Document hosting and encrypted agent memory with multi-tenant persistence.
Agent-native storage with cryptographic verification on Solana. Keyless: clients sign and pay.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP-powered storage system for AI agents that provides IPFS-secured, verifiable, and sovereign data storage capabilities.-
- FlicenseNot gradedqualityDmaintenanceSovereign E2E cloud storage for AI agents. MCP-native, zero-knowledge, RGPD-compliant, built in France.-
- AlicenseNot gradedqualityDmaintenanceProvides encrypted, portable memory for AI agents via MCP, allowing fact storage, conversation recall, and cross-machine sync using Arweave.50MIT
- AlicenseNot gradedqualityDmaintenanceAgent-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