Log inSubmit server
Agreements API Sdk logo

Agreements API Sdk

by CNSLabs

Validates, deploys, and operates Shodai agreements through signed EIP-712 permits over HTTP or local stdio.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Agreements API Sdk

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "cnslabs-agreements-api-sdk": {
      "command": "npx",
      "args": [
        "-y",
        "@shodai-network/agreements-mcp-server"
      ],
      "env": {
        "AGREEMENTS_API_KEY": "YOUR_VALUE_HERE",
        "AGREEMENTS_API_ENVIRONMENT": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

Install not yet sandbox-tested— the server itself is confirmed live (we called its tools/list endpoint). The stdio install command is a separate, ongoing check.

Overview

CNSLabs/agreements-api-sdk MCP server exposes Shodai Agreements workflows for reading, validating, deploying, and operating machine-readable agreements. It connects to the Shodai Agreements API through hosted Streamable HTTP or a local stdio package, using an API key and named environment. Write operations rely on externally signed EIP-712 permits rather than private-key custody by the server. Reach for it when an agent or MCP client needs agreement lifecycle automation, state monitoring, or signed participant input submission.

Use cases

  • Validate agreement JSON before deployment
  • Prepare EIP-712 deployment permits for external signing
  • Submit signed participant inputs to deployed agreements
  • Poll agreement state after lifecycle events
  • Inspect agreement input history and outcomes

Key features

  • Remote Streamable HTTP and local stdio access
  • Agreement listing and record retrieval
  • Authored JSON validation and deployment preflight
  • EIP-712 typed-data preparation
  • Signed deployment and input submission
  • State and input history inspection

Tools11

What Agreements API Sdk lets your agent do. Expand a tool for its parameters.

Verified live~3.3k tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 2d ago

Recent health check succeeded.

20/20 checks healthy over the last 87d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 2d ago via OSV.dev · @shodai-network/agreements-mcp-server (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars2Stargazers on the source repository.
npm downloads60Package downloads in the last 30 days.
Last commit12d agoMost recent push to the default branch.
Tools exposed11Callable tools this server registers over MCP.
Directory activity3 viewsConfig copies, upvotes, and views on AllMCPs.

How Agreements API Sdk works

What CNSLabs/agreements-api-sdk MCP server does

The CNSLabs/agreements-api-sdk MCP server exposes the Shodai Agreements API as MCP tools for agreement lifecycle work. It supports listing visible agreements, retrieving full agreement records, reading hosted documents, checking current state, and inspecting submitted input history.

For authoring and deployment, the server can validate agreement JSON, run deployment preflight checks, prepare deployment signing data, and submit a deployment with a completed EIP-712 permit. For deployed agreements, it can prepare typed data for participant inputs and submit externally signed inputs that match the agreement’s input definitions and signer permissions.

How it works

The repository supports two MCP connection modes. Hosted access uses the Streamable HTTP endpoint at https://shodai.network/mcp. Local access uses the published @shodai-network/agreements-mcp-server package through stdio. Hosted clients provide an environment tool argument, while local configuration uses an environment variable.

Authentication can use an OAuth-capable client with browser sign-in and consent, or an environment-scoped API key. The server does not hold private keys for hosted MCP use. Instead, typed-data preparation returns the exact EIP-712 payload for an external wallet to sign. The resulting signer, deadline, and signature components are then passed to the deployment or input-submission tool.

A typical deployment sequence is agreement validation, deployment preflight, typed-data preparation, external signing, and deployment. Input submission follows the same pattern: prepare typed data, sign with an allowed wallet, submit the signed input, then poll agreement state or inspect input history.

Setup and configuration

For local stdio use, configure an MCP client to run npx -y @shodai-network/agreements-mcp-server. Set AGREEMENTS_API_KEY to an API key and AGREEMENTS_API_ENVIRONMENT to testnet or production. Keys are scoped to their environment, so the selected environment must match the key.

Hosted access uses https://shodai.network/mcp and requires environment: "testnet" for the documented OAuth connection. Clients without OAuth support can send a bearer API key created for the selected environment. The hosted endpoint expects MCP protocol requests; a normal browser GET may return HTTP 405.

Tools and capabilities

The CNSLabs/agreements-api-sdk MCP server provides tools for:

  • Listing and retrieving agreement records and rendered documents.
  • Reading agreement state and paginated input history.
  • Validating authored JSON and checking deployment readiness.
  • Preparing and submitting deployment permits.
  • Preparing and submitting signed participant inputs.
  • Filtering and paginating agreement or input results where supported.

Validation of authored JSON is separate from deployment preflight. Validation does not check wallet mappings, deployment values, signer details, or permit data. Preflight does not deploy and does not require a signature.

Limitations and notes

Write tools require the agreements.write scope. Deployment and input submission require signatures produced outside the server. Agreement inputs must match the authored definition, and the signer must be authorized for the selected input. State values for deployed agreements should be interpreted using the lifecycle states defined in the authored agreement JSON.

The server returns agreement summaries from listing calls; use the individual agreement retrieval tool for the complete record. Hosted MCP does not provide private-key custody, so an agent workflow must have access to an external signing method before it can complete deployment or input submission.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Agreements API Sdk

CNSLabs/agreements-api-sdk is an MCP server that connects AI agents and MCP clients to the Shodai Agreements API. Its main tools list and read agreements, validate authored JSON, preflight and deploy agreements, prepare EIP-712 signing data, submit signed participant inputs, and inspect agreement state and input history.

Install the local server through `npx -y @shodai-network/agreements-mcp-server` in your MCP client configuration. Set `AGREEMENTS_API_KEY` and `AGREEMENTS_API_ENVIRONMENT`, using `testnet` or `production` to match the API key.

Connect an MCP client to `https://shodai.network/mcp` using Streamable HTTP. OAuth-capable clients can complete Shodai browser sign-in and consent; clients without OAuth can send an environment-scoped bearer API key and provide the required `environment` tool argument.

No, the hosted MCP endpoint does not custody private keys. Use `prepare_deployment_typed_data` or `prepare_input_typed_data`, sign the returned EIP-712 payload externally, and pass the signature details to the corresponding write tool.

Run `validate_agreement`, then `preflight_deployment`, and call `prepare_deployment_typed_data`. Sign the returned payload externally and provide the signer, deadline, and signature components to `deploy_agreement`; preflight does not deploy or require a signature.

Related MCP servers

All in Agreements & Coordination All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewAgreements API Sdk AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/cnslabs-agreements-api-sdk?style=directory)](https://allmcps.com/mcp/cnslabs-agreements-api-sdk)
HTML Embed
<a href="https://allmcps.com/mcp/cnslabs-agreements-api-sdk"><img src="https://allmcps.com/api/badge/cnslabs-agreements-api-sdk?style=directory" alt="Agreements API Sdk on AllMCPs" /></a>