Keeta Network MCP Server
Enables cross-chain interoperability with the Ethereum blockchain, allowing for tokenized asset transfers and atomic swaps through Keeta's anchor system.
Integrates with Keeta's GitBook-hosted documentation to provide searchable protocol knowledge, architecture guides, and SDK references.
Supports the management, transfer, and tokenization of Tether (USDT) on the Keeta Network, including enforcement of protocol-level compliance and access controls.
Supports the use of the WebAuthn (SECP256R1) signature algorithm for secure, standards-based transaction signing and identity verification.
Click on "Deploy 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., "@Keeta Network MCP Server check my balance and send 5 KTA to 0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
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.
Keeta Network MCP Server
A dynamic, self-describing MCP (Model Context Protocol) server that gives AI agents native access to the Keeta Network — a Layer 1 blockchain built for payments, asset transfers, cross-chain interoperability, and compliance-ready financial infrastructure.
This server is designed for autonomous agent use. It does not require updates when the Keeta SDK is expanded — new SDK methods are automatically discoverable at runtime through built-in introspection tools.
What is Keeta Network?
Keeta is a Layer 1 blockchain purpose-built for the global financial system:
10M+ TPS with 400ms settlement — faster than any traditional payment rail
Native tokenization — create tokens with built-in rules (transfer restrictions, allowlists, time locks) enforced at protocol level
Atomic swaps — instant exchange between any two assets on the network
Anchors — regulated entry/exit points that bridge Keeta to external systems (SWIFT, ACH, FedNow, other blockchains like Base/Ethereum). Any foreign asset tokenized on Keeta is 1:1 backed and can be returned to its native chain at any time
Built-in compliance — X.509 certificate-based identity for KYC/AML without storing PII on-chain
Permissions system — granular per-account and per-token access controls (ACCESS, ADMIN, SEND, RECEIVE, etc.)
DAG architecture — each account has its own chain, enabling parallel transaction processing
Multiple signature algorithms — ECDSA SECP256K1, SECP256R1 (WebAuthn), ED25519
Token: KTA (used for transaction fees and governance)
Networks: main (production), test (development with free faucet)
Related MCP server: Armor Crypto MCP
Quick Start
Install
git clone <this-repo>
cd kta-mcp
npm install
npm run buildConfigure (Recommended: Both MCP Servers)
Agents building on Keeta should use two MCP servers together:
keeta-docs— The Keeta documentation MCP (hosted by GitBook) provides searchable protocol knowledge: architecture, anchor system, SDK references, tutorialskeeta-sdk— This server provides the tools to execute operations on the network
Claude Code
# Add the Keeta docs MCP (read the docs, understand the protocol)
claude mcp add --transport http keeta-docs https://docs.keeta.com/~gitbook/mcp
# Add the Keeta SDK MCP (execute operations on the network)
claude mcp add keeta-sdk node /absolute/path/to/kta-mcp/build/index.jsClaude Desktop / Other MCP Clients
{
"mcpServers": {
"keeta-docs": {
"type": "url",
"url": "https://docs.keeta.com/~gitbook/mcp"
},
"keeta-sdk": {
"command": "node",
"args": ["/absolute/path/to/kta-mcp/build/index.js"]
}
}
}Why both? The docs MCP gives agents the knowledge to build correctly (protocol rules, anchor architecture, metadata formats, compliance requirements). The SDK MCP gives agents the tools to execute. Using only the SDK server without understanding the protocol is like having a hammer without knowing what you're building.
Development
npm run dev # Run with tsx (no build step)
npm run build # Compile TypeScript
npm start # Run compiled outputArchitecture: Dynamic & Future-Proof
This MCP server uses a discover-then-execute pattern instead of hardcoded tools. When the Keeta SDK adds new methods, classes, or features, agents discover them automatically without any server updates.
9 Tools — Organized in 3 Layers
┌─────────────────────────────────────────────────────────────────────┐
│ BOOTSTRAP TOOLS (entry points) │
│ keeta_generate_seed → create a cryptographic seed │
│ keeta_derive_account → derive account from seed + index │
│ keeta_request_test_tokens → fund an account on testnet │
│ keeta_get_network_config → get network ID, base token, etc. │
├─────────────────────────────────────────────────────────────────────┤
│ DISCOVERY TOOL (runtime introspection) │
│ keeta_list_sdk_methods → introspect any SDK object: │
│ "AnchorCatalog" → auto-discover ALL anchor services │
│ "AnchorService:<Name>" → drill into any service by name │
│ "AnchorLib:<Name>" → drill into any lib module by name │
│ "Client/UserClient/..." → core SDK introspection │
├─────────────────────────────────────────────────────────────────────┤
│ EXECUTION TOOLS (generic, call any SDK method by name) │
│ keeta_client_execute → read-only network queries │
│ keeta_user_client_execute → authenticated account operations │
│ keeta_builder_execute → batch operations → publish │
│ keeta_anchor_execute → ANY anchor service or lib module │
│ subtarget: "service" → dynamic: FX, KYC, AssetMovement... │
│ subtarget: "lib" → dynamic: Resolver, Certificates... │
│ subtarget: "metadata" → Resolver.Metadata shortcuts │
└─────────────────────────────────────────────────────────────────────┘Smart Argument Resolution
Arguments passed to execution tools are automatically resolved based on prefixes:
Pattern | Resolves To | Example |
|
| Token/account addresses |
|
| Token amounts, supplies |
|
| Permission sets |
|
| Key algorithm enums |
|
| Permission adjustment methods |
|
| Block operation types |
|
| Binary data |
Plain values | Pass through unchanged | Strings, numbers, booleans, objects |
Agent Workflow Guide
This section describes the recommended workflow for an AI agent using this MCP server. Follow these patterns for any Keeta operation.
Step 0: Read the Documentation (keeta-docs MCP)
Before writing any code, use the Keeta docs MCP server to understand the protocol:
# Via the keeta-docs MCP server (https://docs.keeta.com/~gitbook/mcp):
# - Search for "anchors" to understand the anchor system
# - Search for "block operations" to understand transaction types
# - Search for "permissions" to understand access control
# - Search for "certificates" to understand KYC/identity
# - Search for "tokenization" to understand native token creationThe docs MCP provides full access to https://docs.keeta.com/ — architecture guides, anchor system documentation, SDK references, and tutorials. This is essential context for building anything beyond basic transfers.
You can also read the keeta://docs/mcp-config resource from this server for setup details and key documentation links.
Step 1: Discover What's Available
Introspect the SDK to understand current capabilities:
keeta_list_sdk_methods({ target: "AnchorCatalog" }) → all anchor services & lib modules
keeta_list_sdk_methods({ target: "Client" }) → read-only methods
keeta_list_sdk_methods({ target: "UserClient" }) → authenticated methods
keeta_list_sdk_methods({ target: "Builder" }) → builder/batch methods
keeta_list_sdk_methods({ target: "Account" }) → account utilities + enums
keeta_list_sdk_methods({ target: "Block" }) → block types + operation types
keeta_list_sdk_methods({ target: "Config" }) → network configurationStep 2: Create an Account
keeta_generate_seed()
→ { seed: "A1B2C3..." }
keeta_derive_account({ seed: "A1B2C3...", index: 0 })
→ { address: "keeta_abc123...", algorithm: "SECP256K1", index: 0 }Step 3: Fund It (testnet)
keeta_request_test_tokens({ address: "keeta_abc123..." })
→ { status: "success", currentBalance: "5000000000000000000" }Step 4: Perform Operations
Read-only queries (no account needed):
keeta_client_execute({
network: "test",
method: "getAccountInfo",
args: ["keeta_abc123..."]
})
keeta_client_execute({
network: "test",
method: "getAllBalances",
args: ["keeta_abc123..."]
})Authenticated operations:
keeta_user_client_execute({
network: "test",
seed: "A1B2C3...",
accountIndex: 0,
method: "allBalances",
args: []
})
keeta_user_client_execute({
network: "test",
seed: "A1B2C3...",
method: "generateIdentifier",
args: ["ALGO:TOKEN"]
})Read UserClient properties:
keeta_user_client_execute({
network: "test",
method: "GET_PROPERTY",
args: ["baseToken"]
})Step 5: Batch Operations with Builder
The builder pattern is the most powerful way to perform multiple operations atomically:
keeta_builder_execute({
network: "test",
seed: "A1B2C3...",
accountIndex: 0,
operations: [
{
"method": "setInfo",
"args": [{
"name": "USDT",
"description": "Tether USD on Keeta",
"metadata": "eyJkZWNpbWFsUGxhY2VzIjo2fQ==",
"defaultPermission": "PERM:ACCESS"
}],
"options": { "account": "keeta_token_address..." }
},
{
"method": "modifyTokenSupply",
"args": ["BIGINT:1000000000000"],
"options": { "account": "keeta_token_address..." },
"computeAfter": true
},
{
"method": "send",
"args": ["keeta_recipient...", "BIGINT:500000000", "keeta_token_address..."]
}
],
autoPublish: true
})Key builder details:
computeAfter: trueforces block computation after that operation (important when later operations depend on earlier ones, e.g., minting supply before sending tokens)optionsis passed as the final argument — commonly{ account: "keeta_..." }to target a specific token/identifierautoPublish: true(default) callscomputeBlocks()andpublish()after all operations
Common Task Recipes
Create a Token
1. keeta_generate_seed() → seed
2. keeta_derive_account({ seed, index: 0 }) → ownerAddress
3. keeta_request_test_tokens({ address: ownerAddress })
4. keeta_user_client_execute({ network: "test", seed, method: "generateIdentifier", args: ["ALGO:TOKEN"] }) → tokenAddress
5. keeta_builder_execute({
network: "test", seed,
operations: [
{ method: "setInfo", args: [{ name: "MYTKN", description: "My Token", metadata: "<base64 of {decimalPlaces:6}>", defaultPermission: "PERM:ACCESS" }], options: { account: tokenAddress } },
{ method: "modifyTokenSupply", args: ["BIGINT:1000000000000"], options: { account: tokenAddress }, computeAfter: true },
{ method: "send", args: [ownerAddress, "BIGINT:100000000", tokenAddress] }
]
})Send Tokens
keeta_builder_execute({
network: "test", seed,
operations: [
{ method: "send", args: ["keeta_recipient...", "BIGINT:1000000", "keeta_token..."] }
]
})Atomic Swap
keeta_user_client_execute({
network: "test", seed,
method: "createSwapRequest",
args: [{
from: { account: "keeta_sender...", token: "keeta_tokenA...", amount: "BIGINT:1000" },
to: { account: "keeta_counterparty...", token: "keeta_tokenB...", amount: "BIGINT:500" }
}]
})FX Swap via Anchor
1. keeta_anchor_execute({ network: "test", subtarget: "service", serviceName: "FX", method: "getQuotes", args: [{ from: "keeta_kta...", to: "$USDC", amount: "BIGINT:1000000", affinity: "from" }] })
2. Use returned quote to execute the exchangeUpdate Permissions
keeta_user_client_execute({
network: "test", seed,
method: "updatePermissions",
args: ["keeta_principal...", "PERM:ADMIN,ACCESS", null, "ADJUST:SET"],
// optional: pass { account: "keeta_target..." } to target a specific token
})Resolve Anchor Metadata
keeta_anchor_execute({
network: "test",
subtarget: "lib",
libModule: "Resolver",
method: "getRootMetadata",
args: []
})KYC Identity Verification
// Discover KYC methods first
keeta_list_sdk_methods({ target: "AnchorKYCClient" })
// Start a KYC verification request
keeta_anchor_execute({
network: "test", seed, subtarget: "service", serviceName: "KYC",
method: "createVerification",
args: [{ account: "keeta_user...", countryCodes: ["US"] }]
})
// Get supported countries
keeta_anchor_execute({ network: "test", subtarget: "service", serviceName: "KYC", method: "getSupportedCountries", args: [] })Cross-Chain Asset Movement
// Find providers for a specific asset transfer
keeta_anchor_execute({
network: "test", seed, subtarget: "service", serviceName: "AssetMovement",
method: "getProvidersForTransfer",
args: [{ asset: { token: "keeta_usdc..." }, from: { location: "keeta" }, to: { location: "base" } }]
})
// Provider methods (after getting a provider): initiateTransfer, getTransferStatus,
// createPersistentForwardingAddress, listForwardingAddresses, listTransactions, shareKYCAttributesUsername Management
// Resolve a username to an account
keeta_anchor_execute({
network: "test", subtarget: "service", serviceName: "Username",
method: "resolve",
args: ["alice@provider"]
})
// Search usernames
keeta_anchor_execute({
network: "test", subtarget: "service", serviceName: "Username",
method: "search",
args: [{ search: "alice" }]
})
// Claim a username (requires funded account)
keeta_anchor_execute({
network: "test", seed, subtarget: "service", serviceName: "Username",
method: "claimUsername",
args: ["alice@provider", { account: "keeta_user..." }]
})Push Notifications
// Get notification providers
keeta_anchor_execute({
network: "test", subtarget: "service", serviceName: "Notification",
method: "getProviders",
args: []
})
// Provider methods: registerTarget, listTargets, deleteTarget,
// createSubscription, listSubscriptions, deleteSubscriptionEncrypted Containers & Certificates
// Create an encrypted container for sensitive data
keeta_anchor_execute({
network: "test", subtarget: "lib", libModule: "EncryptedContainer",
method: "fromPlaintext",
args: ["BUFFER_B64:aGVsbG8gd29ybGQ="]
})
// Parse a Keeta URI
keeta_anchor_execute({
network: "test", subtarget: "lib", libModule: "URI",
method: "parseKeetaURI",
args: ["keeta://..."]
})Building an Anchor (Agent Guide)
An anchor bridges the Keeta blockchain to an external system (another blockchain, a bank, a payment processor). Here's how an agent can build one:
What an Anchor Does
Holds liquidity — the anchor operator's account holds tokens on both sides
Provides FX quotes — tells users what exchange rate they'll get
Executes atomic swaps — uses Keeta's native swap mechanism to guarantee both sides complete
Exposes HTTP endpoints —
getEstimate,getQuote,createExchange,getExchangeStatus
Anchor Architecture
External System (e.g., Base chain)
↕ (bridge logic you build)
Anchor FX HTTP Server
├── /api/getEstimate → estimate conversion rate
├── /api/getQuote → firm quote with provider signature
├── /api/createExchange → execute the swap atomically
└── /api/getExchangeStatus → check swap status
↕ (Keeta SDK)
Keeta Network (native atomic swaps)Steps to Build an Anchor
Create anchor operator account — generate seed, derive account, fund it
Create or identify token pairs — the tokens being swapped (e.g., KTA ↔ USDC)
Fund liquidity — ensure the operator account holds enough of both tokens
Build an FX HTTP server — use
@keetanetwork/anchorSDK'sKeetaNetFXAnchorHTTPServerclass, providing yourgetConversionRateAndFeecallbackRegister anchor metadata — publish on-chain metadata with
setInfo()including the currency map and FX service endpointsTest — use the FX client tools to get quotes and execute swaps against your anchor
Registering Anchor Metadata On-Chain
keeta_user_client_execute({
network: "test", seed,
method: "setInfo",
args: [{
name: "MY_ANCHOR",
description: "My Custom FX Anchor",
metadata: "<use keeta_anchor_execute with subtarget 'metadata', method 'formatMetadata'>"
}]
})The metadata includes:
currencyMap— maps human-readable codes ($KTA,$USDC) to token addressesservices.fx.<ProviderName>— defines available conversion pairs and API endpoint URLs
Format Anchor Metadata
keeta_anchor_execute({
network: "test",
subtarget: "metadata",
method: "formatMetadata",
args: [{
version: 1,
currencyMap: { "$KTA": "keeta_kta...", "$USDC": "keeta_usdc..." },
services: {
fx: {
MyProvider: {
from: [{ currencyCodes: ["keeta_kta..."], to: ["keeta_usdc..."] }],
operations: {
getEstimate: "https://my-anchor.com/api/getEstimate",
getQuote: "https://my-anchor.com/api/getQuote",
createExchange: "https://my-anchor.com/api/createExchange",
getExchangeStatus: "https://my-anchor.com/api/getExchangeStatus/{exchangeID}"
}
}
}
}
}]
})SDK Discovery Targets
Core SDK
Target | What It Exposes | When To Use |
| Read-only methods: | Querying the network without an account |
| All Client methods plus: | Any operation requiring an account |
| Batch operations: | Multi-step operations that should execute atomically |
| Static utilities: | Account creation and key management |
| Block construction: | Low-level block building |
| Permission construction methods | Access control |
|
| Network configuration |
Anchor SDK (Fully Dynamic)
Anchor services and lib modules are not hardcoded — they are auto-discovered from SDK exports at runtime. When the SDK adds new services, they appear automatically.
Discovery flow:
keeta_list_sdk_methods({ target: "AnchorCatalog" })
→ lists all services and lib modules with their methods
keeta_list_sdk_methods({ target: "AnchorService:FX" })
→ drill into a specific service
keeta_list_sdk_methods({ target: "AnchorLib:Resolver" })
→ drill into a specific lib moduleExecution flow:
keeta_anchor_execute({
subtarget: "service",
serviceName: "FX", ← any service name from the catalog
method: "getQuotes",
args: [...]
})
keeta_anchor_execute({
subtarget: "lib",
libModule: "Resolver", ← any lib module from the catalog
method: "getRootMetadata",
args: []
})Currently discovered services (as of anchor SDK v0.0.49):
Service | Methods | Purpose |
|
| Foreign exchange and token swaps |
|
| Identity verification |
|
| Cross-chain/cross-rail transfers |
|
| On-chain usernames |
|
| Push notifications |
Currently discovered lib modules:
Module | Type | Key Members |
| class |
|
| namespace |
|
| class |
|
| namespace |
|
Future services and modules will auto-appear in the catalog without MCP server changes.
Project Structure
kta-mcp/
├── package.json # Dependencies: @keetanetwork/keetanet-client, @keetanetwork/anchor, @modelcontextprotocol/sdk
├── tsconfig.json # TypeScript ES2022 + Node16 modules
├── src/
│ ├── index.ts # MCP server entry point (stdio transport)
│ └── tools/
│ ├── helpers.ts # SDK wrappers, argument resolution, introspection, serialization
│ ├── bootstrap.ts # Essential tools: seed gen, account derivation, faucet, network config
│ ├── discovery.ts # keeta_list_sdk_methods — runtime SDK introspection
│ └── execute.ts # Generic execution: client, user_client, builder, anchor
└── build/ # Compiled JavaScript outputDependencies
@keetanetwork/keetanet-client— Core Keeta SDK (accounts, tokens, transactions, permissions)@keetanetwork/anchor— Anchor SDK (FX, KYC, asset movement, usernames, notifications, resolver, certificates, encrypted containers, URI)@modelcontextprotocol/sdk— MCP server frameworkzod— Schema validation for tool inputs
Resources
License
MIT
Available Tools
9 toolskeeta_anchor_executeA
Execute ANY anchor operation on the Keeta Network. Fully dynamic — auto-discovers services and lib modules from the SDK at runtime.
subtarget types:
"service" → call a method on any anchor service client (FX, KYC, AssetMovement, Username, Notification, or ANY future service). Set serviceName to the service name.
"lib" → call a method/function on any anchor lib module (Resolver, Certificates, EncryptedContainer, URI, or ANY future module). Set libModule to the module name.
"metadata" → shortcut to call Resolver.Metadata static methods (formatMetadata, fullyResolveValuizable)
Use keeta_list_sdk_methods with target "AnchorCatalog" to discover all available services and lib modules. Use "AnchorService:" or "AnchorLib:" to drill into specific ones.
Arguments are auto-resolved (see keeta_client_execute for resolution rules).
Inputs: network (required), subtarget (required), method (required), seed, +5 more.
keeta_builder_executeA
Execute a sequence of operations using the UserClient Builder pattern, then optionally compute and publish.
The builder batches multiple operations into blocks for efficient on-chain execution. Each operation in the "operations" array is an object with "method" and "args".
Use keeta_list_sdk_methods with target "Builder" to discover available methods.
Common builder methods: send, setInfo, modifyTokenSupply, modifyTokenBalance, computeBlocks, receive.
The tool will:
Create a UserClient and initialize a builder
Call each operation in sequence
If autoPublish is true (default): call computeBlocks() then publish()
Return all computed block hashes
Example operations: [ { "method": "setInfo", "args": [{ "name": "TKNA", "description": "My Token" }], "options": { "account": "keeta_..." } }, { "method": "modifyTokenSupply", "args": ["BIGINT:50000000000"], "options": { "account": "keeta_..." } }, { "method": "send", "args": ["keeta_recipient...", "BIGINT:1000000", "keeta_token..."] } ]
Arguments are auto-resolved (see keeta_client_execute for resolution rules). The "options" field in each operation is passed as the last argument (common for { account: tokenAddress }).
Inputs: network (required), seed (required), operations (required), accountIndex, +1 more.
keeta_client_executeA
Execute any method on the Keeta Client (read-only network operations).
Use keeta_list_sdk_methods with target "Client" to discover available methods.
Common methods: getAccountInfo, getBalance, getAllBalances, getHeadBlock, getBlock, getHistory, getTokenSupply, getNetworkStatus, getPeers, getVersion, getLedgerChecksum, getAllCertificates, getAllRepresentativeInfo.
Arguments are auto-resolved:
Strings starting with "keeta_" become Account objects
"BIGINT:123" becomes BigInt(123)
"PERM:ACCESS,ADMIN" becomes a Permissions object
"ALGO:TOKEN" becomes AccountKeyAlgorithm.TOKEN
Plain strings, numbers, booleans, objects, arrays pass through as-is
Inputs: network (required), method (required), args.
keeta_derive_accountA
Derive a Keeta account (public/private keypair) from a seed and index.
Each unique (seed, index, algorithm) combination produces a deterministic account. The returned address (keeta_...) is used in all other tools as account/token identifiers.
Supported algorithms:
SECP256K1 (default) — most common, Ethereum-compatible
SECP256R1 — WebAuthn/passkey compatible
ED25519 — fast signatures
Returns: { address: string, algorithm: string, index: number }
Inputs: seed (required), index (required), algorithm.
keeta_generate_seedA
Generate a new random cryptographic seed for the Keeta Network.
This is the starting point for all Keeta operations. A seed can derive unlimited accounts via keeta_derive_account. Store the seed securely — it controls all derived accounts and their funds.
Returns: { seed: string }
Inputs: no named parameters.
keeta_get_network_configB
Get the configuration for a Keeta network, including the network ID, base token address, and network account address.
This is useful for understanding the network you are operating on before making transactions.
Returns: { networkAlias, networkId, baseToken, networkAddress }
Inputs: network (required).
keeta_list_sdk_methodsA
Discover available methods and properties on Keeta SDK objects at runtime. Use this FIRST to understand what operations are available before calling execute tools.
The "target" parameter accepts:
Core SDK (fixed): "Client" → read-only network queries "UserClient" → authenticated operations "Builder" → batch transaction builder "Account" → account utilities + enums "Block" → block types + operation enums "Permissions" → permission construction "Config" → network configuration
Anchor SDK (dynamic — auto-discovers new services): "AnchorCatalog" → list ALL available anchor services and lib modules (start here!) "AnchorService:" → methods on a specific anchor service client (e.g. "AnchorService:FX", "AnchorService:KYC", "AnchorService:AssetMovement", "AnchorService:Username", "AnchorService:Notification", or ANY new service the SDK adds) "AnchorLib:" → methods on a specific anchor lib module (e.g. "AnchorLib:Resolver", "AnchorLib:Certificates", "AnchorLib:EncryptedContainer", "AnchorLib:URI", or ANY new module)
When in doubt, start with "AnchorCatalog" to see everything available, then drill into specific services/modules.
Inputs: target (required), network.
keeta_request_test_tokensA
Request free KTA tokens from the Keeta test network faucet.
Only works on the test network. Sends 5 KTA to the given address for development/testing. KTA is needed for transaction fees on the network.
Returns: { status, address, amountRequested, currentBalance }
Inputs: address (required).
keeta_user_client_executeA
Execute any method on the Keeta UserClient (authenticated operations requiring an account).
Use keeta_list_sdk_methods with target "UserClient" to discover available methods.
Common methods: allBalances, balance, head, chain, history, state, send, setInfo, generateIdentifier, updatePermissions, createSwapRequest, transmit, listACLsByPrincipal, getCertificates, modifyCertificate, sync.
Properties you can read (pass method "GET_PROPERTY" with args ["propertyName"]): baseToken, networkAddress, network, account, signer.
Arguments are auto-resolved (see keeta_client_execute for resolution rules).
Inputs: network (required), method (required), seed, accountIndex, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Most tools have distinct purposes, such as keeta_derive_account for key derivation and keeta_request_test_tokens for faucet access. However, keeta_anchor_execute, keeta_builder_execute, keeta_client_execute, and keeta_user_client_execute all involve executing SDK methods, which could cause confusion about which to use for specific operations, though their descriptions clarify different contexts (anchor operations, builder patterns, read-only client, authenticated client).
All tool names follow a consistent snake_case pattern with a 'keeta_' prefix and descriptive verb_noun combinations, such as keeta_anchor_execute, keeta_list_sdk_methods, and keeta_generate_seed. This uniformity makes the tool set predictable and easy to navigate.
With 9 tools, the server is well-scoped for interacting with the Keeta Network, covering essential operations like account management, network queries, transaction building, and SDK discovery. Each tool serves a clear purpose without redundancy, fitting typical MCP server ranges.
The tool set provides comprehensive coverage for the Keeta Network domain, including account derivation, seed generation, network configuration, SDK method discovery, test token acquisition, and various execution contexts (client, user client, anchor, builder). There are no obvious gaps, enabling full lifecycle management from setup to transaction execution.
Related MCP Connectors
Provide AI agents and automation tools with contextual access to blockchain data including balance…
AI agent infrastructure for discovery, authorization, execution, identity, and signed receipts.
AI Agent Utility Layer for agent safety, web monitoring, crypto research and tool discovery.
ERC-8004 agent identity, on-chain subscriptions, reputation, A2A tasks and chat over 53 tools.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA comprehensive toolkit for building AI agents with blockchain capabilities, enabling interactions with multiple blockchain networks for tasks like wallet management, fund transfers, smart contract interactions, and cross-chain asset bridging.5GPL 3.0
- AlicenseCqualityDmaintenanceEnables AI agents to interact with cryptocurrency ecosystems through wallet management, trading operations (swaps, DCA, limit orders), staking, and multi-chain support starting with Solana.37GPL 3.0

Bink MCP Serverofficial
AlicenseNot gradedqualityDmaintenanceEnables AI agents to perform blockchain operations like wallet management, token info, DeFi swaps, cross-chain bridging, and price checking across Ethereum, BNB Chain, and Solana.ISC- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to interact with peer-to-peer networks (libp2p) and DeFi protocols, including oracle networks, cross-chain communication, and intent-based execution.2MIT