TomeVault
Server Details
Search, fetch (with provenance), scan, and convert AI instruction files for agents.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.2/5 across 8 of 8 tools scored.
Each tool has a clear, distinct purpose. Convert, fetch, search, scan, verify, and vault operations are well-separated. Even the attestation tools (get_provenance vs verify_attestation) are differentiated by what they return versus what they verify.
All tool names follow a consistent verb_noun pattern with snake_case (e.g., convert_content, list_vault_items). There are no mixed conventions or irregular naming.
With 8 tools, the set is well-scoped for the server's purpose. Each tool serves a specific function without bloat, and the count feels appropriate for managing tomes, vault items, and attestations.
The tool surface covers retrieval, search, conversion, scanning, and verification, but lacks creation or upload capabilities for tomes or vault items. There is no tool to add a tome or create a vault item, which are notable gaps for a vault-like service.
Available Tools
8 toolsconvert_contentARead-onlyInspect
Convert pasted instruction-file text into another tool's format (claude_md, agents_md, cursor_mdc, gemini_md, copilot_instructions, windsurf_rules, skill_md). The same instructions, ready for any tool.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Optional title for the converted file's heading/frontmatter. | |
| content | Yes | The raw instruction-file text to convert. | |
| to_format | Yes | The target tool format. | |
| description | No | Optional one-line description for the converted file. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description's alignment is sufficient. It adds no further behavioral details (e.g., idempotency, rate limits) but does not contradict annotations.
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: first sentence delivers core purpose, second sentence is slightly redundant but still brief. No wasted content.
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?
No output schema exists, so description should hint at return format. It does not mention that the tool returns the converted text. Otherwise, coverage of inputs and purpose is adequate.
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 coverage is 100%, so baseline is 3. Description does not add new semantic info beyond reinforcing purpose; the format list is already in the enum.
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?
Description clearly states the verb ('Convert'), resource ('pasted instruction-file text'), and target formats (specific list). It distinguishes from sibling tools (get_provenance, get_tome, etc.) which are about retrieval, not format conversion.
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?
Description implies use case (convert between tool formats) but lacks explicit when-to-use or when-not-to-use guidance. No mention of alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_provenanceARead-onlyInspect
Return the signed attestation record alone for a tome: quality grade, security scan grade and flags, decay risk, source registry, the content hash it is bound to, and the signing key id for offline verification.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repository name. | |
| owner | Yes | GitHub owner or org. | |
| skill_path | No | Address a specific skill within the repo, e.g. skills/foo. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true; description adds value by specifying what the attestation record contains (quality grade, security scan, etc.) and mentions offline verification, going beyond annotations.
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 efficiently lists fields, but it is slightly dense; could be split for clarity but no wasted words.
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?
No output schema exists, so the description must fully explain the return value; it lists fields but lacks structure or types, and no error conditions are mentioned. Adequate but not comprehensive.
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 coverage is 100% with clear parameter descriptions; the tool description does not add meaning beyond the schema, so baseline score of 3 applies.
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 'Return the signed attestation record alone for a tome' with a specific verb and resource, and lists exact fields, distinguishing it from siblings like get_tome and verify_attestation.
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 usage for 'offline verification' but provides no explicit when-to-use or when-not-to-use guidance, nor contrasts with alternative sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_tomeARead-onlyInspect
Fetch one tome's content in a specific agent format (default claude_md). Every response carries the provenance verdict: quality grade, security scan grade, decay risk, and the content hash it is bound to.
| Name | Required | Description | Default |
|---|---|---|---|
| repo | Yes | GitHub repository name. | |
| owner | Yes | GitHub owner or org. | |
| format | No | Output format, e.g. claude_md, agents_md, skill_md. | claude_md |
| skill_path | No | Fetch a specific skill within the repo (the skill_path from a search_tomes result). Omit for the repo's primary unit. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint and openWorldHint; the description confirms a read operation and adds detail about the provenance verdict (quality grade, security scan, etc.), which goes beyond the annotations.
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-load the core purpose and add key response information without unnecessary words.
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?
Covers main functionality and response fields, but lacks details on error cases or what happens when a tome is not found. Without an output schema, some ambiguity remains.
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 coverage is 100% with parameter descriptions, but the description adds context: default format 'claude_md' and skill_path origin from search_tomes results, enhancing meaning beyond the schema.
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 explicitly states 'Fetch one tome's content in a specific agent format', providing a clear verb and resource. It distinguishes itself from siblings like search_tomes and get_provenance by focusing on retrieving content with provenance.
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?
No explicit guidance on when to use vs alternatives. While the context makes it suitable for fetching a single tome with provenance, it lacks direct comparisons to siblings like search_tomes or get_provenance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_vault_itemARead-onlyInspect
Fetch one of your TomeVault items by id, with its content. Requires a vault access token with the items:read scope. Encrypted items are not retrievable and return not found, indistinguishable from a missing id.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | The vault item id, from list_vault_items. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnlyHint, openWorldHint), the description discloses that encrypted items are not retrievable and return not found, which is critical behavioral context. It also states the required scope.
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, no wasted words. Front-loaded with purpose, then prerequisites and edge case. Very efficient.
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?
Despite having no output schema, the description states it returns content. With annotations covering safety, the description is complete for a simple retrieval tool, covering scope, usage limits, and an important edge case.
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 coverage is 100% and the schema already describes the id parameter clearly, including its source. The description does not add additional meaning but repeats no incorrect information, so baseline 3.
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 action (Fetch) and resource (TomeVault item by id) and includes that it returns content. It distinguishes from siblings like list_vault_items because it retrieves a single item with full content.
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 prerequisites (vault access token with items:read scope) and explains a key edge case (encrypted items return not found). However, it does not explicitly differentiate from sibling tools like list_vault_items or when to prefer this over get_tome.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_vault_itemsARead-onlyInspect
List the items in your TomeVault that this token can read. Requires a vault access token with the items:read scope. Encrypted (private) items are never listed.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey readOnlyHint=true and openWorldHint=true. The description adds valuable behavioral context: the scope requirement and the important detail that encrypted items are never listed. No contradictions with annotations.
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, no filler. First sentence states core purpose, second adds necessary scope and exception. Every word earns its place.
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 simple single-parameter input and no output schema, the description covers the main purpose and a key behavioral exception. However, it doesn't mention that the result is a list of items or any pagination details. Still adequate for a straightforward list operation.
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%, meaning no parameter descriptions in the schema. The tool description does not mention the 'limit' parameter or its meaning (pagination control). Although the schema provides bounds, the description should compensate for the lack of schema descriptions, but it fails to do so.
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?
Clearly states the verb 'list' and resource 'items in your TomeVault', with explicit scope requirement and exception for encrypted items. Distinguishes well from siblings like get_vault_item (singular) and get_tome (single object).
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?
Provides explicit requirement for vault access token with items:read scope, and clarifies that encrypted items will never be listed. Does not explicitly mention alternatives, but the context of a list operation vs. single-item retrieval is implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_contentARead-onlyInspect
Scan submitted instruction-file text for safety, clarity, loadability, and cross-model consistency, and return a verdict with findings. Use before loading a third-party file. Consistency findings are PREDICTIONS (divergence risks across models/tools), never verified facts. The submitted text is scanned and discarded, never stored.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Optional display name, e.g. CLAUDE.md. | |
| text | Yes | Raw instruction-file text to scan. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, and the description adds that submitted text is scanned and discarded, never stored—confirming no side effects. Also clarifies the predictive nature of consistency findings, enhancing transparency beyond annotations.
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?
Three sentences: first states purpose, second advises when to use, third provides critical behavioral caveats. No redundancy, efficiently front-loaded.
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?
Tool has low complexity with 2 parameters, read-only annotations, and no output schema. Description covers all needed aspects: input, behavior, usage context, and output nature. Complete for effective agent selection and invocation.
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 already provides full descriptions for both parameters (100% coverage). Description adds contextual value by citing 'Optional display name, e.g. CLAUDE.md.' for name and reinforcing 'Raw instruction-file text' for text, which aids agent understanding.
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?
Clearly states verb 'scan' and resource 'instruction-file text', detailing four specific dimensions (safety, clarity, loadability, consistency) and outcome (verdict with findings). Differentiates from siblings like convert_content by focusing on scanning and verification.
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?
Explicitly advises to use before loading a third-party file. Notes that consistency findings are predictions, not facts, setting appropriate expectations. Could mention when not to use or alternatives more explicitly, but context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_tomesARead-onlyInspect
Search TomeVault for agent context files (tomes, configs, skills) by a task description. Filter by format, kind, and quality grade. Returns ranked matches with owner/repo, grade, and available formats, not file contents.
| Name | Required | Description | Default |
|---|---|---|---|
| kind | No | tome = full project config + skills; config = one config file; skill = one skill. | |
| grade | No | Screen by graded quality tier. | |
| limit | No | ||
| query | Yes | Free-text task or topic to match. | |
| format | No | Target tool format, e.g. claude_md, agents_md, cursor_mdc. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. Description adds behavioral context: returns ranked matches with owner/repo, grade, and available formats, explicitly noting it does not return file contents. No contradictions.
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, no wasted words. Front-loaded with main purpose; each sentence adds distinct value.
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?
No output schema, but description sufficiently explains return values (ranked matches with metadata). Covers purpose, parameters (aided by schema), and behavioral expectations. A minor gap is lack of pagination or total results info, but not critical for a search tool.
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 coverage is high (80%) with descriptions for each parameter. Description mentions filtering by format, kind, and quality grade, but adds minimal extra meaning beyond what schema provides. Baseline of 3 is appropriate.
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?
Description clearly states verb 'Search' and resource 'TomeVault for agent context files (tomes, configs, skills)'. It specifies it searches by task description, and explicitly distinguishes from siblings like get_tome by noting it returns ranked matches with metadata, not file contents.
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?
Description provides clear context: search by task description, filter by format/kind/grade. It implicitly differentiates from sibling tools (single-item retrieval) but does not explicitly state when not to use or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_attestationARead-onlyInspect
Verify a TomeVault attestation document (the contents of a repo's .tome/attestation.json). Confirms the detached signature is genuinely TomeVault's against the published key, and, if the signed file's text is supplied, that the file has not drifted since it was signed. Returns the signed verdict; consistency in it is a PREDICTION (cross-model divergence risk), never a verified fact. Nothing submitted is stored.
| Name | Required | Description | Default |
|---|---|---|---|
| content | No | Optional: the instruction file the attestation signs, to also confirm it has not changed. | |
| attestation | Yes | The .tome/attestation.json document text. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Disclosures beyond annotations: states that consistency is a PREDICTION (not a verified fact) and that nothing submitted is stored. Annotations already indicate readOnlyHint=true, and the description adds important caveats about the interpretation of results.
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 well-structured sentences that front-load the purpose and provide necessary details without extraneous text. Every sentence adds value.
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 (2 params, no output schema) and presence of annotations, the description is fully sufficient. It explains inputs, process, output (signed verdict), and a critical caveat about the prediction nature of consistency. No gaps remain.
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 100%, and the description provides additional context for the 'content' parameter (the instruction file). While the schema already describes both parameters, the description clarifies their roles beyond the schema.
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?
Clearly states the tool verifies a TomeVault attestation document, specifying the actions: confirming the signature's authenticity and checking file integrity. The verb 'verify' and resource 'attestation document' are explicit, distinguishing it from sibling tools like convert_content or get_provenance.
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?
Provides clear context for when to use the tool (verification of attestation and content consistency). Does not explicitly mention when not to use it or direct alternatives among siblings, but the purpose is well-defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!