DABBLE ME PRO

Dabble Me MCP Server

Connect your private journal to ChatGPT, Claude, and other MCP-compatible AI assistants.

Dabble Me is an AI journal with MCP: a remote Model Context Protocol server for people looking for a journal app for ChatGPT, a Claude journal integration, a personal journal MCP server, or a journal app for AI reflection.

Your journal, available when you ask

Model Context Protocol (MCP) is an open standard that lets an AI client use narrowly defined tools from another service. After you connect Dabble Me, you can ask your AI assistant to retrieve selected journal entries, look for themes, summarize a period, or save a new reflection. The assistant chooses a Dabble Me tool, and Dabble Me applies it only to the account you authorized.

Dabble Me does not train an AI model on your journal.

When you ask a connected AI assistant to read entries, the requested content is sent to that AI provider for processing under its terms and privacy policy. Connect only clients you trust and revoke access at any time.

Supported clients

Dabble Me uses remote Streamable HTTP plus OAuth 2.0. It works with clients that support that MCP transport, OAuth authorization-code flow with PKCE, and dynamic client registration.

Client Connection Notes
Claude Custom remote connector Claude web, Desktop, mobile, and Cowork use the same cloud-hosted connector.
ChatGPT Developer-mode app Available on paid ChatGPT plans with Developer mode enabled; workspace policies may restrict it.
MCP Inspector Streamable HTTP Useful for developers testing discovery, OAuth, and tool calls.
Other MCP clients Remote Streamable HTTP The client must support OAuth-protected remote MCP servers.

Setup instructions

Before connecting

  1. Sign in to a Dabble Me account with an active PRO subscription.
  2. Enable a passkey or two-factor authentication in Account security.
  3. Copy the remote MCP endpoint:

https://dabble.me/mcp

Connect Claude

  1. Open Claude and go to Settings → Connectors. On an individual plan, select Add custom connector. Team and Enterprise workspaces require an owner to add it first.
  2. Name the connector Dabble Me and paste https://dabble.me/mcp as the remote MCP server URL.
  3. Finish adding the connector, select Connect, and sign in to Dabble Me in the browser window.
  4. Review the requested read/write permission and approve access.
  5. Enable Dabble Me in a conversation, then try one of the prompts on this page.

Claude’s interface changes over time. See Anthropic’s current remote connector guide.

Connect ChatGPT

  1. In ChatGPT on the web, open Settings → Security and login and enable Developer mode.
  2. Open Settings → Plugins (called apps or connectors in some interfaces) and create a developer-mode app.
  3. Use Dabble Me as the name, explain that it reads and writes the signed-in user’s private journal, and paste https://dabble.me/mcp as the MCP server URL.
  4. Choose OAuth when asked, complete the browser sign-in, and approve access.
  5. Start a conversation in Developer mode with the Dabble Me app enabled.

Custom MCP apps require an eligible paid ChatGPT plan, and organization administrators may disable them. See OpenAI’s current Developer mode guide.

Connect another MCP client

Add https://dabble.me/mcp as a remote Streamable HTTP server. Let the client discover the OAuth metadata, register as a public client, open the authorization page, and exchange the authorization code using PKCE. No API key or client secret is required.

Authentication and privacy

OAuth 2.0 + PKCE

You sign in on Dabble Me’s own domain and approve the mcp:access scope. Dabble Me never asks you to paste your password into the AI client.

Account-bound access

The OAuth token identifies one Dabble Me user. User IDs are not accepted as tool arguments, so a client cannot switch the journal it is querying.

Strong account security

Tool calls require Dabble Me PRO plus a passkey or two-factor authentication. Access is also blocked while account deletion is pending.

Revocable access

Review and disconnect clients under Account security → Connected apps. Downgrading from PRO also revokes MCP access.

Available MCP tools

These names and descriptions come from the same metadata exposed to MCP clients.

Search journal entries

search_entries

Find text in the signed-in user’s private Dabble Me journal. Use for requests such as “find every time I mentioned burnout,” searching a quoted phrase, or finding a topic within an inclusive date range. Returns matching entry dates, excerpts, hashtags, and image presence; never searches another user’s journal.

Arguments

query (required)
— Required keyword, topic, or quoted phrase to find in entry text. Examples: burnout, "new job", gratitude.
start_date
— Optional YYYY-MM-DD inclusive start date.
end_date
— Optional YYYY-MM-DD inclusive end date.
limit
— Maximum matching entries to return (1–50; default 50). total_matches still reports the full count.

List journal entries

list_entries

Read the signed-in user’s private Dabble Me journal entries newest first, optionally within an inclusive date range. Use when the user asks to review a period such as last week or last month without requiring a keyword.

Arguments

start_date
— Optional YYYY-MM-DD inclusive start date.
end_date
— Optional YYYY-MM-DD inclusive end date.
limit
— Maximum entries to return (1–50; default 50). total_entries reports the full count in the date range.

Analyze journal patterns

analyze_entries

