universal-notebook-mcp

by am-3

Overview Schema Related Servers Score Discussions

Python

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 operation on notebooks, cells, metadata, or kernels. There is no overlap, and descriptions clearly differentiate purposes (e.g., list_cells vs read_cell, run_all vs run_pipeline).
Naming Consistency5/5
All tools follow the `notebook_verb_noun` pattern consistently. Verbs like delete, edit, insert, list, read, restart, run are used uniformly, making it easy to predict tool behavior from its name.
Tool Count5/5
With 17 tools, the set covers cell manipulation, metadata editing, execution modes, and kernel management without being excessive. Each tool serves a clear purpose, and the count is well-suited to the domain.
Completeness4/5
Core workflows like CRUD for cells, multiple execution modes, and kernel management are covered. However, missing notebook creation (e.g., `notebook_create`) and explicit save/export operations are minor gaps that agents may need to work around.
Average 4.2/5 across 17 of 17 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 7 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 MIT License.
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?
The description indicates read-only behavior, which is transparent, but lacks details on error handling, idempotency, or return value structure. Given no annotations, it provides basic but not comprehensive 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (one sentence plus an Args list), front-loaded, and every part adds value. No unnecessary words.
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 core purpose and parameter semantics, but does not address error conditions (e.g., file not found, invalid notebook) or result structure. An output schema exists, mitigating return format concerns, but error handling is missing. For a simple read tool, it is adequate but not fully complete.
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?
The schema provides only type and required for the single parameter. The description adds clear meaning: 'Path to the .ipynb file, relative to the workspace root.' This compensates fully for the missing schema 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?
The description clearly states the verb 'Read' and the resource 'top-level notebook metadata' with examples (kernelspec, language_info). This distinguishes it from sibling tools like notebook_edit_metadata (write) and notebook_read_cell (read cell content).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus its siblings, nor does it mention prerequisites or context. Usage is implicitly clear from the name, but no direct advice is given.
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 behaviors: it saves outputs back to the notebook file (save_outputs), stops on error by default (stop_on_error), and has per-cell timeout. Since no annotations are provided, the description carries the full burden and covers important side effects (writing to file) and execution semantics.
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 highly concise: a single sentence defining the tool's purpose followed by a bullet list of all five parameters with defaults and explanations. No redundant text; every sentence adds value. Information is front-loaded.
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 has 5 parameters, no annotations, and an output schema (assumed to cover return values), the description adequately explains all parameters and core behavior. However, it lacks details on output format, error handling beyond stop_on_error, and any performance or state implications (e.g., kernel reset).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
While the description attempts to explain each parameter, it inaccurately states the default for kernel_name as 'python3' when the input schema specifies default null. This contradiction misleads the agent about the tool's actual default behavior. Schema description coverage is 0%, so accurate parameter documentation is critical.
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 'Execute every cell in the notebook in order and return all outputs,' which specifies the verb (execute), resource (every cell in the notebook), and scope (in order, all outputs). This distinguishes it from sibling tools like notebook_run_cell (single cell) and notebook_run_range (range of cells).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives. It lacks explicit 'when-to-use' or 'when-not-to-use' conditions, and does not mention any prerequisites or context for preferring full notebook execution over running individual cells or ranges.
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?
Describes default stop_on_error, timeout, and save_outputs behavior. Lacks details on kernel instantiation, side effects (e.g., kernel state), and output format. Adequate but not thorough.
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?
Two lead sentences plus a clear bulleted arg list. Every sentence adds value; no redundancy. Well-structured for quick scanning.
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?
Covers core functionality and all parameters. Does not describe output schema or kernel prerequisites, but output schema exists externally. Slightly incomplete for a parameter-rich tool.
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?
With 0% schema coverage, the description explains all 7 parameters with defaults and semantics (e.g., 'relative to workspace root,' 'per-cell timeout'). Adds value but lacks some format constraints.
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 'Execute cells from start to end (inclusive) and return all outputs,' specifying verb, object, and range. This distinguishes it from siblings like notebook_run_all and notebook_run_cell.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives (e.g., notebook_run_all, notebook_run_cell). Does not explain trade-offs or exclusion conditions.
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 full burden. It discloses the backup behavior (timestamped .checkpoint_*.ipynb) and the checkpoint parameter to disable it. However, it does not mention potential side effects like kernel state changes, file locking, or error scenarios, leaving gaps in transparency.
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: two sentences plus bullet-pointed args. Every sentence adds value. The action is front-loaded, and the args are clearly listed with context. No wasted words.
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 tool has an output schema (not shown) which likely documents return values, reducing the burden on the description. The description covers the main behavioral aspect (backup) and parameter semantics. It lacks details on error handling, permission requirements, or cell existence checks, but overall provides sufficient context for a write operation.
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?
The input schema has 0% description coverage, but the tool description adds valuable semantics for all parameters: notebook_path is relative to workspace root, cell_index is zero-based, source is new text, checkpoint defaults to true and controls backup. This compensates fully for the schema's lack of 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?
The description starts with 'Replace the source of a cell', a clear verb-resource action. The verb 'replace' and resource 'source of a cell' accurately describe the core function, and it distinguishes from sibling tools like notebook_delete_cell or notebook_edit_cell_metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. For instance, it does not mention that notebook_edit_cell_metadata should be used for metadata edits, or that notebook_read_cell is for reading. The absence of when-not or alternative recommendations reduces agent decision quality.
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, the description carries the full burden. It mentions the 'checkpoint' parameter for backups and describes merge behavior, but does not cover error handling, permissions, or whether the merge is deep or shallow. Some behavioral aspects are disclosed but not comprehensively.
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, well-structured with an introductory line, an example, and an Args section. Every sentence provides value without redundancy.
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 that an output schema exists, the description covers core functionality and parameters well. However, it lacks details on edge cases like invalid cell_index or notebook_path, and does not explain the return behavior beyond the output schema's presumed role.
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?
Schema description coverage is 0%, so the description fully compensates. Each parameter (notebook_path, cell_index, updates, checkpoint) has a clear, descriptive explanation that adds meaning beyond type and name, including examples and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool merges a JSON object into a cell's metadata, with an example for pipeline tags. The name 'notebook_edit_cell_metadata' combined with the description makes the purpose clear, but it does not explicitly distinguish from sibling tools like 'notebook_edit_metadata' which edits notebook-level metadata.
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 provides an example use case for pipeline stage tags, implying when to use it, but lacks explicit guidance on when not to use it or mentions of alternative tools. The sibling list is provided but no direct comparison.
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 full burden. It mentions the output (absolute paths) but does not disclose any behavioral traits like side effects, performance, or whether it is read-only. For a 0-parameter list operation, this is adequate but not exhaustive.
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 consists of two concise, front-loaded sentences. Every sentence adds value: the first explains the purpose, the second details the return format.
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?
Given the tool has 0 parameters and an output schema exists, the description is sufficiently complete. It clearly defines what the tool does and what it returns, leaving no major gaps.
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?
There are 0 parameters, so baseline is 4. The description does not need to add parameter information; it correctly focuses on the tool's behavior.
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 verb 'list', the resource 'notebooks with running kernels', and the scope 'in this session'. It also specifies the return value (absolute resolved paths), which distinguishes it from siblings like notebook_list_kernels.
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 usage when needing to find notebooks with active kernels, but does not explicitly state when to use this tool versus alternatives such as notebook_list_kernels. No guidance on when-not-to-use is provided.
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 the burden. It states the tool reads cell contents but does not explicitly declare it as read-only or safe, nor mentions side effects. For a read operation, this is adequate but not exemplary.
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 extremely concise: two short sentences plus an Args list with no fluff. The purpose is front-loaded and every sentence adds value.
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 presence of an output schema (implied), the description adequately covers what the tool returns. It could mention error handling (e.g., invalid index) but remains complete for a simple read tool.
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?
Schema coverage is 0% (no descriptions in schema), but the description adds full semantics for both parameters: notebook_path is 'relative to workspace root' and cell_index is 'zero-based index' with hint to use notebook_list_cells. This fully compensates for the schema gap.
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 action ('Read') and the resource ('a single cell'), listing specific attributes (source, type, tags, saved outputs). It distinguishes from siblings like notebook_read_cell_output and notebook_list_cells.
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 usage by mentioning notebook_list_cells to find cell_index, but does not explicitly state when to use this tool versus alternatives or when not to use it.
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 full burden. It discloses the backup behavior ('Write a backup before editing') and implies a shallow merge of top-level keys. However, it lacks details on validation, error handling, or file modification 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 concise: one line of purpose, then three lines for parameter details. Every sentence is necessary and front-loaded for quick understanding.
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 tool has 3 parameters, no annotations, but an output schema exists. The description covers parameters and side effects (backup). It is mostly complete, though missing error handling and path validation details. Return values are handled by the output schema, so no deduction needed.
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 descriptions are missing (0% coverage), so the description compensates well. It explains notebook_path (relative path), updates (JSON string for top-level keys), and checkpoint (boolean for backup). Could be more precise on updates structure, but it adds value 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 states 'Merge a JSON object into the top-level notebook metadata.' This clearly identifies the action (merge) and resource (notebook metadata), distinguishing it from sibling tools that operate on cells or read metadata.
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 gives no explicit guidance on when to use this tool versus siblings like notebook_edit_cell_metadata or notebook_read_metadata. Usage is implied but not clarified with when-not or alternative suggestions.
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 fully relies on itself to disclose behavior. It explicitly mentions that a timestamped backup is written before deletion unless checkpoint=false, which is key behavioral detail. However, it does not mention error handling or side effects like file modification.
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 very concise and well-structured: a one-sentence purpose, a key behavioral note about backups, then a clean parameter list. No unnecessary words or redundancy.
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 (3 parameters, no annotations, output schema exists), the description adequately covers the main action, backup behavior, and parameter meanings. It lacks information about return values (though output schema exists) and potential errors, but is fairly complete for a simple deletion tool.
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?
The description compensates for 0% schema coverage by providing clear, complete explanations for all three parameters: notebook_path (relative path), cell_index (zero-based), and checkpoint (default true with backup behavior). This adds significant value over the raw 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 the tool deletes a cell from a notebook, specifying the action and resource. It distinguishes itself from siblings like notebook_edit_cell or notebook_insert_cell, which have different purposes.
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 usage for deletion but does not explicitly differentiate from alternatives (e.g., editing or clearing a cell) or state when not to use the tool. No guidance on prerequisites or context is given.
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?
No annotations exist, so the description fully carries the burden. It discloses cell shifting, append behavior, and checkpoint backup. It does not mention error conditions or permissions, but this is sufficient for a simple insertion tool.
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, front-loading the main action and behavioral note, then listing parameters in a clear block. Every sentence serves a purpose, with no redundancy.
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 5 parameters and existence of an output schema, the description covers behavior and parameter semantics well. However, it does not describe the return value or error conditions, which would enhance completeness.
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?
Schema description coverage is 0%, so the description must compensate. It provides meaningful explanations for all parameters (notebook_path, index, source, cell_type, checkpoint), including defaults and options, adding significant value beyond the raw 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 'Insert a new cell at the given position,' which is a specific verb and resource. It also explains the shifting behavior and append trick, distinguishing it from sibling tools like notebook_edit_cell or notebook_delete_cell.
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 usage by detailing the operation (insert) and behavioral notes (shifting, appending), but it does not explicitly mention when to use this tool versus alternatives or provide exclusions.
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?
No annotations are provided, so the description carries the full burden. It discloses that the tool runs cells in notebook order, optionally saves outputs back to the file (save_outputs), stops on error (stop_on_error), and uses a specified kernel. It does not mention any destructive actions beyond saving outputs, which is explicitly controlled by a parameter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a brief introductory sentence, a note on setting tags, a sibling tool reference, and a clear 'Args:' section. It is efficient, but could be slightly more condensed without losing clarity. Still, it earns its sentences and is front-loaded.
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 (6 parameters, 2 required) and the presence of an output schema, the description is fairly complete. It explains all parameters, the execution order, and provides a pointer to a related tool. It does not cover return values, but that is acceptable since an output schema exists. Minor gaps like error handling beyond stop_on_error are covered by the parameter description.
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?
The input schema has 0% description coverage, so the tool description compensates fully. It provides clear, meaningful explanations for all six parameters, including defaults (e.g., 'Kernel to use (default: 'python3')') and behavior ('Stop at first failing cell (default: true)'). This adds essential context beyond the schema alone.
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 'Run all cells tagged with a pipeline stage, in notebook order.' It specifies the verb (run), resource (cells tagged with a stage), and behavior (order). It also explains how to set tags and distinguishes itself from siblings like notebook_run_all and notebook_run_cell.
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 guidance to 'Use notebook_list_stages to see what stages exist in a notebook,' indicating when to use this tool versus that alternative. It does not explicitly state when not to use the tool, but the sibling context and the detailed parameter explanations imply appropriate usage.
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 description carries full burden. While it implies a read-only list operation, it does not explicitly state that no side effects occur or that it is safe to call multiple times. More explicit safety disclosure would improve score.
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?
Two short sentences plus an argument description. Front-loaded with key result details. No wasted words.
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?
Given the simple tool (one parameter) and presence of an output schema (not shown but assumed), the description sufficiently explains what is returned (index, type, tags, first line) and how to use it. No missing information.
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 has no parameter descriptions (0% coverage), but description adds meaning beyond schema (type string, title) by specifying 'Path to the .ipynb file, relative to the workspace root,' which clarifies format and location. Could be improved with example.
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 uses specific verb 'list every cell' and identifies the resource as a notebook, detailing what is returned (index, type, tags, first line). This clearly distinguishes it from sibling tools that modify or read individual cells.
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?
Explicitly states 'Call this first to understand the structure before reading or editing specific cells,' providing clear when-to-use guidance and implied exclusion of direct cell manipulation.
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?
No annotations provided, so description carries full burden. It discloses return format (dict of name to display name) and potential module issues with solution. However, it doesn't mention any permissions or failure modes beyond that.
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?
Description is concise with only essential sentences and a code example. Every sentence adds value, well-structured with clear sections.
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?
Given 0 parameters and output schema present, the description fully explains the return structure, usage, and provides troubleshooting, making it complete for an agent.
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?
The tool has 0 parameters, so baseline is 4 per instructions. No parameter info needed, but the description adds no semantics beyond that baseline.
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 'List every Jupyter kernel spec installed on this machine' with a specific verb and resource. It distinguishes from siblings like notebook_list_active_kernels which lists active kernels rather than all specs.
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 provides explicit guidance on using the kernel_name from the output as an argument to execution tools, and includes troubleshooting advice for ModuleNotFoundError. It could mention not using it when you need active kernel info, but context from sibling names mitigates this.
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?
No annotations are provided, so the description carries full behavioral burden. It describes the read-only nature of listing stages and explains how stages are assigned. It does not mention edge cases (e.g., no stages found) but given the simplicity, this is adequate.
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 brief and front-loaded with the action. It includes only essential information: purpose, context on how stages are set, and a pointer to a related tool. No redundancy or unnecessary detail.
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 simple list tool with one parameter and an output schema (presence indicated), the description covers all necessary context: what the tool does, how input is formatted, and how stages are integrated with the JupyterLab workflow.
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?
With 0% schema description coverage, the description adds critical meaning: it specifies that notebook_path is 'relative to the workspace root.' This clarifies the parameter format, which the schema alone does not provide.
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's purpose: 'List every pipeline stage tag present across the notebook's cells.' The verb 'List' and resource 'pipeline stage tags' are clear and specific. It distinguishes itself from sibling tools like notebook_list_cells by focusing on stages.
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 context on how pipeline stages are set (via JupyterLab cell toolbar) and mentions a related sibling tool (notebook_run_pipeline) for executing stages. However, it does not explicitly state when to use this tool versus other list tools like notebook_list_cells or notebook_list_kernels.
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 fully carries the transparency burden. It discloses that outputs are saved from the last execution and lists possible output types. It correctly implies a read-only, non-destructive operation. Missing explicit mention that no execution is triggered, but still adequate.
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?
Two concise paragraphs: first states purpose and return types, second details parameters. Every sentence adds value; no fluff. Front-loaded with the most critical information.
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?
With an output schema likely defining return structure, the description doesn't need exhaustive details. It covers the essential: what outputs contain, when they are available, and how to specify the cell. Tool is fully described given its 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?
Schema coverage is 0%, but the description's 'Args' section fully describes both parameters: notebook_path (relative path) and cell_index (zero-based index). This adds meaning beyond the schema titles and compensates for the lack of schema-level 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?
The description clearly states the verb 'read' and resource 'saved outputs of a code cell'. It distinguishes from siblings like notebook_read_cell and notebook_read_metadata by explicitly stating it reads outputs, not cell content or metadata.
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: outputs are saved from the last run and are empty until execution. However, it does not explicitly compare to alternatives or state when not to use it, so it stops 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that kernel state is preserved, outputs are returned, and save_outputs controls writing back to file. It does not explicitly state if the operation is destructive, but the nature of executing code implies mutation. The description adequately covers behavioral traits.
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 with one main sentence followed by a structured Args list. Every sentence adds value, and the most important information (purpose) is front-loaded. No wasted words.
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?
Given the many sibling tools, the description clearly identifies this tool's role. It covers key aspects: execution behavior, parameter details, and output. The presence of an output schema means return values need not be explained. The description is sufficiently complete for correct tool selection and invocation.
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?
Schema description coverage is 0%, but the description fully explains each parameter in the Args section, adding meaning beyond the schema. It clarifies paths, indices, kernel options, timeout, and save behavior, which is excellent compensation.
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 executes a single code cell and returns outputs, which is a specific verb+resource. It distinguishes from siblings like notebook_run_all or notebook_run_range.
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 explains that kernel state is preserved and cells can depend on earlier ones, providing context for when to use. It also suggests using notebook_list_kernels for kernel options. However, it does not explicitly mention when not to use this tool compared to alternatives like run_range.
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?
No annotations are provided, so the description carries full behavioral disclosure. It details that the kernel process stays alive and only state resets, which is crucial for understanding side effects.
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?
Four sentences efficiently cover purpose, behavior, usage context, and parameter. No superfluous words; well-structured.
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 simple tool with one required parameter and an output schema, the description fully explains the action, behavioral nuance, and parameter meaning. No gaps.
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?
The schema has 0% description coverage, so the description must compensate. It defines the parameter 'notebook_path' as path to the .ipynb file, which adds clarity beyond the schema's title 'Notebook Path'.
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 'Restart the kernel for a notebook, clearing all variables and imports.' This is specific and distinct from sibling tools like cell editing or pipeline runs.
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 explains that the kernel stays alive and state is reset, avoiding startup overhead. This guides when to use it (clean slate without new kernel overhead) but does not explicitly mention when not to use it or list alternatives.
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:

[![jupyter-mcp MCP server](https://glama.ai/mcp/servers/am-3/jupyter-mcp/badges/card.svg)](https://glama.ai/mcp/servers/am-3/jupyter-mcp)

Score Badge

Copy to your README.md:

[![jupyter-mcp MCP server](https://glama.ai/mcp/servers/am-3/jupyter-mcp/badges/score.svg)](https://glama.ai/mcp/servers/am-3/jupyter-mcp)

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/am-3/jupyter-mcp'

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