scratchbook-mcp

by jinyaolin

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct concern: indexing, semantic search, structural outline, journaling, recall, status, forget, and gaze (create/read). There is no overlap in purpose, and the descriptions make boundaries clear.
Naming Consistency5/5
All tools share the `scratchbook_` prefix and use consistent lowercase snake_case. The suffixes are single verbs/nouns, and even the compound `gaze_read` follows the established pattern. No style mixing.
Tool Count5/5
With 9 tools covering codebase indexing/search/outline, journaling/recall, status/forget, and the gaze subsystem, the count is well-scoped and each tool earns its place.
Completeness4/5
Core workflows are covered: index, search, outline, journal, recall, forget, status, gaze, and gaze_read. Minor gaps exist—journal notes cannot be updated or deleted, and gaze boards lack a list/delete capability—but these are workable.
Average 4.3/5 across 9 of 9 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 5 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under Apache 2.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of disclosing behavior. It describes the content of the response (health, project list, detail) but does not explicitly confirm the tool is read-only or non-mutating, nor mention any operational constraints like permissions or latency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence compactly lists all key aspects: health, indexed projects with counts, and optional per-project detail. No redundancy or filler, information-dense and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a status tool with a single optional parameter and no output schema, the description covers the main return components (health, project list, detail) sufficiently. It lacks finer specifics like possible health values or output format, but these are not critical given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides 100% coverage for the single parameter 'project', describing it as 'Absolute project root to detail. Optional.' The description echoes this by saying 'detail for one project if given', adding no new semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool reports scratchbook health and what's indexed, listing concrete outputs: embedding-service status, indexed projects with counts, and per-project detail. This clearly differentiates it from sibling tools like scratchbook_index or scratchbook_search, which perform actions rather than report state.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is the tool for checking health and index state, but it does not explicitly state when to use it over alternatives or provide exclusions. The context is inferred from the tool's purpose rather than directly instructed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral disclosure. It discloses that notes are dated, namespaced, and persisted (recall later), but it omits details like whether notes append or overwrite, error behavior, or any permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences, front-loaded with the core purpose, and includes only relevant guidance on namespacing and self-containment. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the what, when, and namespace behavior, and mentions persistence via recall. However, it does not specify the tool's return value, failure modes, or any limits, and there is no output schema to fill that gap. It is adequate but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes all three parameters comprehensively (100% coverage). The description adds modest context by explaining the project namespace and advising self-contained text, but it adds no new meaning for the tags parameter. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool writes a dated work-note/diary entry into the scratchbook, with specific examples (what you're doing, decision, finding, bug). It differentiates itself from sibling tools by explicitly pointing to scratchbook_recall for retrieval, making it clear this is the write operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives concrete usage contexts (what to record) and explains the namespace options (project vs global). It also names scratchbook_recall as the alternative for reading notes later, though it does not explicitly list when not to use this tool beyond that.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 that the search is by meaning (semantic) and that scope can be set to project, global, or all, which is useful. However, it does not explicitly state whether the operation is read-only, how results are ranked, or whether prior indexing is required. This is adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: three short sentences that lead with the core action, then use cases, then scope. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, typical use cases, and scope options, but it does not describe the output format or any prerequisites (e.g., whether notes must be indexed via scratchbook_index). Given no output schema and no annotations, this is a noticeable gap for a complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers all parameters with descriptions (100% coverage). The description adds minimal extra meaning, merely paraphrasing the scope enum. It does not clarify the 'k' parameter or the 'project' parameter, so the description adds little beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Search your past journal / work-notes by meaning'), identifies the resource, and distinguishes this tool from sibling 'scratchbook_search' by emphasizing semantic search ('by meaning'). It also enumerates concrete use cases like remembering prior decisions or flagged issues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool ('Use it to remember what you were doing, prior decisions, or issues you flagged'), but it does not explicitly mention alternatives or when not to use it. It implies a distinction from lexical search without naming siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral traits: incremental processing ('only files changed since last run are re-read and re-embedded'), respect for .gitignore, and use of `git ls-files`. Since no annotations are provided, the description carries the full burden and does a solid job, though it omits potential runtime costs or side effects (e.g., index storage impact).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, each earning its place. It front-loads the core purpose, then adds incremental behavior, gitignore handling, and usage guidance. There is no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the essential context: purpose, usage timing, and key behaviors. It does not explain return values, but for an indexing action with no output schema, that is less critical. The only minor gap is not explicitly detailing the `reindex` parameter in the description, though it is implied by the incremental explanation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for both `path` and `reindex`. The description reinforces the `path` parameter ('Pass the absolute project root as path') and indirectly explains `reindex` through the incremental behavior, but it doesn't add substantial new meaning beyond the schema. The incremental description does provide context for why `reindex` might be needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Index or refresh a codebase into the scratchbook so it can be semantically searched.' It uses a specific verb ('Index') and resource ('codebase'), and distinguishes itself from sibling tools like scratchbook_search and scratchbook_outline by focusing on the indexing/preparation step rather than querying or summarizing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage timing: 'Run once when you start working on a project, and again after significant edits.' This gives clear context on when to invoke the tool. It does not mention alternatives or when-not-to-use, but the context is sufficient for an agent to decide appropriately in most scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears the transparency burden. It explicitly states what is removed (code chunks and file outlines) and what is preserved (journal notes), giving clear scope of the destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the purpose, and includes a parenthetical clarification. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and no output schema, the description fully covers behavior (what is removed/kept) and usage timing. The schema handles parameter details, so nothing important is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers the only parameter ('project') with a description, achieving 100% coverage. The description adds no additional parameter-specific semantics, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool removes a project's indexed code chunks and file outlines, using a specific verb (remove) and resource. It also distinguishes itself by noting journal notes are kept, separating it from sibling tools like scratchbook_journal.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context: 'Use to clean up or before a fresh full re-index.' It does not explicitly name alternatives or when-not-to-use, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool lists each file's imports and top-level symbols with line numbers, and implies a read-only operation by focusing on structure rather than modification. It also hints at efficiency ('without reading every file'), which adds useful context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences long, each serving a purpose: defining the output, stating the use case, and explaining how to focus the tool. It is front-loaded with the most important information and contains no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple, and the description plus schema cover all necessary aspects. Since there is no output schema, the description appropriately explains what the output contains (imports, symbols, line numbers). The parameter descriptions in the schema handle the rest, making the overall context complete for an agent to select and invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides descriptions for all three parameters (100% coverage), so the baseline is 3. The description adds a small amount of extra guidance by explaining that `path` can focus on a file or directory prefix, but it does not elaborate on `limit` or `project` beyond what the schema already states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: a structural map of a codebase, subtree, or single file, listing imports and top-level symbols with line numbers. It uses specific language that conveys the exact output, distinguishing it from generic 'outline' tools and sibling tools like search or index.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance: 'Use it to grasp how a project is organised without reading every file.' It also tells the user to provide a path to focus on a specific file or directory prefix. However, it does not explicitly mention when not to use it or compare it to alternatives like search or index, which would elevate it to a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the output format ('file:line locations, enclosing symbol and a snippet'), the scope ('across the whole repo'), and a state precondition ('must be indexed first'). This goes beyond generic 'search' descriptions, though it doesn't address error behavior or side effects, which are minimal for a read-only search.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three tight sentences that front-load the core purpose first, then usage guidance, then query mode and prerequisite. Every sentence adds new information without padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers what the tool returns, its scope, and a prerequisite, which is substantial for a search tool. With no output schema, it compensates by naming the return components. It could be even more complete by describing behavior when the project isn't indexed or when no results match, but overall it is well-rounded.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds value by clarifying the 'query' parameter with natural-language examples ('where are TTS chunks cached') and by implying that 'path_prefix' is an optional restrictor via the 'not just one directory' contrast. It also connects the 'project' parameter to the indexing prerequisite.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb and resource: 'Semantic search across a codebase's indexed code.' It distinguishes itself from grep by noting it operates 'across the whole repo, not just one directory.' The title 'Semantic code search' aligns, and the first sentence fully defines the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit context for when to use: 'Use it to locate where a concept or behaviour lives before reading files.' It also provides a prerequisite ('The project must be indexed first') and demonstrates the natural-language query format with examples. However, it does not explicitly mention when to use alternative scratchbook sibling tools or when not to use this tool beyond the 'unlike grep' comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does so thoroughly. It discloses that the flow session is 'CLEAN, isolated', 'runs in the BACKGROUND', 'can read/write files and search the codebase, but has no shell', and explains the wait=true blocking behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence earns its place: it explains what, when, how, and the operational caveats. It is front-loaded with the tool's core purpose and structured to flow from action to use case to background behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, no output schema, no annotations), the description is rich enough to support correct selection and invocation. It covers the workflow, background vs. blocking behavior, and capabilities/restrictions, though it does not specify the exact structure of the returned synthesis.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds practical usage context for key parameters (note=, focus=, project=, wait=true), including the pattern of dumping pieces then focusing a session, going beyond raw schema text.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: write tangled problem pieces to a board, then launch an isolated flow session to reason about relationships. It distinguishes itself from the sibling scratchbook_gaze_read by explicitly referring to polling/blocking behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit guidance: 'Use it when a problem is too tangled to hold in the working session' and explains the workflow with note=..., focus=..., and wait=true. It clearly points to scratchbook_gaze_read for polling, but does not explicitly discuss when not to use it relative to all other sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the burden of disclosing behavior. It reveals the side effect of 'remember=true' (persisting synthesis into recall as durable memory), explains the default behavior (latest session), and discloses the grounding-stamp ('stamped with the commit it was grounded in') and future reusability. This is rich, non-obvious behavioral context beyond what the schema conveys.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each dense with information but neither redundant nor padded. The first sentence states the core purpose, the second gives parameter usage patterns, and the third explains the remember behavior. It front-loads the primary action and resource, and every clause earns its place given the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main output content (notebook, sessions, syntheses, artifacts) and the optional write side effect (remember). It clearly states how to access specific items and what the default view is. Given no output schema, it sufficiently describes return content and behavior for a tool with this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although schema coverage is 100%, the description adds meaning by explaining the interplay between parameters: what happens with just 'board' (returns board plus latest synthesis), the role of 'session' and 'artifact' (specific vs full content), and the purpose of 'remember' (durable memory with commit stamping). It clarifies defaults and usage scenarios beyond the schema's per-parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('Read') and clearly identifies the resource ('a gaze board'), then enumerates the contents returned: 'its notebook, the flow sessions run against it (with status), their syntheses, and the intermediate artifacts they produced.' It distinguishes itself from sibling tools by mentioning the 'remember' parameter's persistence into scratchbook_recall, which sets it apart from pure read tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit invocation patterns: 'Call with just board= to see the board plus the latest session's synthesis; add session=<id> for a specific session, or artifact=<name> to read one artifact file's full content. Pass remember=true to persist...' This gives concrete when-to-use guidance for each parameter combination, and references scratchbook_recall as the target for persistence, effectively distinguishing use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![scratchbook MCP server](https://glama.ai/mcp/servers/jinyaolin/scratchbook/badges/card.svg)](https://glama.ai/mcp/servers/jinyaolin/scratchbook)

Score Badge

Copy to your README.md:

[![scratchbook MCP server](https://glama.ai/mcp/servers/jinyaolin/scratchbook/badges/score.svg)](https://glama.ai/mcp/servers/jinyaolin/scratchbook)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jinyaolin/scratchbook'

If you have feedback or need assistance with the MCP directory API, please join our Discord server