IBM Granite x402 Remote

io.github.nirholasPublished by GitHub account nirholasv1.0.0Updated Oct 24, 2026

Pay-per-use IBM Granite AI via x402: chat, code, embeddings, forecasting. USDC on Base or Solana.

The publisher's own server: Granite

VerifiedStreamable HTTPWeb executableFinanceAI & ML

Overview

AI-generated overview

Remote MCP server exposing IBM Granite chat, code, embedding, analysis and forecasting tools, paid per call in USDC over the x402 protocol.

What you can do
Run IBM Granite chat completions with configurable model, token limit and temperature, and get a free getting-started overview of prices and the payment flow. Generate, review, refactor, explain, test or document code in a chosen language. Produce batch text embeddings for RAG, search or clustering. Analyze documents for entities, sentiment, risk flags, summaries and next steps. Forecast time series from 64 to 1024 timestamped points with a chosen cadence and prediction length.
When to use it
Use it when you want Granite model inference from an assistant without holding an IBM Cloud account, and are willing to pay small per-call USDC amounts. Suitable for occasional chat, code review, embedding or document-analysis tasks where a metered, pay-as-you-go model is acceptable.
Requirements
A remote endpoint at three.ws with OAuth authentication declared. The README describes a locally run npm package instead, which needs Node.js 20 or newer, a Solana wallet address to receive USDC (MCP_SVM_PAYMENT_ADDRESS), and IBM Cloud credentials (WATSONX_API_KEY plus WATSONX_PROJECT_ID or WATSONX_SPACE_ID). Callers need USDC on Solana and an x402-capable client; network access to IBM watsonx.ai and a payment facilitator is required.
Before you install
Every paid tool costs USDC on Solana per call (roughly 0.005 to 0.05 USDC in the listed prices), so usage spends real funds. The operator must supply IBM credentials and a receiving wallet address; the README states the server exits at startup if these are missing. Prompts, code and documents are sent to IBM watsonx.ai and payments go through a third-party facilitator. The project is community-built and not affiliated with IBM.

Installation

In SourceWeft

  1. Open IBM Granite x402 Remote in the dashboard and add it to a workspace.
  2. Connect the required credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.nirholas%2Fibm-x402-mcp-remote/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config. The client completes OAuth sign-in on first connect.

{
  "mcpServers": {
    "ibm-granite-x402-remote": {
      "type": "http",
      "url": "https://three.ws/api/ibm-mcp"
    }
  }
}

README

[three.ws]

@three-ws/ibm-x402-mcp

Pay-per-use IBM Granite AI over MCP — chat, code, embeddings, analysis, and forecasting, billed in USDC on Solana. No IBM account required.

[npm] [downloads] [license] [node] [MCP Registry] [three.ws]

Install · Quick start · Tools · Payment flow · Requirements · three.ws

A Model Context Protocol server that exposes IBM Granite foundation models as pay-per-use tools via the x402 payment protocol. End users pay USDC on Solana per call — no IBM Cloud account of their own. The server operator supplies IBM credentials (WATSONX_*) and a receiving Solana wallet (MCP_SVM_PAYMENT_ADDRESS); callers supply only USDC. One free tool (ibm_granite_getting_started) explains prices and the flow before any payment.

Built by three.ws. Community-built and not affiliated with IBM.

How it works

  1. An MCP client (Claude Desktop, Claude Code, Cursor, or an agent) connects to this server.
  2. The client calls a tool — e.g. ibm_granite_chat.
  3. Without an x402 payment payload, the server returns a 402 PaymentRequired envelope quoting the USDC price and the Solana receiving address.
  4. The client signs a Solana USDC transfer and retries with the payment in _meta["x402/payment"].
  5. The server verifies and settles the payment via the facilitator, calls IBM watsonx.ai, and returns the result with a settlement receipt in _meta["x402/payment-response"].

x402-capable MCP clients handle this loop automatically.

Install

bash
npm install @three-ws/ibm-x402-mcp

Run it directly with npx (no install needed):

bash
MCP_SVM_PAYMENT_ADDRESS=<your-solana-wallet> \WATSONX_API_KEY=<ibm-api-key> \WATSONX_PROJECT_ID=<watsonx-project-id> \npx @three-ws/ibm-x402-mcp

Or install globally for the ibm-x402-mcp binary on your PATH:

bash
npm install -g @three-ws/ibm-x402-mcp

Quick start

Whoever runs the process is the operator: the server fails fast at startup without a payment address and IBM credentials (WATSONX_API_KEY, WATSONX_PROJECT_ID). Callers of the running server need only USDC — no IBM account. With Claude Code, one command:

