Which integrations are available for this server?

Allows timestamping files and verifying cryptographic proofs on the Bitcoin blockchain via OpenTimeStamps calendars.

How do I use OpenTimeStamps MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@OpenTimeStamps MCP Server timestamp the file 'notes.txt'" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

OpenTimeStamps MCP Server

by getAlby

Overview Schema Source Related Servers Discussions Admin

TypeScript

Hybrid

🕰️ OpenTimeStamps MCP Server

A Model Context Protocol (MCP) server that enables AI models to interact with OpenTimeStamps, allowing them to timestamp files and verify proofs on the Bitcoin blockchain.

Trustless timestamping for the AI age.

TypeScript MCP OpenTimeStamps

🚀 Features

🔢 Calculate hash values (SHA256, SHA1, RIPEMD160)
⏰ Submit hashes for timestamping via OpenTimeStamps calendars
📁 Load and parse OTS proof files
📊 Display detailed information about OTS proofs
⬆️ Upgrade incomplete OTS proofs
✅ Verify OTS proofs against original data or hashes
🌐 Server-Sent Events (SSE) support for web integration
🔌 MCP-compliant API for AI integration

Related MCP server: Nostr MCP Server

📋 Prerequisites

Node.js 18+

🛠️ Installation

Installing via Smithery (Coming Soon)

To install OpenTimeStamps MCP Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install @fmar/opentimestamps-mcp --client claude

Manual Installation

Clone the repository:

git clone https://github.com/fmargarita/opentimestamps-mcp
cd opentimestamps-mcp

Install dependencies:

npm install

Build the project:

npm run build

Create a .env file (optional):

You can copy .env.example and modify as needed:

cp .env.example .env

🔧 Setup with Claude Desktop

To use this MCP server with Claude Desktop, add the following to your Claude Desktop configuration file:

macOS

# Edit the configuration file
code ~/Library/Application\ Support/Claude/claude_desktop_config.json

Windows

# Edit the configuration file
notepad %APPDATA%\Claude\claude_desktop_config.json

Configuration

Add this configuration to your claude_desktop_config.json:

{
  "mcpServers": {
    "opentimestamps": {
      "command": "node",
      "args": ["/absolute/path/to/opentimestamps-mcp/build/cli.js"],
      "env": {
        "LOG_LEVEL": "info"
      }
    }
  }
}

Important: Replace /absolute/path/to/opentimestamps-mcp/ with the actual path where you cloned this repository.

After updating the configuration:

Restart Claude Desktop
You should see the OpenTimeStamps tools available in your conversation

🔧 Setup with Goose

For Goose AI assistant, add this to your config.yaml:

mcp:
  servers:
    opentimestamps:
      command: node
      args:
        - /absolute/path/to/opentimestamps-mcp/build/cli.js
      env:
        LOG_LEVEL: info

🚦 Usage

Starting the Server

# Development mode with hot reload
npm run dev

# Production mode
npm start

Available Tools

`calculate_hash`

Calculate the hash of data using the specified algorithm.

Example input:

{
  "data": "Hello, OpenTimeStamps!",
  "algorithm": "sha256"
}

`stamp_hash`

Submit a hash for timestamping using OpenTimeStamps calendar servers.

Example input:

{
  "hash": "a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3",
  "algorithm": "sha256"
}

`load_proof`

Load an OTS proof from hex data or file path.

Example input:

{
  "otsData": "004f70656e54696d657374616d7073000050726f6f66...",
  "isFilePath": false
}

`get_proof_info`

Display detailed information about an OTS proof.

Example input:

{
  "otsData": "004f70656e54696d657374616d7073000050726f6f66..."
}

`upgrade_proof`

Upgrade an incomplete OTS proof by fetching missing attestations.

Example input:

{
  "otsData": "004f70656e54696d657374616d7073000050726f6f66..."
}

`verify_proof`

Verify an OTS proof against original data or hash.

Example input:

{
  "otsData": "004f70656e54696d657374616d7073000050726f6f66...",
  "originalData": "Hello, OpenTimeStamps!",
  "algorithm": "sha256"
}

🔧 Development

Project Structure

opentimestamps-mcp/
├── src/
│   ├── index.ts        # Main server entry point
│   ├── ots-client.ts   # OpenTimeStamps client implementation
│   ├── stdio_server.ts # STDIO transport server
│   ├── sse_server.ts   # SSE transport server
│   ├── types.ts        # TypeScript type definitions
│   ├── types/          # Type declarations
│   └── utils/          # Utility functions
├── .env.example        # Environment configuration template
├── claude_desktop_config.json # Claude Desktop config example
└── tsconfig.json       # TypeScript configuration

Running Tests

npm test

📚 Examples

