MCPサーバーで、Quillinkのノート、フォルダ、タグへの読み取り専用アクセスを、Claude Desktop、Claude Code、その他のMCP互換クライアントなどのAIツールに提供します。
ProのQuillinkプランが必要です（APIアクセスはPro限定機能です）。
PyPIには公開されていません。ソースからローカルでビルドして実行してください。
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 .これにより、quillink-mcpコマンドが.venv/bin/にインストールされます。そのバイナリのフルパス（例：/Users/you/gcp-note-taking-mcp/.venv/bin/quillink-mcp）に注意してください。MCPクライアントはアクティブなシェルを介さずに直接起動するため、絶対パスが必要です。
Related MCP server: Bruin
2つのオプションがあります：
オプションA — OAuthデバイスログイン（対話的な使用に推奨）：
.venv/bin/quillink-mcp loginデバイスコードと確認URLが開きます。ブラウザで承認してください。トークンはOSのキーリング（またはフォールバックとして~/.config/quillink-mcp/credential）に保存されます。
オプションB — パーソナルアクセストークン：
Quillinkの設定 → 開発者 → トークンで作成し（スコープ：notes:read、folders:read、tags:read）、環境変数として設定してください：
export QUILLINK_TOKEN=qlk_pat_...QUILLINK_TOKENは、保存されたOAuthログインよりも常に優先されます。
Claude Desktopの設定（macOSでは~/Library/Application Support/Claude/claude_desktop_config.json）に追加します：
{
"mcpServers": {
"quillink": {
"command": "/absolute/path/to/gcp-note-taking-mcp/.venv/bin/quillink-mcp"
}
}
}loginの代わりにPATを使用する場合は、設定で環境変数として渡します：
{
"mcpServers": {
"quillink": {
"command": "/absolute/path/to/gcp-note-taking-mcp/.venv/bin/quillink-mcp",
"env": { "QUILLINK_TOKEN": "qlk_pat_..." }
}
}
}設定を編集した後、Claude Desktopを再起動してください。
ローカルのstdio MCPサーバーを起動できるクライアントはすべて同じように動作します：.venv/bin/quillink-mcpの絶対パスを指定します（QUILLINK_TOKENを設定するか、quillink-mcp loginを一度実行して資格情報を保存しておきます）。これにはClaude Code（claude mcp add quillink -- /absolute/path/to/.venv/bin/quillink-mcp）や、MCP stdioトランスポートをサポートするOpenAI互換のエージェントランタイムが含まれます。
すべて読み取り専用です。このサーバーは何も作成、編集、削除できません。
ツール | 説明 |
| ノートを一覧表示。フォルダ、ステータス、タグ、ピン留めでフィルタリング可能 |
| IDで単一のノートを取得 |
| タイトルと本文の全文検索 |
| ノート数、使用ストレージ、ピン留め数 |
| ノートが誰と共有されているか |
| 他の人から共有されたノート |
| ノートブック/フォルダを一覧表示 |
| IDで単一のフォルダを取得 |
| 使用中のすべてのタグを一覧表示 |
| チームプラン組織の名前、プラン階層、シート数、アラート |
| 組織のメンバー（一般メンバーは自分のエントリのみ表示） |
Vaultノートはここでは決してアクセスできません。クライアント側でエンドツーエンドに暗号化されているため、このサーバーを含むどのサーバーも読み取ることができません。組織ツールは、Teamプランの組織に属していない呼び出し元には404を返します。
変数 | 目的 |
| パーソナルアクセストークン。OAuthログインを完全にバイパスします |
| APIベースURLを上書きします（デフォルト：本番） |
|
|
.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.
