§ docs · connectors

Connect Solomon to an AI assistant

Let Claude, ChatGPT or another MCP client search, read and propose edits to the notes in your synced Solomon vaults, with every change waiting for your review by default.

Server: https://app.lomon.dev/api/mcpTransport: MCP Streamable HTTP · Auth: OAuth 2.1 or agent key

What the connector does

Solomon is a notes app for Mac, iPhone, iPad and the web. Your notes are Markdown files in vaults, and vaults you sync are stored by the Solomon sync service. The Solomon connector is a hosted MCP server that lets an AI assistant work with the notes in your synced vaults: list and read them, search them, query them by their properties, and create or edit notes when you allow it.

By default, nothing an assistant writes changes your notes directly. Each write becomes a proposal that waits for you to accept or reject it in Solomon. See Propose or apply immediately.

Server URL: https://app.lomon.dev/api/mcp (MCP Streamable HTTP).

Before you connect

A Solomon account. Create one at app.lomon.dev.
At least one vault synced to your account from a Solomon app. The connector works on the synced copy, so a note becomes reachable once a Solomon app has synced it, and an edit you accept reaches your devices through sync.
Calls count against your plan's monthly hosted-MCP allowance. Every plan includes one, the free plan too; see pricing.

Connect

From an assistant's connector directory, or as a custom connector

Add Solomon from your assistant's connector directory, or add a custom connector with the URL https://app.lomon.dev/api/mcp.
Sign in to Solomon when the assistant opens the sign-in page.
Review what the connection will be allowed to do, then approve. Its writes are proposed for your review unless you choose otherwise.

The connector uses OAuth 2.1 with PKCE. The assistant never sees your Solomon password; it receives a credential limited to what you granted, which you can revoke at any time.

From an agent or MCP client that takes a key

Mint an agent key at app.lomon.dev/keys, choosing a vault (or your whole account) and a mode: “Stage for review (propose)” or “Apply immediately (force)”. Send it as an Authorization: Bearer header to https://app.lomon.dev/api/mcp. The key is shown once; store it like a password.

Start by asking the assistant to call health, which reports the access the connection has, and vaults, which lists the vaults it can reach.

Propose or apply immediately

Every connection has one of two write modes, chosen when you grant it. When you connect from an assistant's sign-in screen you can also choose read only: the assistant can list, read, search and query your notes, and every write tool is refused.

Propose (the default). Creating a note, rewriting one, appending to it, or setting its properties is staged as a proposal. The note is untouched until you accept the proposal in the Solomon app; rejecting it discards the change. The assistant can list pending proposals but cannot accept or reject them.
Apply immediately (force). Writes are applied as soon as the assistant makes them, and are recorded in the note's history with the assistant as their author.

Some tools only make sense applied directly, so a propose connection is refused when it calls them (code propose_unsupported): base_write, note_edit_section, note_move, note_delete, proposal_accept, proposal_reject.

Under either mode, deleting a note requires the assistant to pass confirm: true, and a deleted note can be recovered because its history is kept. Moving a note keeps its id and history.

Tools

Each tool declares MCP annotations: a title, and whether it is read-only, whether it can replace or remove existing content, and whether it reaches anything outside your vaults (none do). Assistants use these to decide when to ask you before running a tool.

Read

Tool	What it does
`health` Check Connection Status	Says what this connection may do: its write mode (propose or force) and which vaults it is bound to. Read
`vaults` List Vaults	Lists the vaults the connection can reach. Pass a row's id or name as `vault` to any other tool. Read
`notes_list` List Notes	Lists the notes (or `.base` view files) in a vault, newest first. Read
`note_read` Read Note	Reads one note's frontmatter and body by its vault-relative path. Read
`search` Search Notes	Text or regular-expression search over titles and bodies, optionally limited to a folder or a property filter. Read
`base_query` Query Notes with Bases	Filters, sorts, groups and totals notes by their properties with the base query language (reference below). Read
`proposals_list` List Pending Proposals	Lists the changes waiting for a person to accept or reject. Read

Write

Tool	What it does
`note_create` Create Note	Creates a new note. Never overwrites an existing file. Write (additive)
`base_write` Write Base View File	Creates a `.base` view file, or replaces one when `overwrite` is true. Write (can replace or remove) · apply-immediately access only
`note_write` Overwrite Note	Replaces a note's body and/or sets or removes frontmatter keys. Write (can replace or remove)
`note_append` Append to Note	Adds text to the end of a note's body. Write (additive)
`note_edit_section` Edit Note Section	Edits one part of a note in place, addressed by a heading or a unique piece of text. Write (can replace or remove) · apply-immediately access only
`note_set_properties` Set Note Properties	Sets or removes frontmatter properties, including tags. Write (can replace or remove)
`note_move` Move or Rename Note	Moves or renames a note, keeping its id and history. Write (can replace or remove) · apply-immediately access only
`note_delete` Delete Note	Removes a note from every device. Recoverable: its history is kept. Requires `confirm: true`. Write (can replace or remove) · apply-immediately access only
`proposal_accept` Accept Proposal	Applies one waiting change. Refused if the note changed since the change was proposed. Write (can replace or remove) · apply-immediately access only
`proposal_reject` Reject Proposal	Discards one waiting change and returns its content in the result. Write (can replace or remove) · apply-immediately access only