Basic Workflow

Calculate a hash of your data:

Use the calculate_hash tool with your text or data

Submit for timestamping:

Use the stamp_hash tool with the resulting hash

Check the proof:

Use get_proof_info to see the attestation details

Upgrade proof (after ~10 minutes):

Use upgrade_proof to get Bitcoin confirmations

Verify the proof:

Use verify_proof with your original data and the proof

Sample Conversation with Claude

User: "Please calculate the SHA256 hash of 'Hello World'"

Claude will use: calculate_hash
Input: {"data": "Hello World", "algorithm": "sha256"}

User: "Now timestamp that hash"

Claude will use: stamp_hash  
Input: {"hash": "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e", "algorithm": "sha256"}

User: "Show me the proof information"

Claude will use: get_proof_info
Input: {"otsData": "004f70656e54696d657..."}

🔒 Privacy & Security

OpenTimeStamps provides cryptographic proof of existence without revealing file contents:

Privacy: Only file hashes are submitted to calendar servers, never the actual data
Trustless: Verification is done against the Bitcoin blockchain, not trusted third parties
Immutable: Once timestamped on Bitcoin, proofs cannot be altered or removed
Verifiable: Anyone can independently verify timestamps using the Bitcoin blockchain

⚙️ Configuration

All configuration is optional and handled through environment variables:

OTS_CALENDAR_SERVERS: Custom calendar servers (defaults to standard OTS servers)
BITCOIN_RPC_*: Bitcoin node connection for local verification (optional)
SERVER_MODE: Choose between stdio (default) or sse transport
PORT: HTTP port for SSE mode (default: 3000)

🤝 Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

🔗 Resources

🚀 Getting Started

The fastest way to test the server:

Calculate a hash:

"Calculate the SHA256 hash of 'Hello World'"

Timestamp the hash:

"Timestamp that hash using OpenTimeStamps"

Verify later:

"Verify the proof against the original text 'Hello World'"

Available Tools

7 tools

calculate_hashC

Calculate the hash of data using the specified algorithm (sha256, sha1, or ripemd160)

ParametersJSON Schema

Name	Required	Description	Default
`data`	Yes	The data to hash (as string)
`algorithm`	No	Hash algorithm to use	sha256

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It does not state whether the operation is pure/side-effect-free, what the default output format is, or how it relates to the surrounding proof tools. Only the abstract behavior is described.

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?

A single efficient sentence with the verb front-loaded and no redundant filler. It is appropriately sized for a two-parameter utility.

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?

For a simple two-parameter pure function with full schema coverage and no output schema, the description is minimally adequate. It omits return-format expectations and the relationship to the proof-related siblings, which would help an agent place it in the workflow.

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 both parameters fully documented including the enum and default, so the schema does the heavy lifting. The description repeats the algorithm values but adds nothing beyond the schema.

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?

States a specific verb (calculate) and resource (hash of data), and enumerates the algorithm options. It does not differentiate from the sibling stamp_hash, which likely also produces a hash-related artifact, but the core purpose is unambiguous.

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 guidance on when to use this versus alternatives like stamp_hash, nor any context or prerequisites. The description only states what it does, leaving selection to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_full_proofC

Get the full OTS proof from a given hash

ParametersJSON Schema

Name	Required	Description	Default
`hash`	Yes	Hex-encoded hash to get full proof for
`algorithm`	No	Hash algorithm used	sha256

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a non-mutating read, but the description says nothing about permissions, whether the proof must exist, what happens on a missing hash, or the size/format of the returned proof.

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?

A single short sentence with the key resource front-loaded and no filler. It is efficient, though almost too terse to earn a top score.

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?

For a low-complexity 2-parameter lookup with full schema coverage and no output schema, the description is minimally adequate but omits the one thing that would help most: how the 'full proof' relates to the other proof-related siblings and what it returns.

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 description coverage is 100%, so both the hash and the algorithm enum/default are fully documented in the schema. The description adds only 'from a given hash', giving no format or interaction details beyond what the schema already provides, so the baseline 3 applies.

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?

States a specific verb (get) and resource (full OTS proof) keyed off a hash, which an agent can distinguish from siblings like load_proof or get_proof_info. However, it never explicitly says how 'full proof' differs from 'proof info', so the sibling differentiation is only implicit.

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?

There is no guidance on when to call this versus load_proof, get_proof_info, or verify_proof, nor any stated prerequisite (e.g., whether the hash must have been stamped first). Usage must be entirely inferred from the tool name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_proof_infoC

Display information about an OTS proof

ParametersJSON Schema

Name	Required	Description	Default
`otsData`	Yes	OTS proof data (hex string)

TDQS

