Vector MCP Server
Provides tools for interacting with the Cardano-based Vector blockchain, enabling balance queries, transactions, smart contract deployment and interaction, and on-chain AI agent identity management.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Vector MCP Server
MCP (Model Context Protocol) server for Vector - the Apex Fusion eUTXO L2. Enables AI agents (Claude, GPT, Gemini, or any MCP client) to interact with Vector natively: query balances, send transactions, deploy and interact with smart contracts, manage on-chain agent identities, and submit protocol improvement proposals.
Built on Ogmios + Koios - no Blockfrost dependency.
Vector mainnet is live. Full guides: Vector AI documentation.
Hosted servers - no install
Hosted instances run on both networks. The 87 tools described below are the code of this release; each hosted instance serves them once the release deploys there (testnet automatically on push to main, mainnet on a deliberate cutover dispatch):
Network | Endpoint |
Mainnet |
|
Testnet |
|
Deployment status: both networks are current with the non-custodial migration, and only with that. Both hosted instances run the completed migration: testnet since the 2026-07-31 morning merges (auto-deployed from
main), mainnet since a deliberate cutover deploy the same day (see docs/architecture/non-custodial-split.md, section 11, "Rollout", for the full history). This does not mean a hosted instance serves every tool listed below: the marketplace and reputation tools are newer than those deploys, and an instance serves them only once the release that adds them has deployed there (until then its tool list is shorter than the one below; a client's tool list shows what an instance serves right now). Both hosted instances are open access - no bearer token is required to connect. Callers are admitted anonymously with per-IP rate limiting. That is an access-control property, and it is separate from custody: neither instance accepts a mnemonic from any caller, with or without a token. Self-hosted deployments can still gate access withMCP_AUTH_TOKENS- see Configuration.
Transport: Streamable HTTP only, as of 2.0.0. The legacy SSE pair (
/sse+/messages), deprecated by the MCP spec (2026-07-28 revision), was removed in this release - those paths now answer 404. Every client connects to/mcp, the endpoint the table above lists. This is a breaking change for SSE clients: reconnect with--transport httpand the/mcpURL (below). The server also answers any-origin CORS (browser MCP clients are first-class callers) and exposes an unauthenticatedGET /healthliveness probe. This describes the code - each hosted instance serves it once this release deploys there (testnet automatically on push tomain, mainnet on a deliberate cutover dispatch).
Connect from Claude Code in one command. No token needed for the hosted instances.
claude mcp add --transport http vector-mcp https://mcp.vector.mainnet.apexfusion.org/mcpSwap in the testnet host to connect to testnet instead. Self-hosting (below) gives every
caller open access to your own instance unless you set MCP_AUTH_TOKENS.
Security notice: the non-custodial migration is complete, in this codebase and on both hosted instances, as of the 2026-07-31 cutover deploy. No tool in this repository accepts a mnemonic, private key, or any other key material. Every
build_*tool constructs an unsigned transaction from a wallet address only, and every signing operation happens locally on your own machine, through the local signer companion. Broadcast the signed result withvector_submit_transaction- your seed phrase never leaves your machine, and no server running this release ever holds one. This is enforced mechanically in the code, not just by convention: the builder's custody boundary test scans every source file for key-material vocabulary against an allowlist that is now empty and pinned at size zero, so a future change cannot silently reintroduce a mnemonic parameter without failing that test by name. This describes this release and the 2026-07-31 deploy specifically - a later deploy is a separate operational action, not automatically covered by this notice; see the deployment status note above and docs/architecture/non-custodial-split.md for the full rollout history.
Self-hosting instructions are below.
Related MCP server: Somnia MCP Server
Local signer (non-custodial path)
packages/signer is a local MCP server that holds your key and signs transactions locally
instead of handing your mnemonic to a shared host. It has no network access by default:
stdio transport only, no Provider, no egress, so a key given to it never reaches a shared server
or your model provider. One optional, read-only setting (VECTOR_SIGNER_OGMIOS_URL) lets it look
up the inputs a transaction spends, so that its spend limit counts only what its own inputs fund.
Five tools: vector_signer_get_address, vector_signer_get_public_key, vector_signer_decode_transaction,
vector_signer_sign (also for a transaction that other keys signed first), vector_signer_get_spend_limits.
In this codebase, this signer is the single signing point for every family the builder
exposes. The full non-custodial flow is live in this release for all of them:
vector_signer_get_address → build_* → vector_signer_sign → vector_submit_transaction →
vector_await_transaction. No step in that chain puts a mnemonic in front of a server running
this code, or your model provider, for any tool. The build → submit → await half is E2E-proven
on Vector testnet across the wallet/tx, smart-contract, agent-registry, and self-improvement
families, including the first keyless-built proposal submission the deployed self-improvement
module validator has ever accepted; see
packages/signer/README.md for exactly what that
testing does and does not exercise on the signer's side. This describes the code, not every
deployment of it - see the deployment status note above.
See packages/signer/README.md for configuration, tools, and known
limitations.
Features
Wallet & queries - balances, UTxOs, and transaction history for any address (no key material)
Keyless transaction building - build unsigned AP3X/token/multi-output transactions and contract interactions; sign locally, broadcast via submit
Smart contracts - deploy Plutus/Aiken validators, lock and spend UTxOs at script addresses (keyless)
Agent identity - resolve
did:vectorDIDs through the identity gateway, read an agent's profile by DID (canonical or legacy form), and discover agents with listed adverts through the marketplace indexerIdentity registry (
did:vector) - keyless builders for every record action (register, also subagents; adopt a legacy record; update; change controller; suspend and unsuspend; revoke; retire; reclaim; successor; recovery; end subagents), attestations, delegations and vaults; every build returns the unsigned transaction and the key hashes that must sign it, and each key holder signs in turn. Read tools show attestations, delegations and vaults, and check an attestation against the validity rule and a delegation against the use checks. The legacy registry writes (register, update, transfer) are retired; a legacy record that does not adopt can still deregisterSelf-Improvement Module - browse, submit, critique, and endorse improvement proposals on the Module-6 deployment of the identity registry (the agent is a
did:vectoragent whose record is Active); every write tool is keylessAgents marketplace, both sides - hire a supplier (escrow post, accept, reclaim, send a job, check its receipt) and list one (advert post, update and retire in the identity layout; one retire for both layouts; the legacy-layout Post is refused from the escrow switch on), keyless
Reputation self-stake - keyless builders for an agent's Module-3 stake on the deployment for the identity registry (open, create, increase, capability update, decrease), and a read of the stakes of up to 50 agents (see Reputation); the owner cannot withdraw the module minimum
Module-1 disputes and the jury - publish and read documents on chain (metadata label 22084,
vector-tx:URIs), build a Module-1 claim or challenge (oracle mode), take the stake of a claim that nobody challenged back after its challenge window, and act as a juror of the Module-1 jury (register, exit, top-up, commit, reveal); read the jurors and the cases with the canonical case of each dispute, keylessSafety controls - per-identity rate limiting; spend limits for every family are enforced by the local signer, per user - the server holds no spend-limit state of its own
Streamable HTTP transport - the modern MCP transport at
/mcp, with any-origin CORS for browser clients and an unauthenticatedGET /healthprobe (the legacy SSE pair was removed in 2.0.0)
MCP Tools (87)
Wallet & Queries
Tool | Description |
| Get AP3X and token balances for any address |
| List UTxOs for an address |
| Get transaction history for an address |
Transactions
Each build tool here and under Smart Contracts lists the key hashes that must sign the transaction (the wallet key, and any key that the
transaction names as a required signer) before the unsigned CBOR, and as required_signers in its JSON block, as the identity and
marketplace tools do. The ledger refuses a transaction that is submitted without these signatures.
Tool | Description |
| Build an unsigned AP3X transfer (keyless - sign with the local signer) |
| Build an unsigned native-token transfer (keyless) |
| Build an unsigned multi-output transaction (keyless, never submits) |
| Simulate a transaction without submitting - validate it and show its fee (the fee that a given transaction declares, or the fee of the transaction built from outputs) |
| Broadcast an already-signed transaction (for example one signed by the local signer) |
| Wait for a submitted transaction to be confirmed on-chain |
Smart Contracts
Tool | Description |
| Build an unsigned deployment of a Plutus V1/V2/V3 or Aiken validator (keyless) |
| Build an unsigned lock or spend at a script address, with a redeemer (keyless) |
Agent Identity
Tool | Description |
| Resolve a |
| Check an Ed25519 signature of a |
| Get an agent's profile by DID: a canonical DID through the identity gateway (profile, effective status, keys, record output; the registration time is the block time of the transaction that first minted the identifier), a legacy DID from the legacy registry (no wallet needed) |
| Discover agents with a listed advert, from the marketplace indexer; filter by capability (no wallet needed) |
| Build an unsigned deregistration of a legacy record that does not adopt - burns its token and returns the deposit (keyless) |
Identity Registry (14)
Every tool below is keyless: it builds an unsigned transaction and lists every key hash that must sign it (controller, listed keys, parties, the wallet). Each key holder signs in turn with vector_signer_sign; then one vector_submit_transaction. The server needs the identity deployment values (see Configuration).
Tool | Description |
| Register a new agent (or, with |
| Move a legacy record into the identity registry under the same identifier (allowlist proof against the published root; the legacy owner signs) |
| Change the profile, listed keys, parties (appointments, changes, removals, removal notices) and the guardian threshold |
| Install a new controller key (old and new key sign); ends all subagents |
| Add or renew the author's hold (controller or a party with the suspend right), at most 30 days |
| Remove the author's own hold |
| Revoke the identity (tombstone) with a reason code, an optional "invalid from" time and, for the controller, a successor |
| Retire the identity (tombstone), with an optional successor |
| Take the deposit of a tombstone back down to the ledger minimum |
| Name the successor of a tombstone once |
| Guardians start the replacement of a lost controller key (the new key signs; completes after 7 days) |
| Guardians cancel a pending recovery |
| Complete a pending recovery after its delay (anybody) |
| Raise the subagent epoch: every subagent created under an older epoch ends |
Attestations, Delegations and Vaults (10)
Tool | Description |
| Issue an attestation about an agent (5 AP3X deposit; optional registered issuer, solicited co-signature, links and a COSE_Sign1 envelope signature) |
| Revoke an attestation (issuer authority) |
| The subject's controller attaches a reply (anchor) to an attestation |
| Burn an attestation 90 days after its revocation or expiry and release the deposit |
| Delegate actions and resources to an agent's delegation key (from a principal key, an agent, or a parent delegation), with an optional value limit |
| End a delegation (its delegator or an ancestor's delegator signs); delegations below it stop at once |
| Ask the delegate agent of a Delegate transaction for its co-signature (the signature of the delegate key). The agent must serve the route below. The tool holds no key and adds no signature |
| Open a vault that a delegation may spend from ( |
| The delegate hires a listed supplier from a vault, within the delegation's value limits. With |
| The owner takes the funds of vault outputs (live or returned refunds) back |
Who refuses. A refusal of a contract rule names the rule and says that the contract refuses the same transaction on chain. A refusal of a rule that only the builder enforces says that the builder refuses. With ledger_decides: true, vector_build_vault_pay skips most of its own checks, and the node judges the payment. The answer names the failed validator, not the rule. With the flag, a payment to an advert that no supplier can claim locks the vault funds until deliver_by.
Delegation co-signature route (for agent operators)
A Delegate transaction needs two kinds of signature: the delegator's, and the signature of the delegate key that the delegation names. Only the delegate agent holds that key. vector_delegation_request_cosign carries the transaction to the agent and returns the transaction with the signature of the delegate key added. An agent must serve the route below for the tool to work. An agent that does not serve it answers 404, and the tool says so.
The tool takes one input, txCbor: the unsigned Delegate transaction that vector_build_delegation_delegate returned, or the same transaction signed by the delegator. It takes no endpoint and no agent. It reads the delegate from the transaction, reads the identity record of the delegate, and sends to the origin of the endpoint in that record. The endpoint must be an https URL. The delegate writes its own record, so a refusal about the endpoint never repeats the endpoint text. A subagent has no endpoint by rule (Part 2 Section 3.3), so the tool cannot ask a subagent. The tool says so, and the delegation must name an agent that has an endpoint.
Route, version 1
POST https://<host of the endpoint in the agent's record>/cosign/delegate
content-type: application/json
accept: application/json
user-agent: vector-mcp-builder/<version of this server>
{ "transaction": "<hex CBOR of the Delegate transaction>" }The tool uses the origin of the endpoint: the scheme, the host and the port. It drops the path and the query of the endpoint. The request has no other header and no other field.
Success:
200with{ "transaction": "<hex CBOR>" }. The transaction has the same body, every witness that the request carried, and one more vkey witness: a signature of the delegate key over the body hash. The agent keeps the body bytes exactly as it received them and adds only that witness.Refusal: a
4xxwith{ "error": "<code>", "message": "<words>" }. The codes are:
Code | The agent refuses because |
| the transaction is not a Delegate transaction |
| the delegation names another agent, or a delegate key that this agent does not hold |
| the delegate key is in use: the agent already co-signed another body for it and the validity window of that body is open, or a live delegation uses it |
| the agent does not accept delegations from this delegator |
| an input, a collateral input, a withdrawal or a certificate of the transaction is of a key of the agent |
| the validity window of the transaction has ended |
The tool shows the code of a refusal, and only when it is one of these six. It shows the code with its own words, and it never shows the message of the agent. Any other code, and any code that is not 1 to 64 characters of a-z, 0-9 and _, shows as "the agent refused the transaction (HTTP n)". An agent may use other codes. A caller sees them only as that sentence and the HTTP status. A 404 or 405 without one of the six codes means that the agent does not serve the route.
What the agent learns. The agent gets the whole transaction before anyone submits it. It sees the inputs, the outputs with the change address, the witnesses that exist, the public keys of the key holders that signed before the call, and the validity window. The request comes from this server, so the agent sees the address of the server and the user agent above. It sees nothing else of the caller.
What the tool checks before it sends. The tool refuses what it can check without running the scripts. It does not run them, so the node checks everything, and runs the scripts, when the user submits. If one check fails, the tool sends nothing, and its text ends with "Nothing was sent."
What the tool reads first. The tool reads the keys of the body from the bytes of the transaction, with a reader of its own. It refuses before the decoder library reads the transaction in two cases: the bytes are not a transaction with a well-formed body, or the body has the key of a part that a delegation does not use (below). Only a transaction that passes this step goes to the decoder library. The reader goes over the bytes once, with a loop and no recursion, so its time is linear in the size of the input. The tool also compares the body of the answer of the agent with the body that it sent, from the bytes, before the decoder library reads the answer.
Checks that follow a rule of the ledger or of the delegation contract:
The transaction is marked valid (
is_validtrue) and mints exactly one token of the delegation policy.It has one output at the delegation address. That output holds the minted token alone and a valid delegation datum. The delegate key is a required signer.
Each vkey witness that it carries verifies over the body hash. The tool names a witness that does not.
The validity window has a start and an end, the start is before the end, the window is at most one hour long, and it has not ended. The result shows both times.
The record of the delegate exists, is
Activeover the window (its ancestors included), lists the delegate key with the delegation purpose, and has anhttpsendpoint without a user name or password. The tool names the status of a delegate that is notActive.Every input, collateral input and reference input is on the node. If one is spent or not confirmed yet, the ledger refuses the transaction.
No output is both spent and read as a reference input. The ledger refuses this at protocol version 10.
Checks that are the scope of this tool and not rules of the ledger. They bound what an agent is asked to sign:
The transaction mints nothing else: no second policy.
It has no withdrawals, certificates, votes, proposals, donation or treasury value (the keys 5, 4, 19, 20, 22 and 21 of the body). The tool refuses the part itself, also when it is empty or 0.
It has no witness of the delegate key yet.
The period of the value limit is less than 2^53 ms. The tool reads whole numbers up to that.
The tool does not check all that the delegation script checks. For example, it does not check the name of the token, a reference script on the delegation output, or that the key of the delegator is a required signer. The delegation script refuses such a transaction when the user submits it.
Where the request goes. The request goes through the outbound-call rule of the other tools that call a URL from chain data: https only, no private or reserved address, no redirect, an answer of at most 65,536 bytes, and 30 seconds. The tool makes one request and does not retry. The server sends at most 3 requests a minute for each caller to one origin, and at most 30 a minute to one origin for all callers together. The caller is the identity that the server uses for its rate limit. Both counts are in memory (a restart clears them), and each remembers a bounded number of callers and origins.
One co-signature is one request, so 3 a minute lets a user try again.
The limit for each caller stops one caller from using the whole budget of an agent with one unsigned transaction that it sends again and again. That would block every other user of the agent.
The limit for all callers bounds what one host gets from this server. Ten callers at their limit fill it.
The checks above run before the count, and a refused request does not count. A transaction that fails a check does not use a slot.
When a call fails. The text says whether the host got the transaction. If the host does not resolve, nothing was sent. After a redirect, the host received the transaction, whatever words the redirect holds. After a time limit, a size limit or a network error, the host may have received it, and the caller can ask again. A text that names the host shows it only when it is a plain name: letters, digits, dots, hyphens and a port. Any other host shows as "a host with unusual characters", in the texts and in the JSON.
What the tool takes from the answer. The tool takes one thing from a 200 answer: the one vkey witness of the delegate key. The body of the answer must be the body that was sent, byte for byte. The tool reads the body from the bytes of the answer and compares it before the decoder library reads the answer, and the decoded body must have the same hash as the body that was sent. The signature must verify over that hash by the rules of the ledger: a public key of small order, a signature that starts with a point of small order, and a scalar at or above the group order do not verify. The tool adds that witness, last, to the transaction that the caller gave. Only the list of vkey witnesses is written again, as a set (tag 258). The body, the validity flag, the auxiliary data, each other entry of the witness set and each witness that the caller sent keep their bytes. Nothing else of the answer comes back: not its other witnesses, its datums, its wrapping or its words. A refused answer returns nothing from the agent. A refusal of the answer names the number of its vkey witnesses and no key.
The result lists the keys that have signed and the keys that are still missing, and the validity window. Each missing key holder signs in turn with vector_signer_sign, passing on the CBOR that the previous signer returned. Then one vector_submit_transaction broadcasts it before the window ends. The tool never signs and never submits.
The route is public. Anyone can call it, with or without this tool. The checks of the tool give the agent no assurance. The agent decides alone. The agent signs only when
it decodes the transaction itself;
the only action is the Delegate: one delegation token minted,
is_validtrue, and no withdrawal, no certificate, no vote and no proposal;no input and no collateral input is at an address of a key of the agent;
the datum names this agent and one of its own delegation keys.
The agent never signs anything else with a delegation key.
Fresh keys. The contract does not enforce fresh delegation keys. So the agent remembers each body that it co-signed. While the validity window of the first body is open, it refuses another body for the same key with key_in_use. For the same body it gives the same answer again. A live delegation that uses the key ends only when its delegator, or the delegator of one of its ancestors, signs vector_build_delegation_undelegate.
Attestation, Delegation and Vault Reads (6)
Every tool below only reads: it builds, signs and submits nothing. The server needs the identity deployment values (see Configuration).
Tool | Description |
| Show an attestation by its identifier: every datum field, the status now, the output, the deposit and the time from which the issuer can withdraw it |
| List the attestations about a subject, from an issuer (a DID, a key hash, a public key, or 64 hex that name an identifier or a key), or both; newest first, with an optional type and paging. With neither, it lists every attestation a page at a time, in the order of the output reference. Koios narrows the read by the bytes of the subject or the issuer, and the rows are as Koios lists them |
| Check an attestation against the validity rule of Part 2 Section 4.3 at a time, and against an expected type, subject, issuer and digest; every condition and expectation shows its result |
| Show a live delegation with its terms and its chain of parents up to the root, or say that it is not live |
| List the problems that stop a delegation from being used for an action on a resource at one instant (an empty list means usable at that instant); optional minimum confirmations |
| Show vault outputs (Live and Returned) by output reference, owner key hash or delegation, in pages. The outputs whose owner is the delegator of their delegation come first, the one with the most AP3X first. The page is confirmed on the node. For an output that can pay, it gives the value limit of the delegation, what the period still allows, and the ledger minimum of the smallest escrow output |
Self-Improvement Module
Tool | Description |
| Browse improvement proposals, critiques, endorsements and the treasury; |
| Proposal metrics: activity, adoption rate, treasury health, engagement (current or previous deployment) |
| Build an unsigned proposal lock with its stake (step 1 of 2, keyless). It checks every submission rule first: the identity record, the declared credential, the module parameters, the rate limit and the activity list |
| Build an unsigned proposal submission (step 2 of 2, keyless): spends the lock, mints the proposal token, and inserts the agent's node into the activity list on its first proposal. The record and its ancestors are reference inputs; the declared credential signs |
| Build an unsigned critique lock - support, oppose, or propose amendments (step 1 of 2, keyless). The critique names the proposal by its seed |
| Build an unsigned critique creation (step 2 of 2, keyless): spends the lock and mints the critique token |
| Build an unsigned endorsement lock by staking AP3X (step 1 of 2, keyless). The endorsement names the proposal by its seed |
| Build an unsigned endorsement creation (step 2 of 2, keyless): spends the lock and mints the endorsement token ( |
Marketplace (15)
The escrow switch passed on mainnet at slot 37226741 (2026-11-03T13:25:41Z). From that slot on, the builders create identity-layout adverts and escrows only:
vector_build_marketplace_post_advertrefuses, andvector_build_marketplace_post_escrowrefuses a legacy-layout advert. The refusals name the identity-layout tool to use. Accept, reclaim and release of legacy escrows, and the retire of legacy adverts, keep working until the drain ends. The tools compare the slot with the chain tip.
Tool | Description |
| List the capability ids advertised on the agents marketplace, with supplier counts (read-only, no wallet needed) |
| List supplier adverts: advert ref, model, price, bonds, processing window, status. Filter by capability; free suppliers by default; fleet adverts are marked "not hireable through these tools (fleet route)", since |
| Read one advert from the ledger by advert ref (legacy or identity layout, with the agent DID) plus the indexer's live status, and the manifest its Detail URI points to (fetched from the supplier's host and shown as the supplier's own JSON, with the sha256 of its bytes held against the advert's detail hash and reported as a match or a mismatch); refuses UTxOs that are not at an advert script address or hold no advert datum (read-only, no wallet needed) |
| Build an unsigned escrow post that hires a supplier: locks price + supplier bond + buyer bond (at most 10,000 AP3X together) for an advert and commits a hash of your payload (its JSON block echoes the payload verbatim; the transaction is valid for at most 180 s). An advert of the identity layout must be listed by the indexer; the escrow then names its agent and refunds go to your own address. A legacy-layout advert is refused from the escrow switch on; escrows posted before it keep their accept, reclaim and release. Template-contract suppliers only: a fleet advert is refused, since |
| Build an unsigned accept of a Submitted job (legacy or identity escrow), within 600 s of the supplier's Submit: pays the supplier price + supplier bond and returns your buyer bond (keyless) |
| Build an unsigned reclaim of an Open or Claimed escrow once deliver_by has passed: everything returns to the buyer (an identity escrow with a refund address can be reclaimed by anybody) (keyless) |
| Build an unsigned release of a Submitted escrow by its supplier once the accept window has passed (both layouts, keyless) |
| Build an unsigned full refund of an identity escrow whose agent is revoked or retired (anybody, keyless) |
| Build an unsigned advert in the identity layout for an agent whose record lists the supplier key and the capability (the supplier key signs). The terms rules of both layouts apply: |
| Build an unsigned update of an identity-layout advert (it keeps its agent; the new terms follow the rules of a post; the supplier signs; the advert ref changes, so |
| Build an unsigned retirement of an advert in either layout, so that suppliers retire their legacy adverts during the switch: only the supplier key retires, and the deposit returns to it. A legacy advert needs the supplier key's wallet as |
| Send your payload to the supplier of a posted escrow and get a job id. Template-contract suppliers only; the wallet must have posted and funded the escrow; the whole call, its checks included, waits up to 90 s for the supplier to answer (nothing is sent if the checks leave it less than the 60 s a supplier may need) |
| Poll a job: pending, failed, or done with the result and the supplier's signed receipt. Template-contract suppliers only; works after the escrow is accepted or released; waits up to 20 s |
| Check a receipt without trusting the supplier: the escrow, the result's hash, the supplier's key, the Ed25519 signature and the hash the supplier committed on chain, plus an extra row for the request the receipt was made for. Works before and after the Accept: a settled escrow's Submitted output is located through the marketplace indexer and proven by the spend chain (read-only; the supplier's key is read from its |
| Legacy layout, refused from the escrow switch on: use |
Agent DIDs have two forms: the canonical did:vector:<64 hex> and the legacy did:vector:agent:{policyId}:{nftAssetName}. The identity tools take either form; vector_build_deregister_agent takes the legacy form.
Example non-custodial flow for an identity action with two keys: vector_build_identity_register → vector_signer_sign (controller key) →
vector_signer_sign (listed key, on the CBOR the first signer returned) → vector_submit_transaction → vector_await_transaction.
Reputation (6)
The Module-3 reputation stake of an agent, on the deployment for the identity registry (reputation validator
fad945ab20f61a58fbdf6a33a8f491899b7dd4167fb64200bc060424, on Vector mainnet since 2026-11-03). The agent is an identity DID
(did:vector:<64 hex>) whose record is Active; a DID of the legacy registry is refused, and the refusal names the identity form. A stake
takes two builds. The owner then adds AP3X, replaces the staked capabilities, or takes AP3X out down to the module minimum. Each build tool
is keyless: it checks the rules of the validator, lets Lucid run the deployed validator on the transaction, and returns the unsigned
transaction with every key hash that must sign it: the controller key of the agent, the owner key of the stake, and the wallet (an exit
needs the controller key only, besides the wallet). Step 1 is the exception: it only locks an opening output, no script runs, and only the
wallet signs. The owner of the stake is owner_key_hash when it is passed; when it is not, step 1 takes the key of changeAddress and
step 2 takes the owner that the opening output names, if the record declares that key now (else it refuses and says what to pass). The
validator reads the owner of the stake, not the owner in the opening output, so the answer of step 2 says when the stake gets another owner
than the opening output names. The build tools find the agent's record through the identity
registry of the server (see Configuration) and refuse on a server that has none; vector_get_reputation_stake needs no
identity registry and works there. All six need a node on Vector mainnet, and no other setting. The owner cannot withdraw the module
minimum. Each agent has one stake through these tools.
Tool | Description |
| Step 1 of 2 of an agent's Module-3 reputation self-stake: an opening output at the reputation validator, naming the agent and the capabilities. It checks the record (Active over the window, lists each capability), the owner key (the controller key, or a listed key with the transaction purpose; default your wallet key), that the agent has no stake yet, and that the wallet can pay step 2. It refuses when an opening output that names the agent is already at the reputation address: step 2 can spend any of them with any owner key that the record declares, and the refusal lists them with their AP3X and owner (at most 5, those whose owner the record declares first, then the number of the rest); |
| Step 2 of 2 (CreateStake): consumes the opening output, mints the agent's stake token and locks the stake: at least the module minimum, 10 AP3X, read from the module's parameters ( |
| Add AP3X to a stake (IncreaseStake). No cooldown. The record must list each capability that the stake backs. Name the stake with |
| Replace the staked capabilities (UpdateCapabilities): each must be one that the record lists. The cooldown of the stake (24 h after |
| Take AP3X out of a stake (DecreaseStake), down to the module minimum. The cooldown must be over and no challenge may lock the stake. Only the controller key signs, besides the wallet. The AP3X go to the owner key of the stake while the record declares it, else to the controller key; the answer names the payee. A revoked or retired agent can exit (keyless) |
| Read the stakes of 1 to 50 agents with one Koios call: each stake (reference, |
The stake datum (8 fields), the stake token and the transaction shape follow the deployed validator
(Apex-Fusion/vector-agent-modules, Module-3/reputation-staking) and its reference Python SDK (Module-3/python/reputation_staking).
Launching a supplier agent from a chat client, with the hosted server and the local signer (each build is signed
with vector_signer_sign, broadcast with vector_submit_transaction and confirmed with vector_await_transaction
before the next): vector_build_identity_register (the identity, listing the supplier key and the capability) →
vector_build_marketplace_advert_post (the listing; then set the supplier runtime's ADVERT_REF to the new advert
ref). vector_build_marketplace_advert_retire takes the listing down, in either layout.
Module-1 Disputes and Jury (12)
The Module-1 jury decides Module-1 disputes on Vector. AI jurors vote on each challenge, and the relay of the Foundation signs the
Module-1 OracleResolve with the result (Module-1 jury specification, Module-1/jury/SPEC.md in Apex-Fusion/vector-agent-modules).
The build tools are keyless: each returns the unsigned transaction and the key hashes that must sign it. The claim and challenge tools
need VECTOR_MODULE1_MANIFEST, the juror and jury tools need VECTOR_JURY_MANIFESTS (see Configuration); without
them the tools say which variable to set. The document tools need neither.
Tool | Description |
| Build an unsigned transaction that carries a document (UTF-8, normally JSON) as metadata under label 22084, in text chunks of at most 64 bytes. Returns the document URI |
| Read a document by its URI ( |
| Build an unsigned Module-1 SubmitClaim (oracle mode): the claim token and the stake (at least 50 AP3X on mainnet) in a claim output with the claim document hash and URI. The wallet key is the claimer credential; the claimer DID must be Active. Without |
| Build an unsigned Module-1 OpenChallenge (oracle mode): spends the claim into state Challenged and locks the auditor stake (at least the claim stake) in a challenge output in state PendingOracle. The claim can sit at any address that has the claim script as its payment credential (a stake part is allowed, as Module-1 checks the payment credential only); the continuing claim output stays at that address. The resolution deadline defaults to 72 h; the jury needs at least 6 h 10 min, and the answer warns below that (keyless) |
| Build an unsigned Module-1 WithdrawClaim: the claimer takes the stake of an Open claim back after its challenge window. It spends the claim output with the WithdrawClaim redeemer, burns the claim token and pays exactly the stake to the wallet in one output; no claim output continues. The tool refuses before it builds when the claim is not Open, when the challenge window has not ended (the transaction must start after |
| Register a DID as a juror: mints a juror token and locks the bond (at least 250 AP3X on mainnet); the wallet key becomes the juror owner; the transaction carries the juror prompt document; the juror can vote 3 days later (keyless) |
| Step |
| Add AP3X to the bond of a juror (keyless) |
| Commit a vote in a case: blake2b-256 of the case token, the juror DID, the vote, a 32-byte salt and the hash of the juror record. Without a salt the tool makes one and returns it: keep the salt and the exact record for the reveal (keyless) |
| Reveal a committed vote in the reveal window: checks the vote, the salt and the record hash against the commitment, adds the vote to the tally and carries the record as metadata. When the reveal with the record does not fit in one transaction: first publish the same record bytes with |
| The followed jury deployments: their parameters and their jurors (bond, prompt hash, when each can vote, exit state, open votes) (read-only) |
| The live jury cases: parties, the claim and evidence URIs (read from the claim and challenge outputs that the case names) and hashes, windows, ballots, tally, the result of the tally, and whether the case is the canonical case of its dispute (the claim token; the flag comes from the marketplace indexer's |
A dispute from a chat client: vector_build_document_publish (the claim document) → vector_build_module1_claim; a claimer that nobody challenged
takes the stake back after the challenge window with vector_build_module1_withdraw_claim; an auditor:
vector_build_document_publish (the evidence) → vector_build_module1_challenge. The relay opens a jury case for the challenge. A juror:
vector_get_jury_cases → vector_get_document (claim and evidence) → vector_build_jury_commit (keep the salt and the record) → in the
reveal window vector_build_jury_reveal. Each build is signed with vector_signer_sign, broadcast with vector_submit_transaction and
confirmed with vector_await_transaction.
Self-hosting
1. Install and build
Requires Node.js >= 22 (matches engines in every package.json and the Dockerfile's
node:22-alpine base).
npm install
npm run buildDependency advisories. npm audit currently reports 1 low-severity advisory: an esbuild
arbitrary-file-read issue that only triggers via its own Windows dev server, reachable solely
through tsup (a build-time-only dependency, absent from the production image, which installs
with npm ci --omit=dev). As of 2026-07-31 this tree carried 44 advisories, including 1
critical (tar, GHSA-23hp-3jrh-7fpw) that arrived because @cardano-sdk/crypto - pulled in
transitively through @lucid-evolution/lucid - declared the entire npm CLI package as a
runtime dependency. That dependency was dead weight: @cardano-sdk/crypto's own published code
never requires npm, and neither npm nor tar appears anywhere in this server's built
bundle. Regenerating the lockfile picked up a newer @cardano-sdk/crypto release that dropped
the stray dependency outright, clearing all 43 of those advisories without any override needed;
package.json also carries a defensive overrides pin on tar and brace-expansion against
future regressions, though it is not what resolved this one.
2. Configure environment (optional)
cp .env.example .env
# Edit .env with your endpoint URLs (defaults point to Vector testnet; mainnet URLs below)Every build_* tool is keyless: it takes a wallet address, never a mnemonic. No tool call
against this server ever needs a mnemonic parameter, for any family - see the security notice
above.
3. Run
npm start
# Server listens on port 3000 (configurable via PORT env var)Connect:
claude mcp add --transport http vector-mcp http://localhost:3000/mcpAdd --header "Authorization: Bearer <your-token>" if you set MCP_AUTH_TOKENS. A liveness
probe is at GET /health - unauthenticated, returns {"status":"ok","version":"<version>"}.
If this instance will be reachable by anyone but you, set MCP_AUTH_TOKENS first - see Configuration below.
4. Add to Claude Desktop
Add to your Claude Desktop MCP config (claude_desktop_config.json):
{
"mcpServers": {
"vector": {
"command": "node",
"args": ["/path/to/vector-mcp-server/packages/builder/build/index.js"],
"env": {
"VECTOR_OGMIOS_URL": "https://ogmios.vector.testnet.apexfusion.org",
"VECTOR_SUBMIT_URL": "https://submit.vector.testnet.apexfusion.org/api/submit/tx",
"VECTOR_KOIOS_URL": "https://koios.vector.testnet.apexfusion.org/",
"VECTOR_EXPLORER_URL": "https://vector.testnet.apexscan.org"
}
}
}
}For mainnet, use the mainnet endpoint table below. (No local setup needed if you use the hosted servers above.)
Docker
npm run build
docker build -t vector-mcp .
docker run -p 3000:3000 vector-mcpIf this instance will be reachable by anyone but you, set MCP_AUTH_TOKENS first - see Configuration below (docker-compose.yml in this repo binds 127.0.0.1 by default; the command above does not).
Configuration
Variable | Description | Default |
| HTTP server port |
|
| Ogmios HTTP JSON-RPC endpoint |
|
| Koios REST API endpoint |
|
| Transaction submit API |
|
| Block explorer base URL |
|
| Marketplace indexer behind the |
|
| Identity gateway behind |
|
| Blockfrost behind the CBOR form of document metadata ( |
|
| Identity registry deployment value: the Merkle root of the adoption allowlist (64 hex). With | unset (identity tools answer "not configured") |
| Identity registry deployment value: the seed output of the configuration seal ( | unset |
| Optional check: the published identity policy; the start fails when the two values above give another one | unset |
| The reference-script UTxOs ( | unset |
| The reference-script UTxO of Module-1's | unset |
| Optional https URL of the published adoption allowlist (JSON list of identifiers); | unset |
| Module-6 deployment on the identity registry: the hashes of the applied validators (its deploy state). Set every required | unset (Module-6 build tools answer "not configured") |
| The record token policy (GovernanceParams record and the head of the activity list) and the CrossRefs token policy of the Module-6 deployment | unset |
| The params holder address, the CrossRefs address (the oracle holder) and the treasury holder address. The builders find the params record, the CrossRefs output and the activity list by their tokens | unset |
| The reference-script UTxOs ( | unset |
| The Module-1 deployment manifest ( | unset (the claim and challenge tools answer "not configured") |
| The jury deployment manifests ( | unset (the juror and jury tools answer "not configured") |
| Max tool calls per minute, per identity (min |
|
|
|
|
| How often the |
|
| Max concurrent |
|
| Bearer tokens that may call this server. Comma-separated; each entry is | (unset - auth disabled) |
The four numeric knobs above fail loudly at startup on a malformed value: anything that is not a plain integer, or is below its listed minimum, raises a startup error naming the variable and the value it got, rather than silently falling back to some other behavior (an unparseable rate limit silently disabling rate limiting, for example).
This server has no spend-limit or audit-log configuration of its own: it holds no key material
for any family, so it has nothing left to limit. Every spend limit, and the audit log recording
it, lives in your local signer instead - see VECTOR_SIGNER_SPEND_LIMIT_PER_TX /
VECTOR_SIGNER_SPEND_LIMIT_DAILY / VECTOR_SIGNER_AUDIT_LOG_PATH in
packages/signer/README.md.
Running a public instance? Set
MCP_AUTH_TOKENSto gate access to known callers, each with its own rate-limit budget. Note that the server answers any-origin CORS by design: with auth unset, any web page a browser user visits can drive your instance from JavaScript, sharing that user's per-IP rate-limit bucket - one more reason a public instance should setMCP_AUTH_TOKENS. WithMCP_AUTH_TOKENSunset, callers are admitted anonymously with per-client-IP rate limits; the deployment's reverse proxy supplies the client address via the rightmost X-Forwarded-For entry. Tracked identities are capped (LRU); eviction resets a bucket's budget - a memory bound, not a security boundary, since an attacker rotating enough source IPs can still defeat per-IP limiting at a tier only the reverse proxy or network layer can police./mcpsessions get the same per-identity treatment: idle sessions are reaped (VECTOR_MCP_SESSION_IDLE_MS, swept everyVECTOR_MCP_SESSION_SWEEP_MS), and concurrent sessions per identity are capped (VECTOR_MCP_MAX_SESSIONS_PER_IDENTITY) - see the Configuration table above for defaults and minimums.
Malformed values fail loudly. The server refuses to start if
MCP_AUTH_TOKENScontains an empty token, a token with embedded whitespace, a duplicate token, or a value where every comma-separated entry is blank (e.g. a stray,,,). Each case raises a startup error that names the problem but never echoes a token value. Commas delimit entries and cannot be escaped, so generate tokens from a comma-free charset (hex / base64url / alphanumeric).
Error responses do not echo configured endpoints. This covers every failure mode a network call can produce, not just an HTTP-level rejection: a DNS failure, a dropped connection, and a malformed (non-JSON) response body are all sanitised the same way an ordinary
4xx/5xxstatus is - the underlying HTTP client is the platform's nativefetch, chosen in part because its own errors do not embed the request URL the way some polyfills do. A failed Ogmios or Koios query is this server's own infrastructure problem, not something the caller can act on - it is reported by service name and status only, for example "Ogmios request failed (queryLedgerState/utxo): 503 Service Unavailable" or, for a connection failure, "...: network error". A rejected transaction submission is different: the ledger's verdict on the CALLER'S OWN transaction (a bad input, an unmet script condition, a fee too small) stays in the response, since it is the feedback loop an agent needs to self-correct after build → sign → submit - only URL-shaped content is scrubbed out of it first, for example "Transaction submission rejected (400 Bad Request): ValueNotConservedUTxO...". A NETWORK failure to even reach the submit API is reported as an infrastructure failure instead ("...: network error"), never worded as a ledger rejection, since nothing looked at the transaction at all. Neither case ever echoes the configuredVECTOR_OGMIOS_URL/VECTOR_KOIOS_URL/VECTOR_SUBMIT_URLvalue itself, and full unscrubbed detail always goes to the server's ownconsole.errorlog for operators. Known limit: the submission-rejection scrub removes http(s) URLs and the three endpoints above by name - a rejection body that happens to name some other internal hostname passes through unscrubbed, bounded by a 2000-character cap.
Mainnet endpoints
Variable | Mainnet value |
|
|
|
|
|
|
|
|
The tool vector_verify_signature_at needs VECTOR_OGMIOS_URL and VECTOR_IDENTITY_GATEWAY_URL on the same network. Otherwise it cannot check that the gateway is current, and its answers are not reliable.
Testing
npm run test:unitNo wallet, no network - pure logic only (CBOR encode/decode assertions).
npm run test:smokeBuilds the server, boots it, and asserts the exposed tool inventory matches the checked-in snapshot. No wallet, no external network. CI runs this and test:unit on every PR.
echo "your mnemonic words here" > packages/builder/mnemonic.txt
npm run test:integrationRequires mnemonic.txt in packages/builder/ containing a funded Vector testnet mnemonic. Covers the core tools end-to-end against Vector testnet, including discover, profile and, without submitting, the identity registration and the legacy deregistration (the legacy registration tools are retired; the Module-6 section uses a legacy record that the wallet owns). Also runs keyless-build.test.ts, registry-keyless.test.ts, and self-improvement-keyless.test.ts - tier-1 suites needing no mnemonic at all, each building unsigned transactions against live public data only (vector_build_send_tokens is covered offline, by unit tests and the legacy suite above; self-improvement-keyless.test.ts covers critique, endorse, and proposal-lock builds, plus a not-found rejection path on proposal-spend). Set VECTOR_E2E_SUBMIT=1 to additionally run each family's gated end-to-end suite, fully on-chain: keyless-e2e.test.ts lands one real self-send (~0.16 AP3X fee); registry-e2e.test.ts runs the identity registry lifecycle register → update → retire → reclaim (only when the identity deployment variables are set as well); self-improvement-e2e.test.ts locks and spends a real improvement proposal through the deployed module validator with a legacy record that the wallet owns, then critiques and endorses it (≈48 AP3X in stakes and module minimums, plus four transaction fees, one-way - the stakes are locked by the module's own design, not lost). Set LEGACY_FULL=1 to additionally exercise the same self-improvement lock → spend sequence inside run.test.ts itself (off by default, since self-improvement-e2e.test.ts already proves that exact path). Never runs in CI.
npm run test:smoke:signerBuilds the local signer (packages/signer), boots it over stdio, and exercises all five of
its tools, including the fail-closed audit-write-failure path and input resolution against a
local Ogmios stand-in. No wallet, no external network. CI runs
this on every PR alongside the two smoke tests above.
export VECTOR_SIGNER_MNEMONIC_FILE=/absolute/path/to/testnet-mnemonic.txt
npm run test:integration:signerRequires a funded Vector testnet wallet. Builds a real unsigned transaction the way the
hosted builder does (no key), then has the local signer decode, policy-check, and sign it
against live chain data. Never submits. Never runs in CI. See
packages/signer/README.md.
Architecture
┌──────────────────────┐ ┌──────────────────────────┐
│ Claude / GPT / etc. │◄───────────►│ vector-mcp-server │
│ (any MCP client) │ /mcp │ │
└──────────────────────┘ │ ┌────────────────────┐ │
│ │ Rate Limiter │ │
│ │ (60 calls/min) │ │
│ └────────┬───────────┘ │
│ │ │
│ ┌────────▼───────────┐ │
│ │ Lucid + Ogmios │ │
│ │ Provider │ │
│ └────────┬───────────┘ │
│ │ │
│ ┌────────▼───────────┐ │
│ │ Ogmios / Koios / │ │
│ │ Submit API │ │
│ └────────────────────┘ │
└──────────────────────────┘No safety layer sits between the rate limiter and the provider: this server holds no key material for any family, so it has no spend limits of its own left to enforce. Every spend limit lives in your local signer instead.
About Vector
Vector is Apex Fusion's eUTXO L2, running Cardano mainnet parameters (Conway era, Plutus V3). Sub-1-second optimistic finality and deterministic fees make it a natural chain for AI agent workloads. Mainnet is live.
Docs: https://apex-fusion.github.io/vector-ai-documentation/
Explorer (mainnet): https://vector.apexscan.org/en/
Explorer (testnet): https://vector.testnet.apexscan.org
Apex Fusion: https://apexfusion.org
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Provide AI agents and automation tools with contextual access to blockchain data including balance…
AI Agent Utility Layer for agent safety, web monitoring, crypto research and tool discovery.
Crypto wallet for AI agents: balances, payments, swaps and trading with owner controls.
Agentic AI runtime: persistent memory, vault, autonomous agents, deep research, DeFi execution.
Related MCP Servers
- 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
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to interact with the Somnia blockchain network, including documentation search, blockchain queries, wallet management, cryptographic signing, and on-chain operations.MIT
- AlicenseNot gradedqualityNot gradedmaintenanceEnables AI applications to interact with the Base blockchain network, allowing wallet management, smart contract deployment, token transfers, NFT operations, DeFi interactions with Morpho vaults, and onramping funds via Coinbase.26 npm-
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to interact with the AI Network blockchain by managing accounts, submitting transactions, and reading database values. It supports registering Hyper Agents and accessing a Layer 2 DAG-based shared agent memory system based on staking status.6MIT