# Metis RWA Research [Health: Active]

**Category:** 💰 Finance & Fintech  
**Repository:** https://github.com/metis-rwa/mcp  
**GitHub Stars:** 0  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/metis-rwa-research

## Description
Research tokenized real-world assets on Solana: issuer controls, supply, liquidity, premiums

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "metis-rwa-research": {
    "command": "npx",
    "args": ["-y","@metisagent/mcp"]
  }
}
```

## Documentation & README

# Metis MCP

An MCP server for researching tokenized real-world assets on Solana.

It gives an assistant twelve tools: six that read chain and market state live,
and six that reach the research the [Metis](https://metisagent.co) agent has
already published. Every figure it returns comes from a fresh read, stamped with
its source, the time it was taken, and a hash of the raw payload.

The point is the first question anyone should ask about a tokenized asset and
almost nobody can answer quickly: who controls this token, and what happens to
my position if they use that control?

## Three ways to connect

**As a plugin.** The easiest path, and the only one that also carries the
skills. In Claude Code:

```
/plugin marketplace add metis-rwa/mcp
```

```
/plugin install metis@metis-rwa
```

In Claude Desktop or on the web, open Customize, then Plugins, then add from a
repository with `https://github.com/metis-rwa/mcp.git`. The plugin connects to
the hosted endpoint and adds `/metis:due-diligence`, `/metis:premium-watch`,
and a `token-safety` skill that runs whenever someone asks who controls a
token. See [plugin/README.md](https://github.com/metis-rwa/mcp/blob/HEAD/plugin/README.md).

**Hosted, nothing to install.** The same tools are served over HTTP at
`https://metisagent.co/mcp`:

```bash
claude mcp add --transport http metis https://metisagent.co/mcp
```

The hosted endpoint answers observation questions from the research agent's own
stored history, which goes back further than any single machine can. It reads
only, needs no key, and holds no session.

**Local, over stdio.** Run the package when you want your own RPC endpoint, your
own asset list, or history kept on your machine:

```bash
npx -y @metisagent/mcp
```

Or clone and build:

```bash
git clone https://github.com/metis-rwa/mcp.git
cd mcp
npm install
npm run build
node dist/index.js
```

The server speaks MCP over stdio.

## Connect the local server

Claude Code:

```bash
claude mcp add metis -- npx -y @metisagent/mcp
```

Claude Desktop, in `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "metis": {
      "command": "npx",
      "args": ["-y", "@metisagent/mcp"],
      "env": {
        "SOLANA_RPC_URL": "https://your-endpoint.example/rpc"
      }
    }
  }
}
```

Any other MCP client works the same way: run `metis-mcp` (or
`node dist/index.js`) and speak MCP on stdin and stdout.

## Tools

On-chain checks:

| Tool | What it answers |
| --- | --- |
| `list_rwa_assets` | Which assets this server knows by symbol, and their mints |
| `get_token_controls` | Can the issuer mint, freeze, seize, pause, or gate transfers |
| `get_token_supply` | How many tokens exist, and whether supply is capped |
| `get_holder_concentration` | Who holds the supply, and is any of it frozen |
| `get_token_market` | How deep the liquidity is, pool by pool |
| `get_reference_premium` | Is the token trading away from the security it tracks |

Research:

| Tool | What it answers |
| --- | --- |
| `observe_asset` | One full research cycle: read everything, compare against history, report detections and confidence |
| `get_observation_history` | What this server has recorded for the asset so far, and the trend |
| `list_research` | What the Metis agent has published, filtered by asset or category |
| `get_research` | The full object behind one publication: claims, evidence, methodology, provenance |
| `get_research_status` | What the agent is investigating right now, and source health |
| `check_sources` | Which data sources are answering, and how fast |

Every tool takes either a registry symbol (`TSLAx`) or a raw Solana mint
address, so assets outside the registry work too.

The registry ships with the 72 xStocks on Solana, from `AAPLx` through `XOMx`,
including the index and commodity fund shares (`SPYx`, `QQQx`, `GLDx`, `PPLTx`,
`TBLLx`) and the private-market listings (`SPCXx`, `VCXx`). Filter it with
`list_rwa_assets`, by substring or by asset type.

Two prompts ship with the server: `rwa_due_diligence` walks an asset through
controls, supply, concentration, depth, and premium, and `premium_watch` reads a
price gap against stored history. Two resources are exposed as well:
`metis://registry` and `metis://methodology`.

## What `get_token_controls` is for

A tokenized equity is a claim on something held off chain, so the issuer keeps
powers a plain token does not have. Token-2022 makes those powers explicit on
the mint, and this tool translates each one into what it means for a holder:

- **Permanent delegate**: tokens can be moved or burned out of any account
  without the holder signing.
- **Freeze authority**: any account can be frozen, which blocks selling and
  redemption.
- **Transfer hook**: every transfer runs through a program that can reject it,
  which is how an allowlist is enforced.
- **Default account state frozen**: new accounts cannot transact until the
  issuer thaws them, so the token is permissioned by default.
- **Pausable**: transfers can be halted chain-wide.
- **Scaled UI amount**: displayed balances are rescaled, which is how splits
  and similar corporate actions land on chain.

None of these are defects. Redeemable backed assets need most of them. They are
simply facts about the asset that belong in any answer about whether it is worth
its reference price.

## Configuration

| Variable | Default | Purpose |
| --- | --- | --- |
| `SOLANA_RPC_URL` | a public node | Solana JSON-RPC endpoint |
| `METIS_API_URL` | `https://metisagent.co` | Metis research API |
| `METIS_ASSETS_FILE` | none | JSON file of extra assets to register |
| `METIS_MCP_STATE_DIR` | `~/.metis-mcp` | Where observation history is stored. Set to `off` for memory only |
| `METIS_MCP_TIMEOUT_MS` | `20000` | Network timeout per request |

Set `SOLANA_RPC_URL` to an endpoint you control if you can. Public nodes
throttle the heavier reads, and `get_holder_concentration` is the first one they
refuse.

`METIS_ASSETS_FILE` takes an array. Only `symbol` and `mint` are required:

```json
[
  {
    "symbol": "AAPLx",
    "name": "Apple xStock",
    "mint": "<mint address>",
    "decimals": 8,
    "assetType": "tokenized_equity",
    "referenceTicker": "AAPL",
    "issuerName": "Backed Assets"
  }
]
```

Verify a mint against the chain before adding it. A wrong address returns
confident, wrong answers. Everything already in the registry was read back from
Solana first: the names and symbols in `src/assets.ts` are the ones written into
each mint's own Token-2022 metadata, not labels copied from a token list. Check
them again at any time:

```bash
npm run verify-assets
```

## How an observation cycle works

`observe_asset` reads supply and holder concentration from Solana, pooled
liquidity and volume from DEX venues, and the token and reference prices from a
public price service. It compares the result against the observations already
stored for that asset, then reports:

- **Observations**: what is true right now, each tied to the reads behind it.
- **Detections**: metrics that crossed a threshold, with the baseline they
  crossed it against.
- **Conflicts**: sources that disagree, recorded rather than averaged away.
- **Confidence**: computed from source coverage, source failures, cross-source
  agreement, and how much history backs the comparison. A model's own stated
  confidence is never an input.

History lives on the machine running the server. The first call on an asset has
no baseline, so only the premium threshold can fire. Call it again over time and
supply, liquidity, activity, and concentration detections come alive. The hosted
endpoint skips that warm-up entirely: it compares against the history the
research agent has been recording every ten minutes since it went live.

## Limits worth stating

- Largest token accounts are accounts, not beneficial owners. Pools, bridges,
  and custodial accounts sit at the top of most lists.
- DexScreener refuses datacenter traffic. Run the server from a laptop and it
  answers; run it from a cloud host and pool data falls back to the price
  service, which reports liquidity, 24h volume, and a holder count but no pool
  breakdown and no transaction counts. Tools say when a number came from the
  standby.
- A republished reference price can be stale outside market hours, and that
  alone can look like a premium.
- Aggregated venue data covers listed pools. Anything traded over the counter
  or internally is invisible here.
- This is informational research produced by software. It is not financial
  advice, and it can be wrong.

## Development

```bash
npm install
npm run typecheck
npm test
npm run inspector
```

Tests cover the analysis rules, the control translations, the registry, and the
history store. They run against the build, so `npm test` builds first.

## Releasing

The package publishes to npm as `@metisagent/mcp`, and `server.json` describes it
for the MCP registry. The registry proves ownership by matching `mcpName` in
`package.json` against the server name in `server.json`, so those two strings
have to stay in step.

1. Bump the version in `package.json` and in both places in `server.json`, then
   add a `CHANGELOG.md` entry.
2. `npm run verify-assets` to confirm the registry still matches the chain.
3. `npm test`.
4. `npm publish --access public`.
5. `mcp-publisher login github` then `mcp-publisher publish` to list the release
   in the MCP registry.

## License

MIT