C2.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It implies a read ('Display') but says nothing about what is returned, whether the proof must be loaded first, or whether any network/validation work happens.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The single sentence is front-loaded and free of waste, but for a tool with no annotations and no output schema it is arguably under-sized rather than appropriately concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description is the only source of behavioral context, and it supplies none. It never says what 'information' comprises or how the result differs from get_full_proof, leaving an agent under-informed.

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 description coverage is 100% for the single otsData parameter ('OTS proof data (hex string)'), so the schema already carries the semantics. The description adds no further meaning such as expected format constraints or where the hex string comes from, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a verb ('Display') and a resource ('OTS proof'), so the basic purpose is legible. However, 'information' is undefined and it does not distinguish itself from close siblings like get_full_proof or verify_proof, which an agent could easily confuse it with.

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?

There is no guidance on when to use this tool versus load_proof, get_full_proof, or verify_proof. The agent must infer from the name alone which of the seven proof-related siblings to pick.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

load_proofB

Load an OTS proof from hex data or file path

ParametersJSON Schema

Name	Required	Description	Default
`otsData`	Yes	OTS proof data (hex string or file path)
`isFilePath`	No	Whether otsData is a file path

TDQS

B3.1/5.0

Behavior2/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, but it only states that it loads a proof. It does not clarify whether the operation is read-only, whether it modifies state, what happens on invalid input, or any auth/rate-limit constraints.

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 a single, front-loaded sentence with no wasted words. It immediately communicates the action, resource, and input source.

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?

For a simple two-parameter tool with a fully described schema and no output schema, the description is minimally adequate to invoke it. However, with no annotations and no usage or behavioral context, it leaves important gaps about when and how to use it relative to sibling proof tools.

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 description coverage is 100%, so the schema already fully documents both parameters. The description's phrase 'from hex data or file path' mirrors the schema and adds no extra syntax, format, or default details beyond it.

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 states a specific verb ('Load') and resource ('OTS proof') and clarifies the input source ('hex data or file path'). It is clear enough for an agent to know what the tool does, though it does not explicitly differentiate from siblings like get_proof_info or verify_proof.

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 gives no guidance on when to use this tool versus alternatives such as get_proof_info or get_full_proof. It only describes the accepted inputs, leaving usage context entirely to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

stamp_hashC

Submit a hash for timestamping using OpenTimeStamps calendar servers

ParametersJSON Schema

Name	Required	Description	Default
`hash`	Yes	Hex-encoded hash to timestamp
`algorithm`	No	Hash algorithm used	sha256

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full behavioral burden. It discloses the external OpenTimeStamps calendar servers as the backend, but says nothing about side effects, authentication requirements, network behavior, failure modes, or whether the submission is persistent or reversible.

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 a single, front-loaded sentence with no filler or repetition. It is efficient, though it could do slightly more to structure usage context without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description should convey more about what happens after submission and what the agent receives. It states the action and backend but omits usage context, behavioral expectations, and return-value information, leaving significant gaps for an agent to call it correctly.

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 description coverage is 100%, so the input schema already documents both parameters fully, including the hex-encoded format and the algorithm enum with default. The description adds no parameter details beyond what the schema provides, so the baseline score of 3 applies.

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 states a specific verb ('Submit') and resource ('a hash for timestamping') plus the backend ('OpenTimeStamps calendar servers'), so the tool's basic action is clear. It implicitly distinguishes from calculate_hash by saying the hash is already formed, but it does not explicitly name or contrast with any sibling tool.

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 when-to-use guidance, prerequisites, or alternatives. It never mentions that a hash should first be produced with calculate_hash, nor when timestamping is appropriate versus verifying or loading existing proofs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

upgrade_proofA

Upgrade an incomplete OTS proof by fetching missing attestations

ParametersJSON Schema

Name	Required	Description	Default
`otsData`	Yes	OTS proof data (hex string)

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry behavioral disclosure. It does reveal that the tool fetches missing attestations (likely a network operation), but it omits whether the proof is mutated or returned, failure modes, and any auth/rate-limit 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?

A single, front-loaded sentence with no wasted words. It is appropriately sized for a one-parameter utility.

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?

For a simple one-parameter tool, the description covers purpose and mechanism, but with no output schema it should explain the return value, and with no annotations it should cover behavior more fully. Sibling guidance is also 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 single parameter otsData has full schema description ('OTS proof data (hex string)'). The description adds no syntax, format, or validation details beyond the schema, so the baseline of 3 applies.

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?

States a specific verb ('Upgrade') and resource ('incomplete OTS proof') and adds the mechanism of fetching missing attestations. It does not name or contrast with sibling tools such as get_full_proof, so sibling differentiation is absent.

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 phrase 'incomplete OTS proof' implies a precondition, but the description never states when to choose this over get_full_proof, load_proof, or verify_proof, nor does it list exclusions. Usage is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