Desktop-only tools

The Solomon desktop app and the local daemon also serve design-document and cloud-pull tools. They cannot run on the hosted server, so it does not list them. An assistant that calls one anyway gets a coded refusal (unsupported_on_host), not “unknown tool”.

Example prompts

“Search my Solomon vault for notes about the Q3 launch and summarize the open questions.”
“Which tasks in Solomon have status active? Group them by project.”
“Read my note Meetings/2026-11-03.md and append a list of action items to it.”
“Create a note in Ideas/ called Reading list with these five books, tagged reading.”
“Show me the changes waiting for my review in Solomon.”

Base query reference

base_query (and search's where argument) use Solomon's base query language. A query is a few lines, one directive per line:

from notes
where status is "active"
where __folder under "Projects"
sort __modified desc
columns title, status, owner
limit 20

where <field> <op> [value]: operators are is, is not, contains, not contains, gt, gte, lt, lte, under (a folder and its subfolders), exists and missing. Several where lines must all match; or inside one line matches either side. Quote values that contain spaces.
Fields are frontmatter keys, plus __title, __path, __folder, __modified, and the computed __words, __size, __tasks_open, __backlinks and __broken_links.
sort <field> [asc|desc], columns a, b, c (up to six), group by <field>, aggregate count(), sum(<field>), view table|list|cards|kanban|graph|stats|chart|outline, and limit <n>. Without sort, rows are newest first.
A mistake in a query comes back as a structured error with the line number, not as a failed call.

To run a view you saved in a .base file, pass its path as base (and optionally a view name) instead of a query.

Limits and what stays private

Notes marked access: private, anything under a _private/ folder, dot-folders, and the top-level Widgets/ folder are never listed, read, searched or written through the connector.
HTML design documents and plugin files stay in the Solomon desktop app; the connector reports them with a coded refusal.
A listing or search that reaches the per-call budget returns what it found so far with truncated: true. Narrow it with a folder (path) or a where filter.
Calls are rate-limited per connection and count against your plan's monthly allowance.

Disconnect or revoke access

Open app.lomon.dev/keys to see every connection and agent key on your account. Revoke ends one; Revoke all ends every one for a vault or for your account. A revoked credential is refused on its next call.

Removing the connector inside your assistant stops that assistant from using it, but revoking it in Solomon is what makes the credential stop working everywhere.

Proposals an assistant already made stay in your review queue until you accept or reject them.

Troubleshooting

The assistant says it is not authorized, or sign-in loops. The credential expired or was revoked. Disconnect and reconnect the connector, or mint a new key.
A note you know exists is not found. Check that a Solomon app has synced it (it appears on your other devices), that it is not private (see Limits), and that the assistant is using the right vault.
An edit did not show up. On a propose connection it is waiting for your review. Ask the assistant to call proposals_list, or open the proposals view in Solomon.

Every refusal carries a code. The common ones:

Code	What it means
`vault_required`	The connection can reach more than one vault and the call did not say which. Ask the assistant to call `vaults` and pass the vault's id or name.
`vault_mismatch`	The call named a vault this connection is not bound to.
`vault_ambiguous`	More than one of your vaults has that name. Pass the vault's id instead.
`propose_unsupported`	The tool applies changes directly and this connection has propose access. Use a proposing tool (for example `note_write` instead of `note_edit_section`), or reconnect with apply-immediately access.
`proposal_stale`	The note changed after the proposal was made, so accepting it would overwrite text it never saw. Ask the assistant to propose the change again.
`exists`	A file is already at that path. Creating never overwrites; choose another path or edit the existing note.
`html_frozen`	The path is an HTML design document, which only the Solomon desktop app can read and edit.
`base_frozen`	The path is a `.base` view file. Note tools never touch one; use `base_write`.
`bad_argument`	An argument is missing or malformed. The error message names the argument and what was expected.
`unsupported_on_host`	The tool exists in the Solomon desktop app or local daemon but cannot run on this server.
`mcp_quota`	The account has used its plan's hosted-MCP allowance for the month. See the pricing page for limits.

Data and privacy

The connector reads and writes only the vaults you granted, and only on the assistant's calls. It does not read your conversations with the assistant, and it receives only the arguments of each tool call. What an assistant does with the notes it reads is governed by that assistant's own terms and privacy policy.

See the Privacy Policy for what Solomon collects and who processes it, and the Terms of Service.

Support

Questions, problems and security reports: david@pnthn.ai. More on the support page.