Summarize patterns in the signed-in user’s private Dabble Me journal over an optional inclusive date range. Returns entry counts, year coverage, top hashtags, average words per entry, and sample highlights for reflection requests such as “summarize my journaling habits this year.”

Arguments

start_date
— Optional YYYY-MM-DD inclusive start date.
end_date
— Optional YYYY-MM-DD inclusive end date.

Prepare a journal image upload

get_image_upload_url

Prepare one image for a new Dabble Me journal entry. Returns a short-lived presigned PUT URL, required headers, and an uploaded_image_key. Upload the user-provided bytes to that URL, then pass the key to create_entry. Prefer this flow over base64 for local images.

Arguments

filename
— Original image filename, used only to choose a safe extension. Example: photo.jpg.
content_type (required)
— Image MIME type for the upload, e.g. image/jpeg, image/png, image/webp, image/heic.

Create or append a journal entry

create_entry

Write to the signed-in user’s private Dabble Me journal on a calendar day (default: today in the account timezone). Plain text becomes paragraphs. By default, text appends to an existing entry on that day; set merge_with_existing false to fail instead. Optionally attach one image using uploaded_image_key (preferred), a public HTTPS image URL, or small base64 data.

Arguments

date
— Optional YYYY-MM-DD; omitted means today in the account timezone.
body (required)
— Entry text (plain text; line breaks become paragraphs). HTML is escaped. Use an empty string for an image-only entry when image_url or image_base64 is set.
merge_with_existing
— When true (default), append to the existing entry for this date if one exists. When false, return an error if the date is already taken.
image_url
— Optional https URL of an image to attach (one image per call). Fetched by the server; private/loopback hosts are rejected. In production, only https URLs are accepted.
uploaded_image_key
— Preferred image attachment flow. First call get_image_upload_url, upload the image bytes with the returned PUT URL and headers, then pass the returned uploaded_image_key here. Do not combine with image_url or image_base64.
image_base64
— Optional image as base64: either a data URL (data:image/png;base64,...) or raw base64 bytes. Resize the image to fit within 800x800 before encoding. If raw, set image_mime_type (e.g. image/png) or it defaults to image/jpeg.
image_mime_type
— When image_base64 is raw (not a data URL), MIME type of the decoded bytes, e.g. image/png or image/jpeg.

Permissions and behavior

Capability Read or write What happens
search_entriesReadReturns matching excerpts, dates, hashtags, and image presence.
list_entriesReadReturns entries in a requested date range, newest first.
analyze_entriesReadComputes counts, date coverage, top hashtags, and writing-volume summaries.
get_image_upload_urlPrepare writeCreates a short-lived URL for one user-selected journal image.
create_entryWriteCreates an entry or, by default, appends to an existing entry on the same day.

There is no delete-entry tool. Dabble Me marks tools with MCP read-only, destructive, idempotent, and open-world annotations so compatible clients can present appropriate confirmation behavior.

Real example prompts

Ask naturally. The client decides which Dabble Me tools to call.

Reflect on a month

“Summarize my journal entries from last month. What themes kept coming up?”

Find a recurring topic

“Find every time I mentioned burnout and show how the language changed over time.”

Review a year

“How often did I journal this year? What hashtags did I use most?”

Recall a memory

“What did I write about my trip to Iceland? Include dates and short excerpts.”

Look for progress

“Search my journal for running and summarize the milestones I recorded.”

Compare periods

“List entries from January and June, then compare what I was focused on.”

Save a reflection

“Add this to today's journal: I felt calmer after taking a long walk.”

Create a dated entry

“Create a journal entry for July 17, 2026: Dinner with old friends reminded me how much I value staying connected.”

Technical metadata

Server name
dabble-me
Endpoint
https://dabble.me/mcp
Transport
Streamable HTTP; JSON-RPC requests use POST
Authentication
OAuth 2.0 authorization code, PKCE S256, public clients, refresh tokens
OAuth scope
mcp:access — read and create journal entries on your behalf
Tool result limit
Up to 50 entries per search/list call; aggregate analysis samples up to 500 entries
Write behavior
Create or append only; no MCP delete tool

The official registry manifest is maintained as server.json in the public source repository.

Frequently asked questions

What can the Dabble Me MCP server do?

It lets an MCP-compatible AI assistant search, list, analyze, and create entries in the journal belonging to the person who approved OAuth access.

Can ChatGPT connect to Dabble Me?

Yes. ChatGPT paid plans that include Developer mode can add Dabble Me as a remote MCP app using the Dabble Me MCP endpoint.

Can Claude connect to Dabble Me?

Yes. Add Dabble Me as a custom remote connector in Claude and complete the Dabble Me OAuth approval flow.

Can the connector read another user's journal?

No. OAuth binds every tool call to the signed-in Dabble Me account. Tool arguments cannot select another user.

Choose the journal workflow that fits

Compare remote, email-first Dabble Me with a local Mac journal, or review the current MCP journaling options.