verify_proofC

Verify an OTS proof against original data or hash

ParametersJSON Schema

Name	Required	Description	Default
`otsData`	Yes	OTS proof data (hex string)
`algorithm`	No	Hash algorithm used	sha256
`originalData`	No	Original data to verify against
`originalHash`	No	Original hash to verify against (hex string)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It says nothing about the verification outcome (boolean, timestamp confidence, error conditions) or that this is a read-only, non-mutating operation, leaving the agent to infer behavior.

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?

A single front-loaded sentence with no filler. It is efficient, though slightly terse given the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No annotations and no output schema exist, so the description should explain what verification yields (e.g., valid/invalid, blockchain confirmation, timestamp). It omits this entirely, and also leaves the either/or relationship between originalData and originalHash unexplained.

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%, so all four parameters are already documented, establishing a baseline of 3. The description adds a small hint that originalData and originalHash are alternative verification inputs, but does not clarify their mutual exclusivity or the default algorithm behavior beyond the schema.

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?

States a specific verb (Verify) and resource (an OTS proof) with the two input modes it accepts. It distinguishes itself implicitly from siblings like load_proof and get_proof_info, but never names an alternative, so it falls short of a 5.

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?

There is no explicit when-to-use guidance and no contrast with the six sibling tools. The 'original data or hash' phrasing hints at input alternatives but is a parameter note, not tool-selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

7 tool updatesv0.1.0Sep 13, 2026
- First observedcalculate_hash
- First observedget_full_proof
- First observedget_proof_info
- First observedload_proof
- First observedstamp_hash
- First observedupgrade_proof
- First observedverify_proof

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

B3.3/5.0

Scored 2026-09-13 11:15 across 7 tools

Disambiguation4/5

Each tool maps to a distinct step in the OpenTimestamps workflow (hash, stamp, load, info, upgrade, verify, retrieve). The only potential overlap is load_proof vs get_full_proof, but their descriptions distinguish inputs (hex/file vs hash), so confusion is limited.

Naming Consistency5/5

All tool names use snake_case with a verb-first pattern (calculate_hash, stamp_hash, load_proof, upgrade_proof, verify_proof, etc.). The naming is predictable and consistent across the set.

Tool Count5/5

Seven tools is well-scoped for the OpenTimestamps lifecycle; each operation serves a distinct purpose without redundancy. The count fits comfortably within the recommended 3–15 range.

Completeness4/5

Core lifecycle operations—hashing, stamping, loading/retrieving proofs, inspecting, upgrading, and verifying—are all covered. A minor gap is the lack of an explicit save/export proof tool, though load_proof and get_full_proof may cover retrieval needs.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

AccordTrace A
io.github.Kosta1985
Tamper-evident proof creation and verification for AI agents via MCP, A2A, and REST.
Security AI & Machine Learning
91
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
238
mcp A
com.everstake
MCP server connecting AI agents to non-custodial staking data across 130+ networks.
Blockchain Cryptocurrency
1111
Touchstone
cv.touchstone
Bitcoin-anchored, tamper-evident audit log for AI agents — record, disclose and verify actions.
Blockchain Security Autonomous Agents
2

Related MCP Servers

Nostr MCP Server
Communication Blockchain Web3 & Decentralized Tech
AbdelStark
A
license
Not graded
quality
F
maintenance
A Model Context Protocol (MCP) server enabling AI models to interact with the Nostr network, facilitating note posting and interaction with the freedom of speech protocol.
Updated 2 years ago (2025-02-05 09:04 UTC)
24 npm
38
MIT
Nostr MCP Server
mikeysrecipes
A
license
Not graded
quality
D
maintenance
A Model Context Protocol server that enables AI models to interact with the Nostr network, allowing them to post notes and eventually send Lightning zaps to users.
Updated a year ago (2025-07-22 06:57 UTC)
24 npm
1
MIT
Mempool MCP Server
Blockchain Data Platforms
alexandresanlim
A
license
B
quality
D
maintenance
A Model Context Protocol server that provides real-time Bitcoin blockchain and mempool data to AI clients, allowing access to comprehensive Bitcoin network information through various data tools.
Updated a year ago (2025-07-24 11:34 UTC)
31
4 npm
5
MIT
@unfakable/mcp
Blockchain File Systems
unfakable
A
license
A
quality
D
maintenance
Document verification MCP server enabling AI agents to verify file authenticity by computing SHA-256 fingerprints locally and checking Bitcoin-anchored proofs via OpenTimestamps.
Updated 4 months ago (2026-05-14 19:28 UTC)
5
5 npm
MIT