This server provides read-only access to your Quillink notes, folders, tags, and organization info via MCP.
List notes with filters (folder, status, tags, pinned, limit, pagination)
Retrieve a single note by ID
Full-text search across titles and body (locked notes only match on title)
Get aggregate stats (count, storage, pinned count, daily histogram)
List recipients of a note you own
List notes shared with you by others
List folders/notebooks (optionally include trashed)
Get a single folder by ID
List all tags used across your active notes
Get organization details (name, plan tier, seats, alerts) for Team-plan users
List organization members (plain members see only themselves)
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., "@quillink-mcp search my notes for API design"
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.
An MCP server exposing read-only access to your Quillink notes, folders, and tags to AI tools like Claude Desktop, Claude Code, and other MCP-compatible clients.
Requires a Pro Quillink plan (API Access is a Pro-only feature).
Not published to PyPI -- build and run it locally from source.
git clone https://github.com/dagistankaradeniz/gcp-note-taking-mcp.git
cd gcp-note-taking-mcp
python3 -m venv .venv
.venv/bin/pip install -e .This installs the quillink-mcp command into .venv/bin/. Note the full
path to that binary (e.g. /Users/you/gcp-note-taking-mcp/.venv/bin/quillink-mcp)
-- MCP clients launch it directly, not through an activated shell, so
they need the absolute path.
macOS: if you clone the repo under ~/Documents, ~/Desktop, or
~/Downloads, Claude Desktop may fail to launch the server with
"Server disconnected" -- macOS privacy protection (TCC) blocks its child
processes from reading those folders. Either grant Claude Desktop access
to the folder (System Settings -> Privacy & Security -> Files and
Folders), or build the venv outside the protected folders:
python3 -m venv ~/.local/share/quillink-mcp-venv
~/.local/share/quillink-mcp-venv/bin/pip install /path/to/gcp-note-taking-mcp
# then point your MCP client at ~/.local/share/quillink-mcp-venv/bin/quillink-mcpRelated MCP server: Bruin
Two options:
Option A — OAuth device login (recommended for interactive use):
.venv/bin/quillink-mcp loginOpens a device code + verification URL; approve it in your browser. The token is stored in your OS keyring (or ~/.config/quillink-mcp/credential as a fallback).
Requires a registered OAuth client id for this tool -- if login fails with an "Unknown client_id" error, set QUILLINK_CLIENT_ID to a registered client id (see Configuration below), or use a PAT instead.
Option B — Personal Access Token:
Create one in Quillink under Settings → Developer → Tokens (scopes: notes:read, folders:read, tags:read, organizations:read), then set it as an environment variable:
export QUILLINK_TOKEN=qlk_pat_...QUILLINK_TOKEN always takes priority over a stored OAuth login.
Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"quillink": {
"command": "/absolute/path/to/gcp-note-taking-mcp/.venv/bin/quillink-mcp"
}
}
}If using a PAT instead of login, pass it as an env var in the config:
{
"mcpServers": {
"quillink": {
"command": "/absolute/path/to/gcp-note-taking-mcp/.venv/bin/quillink-mcp",
"env": { "QUILLINK_TOKEN": "qlk_pat_..." }
}
}
}Restart Claude Desktop after editing the config.
Any client that can launch a local stdio MCP server works the same way: point it at the absolute path to .venv/bin/quillink-mcp (with QUILLINK_TOKEN set, or after running quillink-mcp login once so the credential is already stored). This includes Claude Code (claude mcp add quillink -- /absolute/path/to/.venv/bin/quillink-mcp) and any OpenAI-compatible agent runtime that supports the MCP stdio transport.
All read-only — this server cannot create, edit, or delete anything.
Tool | Description |
| List notes, filterable by folder, status, tags, pinned |
| Get a single note by id |
| Full-text search over title + body |
| Note count, storage used, pinned count |
| Notes that link to a given note |
| Local link graph (1 or 2 hops) centered on a note |
| Whole-account link graph, paginated (Pro plan) |
| Who a note has been shared with |
| Notes shared with you by others |
| List notebooks/folders |
| Get a single folder by id |
| List all tags in use |
| Your Team-plan organization's name, plan tier, seats, alerts |
| Your organization's members (plain members see only their own entry) |
Vault notes are never accessible here — they're end-to-end encrypted client-side, so no server (including this one) can read them. Organization tools 404 for a caller who isn't on a Team-plan organization.
Variable | Purpose |
| A Personal Access Token — bypasses OAuth login entirely |
| Override the API base URL (default: production) |
| Override the OAuth client id used by |
| Use a named workspace's api-base/client-id/credential instead (see below) |
This server is a single long-running process, launched once per MCP client config entry — there's no per-call "switch workspace" the way the CLI has --workspace. To use several environments or accounts, register one server entry per workspace, each pinned to a different QUILLINK_WORKSPACE:
# One-time: define the workspaces with the CLI (gcp-note-taking-cli)
quillink workspace add staging --api-base https://staging.example.com
quillink workspace login staging
# Point this server at it
QUILLINK_WORKSPACE=staging .venv/bin/quillink-mcp loginThen in your MCP client config, add a second server entry (e.g. quillink-staging) alongside your existing one, with "env": {"QUILLINK_WORKSPACE": "staging"} — both can be active at once.
Workspace metadata (api_base/client_id, no secrets) lives in ~/.config/quillink/workspaces.json — the same file gcp-note-taking-cli's quillink workspace add/use manages, so a workspace defined once via the CLI is immediately visible here. This server keeps its own separate keyring entry per workspace for the actual token, though, so you still need to login (or set QUILLINK_TOKEN) once per workspace here too. QUILLINK_TOKEN/QUILLINK_API_BASE/QUILLINK_CLIENT_ID set directly always take precedence over QUILLINK_WORKSPACE.
.venv/bin/quillink-mcp login
.venv/bin/quillink-mcp # runs the server on stdio -- an MCP client normally launches this for youGet a single folder by id.
| Name | Required | Description | Default |
|---|---|---|---|
| folder_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the action and gives no information about error handling, permissions, read-only nature, or what happens if the folder is not found. This leaves the agent with significant uncertainty.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of six words, completely front-loaded with the action and resource. Every word contributes value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the operation and the presence of an output schema, the description is nearly sufficient. However, it does not mention behavior when the folder does not exist or when access is denied, which could be relevant for error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has a single parameter with 0% description coverage. The description's 'by id' adds minimal context, indicating that folder_id is the identifier, but it does not explain format, constraints, or usage beyond what the schema's title already conveys.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('folder') with a clear identifier ('by id'), clearly distinguishing it from sibling tools like list_folders and get_note. It immediately conveys the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'by id' implies this is for retrieving a single known folder, but there is no explicit guidance on when to use it versus alternatives like list_folders. No exclusions or alternative recommendations are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a single note by id. Fails with 403 if it isn't owned by the caller, 404 if it doesn't exist.
| Name | Required | Description | Default |
|---|---|---|---|
| note_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the responsibility for behavioral disclosure. It explicitly reports 403 for non-ownership and 404 for non-existence, giving valuable error semantics. This goes beyond a simple 'get' and is sufficient for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the operation, and every sentence contributes useful information (action and error behavior). No fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, an output schema exists, and the description covers the key behavioral aspects (ownership, errors). It could mention return format, but the output schema handles that. Overall, it's complete for a single-note retrieval.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema's note_id parameter has no description, so the tool description's 'by id' adds some context. However, it does not specify the format or constraints of the ID, leaving room for interpretation. For a single parameter, this minimal addition is adequate but not robust.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a single note by its ID, using a specific verb and resource. This distinguishes it from sibling tools like list_notes and search_notes, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case—when you have a note ID—but does not explicitly mention alternatives or exclusions. It provides context through error conditions but lacks explicit guidance on when to choose this over sibling listing/search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Aggregate stats: total active notes, total storage bytes used, pinned-note count, and a created-at histogram by day.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It clearly discloses what the tool returns: active note count, storage bytes, pinned count, and a daily created-at histogram. It does not mention edge cases like how 'active' is defined or whether any filtering applies, but the 'get/stats' framing communicates a non-mutating aggregation operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence. It opens with 'Aggregate stats' to immediately orient the agent, then lists each returned metric in a compact, scannable structure with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with an output schema, the description is largely complete: it names all major result categories. It leaves minor ambiguity about the exact definition of 'active' and the time range of the histogram, but these are likely covered by the structured output schema and do not block correct tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the input schema imposes no burden. The description appropriately focuses on the nature of the computed statistics rather than argument details, which is the correct emphasis for a zero-parameter endpoint.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb and resource: aggregating note statistics. It enumerates exact metrics (total active notes, storage bytes, pinned-note count, created-at histogram), which clearly distinguishes it from sibling tools like list_notes or get_note that handle individual records.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives. The phrase 'Aggregate stats' implies it is for high-level overviews, but the description does not name alternatives or provide when-not-to-use criteria, so usage context is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the caller's notebooks/folders.
| Name | Required | Description | Default |
|---|---|---|---|
| include_trashed | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden of behavioral disclosure. It only states that it lists folders, without addressing whether trashed items are included by default, pagination, ordering, or any side effects. No annotation contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the action and resource. No wasted words; it is appropriately concise for a simple list tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, but the description leaves out important context: it does not mention whether the list is limited to non-trashed folders (though the schema default implies it), return format details, or any pagination/limits. An output schema exists, but the description does not reference or support it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% (the description does not mention 'include_trashed'). The description fails to compensate for this low coverage, adding no meaning beyond the schema's own name and default. The agent receives no extra context about the parameter's semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('the caller's notebooks/folders'), clearly distinguishing it from siblings like 'get_folder' (single folder) and 'list_notes' (notes, not folders). The scope is explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or scenarios where another sibling tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List who a note (owned by the caller) has been shared with.
| Name | Required | Description | Default |
|---|---|---|---|
| note_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It adds the important constraint that the note must be owned by the caller, which is a behavioral trait. However, it does not disclose what happens for non-owned notes (e.g., error vs. empty list) or any other side effects. The verb 'List' implies read-only, but that is not made explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no fluff. Every word contributes to clarifying the tool's purpose and the key constraint. It is appropriately concise for a simple list operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is only one parameter, an output schema exists, and the tool is straightforward, the description is largely complete. It covers the essential purpose and the ownership constraint. It lacks detail on error handling or return format, but the output schema likely handles the latter. For the simplicity of the tool, this is sufficient without being overly verbose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides a bare 'note_id' string with no description, so the tool description must compensate. The description clarifies that the note must be owned by the caller, adding meaning to the parameter. It does not specify format or additional constraints, but for a single required parameter, the added ownership context is valuable and mostly sufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'List' and the resource 'who a note (owned by the caller) has been shared with.' It clearly distinguishes this from sibling tools like list_notes (which lists one's own notes) or list_shared_notes (which likely lists notes shared with the caller). The ownership constraint is explicitly stated, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use this when you need to see the sharing recipients of a note you own. It does not explicitly name alternatives or state when not to use it, but the specificity of the description implies the appropriate situation. Since it lacks exclusions or explicit alternative references, it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the caller's notes. folder_id="" lists notes with no folder; omit it to list across all folders. status is "active" or "trashed". Locked notes are included but their body is withheld (null).
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | ||
| limit | No | ||
| pinned | No | ||
| status | No | active | |
| folder_id | No | ||
| start_after | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that locked notes are included with withheld bodies, explains folder_id behavior, and clarifies status values. It omits pagination and sorting details, but for a read-only list tool it provides meaningful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the main purpose, and contains no fluff. The phrasing 'folder_id=""' is slightly awkward but compact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core purpose and key edge cases (locked notes, folder filtering) but misses important operational details like pagination (limit, start_after) and filtering by tags/pinned. The output schema presumably covers return shape, but the tool's overall behavior is not fully specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds clarity for folder_id and status but ignores tags, limit, pinned, and start_after, leaving four of six parameters unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List the caller's notes,' using a specific verb and resource. It distinguishes itself from siblings like get_note (single note) and list_shared_notes (shared notes) by specifying 'caller's notes.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly mention when to use this tool versus search_notes or get_note. It implies usage through the listing action and provides parameter details, but lacks explicit exclusions or alternative tool recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List every tag used across the caller's active notes.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It discloses the scope (active notes) and implies completeness ('every tag'), and being a list operation, no side effects are expected.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loaded with the action and clearly conveying the purpose without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no parameters and an output schema, the description adequately covers the action and scope. No further detail is necessary for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description properly avoids adding unnecessary parameter details since there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the action (list), the resource (tags), and the scope (caller's active notes). This distinguishes it from sibling tools, none of which mention tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context is clear: the tool is used to list tags from the caller's active notes. It doesn't explicitly mention alternatives or exclusions, but the scope is well-defined and siblings don't compete for this functionality.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Full-text search over the caller's active notes' titles and body text. Locked notes only match on title (their body is never substring-matched, so a search hit can't leak hidden content).
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | ||
| limit | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: locked notes only match on title and body is never substring-matched, preventing content leakage. This goes beyond a simple 'search' statement. It does not mention pagination or result ordering, but the limit parameter and output schema provide some structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core purpose, followed by a concise and relevant caveat. Every word earns its place; no redundant phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and only two parameters, the description covers the key aspects: purpose, scope, and a critical privacy-related limitation. It does not elaborate on search semantics like case sensitivity, but given the tool's simplicity and output schema, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning to the 'q' parameter by explaining what is searched (titles and body) and the locked-note exception. However, it does not explain the 'limit' parameter behavior beyond what the schema's default indicates. Partial compensation but not full.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs full-text search over the caller's active notes' titles and body text. It distinguishes itself from sibling tools like list_notes and get_note by focusing on search, not listing or retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates when to use the tool: when full-text search over active notes is needed. It provides context about the caller's active notes, but does not explicitly contrast with alternatives or state when not to use it. This is acceptable but not top-tier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0get_folderget_noteget_note_statslist_folderslist_note_recipientslist_noteslist_shared_noteslist_tagssearch_notesScored across 9 tools
Every tool targets a distinct resource and action: notes, folders, tags, stats, sharing, and shared-with-me. There is no overlap in purpose; even list_notes and search_notes are clearly separated by behavior. An agent can unambiguously pick the right tool for a query.
All tools follow a consistent verb_noun pattern in snake_case, e.g., list_notes, get_note, search_notes, list_folders. No mixed conventions or vague verbs appear. The naming is predictable and self-documenting.
Nine tools is a well-scoped set for a note-taking/sharing domain. Each tool covers a distinct read or metadata feature without bloat or redundancy. The count feels appropriate and complete for a read-focused server surface.
The tool surface is entirely read-only: there is no way to create, update, delete, share, or organize notes, folders, or tags. Agents can retrieve information but cannot perform any write workflow, which is a significant gap for a note management service. The lack of any mutating operations will cause failures in most practical tasks.
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
OAuth-protected, read-only-by-default MCP server for provenance-labeled QuillCaddie project memory.
Google Keep-style notes app with an MCP server for AI agents to read/write notes.
Read-only MCP server for ClassQuill, a tutoring-business-management platform.
