tezos-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@tezos-mcpHow does adaptive issuance work?"
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.
tezos-mcp
RAG-powered MCP server for Tezos protocol specs, TZIPs, and Octez source code.
What It Does
Indexes and searches across:
Octez Protocol - OCaml protocol implementations (
src/proto_*/lib_protocol/)Octez Node - Shell architecture, RPC specs, P2P, storage (
src/,docs/)TZIPs - Tezos Improvement Proposals (FA2, metadata, wallet standards)
Related MCP server: mcp-rag-server
Installation
# From PyPI
pip install tezos-mcp
# From source
pip install -e .
# With Voyage API embeddings (best quality)
pip install -e ".[voyage]"
# With tree-sitter OCaml parsing
pip install -e ".[ocaml]"Quick Start
# Build the index (downloads repos + creates embeddings)
tezos-mcp build
# Search
tezos-mcp search "FA2 token standard"
# Check status
tezos-mcp statusFeatures
Incremental Indexing
Only re-embeds changed files instead of rebuilding the entire index. Reduces update time from minutes to seconds.
# Update repos and incrementally re-index (fast!)
tezos-mcp update
# Incremental index (default behavior)
tezos-mcp index
# Force full rebuild
tezos-mcp index --fullHow it works:
Tracks file hashes and modification times in a manifest
Detects which files changed since last index
Only re-embeds the changed content
Updates LanceDB incrementally (add/delete operations)
Configurable Embedding Models
Choose from multiple embedding models based on your quality/speed tradeoff:
# List available models
tezos-mcp models
# Use a specific model
tezos-mcp index --model codesage/codesage-largeModel | Dims | Quality | Speed | Notes |
| 384 | Fair | Fast | Default, good for quick searches |
| 768 | Good | Medium | Better quality |
| 1024 | Good | Medium | Code-specialized |
| 1024 | Excellent | API | Best quality, requires API key |
Configure in ~/.tezos-mcp/config.yaml:
embedding_model: all-MiniLM-L6-v2
chunk_size: 1000
chunk_overlap: 200
protocol_depth: 3 # Number of past protocols to indexExpert Guidance
Curated knowledge beyond what's in the code:
# Via MCP tool
tez_expert_guidance("baking")
tez_expert_guidance("governance")
tez_expert_guidance("smart_rollups")Topics include: baking, delegation, staking, tenderbake, governance, smart_rollups, dal, michelson, fa2, adaptive_issuance, slashing
CLI Commands
# Full build pipeline
tezos-mcp build # Download + compile + index
tezos-mcp build --full # Force full rebuild
# Individual steps
tezos-mcp download # Clone octez + tzip repos
tezos-mcp compile # Parse OCaml/markdown into JSON
tezos-mcp index # Build vector embeddings
tezos-mcp index --full # Force full rebuild
tezos-mcp index --model MODEL # Use specific embedding model
# Update (git pull + incremental index)
tezos-mcp update
tezos-mcp update --full # Update + force rebuild
# Search
tezos-mcp search "stake delegation"
tezos-mcp search "tenderbake consensus" --protocol paris
tezos-mcp search "FA2 transfer" --limit 10
# Lookup
tezos-mcp constant max_operations_ttl
tezos-mcp function apply_operation
# Info
tezos-mcp status # Index status, manifest info
tezos-mcp models # List embedding models
tezos-mcp serve # Start MCP serverMCP Tools
When running as an MCP server:
Tool | Purpose |
| Semantic search across all indexed content |
| Search TZIP standards (FA2, metadata, wallet specs) |
| Search protocol specs and OCaml source |
| Search Octez node docs and source code |
| Fast OCaml constant lookup |
| Get OCaml function source code |
| Current mainnet protocol (Tallinn) |
| Full amendment history (Athens through Tallinn) |
| Curated guidance on Tezos topics |
Protocol Amendments
Tezos upgrades through on-chain governance. The index covers the full amendment history:
Protocol | Date | Notable Features |
Athens | 2019-05 | First amendment |
Ithaca | 2022-03 | Tenderbake consensus |
Mumbai | 2023-03 | Smart rollups |
Paris | 2024-06 | Adaptive issuance, staking |
Quebec | 2025-02 | Universal baker attestation |
Tallinn | 2026-01 | 6s block time |
Project Structure
src/tezos_mcp/
├── server.py # MCP server (FastMCP)
├── cli.py # CLI commands (Click)
├── config.py # Configuration management
├── models.py # Pydantic input validation
├── protocols.py # Protocol amendment history
├── logging.py # Structured logging
├── indexer/
│ ├── downloader.py # Git clone with sparse checkout
│ ├── compiler.py # Markdown/RST extraction
│ ├── ocaml_compiler.py # OCaml parsing (tree-sitter + regex)
│ ├── chunker.py # Document chunking + chunk IDs
│ ├── embedder.py # Embeddings + LanceDB + incremental
│ └── manifest.py # File tracking for incremental updates
└── expert/
└── guidance.py # Curated expert knowledgeData Location
~/.tezos-mcp/
├── config.yaml # Configuration (optional)
├── manifest.json # Index state tracking
├── repos/
│ ├── tezos/ # Octez protocol + node (sparse checkout)
│ └── tzip/ # TZIP standards (full clone)
├── compiled/ # Extracted JSON specs
│ ├── tzips/
│ └── octez_docs/
└── lancedb/ # Vector indexExpert Guidance Topics
The tez_expert_guidance tool provides curated knowledge on:
Consensus & Baking:
baking- Block production, endorsing, rightsdelegation- Delegating to bakers, rewardsstaking- Direct staking (Paris+), frozen depositstenderbake- Deterministic finality consensusslashing- Double-baking/endorsing penalties
Governance & Standards:
governance- On-chain amendment processfa2- FA2 token standard (TZIP-012)michelson- Smart contract language
Scaling & Data:
smart_rollups- L2 scaling (WASM rollups)dal- Data Availability Layeradaptive_issuance- Dynamic reward adjustment
Development
# Install with dev dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Run tests with coverage
pytest --cov=tezos_mcp
# Lint
ruff check src/Running as MCP Server
# Start the server
tezos-mcp serveAdd to your Claude Code MCP configuration:
{
"mcpServers": {
"tezos-mcp": {
"command": "tezos-mcp",
"args": ["serve"]
}
}
}License
MIT
Available Tools
9 toolstez_analyze_functionTez Analyze FunctionB
Extract an OCaml function implementation from the protocol source.
| Name | Required | Description | Default |
|---|---|---|---|
| protocol | No | Optional protocol name filter | |
| function_name | Yes | Function name (e.g. 'apply_operation', 'bake') |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden. It only states the action but does not disclose what the function returns, whether it searches across protocols, or error behavior, so it is limited.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loaded with the action, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is minimal and lacks information about return value, expected output format, or any prerequisites. For a source extraction tool, this could be incomplete, so it scores low.
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?
Both parameters have descriptions in the schema: 'Optional protocol name filter' and 'Function name (e.g. 'apply_operation', 'bake')'. The description itself does not add additional parameter context beyond the schema, so it meets baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Extract an OCaml function implementation from the protocol source.' It uses a specific verb 'Extract' and specifies the resource, distinguishing it from sibling search tools.
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 usage guidance is provided. The description does not indicate when to use this tool versus alternatives like tez_search or tez_grep_constant, leaving the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_expert_guidanceTez Expert GuidanceB
Get curated expert knowledge about a Tezos topic.
Available topics: baking, delegation, staking, tenderbake, governance, smart_rollups, dal, michelson, fa2, adaptive_issuance, slashing
| Name | Required | Description | Default |
|---|---|---|---|
| topic | Yes | Topic name (e.g. 'baking', 'governance', 'smart_rollups') |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description carries the full burden of explaining behavior. It states the tool returns curated knowledge but does not disclose side effects, safety properties, or operational details such as rate limits, error handling, or whether the tool is read-only. Minimal transparency is provided.
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 concise and well-structured. It consists of two clear sentences: the first states the tool's purpose, and the second lists the available topics. There is no redundant information or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides the tool's purpose and the valid input values, which are essential for basic usage. However, it lacks information about expected output, return format, or how this tool fits into workflows compared to other tools. More context would be needed for a fully informed agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes the 'topic' parameter with examples. The tool description adds value by enumerating the full set of accepted topics, which is not present in the schema. This clarifies the parameter's range and reduces ambiguity.
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 that the tool provides curated expert knowledge about Tezos topics, using a specific verb ('get') and resource ('expert knowledge about Tezos topics'). It implicitly differentiates from sibling search tools by emphasizing 'curated expert knowledge', but does not explicitly name any alternative or contrast them.
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 offers no guidance on when to use this tool versus the sibling search or grep tools. It only lists available topics and does not indicate scenarios where this tool is preferred or where others should be used instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_get_current_protocolTez Get Current ProtocolA
Get the current Tezos mainnet protocol name, number, and features.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not explicitly mention side effects, permissions, rate limits, or that the operation is read-only. Though 'Get' suggests a safe read, the description carries the full burden and omits any behavioral details beyond the return value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no unnecessary words. It clearly front-loads the verb and resource, making it easy to parse and act upon.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and a simple output, the description fully specifies what is returned (name, number, features). It is complete and self-contained for the intended use 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?
The input schema has zero parameters and the schema coverage is 100% since there is nothing to document. With no parameters, the baseline score of 4 applies, and the description correctly implies no arguments are needed.
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 a specific action ('Get') and a specific resource ('current Tezos mainnet protocol') along with the exact data returned (name, number, features). This clearly distinguishes it from the sibling tools which focus on searching, listing, or analyzing Tezos data.
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 by naming the exact resource retrieved, but it does not explicitly state when to use this tool over alternatives (e.g., when you need the current protocol rather than searching or listing protocols). No exclusions or alternative conditions are mentioned, so guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_grep_constantTez Grep ConstantA
Look up an OCaml constant definition from the protocol source.
| Name | Required | Description | Default |
|---|---|---|---|
| protocol | No | Optional protocol name filter | |
| constant_name | Yes | Constant name (e.g. 'max_operations_ttl', 'blocks_per_cycle') |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. The word 'Look up' implies a read-only operation, but there is no explicit statement about side effects, error behavior, or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that directly states the tool's purpose without any fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for a simple lookup tool, but it lacks context about when to choose this over search tools. However, the presence of an output schema means the return value explanation is not required.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides descriptions and examples for both parameters (constant_name and protocol). The tool description adds nothing beyond what is already in the schema, so it provides minimal additional value.
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 verb 'Look up' is specific and the resource 'OCaml constant definition from the protocol source' is clearly defined. This distinguishes it from sibling tools like tez_search which likely performs broader searches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for exact, direct constant lookup or that searching would be more appropriate for fuzzy queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_list_protocolsTez List ProtocolsA
List all Tezos protocol amendments in chronological order.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden. It indicates a read-only operation (listing) and implies no side effects, but it does not mention any potential limitations such as pagination, size limits, or whether the list is exhaustive. The scope is implied but not explicitly disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that conveys all essential information without redundancy. It is well-structured and front-loaded with the action and object.
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 (no parameters, no output schema revealed), the description is complete. It specifies the exact scope and ordering. There is no missing context that would confuse an agent.
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?
There are zero parameters, so the baseline is 4. The description does not need to explain parameters and none exist. The tool name and description fully cover what is needed to invoke it.
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 a specific verb ('List') and resource ('Tezos protocol amendments'), and adds the qualifier 'chronological order' which distinguishes it from sibling tools that search or analyze. It is immediately obvious what the tool does and how it differs from the other listed tools.
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 when a complete enumeration is needed, but it does not explicitly contrast with alternatives like tez_get_current_protocol or tez_search_protocol. There is no guidance on when to prefer this over a search tool, though the purpose is fairly intuitive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_searchTez SearchA
Cross-source semantic search across Tezos documentation, TZIPs, and protocol source.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results (1-50, default 5) | |
| query | Yes | Natural language search query | |
| protocol | No | Optional protocol name filter (e.g. 'paris', 'tallinn') |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must convey behavior. It only says 'semantic search', which suggests a read-only operation but does not explicitly state side effects, permissions, or whether results are limited in any way. This is adequate but not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that directly conveys the tool's scope without unnecessary detail or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
It provides the essential context that this is a cross-source search tool, which helps select among siblings. It does not mention output format or result handling, but for a search tool with the given schema, the context is mostly sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers all three parameters with clear descriptions. The tool description does not add extra meaning beyond the schema, so it meets the baseline for fully covered parameters without enhancing 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?
The description states a specific verb ('search'), specifies the resource ('Tezos documentation, TZIPs, and protocol source'), and highlights the cross-source nature, clearly distinguishing it from sibling tools that target individual sources.
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?
It implies usage for cross-source queries by calling out 'cross-source semantic search', and the sibling tools for specific sources are implicitly alternatives. However, it does not explicitly state when to use this versus the specific-source tools, leaving some inference needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_search_octezTez Search OctezB
Search Octez node documentation and source code.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results (1-50, default 5) | |
| query | Yes | Search query about Octez node, shell, RPC, P2P, storage, etc. |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility for behavioral transparency, but it only states the action and resource. It does not mention whether the tool is read-only, what it returns, or any side effects, leaving significant ambiguity.
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, focused sentence that immediately communicates the tool's function without verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too minimal to be fully complete. It does not explain how this tool differs from the similar 'tez_search' or when to prefer it, nor does it provide any usage context or expected output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The parameter schema already includes descriptive text for both query and limit, so the description adds no extra semantic information. Baseline of 3 is applied due to high schema coverage.
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 a specific action (Search) and a specific resource (Octez node documentation and source code), distinguishing it from general search tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool over its siblings (e.g., tez_search, tez_search_tzip). It lacks any 'when to use' or 'when not to use' context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_search_protocolTez Search ProtocolB
Search protocol specifications and OCaml source code.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results (1-50, default 5) | |
| query | Yes | Search query | |
| protocol | No | Optional protocol name filter (e.g. 'paris', 'tallinn', 'alpha') |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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 does not state whether the tool is read-only or has any side effects, although search operations are typically safe. This lack of explicit mention reduces transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that states the action and target without any unnecessary words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool, the description is minimally sufficient. It does not mention the return format or any specific behaviors, but it covers the core function. With sibling tools present, a bit more context would be helpful, but it is not critically incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers all three parameters with descriptions, achieving 100% coverage. The description adds nothing beyond the schema, so per the baseline for full schema coverage, a score 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?
The description clearly states a specific verb ('Search') and resource ('protocol specifications and OCaml source code'), making the tool's purpose explicit. It does not fully differentiate from sibling search tools like tez_search_octez or tez_search_tzip, but the focus on 'protocol' provides some distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus the sibling search tools. It does not mention any conditions or alternatives, leaving the choice to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tez_search_tzipTez Search TzipA
Search TZIP standards (token standards, metadata specs, wallet standards).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results (1-50, default 5) | |
| query | Yes | Search query | |
| tzip_number | No | Optional TZIP number filter (e.g. 12 for FA2) |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description alone must convey behavioral traits. It only states 'Search TZIP standards' without mentioning whether the operation is read-only, what the return format is, or any potential side effects or limitations. This lack of detail leaves the agent uncertain about the tool's behavior.
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, succinct sentence that conveys the essential purpose without any redundant words or fluff. It is well-structured and immediately understandable, exemplifying excellent conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides enough for a basic understanding but omits critical context such as how this tool differs from the general 'tez_search' or what the output schema looks like. Although the output schema exists separately, the description does not mention the return type or any usage nuances, leaving some gaps for an agent deciding whether to use this 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?
The schema description covers 100% of parameters, each with a brief explanation (e.g., 'Search query', 'Maximum results (1-50, default 5)'). The tool description adds no additional parameter detail, so it relies fully on the schema. Since coverage is high, the baseline score 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?
The description clearly states the tool's purpose with the verb 'Search' and the resource 'TZIP standards', and it even provides examples (token standards, metadata specs, wallet standards) that clarify the scope. The name 'tez_search_tzip' reinforces the specific target, making the intent unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for TZIP-specific searches, but it does not explicitly contrast it with sibling tools like 'tez_search' or 'tez_search_protocol'. There is no direct guidance on when to choose this over alternatives, leaving the decision to inference from the name and context.
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.
9 tool updates
v0.1.0- First observed
tez_analyze_function - First observed
tez_expert_guidance - First observed
tez_get_current_protocol - First observed
tez_grep_constant - First observed
tez_list_protocols - First observed
tez_search - First observed
tez_search_octez - First observed
tez_search_protocol - First observed
tez_search_tzip
TDQS
Scored across 9 tools
Most tools have distinct purposes, though the four search variants (tez_search, tez_search_tzip, tez_search_protocol, tez_search_octet) are closely related and could be confused if users don't read descriptions carefully. However, each targets a specific source, reducing ambiguity.
All tools follow the consistent 'tez_' prefix with a verb_noun pattern (e.g., search, grep, analyze, get, list). This uniformity makes the toolkit predictable and easy to navigate.
With 9 tools, the set is well-scoped for a Tezos protocol assistant. It covers searching, specific lookups, and expert guidance without being overwhelming or sparse.
The tools cover core needs: general and targeted search, constant/function extraction, protocol info, and expert knowledge. Minor gaps like broader CRUD operations or editing are absent, but this fits the read-only analytical intent of the server.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
MCP server for querying Forkast documentation
MCP server for building and testing AI agents with multi-model experimentation and insights.
Related MCP Servers
- AlicenseAqualityDmaintenanceLocal-first RAG indexing and semantic search MCP server. Enables document retrieval and context-aware queries using local embedding models.36MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that indexes documents and serves relevant context to LLMs via Retrieval Augmented Generation (RAG).2837MIT
- FlicenseNot gradedqualityDmaintenanceA RAG service based on FastMCP that enables document indexing and retrieval (keyword/vector search) through the MCP protocol.-
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enables semantic search over a private knowledge base via pgvector, with GitHub OAuth authentication and a RAG pipeline.6MIT