zkproofport-ai
Server Details
Zero-knowledge proof generation MCP server. AI agents can prove identity claims (Coinbase KYC, Country, Google OIDC, Google Workspace, Microsoft 365) without revealing personal data.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
TDQS
Scored across 3 tools
Each tool has a clearly distinct role: get_supported_circuits handles discovery, get_guide provides preparation instructions, and prove submits proof generation inputs. There is no meaningful overlap between them.
get_supported_circuits and get_guide follow a consistent get_ noun pattern, while prove is a single verb. This is a minor stylistic deviation but the intent remains clear and predictable.
Three tools is well-scoped for this server's purpose: discovering supported circuits, learning how to prepare inputs, and submitting a proof. Each tool earns its place without unnecessary bloat.
The tool set covers the full workflow: discovery, detailed input preparation guidance, and proof submission via the REST redirect flow. No obvious dead ends or missing operations exist for the stated ZK proof generation domain.
Available Tools
3 toolsget_guideAInspect
Get a comprehensive step-by-step guide for preparing all inputs required for a specific circuit. Read this BEFORE attempting proof generation — the guide covers how to compute signal_hash, nullifier, scope_bytes, merkle_root, how to query EAS GraphQL for the attestation, how to RLP-encode the transaction, how to recover secp256k1 public keys, and how to build the Merkle proof.
| Name | Required | Description | Default |
|---|---|---|---|
| circuit | Yes | Circuit alias to get the guide for. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full behavioral burden. It discloses the guide's concrete content—signal_hash, nullifier, merkle_root, EAS GraphQL querying, RLP encoding, secp256k1 recovery, and Merkle proof construction—which tells the agent what to expect. Side effects and return format are not discussed, but this is a read-oriented guide retrieval with sufficiently disclosed 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 first sentence front-loads the purpose, and the second sentence adds a usage directive plus a detailed list of covered topics. The list is long but each item helps the agent assess whether the guide matches its task.
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?
With one enum-constrained parameter and no output schema, the description tells the agent what the guide contains and when to read it. It does not explicitly describe the return shape, but for a guide-fetching tool this is a minor omission and the overall definition is adequate for correct 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?
The only parameter, circuit, has 100% schema description coverage with 'Circuit alias to get the guide for' and an enum of valid values. The tool description adds no further parameter semantics, so the schema already carries the load; baseline 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 opens with 'Get a comprehensive step-by-step guide for preparing all inputs required for a specific circuit,' naming a clear action and resource. It is easily distinguished from siblings get_supported_circuits and prove, so an agent can tell exactly what this tool does.
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 instruction 'Read this BEFORE attempting proof generation' explicitly tells the agent when to call this tool relative to prove. It does not mention get_supported_circuits or negative cases, but the sequencing guidance is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_supported_circuitsAInspect
List all ZK circuits supported by ZKProofport. Call this first to discover available circuits before starting proof generation.
AVAILABLE MCP TOOLS (use EXACT names — no other tool names exist):
get_supported_circuits — this tool (discovery)
prove — submit proof inputs (redirects to REST endpoint for long-running proof generation)
IMPORTANT: Do NOT call "generate_proof", "proof_request", or any other tool name. The correct flow is: get_supported_circuits → prove (x402 single-step: POST → 402 → pay → retry)
CIRCUITS:
coinbase_attestation ("coinbase_kyc")
Proves the user has passed Coinbase KYC identity verification
EAS Schema ID: 0xf8b05c79f090979bf4a80270aba232dff11a10d9ca55c4f88de95317970f0de9
Verifier (Ethereum Mainnet, chain 1): 0xf3d5a09d2c85b28c52ef2905c1be3a852b609d0c
Required inputs: address, signature, scope
Use circuit = "coinbase_kyc" in the prove tool
coinbase_country_attestation ("coinbase_country")
Proves the user's country of residence from Coinbase attestation is in (or not in) a given country list
EAS Schema ID: 0x1801901fabd0e6189356b4fb52bb0ab855276d84f7ec140839fbd1f6801ca065
Verifier (Ethereum Mainnet, chain 1): 0x78792554e1582cb49d858eacb5c3607b42d28224
Required inputs: address, signature, scope, countryList, isIncluded
Use circuit = "coinbase_country" in the prove tool
CHAIN INFORMATION:
Current deployments are on Ethereum Mainnet (chain ID 1)
EAS (Ethereum Attestation Service) on Base: https://base.easpcan.org/graphql
EAS on Base Sepolia: https://base-sepolia.easpcan.org/graphql
AUTHORIZED COINBASE ATTESTERS (used for Merkle proof construction):
0x952f32128AF084422539C4Ff96df5C525322E564 (index 0)
0x8844591D47F17bcA6F5dF8f6B64F4a739F1C0080 (index 1)
0x88fe64ea2e121f49bb77abea6c0a45e93638c3c5 (index 2)
0x44ace9abb148e8412ac4492e9a1ae6bd88226803 (index 3)
USDC ADDRESSES (for payment):
Base Sepolia (testnet): 0x036CbD53842c5426634e7929541eC2318f3dCF7e
Base mainnet: 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
Response fields:
circuits (array): List of supported circuits with id, displayName, description, requiredInputs, easSchemaId, verifierAddress
chainId (string): Chain ID for verifier addresses
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of explaining behavior. It does so by labeling the operation as discovery/list, describing the response fields (circuits, chainId), and documenting the circuit catalog. It does not mention side effects or auth, but for a read-only, zero-arg tool these omissions are minor.
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 clearly structured with headings and bullet lists and front-loads the main purpose. However, it is lengthy and includes substantial tangential reference data (attester addresses, USDC addresses, chain endpoints) that is not needed to invoke this no-param tool, and the repeated 'AVAILABLE MCP TOOLS' warning is redundant and misleading.
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 zero-param discovery tool with no output schema, the description is more than complete: it states the response shape, the two circuits, verifier addresses, required inputs for downstream prove calls, and the intended sequence. Nothing needed to call this tool correctly is missing.
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 tool has zero parameters and the schema already covers this with an empty properties object, so the baseline for 0 params is 4. The description need not add parameter meanings; it instead describes output fields and circuit inputs, which is useful for the subsequent prove call.
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 opening sentence states a specific verb and resource ('List all ZK circuits supported by ZKProofport') and explicitly labels this tool as the discovery step before proof generation. It also distinguishes it from the prove sibling by naming the workflow get_supported_circuits → prove.
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 gives explicit when-to-use guidance ('Call this first to discover available circuits before starting proof generation'), names the prove tool as the follow-up, and warns against calling other names. However, it claims 'no other tool names exist' while the sibling list includes get_guide, so its exclusivity statement is inaccurate and slightly undermines the guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
proveAInspect
Submit proof inputs to generate a ZK proof via the x402 single-step flow. Atomically verifies USDC payment on-chain and runs the Noir circuit in a TEE to produce a Groth16 SNARK proof.
IMPORTANT: MCP tool calls have timeout limitations that make this tool UNSUITABLE for the 30-90 second proof generation process. This tool returns a redirect message. Use the REST endpoint directly: POST https://stg-ai.zkproofport.app/api/v1/prove (staging) POST https://ai.zkproofport.app/api/v1/prove (production)
x402 SINGLE-STEP FLOW:
POST /api/v1/prove with { circuit, inputs } — no payment yet
Server returns 402 with nonce in body
Pay USDC using nonce, get tx hash
Retry POST /api/v1/prove with same body + X-Payment-TX and X-Payment-Nonce headers
REQUEST BODY SCHEMA: { "circuit": "coinbase_kyc" | "coinbase_country", "inputs": { "signal_hash": "", // 0x, 32 bytes: keccak256(abi.encodePacked(address, scope, circuitId)) "nullifier": "", // 0x, 32 bytes: privacy-preserving unique identifier "scope_bytes": "", // 0x, 32 bytes: keccak256 of the scope string "merkle_root": "", // 0x, 32 bytes: Merkle root of authorized attesters "user_address": "", // 0x, 20 bytes: the KYC wallet address "signature": "", // 65-byte hex: eth_sign(signal_hash) by KYC wallet "user_pubkey_x": "", // 32-byte hex: secp256k1 public key X coordinate "user_pubkey_y": "", // 32-byte hex: secp256k1 public key Y coordinate "raw_transaction": "", // 0x-prefixed RLP-encoded EAS attestation TX (padded to 300 bytes by server) "tx_length": , // actual byte length of raw_transaction BEFORE zero-padding "coinbase_attester_pubkey_x": "", // 32-byte hex: Coinbase attester secp256k1 X coordinate "coinbase_attester_pubkey_y": "", // 32-byte hex: Coinbase attester secp256k1 Y coordinate "merkle_proof": ["", ...], // array of 32-byte hex sibling hashes (one per tree level) "leaf_index": , // 0-based index of attester leaf in the Merkle tree "depth": , // number of levels in the Merkle tree (max 8) "country_list": ["", ...], // optional: only for coinbase_country circuit "is_included": // optional: only for coinbase_country circuit } }
VERIFIER ADDRESSES (Ethereum Mainnet, chain ID 1): coinbase_kyc (coinbase_attestation): 0xf3d5a09d2c85b28c52ef2905c1be3a852b609d0c coinbase_country (coinbase_country_attestation): 0x78792554e1582cb49d858eacb5c3607b42d28224
| Name | Required | Description | Default |
|---|---|---|---|
| inputs | Yes | All circuit inputs required to generate the ZK proof. | |
| circuit | Yes | Which circuit to use. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It clearly warns that the tool returns a redirect message rather than a proof, explains the payment requirement, mentions the TEE execution, and provides verifier addresses. This is substantial behavior context beyond what the input schema conveys.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly structured and front-loaded with the critical timeout warning, but it is far too long: the inline REQUEST BODY SCHEMA repeats nearly all parameter documentation that already exists in the input schema. Many sentences simply duplicate structured data and do not earn their 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?
Despite its verbosity, the description is complete for a complex tool with no output schema. It covers the full payment protocol, the redirect behavior, timeout constraints, alternate REST endpoints, circuit choices, required input fields, and verifier addresses. An agent has enough context to decide not to call the MCP tool and to use the proper REST flow.
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%, so the baseline is 3. The description adds a few small extras, such as noting that raw_transaction is zero-padded to 300 bytes by the server and that verifier addresses map to specific circuits, but the large inline request body schema largely duplicates the input schema rather than adding new parameter meaning.
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 opens with a specific verb and resource: "Submit proof inputs to generate a ZK proof via the x402 single-step flow." It further explains the mechanism (USDC payment verification, Noir circuit, TEE, Groth16 SNARK), clearly distinguishing this from the sibling get_guide and get_supported_circuits 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 explicitly states that the MCP tool is UNSUITABLE due to timeout limitations and instructs the agent to use the REST endpoint instead, naming both staging and production URLs. It also provides a numbered x402 flow with exact request/response steps, leaving no ambiguity about when and how to invoke the underlying operation.
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.
3 tool updates
- First observed
get_guide - First observed
get_supported_circuits - First observed
prove
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables detection and analysis of pre-public product launches through web search, content extraction, AI-powered scoring, and automated alerting. Provides comprehensive tools for surfacing stealth startup signals before they trend publicly.MIT

industrylens-mcpofficial
AlicenseNot gradedqualityBmaintenanceBrowse IndustryLens's published competitive-intelligence reports and head-to-head competitor comparisons from any AI agent — real, source-backed data.MIT- AlicenseNot gradedqualityBmaintenanceAnalyze LinkedIn & email outreach campaigns, track pipeline performance, and review lead conversations for RevOps, Sales Managers, and SDR teams.Apache 2.0
- AlicenseAqualityAmaintenanceDetects hiring intent signals by scanning job boards for specific companies. Returns structured role data for outbound sales targeting.1129 npm1MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.