Snackbar

A personal note store with an MCP front door, so any assistant you're talking to can capture an idea wherever you happen to be.

The problem it solves is narrow and specific: ideas arrive on the couch, on a walk, at a desk that isn't yours — and by the time you're back at the machine where your notes live, they're gone. Snackbar puts the notes somewhere both you and your assistants can reach, and lets whichever assistant is already in the conversation write them down.

It is not a Claude accessory. MCP is cross-vendor, so anything that speaks the protocol can post to it. The store is yours; the assistants are interchangeable front ends.

How it works

Phone / laptop / wherever          this app                Supabase
┌──────────────────────┐      ┌──────────────────┐      ┌──────────┐
│ any MCP-speaking     │─────▶│ /api/mcp         │─────▶│  notes   │
│ assistant            │ HTTP │ bearer token     │      │          │
└──────────────────────┘      │   → author       │      └──────────┘
                              └──────────────────┘

One Next.js route handler, four tools, one table. That's the whole thing.

Per-client bearer tokens double as the author field. Each client — phone, laptop, work machine — gets its own token, so the server knows who wrote a note rather than trusting a self-reported value, and a leaked token revokes one client instead of the whole store.

Notes carry two orthogonal qualifiers. category is the subject (music, code, video…) and is a free-form string the server never rejects — new ones just start appearing in list_categories. type is what the entry is, and is one of idea, memory, or todo. The distinction is load-bearing: category says which shelf, type says what eventually happens to it. A memory stays a note forever; a todo becomes work immediately; an idea waits until it's ripe.

Related MCP server: Notes MCP Server

Tools

Listings return one compact line per note rather than JSON, so reading the whole store costs very little context.

Setup

1. Database. Create a Supabase project, then:

supabase link --project-ref <your-project-ref>
supabase db push

2. Tokens. Generate one per client:

node -e "console.log('snk_phone_'+require('crypto').randomBytes(24).toString('base64url'))"

3. Environment. Copy .env.example to .env.local and fill in:

• SUPABASE_URL — https://<project-ref>.supabase.co

• SUPABASE_SERVICE_ROLE_KEY — the secret key, not the publishable one

• SNACKBAR_TOKENS — JSON object mapping token to author, e.g. {"snk_phone_...":"phone","snk_home_...":"home"}

Adding a client is an env var edit. There is no token table and no admin UI — at this scale that would be more moving parts than the problem deserves.

4. Run it.

npm install
npm run dev

Deploy anywhere that runs Next.js; set the same three variables there.

Connecting a client

The token can travel three ways, and the server accepts all of them:

Claude Code — headers work, so use them:

claude mcp add --transport http snackbar https://<your-deployment>/api/mcp \
  --header "Authorization: Bearer <token>"

claude.ai (managed on desktop web, then usable on mobile) — Settings → Connectors → Add custom connector. The dialog offers a URL and optional OAuth fields, with no way to set a header, and it drops the query string — so the token has to be a path segment:

https://<your-deployment>/api/mcp/<token>

Leave both OAuth fields empty; there is no separate authentication step, because the URL is the credential.

Any other MCP client that speaks Streamable HTTP works with whichever form it can express.

A note on security

Authorization is a bearer token and nothing else — there are no users, no roles, and no sharing. Row Level Security is enabled on the table with zero policies, so the anon key can read nothing; the server holds the service role key and does its own authorization. That means the deployment is exactly as private as its tokens, and a token in a client's config is a token someone with that device can read. Rotate by editing the env var.

This is built for one person's notes. If you fork it for anything with more than one human in it, the auth model is the first thing to replace.

Status

Working, but young. Built with Claude Code as part of an ongoing experiment in working with AI as a development partner — see ai-workshop for the wider setup.