bash
claude mcp add ibm-granite-x402 \  -e MCP_SVM_PAYMENT_ADDRESS=your-solana-wallet \  -e WATSONX_API_KEY=your-ibm-api-key \  -e WATSONX_PROJECT_ID=your-watsonx-project-id \  -- npx -y @three-ws/ibm-x402-mcp

Or wire the server into your MCP client config (claude_desktop_config.json, Cursor's mcp.json):

json
{	"mcpServers": {		"ibm-x402": {			"command": "npx",			"args": ["-y", "@three-ws/ibm-x402-mcp"],			"env": {				"MCP_SVM_PAYMENT_ADDRESS": "your-solana-wallet-address",				"WATSONX_API_KEY": "your-ibm-cloud-api-key",				"WATSONX_PROJECT_ID": "your-watsonx-project-id"			}		}	}}

Inspect the tool surface with the MCP Inspector:

bash
npx -y @modelcontextprotocol/inspector npx @three-ws/ibm-x402-mcp

Tools

ToolWhat it doesPrice
ibm_granite_getting_startedOverview, prices, and the x402 payment flow. No payment or IBM account required.Free
ibm_granite_chatConversational AI via IBM Granite (default ibm/granite-3-8b-instruct).$0.02 USDC
ibm_granite_codeCode generate, review, refactor, explain, test, document.$0.025 USDC
ibm_granite_embedBatch text embeddings for RAG, search, and clustering (1–64 texts).$0.005 USDC
ibm_granite_analyzeStructured document analysis: entities, sentiment, risk flags, summary, next steps.$0.04 USDC
ibm_granite_forecastZero-shot time-series forecasting via IBM Granite TTM (Tiny Time Mixer).$0.05 USDC

Every tool is a read-only model-inference call — nothing on your machine or in any account is modified — and declares MCP tool annotations (readOnlyHint, openWorldHint, idempotentHint) so clients can reason about side effects before paying.

Input parameters

ibm_granite_getting_started — section (optional: overview (default, everything) / pricing / payment / tools / setup).

ibm_granite_chat — messages (required: 1–50 { role, content } pairs; roles system/user/assistant, content ≤ 32,000 chars), model (default ibm/granite-3-8b-instruct), max_new_tokens (1–4096, default 1024), temperature (0–2, default 0.7).

ibm_granite_code — task (required: generate/review/refactor/explain/test/document), prompt (required, ≤ 16,000 chars: the description for generate, the code for everything else), language, context (≤ 4,000 chars).

ibm_granite_embed — inputs (required: 1–64 texts, ≤8000 chars each), model.

ibm_granite_analyze — document (required), analysis_type (general/contract/financial/technical/medical/sentiment, default general), language.

ibm_granite_forecast — timestamps (required: 64–1024 ISO-8601, uniform cadence, oldest first), values (required: 64–1024 numbers, same length), freq (required: pandas cadence, e.g. 1h, 1D), prediction_length (1–96), label.

Example calls

jsonc
// ibm_granite_chat{  "messages": [    { "role": "system", "content": "You are an expert data engineer." },    { "role": "user", "content": "Design a lakehouse schema for IoT sensor telemetry." }  ],  "max_new_tokens": 1024,  "temperature": 0.7}
// ibm_granite_code{ "task": "review", "prompt": "def calculate_roi(revenue, cost): return revenue / cost", "language": "Python" }
// ibm_granite_embed{ "inputs": ["enterprise data governance", "cloud-native AI pipeline", "real-time analytics"] }
// ibm_granite_analyze{ "document": "This Software License Agreement is entered into between...", "analysis_type": "contract" }
// ibm_granite_forecast  (timestamps/values must be 64–1024 points; abbreviated here){ "timestamps": ["2025-01-01T00:00:00Z", "...", "2025-03-05T00:00:00Z"], "values": [12500, "...", 13200], "freq": "1D", "prediction_length": 14, "label": "daily_revenue_usd" }

Payment flow

This server uses the x402 protocol for micropayments:

  1. Client calls a tool without payment → 402 PaymentRequired with the USDC amount and Solana address.
  2. Client builds and signs a Solana USDC transfer transaction.
  3. Client retries with the signed tx in _meta["x402/payment"].
  4. Server verifies and settles via the configured facilitator (default PayAI).
  5. Server calls IBM watsonx.ai and returns the result with _meta["x402/payment-response"] (settlement receipt).
MCP Client (Claude Desktop / Cursor / agent)       │  tools/call (with x402 payment in _meta)       ▼ibm-x402-mcp (stdio MCP server)       │  verify + settle USDC on Solana       ├──► x402 facilitator (default https://facilitator.payai.network)       │       │  inference call with IAM Bearer token       └──► IBM watsonx.ai (us-south.ml.cloud.ibm.com)                 └── IBM Granite 3 8B Instruct / Embedding / TTM

Requirements

  • Node.js >= 20.
  • A Solana wallet address to receive USDC (MCP_SVM_PAYMENT_ADDRESS).
  • IBM Cloud credentials: an API key (create one) and a watsonx.ai project id (Project → Manage → General → Project ID), or a deployment space id.

Environment variables

VariableRequiredDefault
MCP_SVM_PAYMENT_ADDRESSyes— (aliases: X402_PAY_TO_SOLANA, X402_PAY_TO)
WATSONX_API_KEYyes—
WATSONX_PROJECT_IDyes (or WATSONX_SPACE_ID)—
WATSONX_SPACE_IDalternative to WATSONX_PROJECT_ID—
WATSONX_URLnohttps://us-south.ml.cloud.ibm.com
WATSONX_MODEL_IDnoibm/granite-3-8b-instruct
WATSONX_CODE_MODEL_IDnoibm/granite-3-8b-instruct
WATSONX_EMBED_MODEL_IDnoibm/granite-embedding-278m-multilingual
WATSONX_FORECAST_MODELnoibm/granite-ttm-512-96-r2
WATSONX_TIMEOUT_MSno90000
X402_FEE_PAYER_SOLANAnothree.ws fee payer
X402_FACILITATOR_URLnohttps://facilitator.payai.network
X402_FACILITATOR_TOKENno— (Bearer token for a private facilitator)
X402_ASSET_MINT_SOLANAnocanonical Solana USDC mint

Regional hosts: us-south, eu-de, eu-gb, jp-tok, au-syd, ca-tor — e.g. https://eu-de.ml.cloud.ibm.com.

Errors

Every failure state is explicit — there is no silent fallback:

StateWhat you seeRecovery
Missing env at startupThe process exits with a one-line configuration error: … naming the missing variable (MCP_SVM_PAYMENT_ADDRESS, WATSONX_API_KEY, or WATSONX_PROJECT_ID/WATSONX_SPACE_ID).Set the variable and restart.
Unpaid call to a paid toolAn x402 PaymentRequired envelope quoting the USDC price and pay-to address — not an error; it is step 1 of the payment loop.Pay and retry (x402-capable clients do this automatically).
Invalid/underpaid paymentThe facilitator rejects verification and a fresh PaymentRequired envelope is returned; no inference runs and no funds settle.Re-sign against the quoted accepts.
IBM-side failureTool result { "ok": false, "error": "watsonx_error", "message": "…", "status": … } — IAM auth failure (bad WATSONX_API_KEY), model error, or a watsonx.ai timeout (WATSONX_TIMEOUT_MS, default 90 s).The message carries IBM's reason; check credentials, project id, and region.
Unexpected server faultTool result { "ok": false, "error": "internal_error", "message": "…" }.Retry; file an issue if it persists.
Facilitator unreachable at bootA facilitator init warning: … line on stderr; the server still starts and retries lazily on the first paid call.Check X402_FACILITATOR_URL connectivity.

ibm_granite_getting_started is always free and never touches IBM or the facilitator — use it to sanity-check the server before paying.

Related

  • @three-ws/ibm-watsonx-mcp — the same IBM Granite tools driven by your own IBM Cloud credentials (no x402, no per-call payment).

Links

Part of the three.ws SDK suite — 3D AI agents, on-chain identity, and agent payments.
Website · Changelog · GitHub

Source: packages/ibm-x402-mcp/README.md at commit c8f2cde

Tools

0
This server asks you to sign in, so SourceWeft could not read its tools without an account and has not indexed them. What a connected account sees can depend on that account and its permissions.

Version history

1
  1. v1.0.0LatestSep 16, 2026

Score

85% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

Other Granite integrations

Granite

md.graniteOfficial publisher

Encrypted Markdown notes and team knowledge base. Search, read and write notes in vaults you allow.

Streamable HTTPWeb executableAuth
Credential requiredOct 25, 2026

IBM Granite via x402

Published by GitHub account nirholas

A local MCP server that exposes IBM Granite chat, code, embedding, analysis and forecasting tools, billed per call in USDC on Solana via x402.

STDIODesktop only
FinanceNot validated yetOct 24, 2026

IBM watsonx.ai Granite

Published by GitHub account nirholas

Local MCP server that connects an assistant to IBM watsonx.ai Granite models for chat, text generation, embeddings, tokenization and forecasting.

STDIODesktop only
Data & AnalyticsNot validated yetOct 24, 2026