Server definition

Hash: sha256:d9d8d7857b23cb53d07273c2b2a175e6b2bc6c881f69370db8d912dd78c7907c
What it is: What a remote MCP server returned when asked what it offers: 5 tools

The blob, as servednamed by its sha256

{
  "instructions": null,
  "tools": [
    {
      "description": "Retrieve a zero-knowledge proof circuit by its circuitId via GET /v1/circuits/{circuitId}. A circuit defines the constraints that proofs must satisfy and binds to a single schema. Returns CircuitMeta { circuitId, schema, description?, inputs?, verifier?: { type: 'onchain'|'offchain', address?, chainId? }, artifact?: { location: { type: 'ipfs'|'https', wasm, zkey } } }. Use this before lemma_submit_proof to confirm the circuit's schema, public inputs, and verifier configuration. Circuits are immutable; new variants get new circuitIds.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "circuitId": {
            "description": "Circuit ID. Returned in the `proof.circuitId` field of VerifiedAttributesQueryResponseItem from lemma_query_verified_attributes, or registered via POST /v1/circuits. NOTE: this matches the OpenAPI field name `circuitId`, not a generic `id`.",
            "type": "string"
          }
        },
        "required": [
          "circuitId"
        ],
        "type": "object"
      },
      "name": "lemma_get_circuit",
      "outputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "artifact": {
            "additionalProperties": false,
            "description": "Circuit artifact location (WASM + zkey).",
            "properties": {
              "location": {
                "additionalProperties": false,
                "properties": {
                  "type": {
                    "enum": [
                      "ipfs",
                      "https"
                    ],
                    "type": "string"
                  },
                  "wasm": {
                    "description": "Circuit WASM artifact URL/CID.",
                    "type": "string"
                  },
                  "zkey": {
                    "description": "Circuit proving key URL/CID.",
                    "type": "string"
                  }
                },
                "required": [
                  "type",
                  "wasm",
                  "zkey"
                ],
                "type": "object"
              }
            },
            "required": [
              "location"
            ],
            "type": "object"
          },
          "circuitId": {
            "description": "Circuit ID, echoing the request.",
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "inputs": {
            "description": "Ordered names of the circuit's public/private inputs.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "schema": {
            "description": "Schema ID this circuit is bound to.",
            "type": "string"
          },
          "verifiers": {
            "description": "Available verifier configurations for this circuit.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "address": {
                  "description": "Verifier contract address (onchain only).",
                  "type": "string"
                },
                "alg": {
                  "description": "Proof algorithm identifier (e.g. 'groth16-bn254-snarkjs').",
                  "type": "string"
                },
                "chainId": {
                  "description": "EVM chain ID (onchain only).",
                  "type": "number"
                },
                "type": {
                  "description": "Verifier location.",
                  "enum": [
                    "onchain",
                    "offchain"
                  ],
                  "type": "string"
                }
              },
              "required": [
                "type"
              ],
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "circuitId",
          "schema"
        ],
        "type": "object"
      }
    },
    {
      "description": "Retrieve a Lemma document generator by generatorId via GET /v1/doc-generators/{generatorId}. A generator describes how a class of source documents is produced (e.g., what fields a 'KYC-v2' issuer must populate). Returns GeneratorMeta { generatorId, schema, description?, language?, source?: { type: 'url', uri }, inputsSpec?, outputsSpec? }. Each generator is bound to one schema. Use this when onboarding a new issuer or auditing how an existing schema is being populated.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "generatorId": {
            "description": "Generator ID. Each generator is bound to a single schema and describes how source documents are produced. Registered via POST /v1/doc-generators. NOTE: this matches the OpenAPI field name `generatorId`, not a generic `id`.",
            "type": "string"
          }
        },
        "required": [
          "generatorId"
        ],
        "type": "object"
      },
      "name": "lemma_get_generator",
      "outputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "description": {
            "type": "string"
          },
          "generatorId": {
            "description": "Generator ID, echoing the request.",
            "type": "string"
          },
          "inputsSpec": {
            "additionalProperties": {},
            "description": "Specification of fields the issuer must populate.",
            "type": "object"
          },
          "language": {
            "description": "Implementation language (e.g. 'rust', 'typescript').",
            "type": "string"
          },
          "outputsSpec": {
            "additionalProperties": {},
            "description": "Specification of fields the generator produces.",
            "type": "object"
          },
          "schema": {
            "description": "Schema ID this generator is bound to (1:1 binding).",
            "type": "string"
          },
          "source": {
            "additionalProperties": false,
            "description": "Reference to the generator's source code.",
            "properties": {
              "type": {
                "const": "url",
                "type": "string"
              },
              "uri": {
                "description": "Source URL (git, IPFS, etc.).",
                "type": "string"
              }
            },
            "required": [
              "type",
              "uri"
            ],
            "type": "object"
          }
        },
        "required": [
          "generatorId",
          "schema"
        ],
        "type": "object"
      }
    },
    {
      "description": "Get the verification status of a proof. NOTE: the v2 API does not yet expose a dedicated GET /v1/proofs/{id} endpoint, so this tool internally calls POST /v1/verified-attributes/query filtered by docHash (treating the verificationId returned from lemma_submit_proof as a docHash filter). Returns { status, circuitId, chainId, docHash } extracted from the matched item, or undefined if the verificationId is unknown. Status enum: received | verified | onchain-verified | rejected. Use the SDK's isVerified() helper (or check status === 'verified' || status === 'onchain-verified') to determine cryptographic validity.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "verificationId": {
            "description": "verificationId returned by lemma_submit_proof. Internally treated as a docHash filter on POST /v1/verified-attributes/query (no dedicated GET /v1/proofs/{id} endpoint in v2 API).",
            "type": "string"
          }
        },
        "required": [
          "verificationId"
        ],
        "type": "object"
      },
      "name": "lemma_get_proof_status",
      "outputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "chainId": {
            "description": "EVM chain ID where the proof was verified, if applicable.",
            "type": "number"
          },
          "circuitId": {
            "description": "Circuit ID this proof was generated against.",
            "type": "string"
          },
          "docHash": {
            "description": "Document hash this proof attests to.",
            "type": "string"
          },
          "status": {
            "description": "Verification status enum: 'received' | 'verified' | 'onchain-verified' | 'rejected'. Use the SDK's isVerified() helper (or check status === 'verified' || status === 'onchain-verified') for cryptographic validity.",
            "type": "string"
          }
        },
        "type": "object"
      }
    },
    {
      "description": "Retrieve a Lemma schema by its ID via GET /v1/schemas/{id}. A schema declares how documents of a given type are interpreted and normalized. Returns SchemaMeta { id, description? } with additionalProperties open — implementations commonly include a `normalize` artifact (WASM that maps raw documents to canonical form) and its content hash. Use this when you need to interpret attribute keys returned by lemma_query_verified_attributes.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "id": {
            "description": "Schema ID. Returned in the `schema` field of VerifiedAttributesQueryResponseItem from lemma_query_verified_attributes, or registered via POST /v1/schemas.",
            "type": "string"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "name": "lemma_get_schema",
      "outputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "description": {
            "description": "Human-readable description of the schema.",
            "type": "string"
          },
          "id": {
            "description": "Schema ID, echoing the request.",
            "type": "string"
          },
          "normalize": {
            "additionalProperties": false,
            "description": "Normalize artifact — WASM that maps raw documents to canonical form.",
            "properties": {
              "abi": {
                "additionalProperties": false,
                "description": "Optional ABI mapping between raw input keys and normalized attribute names.",
                "properties": {
                  "norm": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "type": "object"
                  },
                  "raw": {
                    "additionalProperties": {
                      "type": "string"
                    },
                    "type": "object"
                  }
                },
                "required": [
                  "raw",
                  "norm"
                ],
                "type": "object"
              },
              "artifact": {
                "additionalProperties": false,
                "properties": {
                  "js": {
                    "description": "URL or CID of the wasm-bindgen JS shim required for instantiation.",
                    "type": "string"
                  },
                  "type": {
                    "description": "URI scheme for fetching the WASM artifact.",
                    "enum": [
                      "ipfs",
                      "https"
                    ],
                    "type": "string"
                  },
                  "wasm": {
                    "description": "URL or CID of the WASM module.",
                    "type": "string"
                  }
                },
                "required": [
                  "type",
                  "wasm",
                  "js"
                ],
                "type": "object"
              },
              "hash": {
                "description": "Content hash of the WASM module (verifies integrity).",
                "type": "string"
              }
            },
            "required": [
              "artifact",
              "hash"
            ],
            "type": "object"
          }
        },
        "required": [
          "id",
          "normalize"
        ],
        "type": "object"
      }
    },
    {
      "description": "Query cryptographically verified attributes from Lemma. Use this as the primary tool for finding documents whose attributes match given conditions (e.g., \"subject's birthYear lt 2008\"). Returns { results: Array<{ docHash, schema, issuerId, subjectId, attributes, isVerified, proof?: { status, circuitId, chainId }, disclosure? }>, hasMore }. The MCP layer enriches each item with an `isVerified` flag derived from `proof.status` (true when status is 'verified' or 'onchain-verified'). Use lemma_get_proof_status to monitor a specific proof; use lemma_get_schema to interpret the keys returned in `attributes`.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "attributes": {
            "description": "Attribute predicates to AND-combine.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "name": {
                  "description": "Attribute key as defined by the schema.",
                  "type": "string"
                },
                "operator": {
                  "description": "Comparison operator. Defaults to eq when omitted. 'in' takes an array value; 'contains' is substring/array-element match.",
                  "enum": [
                    "eq",
                    "neq",
                    "gt",
                    "gte",
                    "lt",
                    "lte",
                    "in",
                    "contains"
                  ],
                  "type": "string"
                },
                "value": {
                  "description": "Comparison target value. Type depends on the schema's attribute definition. For 'in', pass an array."
                }
              },
              "required": [
                "name"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "chainIds": {
            "description": "Restrict results to attributes verified on these chain IDs (EVM).",
            "items": {
              "type": "number"
            },
            "type": "array"
          },
          "limit": {
            "description": "Max results per page (1–200). Defaults to API server default (50).",
            "maximum": 200,
            "minimum": 1,
            "type": "number"
          },
          "offset": {
            "description": "Pagination offset. Pair with `hasMore` in the response to walk pages.",
            "minimum": 0,
            "type": "number"
          },
          "schemas": {
            "description": "Restrict results to documents conforming to these schema IDs.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "name": "lemma_query_verified_attributes",
      "outputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "hasMore": {
            "description": "True when more results exist beyond this page; pair with `offset` to walk pages.",
            "type": "boolean"
          },
          "results": {
            "description": "Result set; each item has been MCP-enriched with `isVerified`.",
            "items": {
              "additionalProperties": false,
              "properties": {
                "attributes": {
                  "additionalProperties": {},
                  "description": "Attribute key/value pairs as defined by the schema.",
                  "type": "object"
                },
                "chainId": {
                  "description": "EVM chain ID, if anchored on-chain.",
                  "type": "number"
                },
                "disclosure": {
                  "description": "Selective-disclosure payload, if present."
                },
                "docHash": {
                  "description": "Document hash (commitment root).",
                  "type": "string"
                },
                "isVerified": {
                  "description": "MCP-layer flag — true when proof.status is 'verified' or 'onchain-verified'. Prefer this over raw status for boolean checks.",
                  "type": "boolean"
                },
                "issuerId": {
                  "description": "Issuer DID/identifier.",
                  "type": "string"
                },
                "proof": {
                  "additionalProperties": false,
                  "description": "Proof envelope (status, circuit, chain).",
                  "properties": {
                    "chainId": {
                      "type": "number"
                    },
                    "circuitId": {
                      "type": "string"
                    },
                    "status": {
                      "type": "string"
                    }
                  },
                  "type": "object"
                },
                "schema": {
                  "description": "Schema ID this document conforms to.",
                  "type": "string"
                },
                "subjectId": {
                  "description": "Subject DID/identifier.",
                  "type": "string"
                }
              },
              "required": [
                "docHash",
                "schema",
                "issuerId",
                "subjectId",
                "attributes",
                "isVerified"
              ],
              "type": "object"
            },
            "type": "array"
          }
        },
        "required": [
          "results",
          "hasMore"
        ],
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:d9d8d7857b23cb53d07273c2b2a175e6b2bc6c881f69370db8d912dd78c7907c | sha256sum