Abstraxn Public Web3 MCP Service

A free, public **MCP (Model Context Protocol) server** for

Web3 data. Point any MCP client — Claude Desktop, Cursor, your own agent — at it and it can read

live chain data (block height, gas, transaction status, ERC-20 info, spot prices), look up

weather forecasts, build unsigned EVM/Solana transfer transactions, and, for a handful of

pay-per-call tools, look up market data, wallets/tokens/ENS, travel search, places/solar/aerial-view

data, and social-profile identity.

No API key, no account, no signup. Free tools are open to anyone; paid tools are settled

directly from the caller's own wallet via the x402 payment protocol —

this service never holds or signs funds on your behalf.

Built on the official `@modelcontextprotocol/sdk`

and NestJS 11.

Contents

• Quick start
• Use it from Claude Desktop / Cursor
• Available tools
• Calling tools directly (curl)
• Configuration
• How it works
• Database
• Security
• Scripts
• Contributing

Quick start

git clone https://github.com/Abstraxn-Labs/abstraxn-agent-layer.git
cd abstraxn-agent-layer
npm install
cp .env.example .env
# Edit .env: Postgres connection + UPSTREAM_RELAY_BASE_URL / ENRICHMENT_RELAY_BASE_URL
# (each required for its own group of paid tools) + WEATHERAPI_KEY (required for weather.forecast)
npm run start:dev

• Health check: `GET http://localhost:3011/health`
• MCP endpoint: `POST http://localhost:3011/mcp`
• API docs (health only): `http://localhost:3011/api/docs`

Database migrations run automatically on boot — no separate CLI step needed.

Use it from Claude Desktop / Cursor

Add this to your MCP client's config (e.g. `claude_desktop_config.json` or Cursor's `mcp.json`):

{
  "mcpServers": {
    "abstraxn-public-web3": {
      "url": "http://localhost:3011/mcp"
    }
  }
}

Restart the client and the tools below become available to it — no further setup.

Available tools

Tools are namespaced by area (`network.*`, `market.*`, `web3.*`, `travel.*`, `places.*`,

`social.*`) so an MCP client can browse them as a tree rather than a flat list.

How paid tools work: call one with no payment, and you get back a `paymentRequired` challenge

(not an error). Your wallet client signs it and retries the same call with `paymentPayload` set —

your wallet pays directly; this service only relays the request.

Calling tools directly (curl)

Most people will use an MCP client (above), but the endpoint is plain JSON-RPC over HTTP if you

want to script against it directly:

BASE=http://localhost:3011
ACCEPT='Accept: application/json, text/event-stream'   # required by the MCP spec

# 1. Initialize a session
curl -s -X POST "$BASE/mcp" -H 'Content-Type: application/json' -H "$ACCEPT" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"my-client","version":"1.0"}}}'

# 2. List available tools
curl -s -X POST "$BASE/mcp" -H 'Content-Type: application/json' -H "$ACCEPT" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

# 3. Call a tool
curl -s -X POST "$BASE/mcp" -H 'Content-Type: application/json' -H "$ACCEPT" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"network.token_price","arguments":{"symbol":"bitcoin"}}}'

`GET /mcp` returns `405` by design — every call is stateless, so there's no session to resume.

Configuration

Copy `.env.example` to `.env`. Everything has a safe default except the one

marked required:

How it works

MCP client (Claude Desktop, Cursor, your agent)
    → POST /mcp  (this service, stateless — a fresh McpServer per request)
    → free tools: direct chain RPC / CoinGecko calls
    → paid tools: relayed upstream, settled by the caller's wallet via x402

This is a single, standalone deployable — it doesn't share a workspace or database with any

other Abstraxn service. That's deliberate: several MCP registries expect a public MCP server to

live in its own repo with one route and one fixed tool set, reviewable end to end.

Stack: Node.js 20+ · NestJS 11 · `@modelcontextprotocol/sdk`

`^1.30.0` (official SDK) · PostgreSQL + TypeORM · `@x402/core` ·

`viem` (EVM) + raw JSON-RPC (Solana reads) · `@solana/web3.js` + `@solana/spl-token` (Solana

transfer building) · `@skalenetwork/bite` (SKALE privacy-encrypted transfers) · `helmet`,

`@nestjs/throttler`

Database

Postgres is used for abuse tracking only — no tenant, policy, or config tables exist:

If Postgres is unreachable, a call still succeeds — tracking writes are best-effort and never

block or fail a real MCP request.

Security

Since anyone can call this service with no key, a few invariants matter:

• No SSRF surface: every outbound URL (chain RPC, upstream relay, CoinGecko) comes from

server-side config — no tool accepts a caller-supplied URL.

• Rate limiting is global and IP-keyed — the only lever available with no accounts. If you

deploy behind a reverse proxy, set `app.set('trust proxy', ...)` in `main.ts`, or the limiter

ends up rate-limiting the proxy instead of real callers.

• No secrets beyond the DB password and `WEATHERAPI_KEY`, both env-only and never logged —

`weather.forecast` builds its provider request URL with the key as a query param, but every

log line only ever carries the action name and error message, never the URL itself.

• CORS is wildcard by design — nothing tenant-specific ever crosses an origin here.

Found a security issue? See CONTRIBUTING.md

before opening a public issue.

Scripts

Contributing

Issues and PRs are welcome — see CONTRIBUTING.md for how to add a new tool

and the project's definition of done.

License: MIT