Skip to main content
Glama
dennisonbertram

Rotki MCP Server

Rotki MCP Server

A Model Context Protocol (MCP) server that provides seamless integration with Rotki portfolio tracker. This server exposes Rotki's functionality through intuitive, jobs-to-be-done tools for AI assistants like Claude.

Author

Dennison Bertram (@dennisonbertram) Email: dennison@dapphero.io

Related MCP server: Datai MCP Server

Features

  • 7 Production-Ready Tools for portfolio management

  • Real-time crypto prices (BTC, ETH, stablecoins, etc.)

  • Portfolio overview with net worth and allocation

  • Transaction history with flexible filtering

  • Resource endpoints for portfolio summaries

  • Input validation using Zod schemas

  • Comprehensive error handling

  • stdio transport for Claude Desktop/Code integration

Prerequisites

  • Node.js 18+

  • pnpm 10+

  • A running Rotki instance (default: http://127.0.0.1:4242)

Installation

# Clone the repository
git clone https://github.com/dennisonbertram/mcp-rotki.git
cd mcp-rotki

# Install dependencies
pnpm install

# Build the server
pnpm build

Configuration

Environment Variables

  • ROTKI_MCP_BASE_URL - Rotki API base URL (default: http://127.0.0.1:4242/api/1)

  • ROTKI_MCP_TIMEOUT_MS - HTTP timeout in milliseconds (default: 120000)

  • ROTKI_MCP_USER - Optional: Rotki username for auto-login

  • ROTKI_MCP_PASSWORD - Optional: Rotki password for auto-login

  • ROTKI_MCP_ALLOW_LOGIN_TOOL - Enable login tool (default: false)

Claude Desktop/Code Integration

Add to your Claude configuration file:

macOS: ~/.config/claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "rotki-mcp": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/mcp-rotki/dist/server.js"],
      "env": {
        "ROTKI_MCP_BASE_URL": "http://127.0.0.1:4242/api/1",
        "ROTKI_MCP_TIMEOUT_MS": "120000"
      }
    }
  }
}

Important:

  1. Replace /absolute/path/to/mcp-rotki with your actual path

  2. Restart Claude Desktop/Code after updating the config

  3. Ensure Rotki is running and unlocked

Available Tools

Portfolio Management

get_portfolio_overview

Get a complete portfolio snapshot with net worth, allocation, and top positions.

Parameters:

  • currency (optional): Target currency (default: "USD")

Example:

"Show me my portfolio overview"

get_positions

View open positions across exchanges and blockchain networks.

Parameters:

  • include_protocols (optional): Include DeFi protocol positions

Example:

"What are my current positions?"

get_prices

Fetch real-time asset prices.

Parameters:

  • assets (required): Array of asset identifiers (e.g., ["BTC", "ETH"])

  • currency (optional): Target currency (default: "USD")

  • at_time_ms (optional): Historical timestamp

Example:

"Get current prices for BTC and ETH"

Transaction History

list_transactions

List recent transactions within a time window.

Parameters:

  • window_days (optional): Days to look back (1-365, default: 30)

  • limit (optional): Max results (1-500, default: 200)

  • offset (optional): Pagination offset

Example:

"Show me transactions from the last 7 days"

find_transactions

Search transactions with specific filters and time range.

Parameters:

  • from_ts_ms (required): Start timestamp in milliseconds

  • to_ts_ms (required): End timestamp in milliseconds

  • limit (optional): Max results

  • offset (optional): Pagination offset

  • tx_hashes (optional): Filter by transaction hashes

  • counterparties (optional): Filter by counterparties

Example:

"Find transactions between January 1st and February 1st"

explain_transaction

Get detailed information about a specific transaction.

Parameters:

  • txhash (required): Transaction hash

Example:

"Explain transaction 0x123..."

Analytics

counterparty_summary

View aggregated activity by counterparty.

Parameters:

  • from_ts_ms (optional): Start timestamp

  • to_ts_ms (optional): End timestamp

  • top_n (optional): Return top N counterparties (1-100)

Example:

"Show me my top counterparties"

Resources

rotki://user/summary

Portfolio summary resource with totals, allocation, and recent PnL.

Format: application/json

Prompts

summarize_portfolio

Guided prompt to analyze portfolio risk and allocations.

Parameters:

  • horizon (optional): Time horizon (e.g., "30d", "90d", "1y")

Development

# Run in development mode
pnpm dev

# Build for production
pnpm build

# Type check
pnpm typecheck

Testing

Manual stdio Testing

# Test initialize
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0.0"}}}' | node dist/server.js

# Test tool call
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0.0"}}}
{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_prices","arguments":{"assets":["BTC","ETH"]}}}' | node dist/server.js

Using the Test Scripts

# SDK-based test
pnpm exec tsx scripts/test-stdio.ts

# Bash-based test
./scripts/test-stdio-bash.sh

Architecture

Design Philosophy

This server follows a jobs-to-be-done approach, providing high-level tools that abstract Rotki's REST API complexity:

  • Single tools compose multiple API calls when needed

  • Clear input validation with descriptive error messages

  • Consistent response formats

  • Proper error handling with isError flags

File Structure

mcp-rotki/
├── src/
│   ├── server.ts       # MCP server with tool/resource registration
│   ├── rotki.ts        # Thin REST client for Rotki API
│   └── types.ts        # TypeScript type definitions
├── scripts/
│   ├── test-stdio.ts          # SDK-based test
│   └── test-stdio-bash.sh     # Bash-based test
├── dist/               # Compiled output
├── package.json
├── tsconfig.json
└── README.md

Security

  • Never commit secrets: Use environment variables for credentials

  • Read-only by default: Server only queries data, no modifications

  • Local-first: Designed for local Rotki instances

  • Validated inputs: All parameters validated with Zod schemas

Troubleshooting

Server not appearing in Claude

  1. Check config path: Ensure the path to dist/server.js is absolute

  2. Restart Claude: Configuration is only loaded on startup

  3. Check logs: Look for MCP connection errors in Claude's logs

  4. Verify build: Run pnpm build to ensure server is compiled

Rotki connection errors

  1. Is Rotki running? Check http://127.0.0.1:4242/api/1/ping

  2. Is Rotki unlocked? Some endpoints require authentication

  3. Check base URL: Verify ROTKI_MCP_BASE_URL environment variable

  4. Check timeout: Increase ROTKI_MCP_TIMEOUT_MS if needed

Tool validation errors

All tools use strict Zod validation. Common issues:

  • Empty arrays: Some parameters require at least 1 item (e.g., assets)

  • Missing required fields: Check the tool's inputSchema for required parameters

  • Invalid ranges: Some numbers have min/max constraints (e.g., window_days: 1-365)

Roadmap

  • Add WebSocket support for real-time updates

  • Implement resource subscriptions

  • Add more advanced DeFi protocol integrations

  • Support for historical PnL calculations

  • Multi-user support

Contributing

Contributions are welcome! Please:

  1. Fork the repository

  2. Create a feature branch

  3. Make your changes with tests

  4. Submit a pull request

License

MIT License - See LICENSE file for details

Support


Built with ❤️ for the Rotki and MCP communities

Available Tools

7 tools
counterparty_summaryCounterparty SummaryB

Get aggregated volume and counts by counterparty

ParametersJSON Schema
NameRequiredDescriptionDefault
top_nNoReturn top N counterparties (optional)
to_ts_msNoEnd timestamp in milliseconds (optional)
from_ts_msNoStart timestamp in milliseconds (optional)

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full behavioral disclosure burden, but it only states the operation and metric. It does not disclose aggregation defaults, time-range semantics, sorting, limits, or that this is a read-only aggregate rather than a transaction-level detail tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single clear sentence that is front-loaded with the action and key output. It contains no fluff or redundant restatement of the tool name.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple optional-parameter aggregate tool, the description is minimally adequate, but it leaves gaps: no default time window, no default top_n behavior, and no explicit statement of the return shape given that no output schema exists. Slightly more context would make it safe for an agent to call without assumptions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema fully documents all three parameters at 100% coverage, so the baseline is 3 even though the description adds no parameter detail. The description does not help clarify top_n ordering or timestamp semantics, but the schema already handles parameter meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Get' and names the resource ('aggregated volume and counts by counterparty'), making the action and grouping clear. It is distinguishable from the sibling tools by the counterparty grouping, though it does not explicitly contrast itself with them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance about when to use this tool instead of get_portfolio_overview, list_transactions, or the other siblings. No exclusions, prerequisites, or alternative conditions are stated, leaving the agent to infer the appropriate context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

explain_transactionExplain TransactionA

Get a human-readable explanation and structured event list for a transaction

ParametersJSON Schema
NameRequiredDescriptionDefault
txhashYesTransaction hash to explain

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the behavioral disclosure burden. It indicates the tool produces an explanation and event list, which implies a read-only operation, but it does not explicitly state that no data is modified, nor does it mention potential errors or limitations. Still, the 'Get' framing is honestly informational.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence with no filler or redundant wording. It front-loads the action ('Get') and the output content, making it immediately scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description appropriately names the return value: 'human-readable explanation and structured event list'. For a one-parameter tool this is largely sufficient, though it could be slightly more specific about the structure of the event list or error behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage for the single parameter txhash is 100%, and its description ('Transaction hash to explain') is clear. The tool description adds no extra parameter semantics, but none are needed because the schema already documents the parameter fully.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and clearly identifies the resource ('human-readable explanation and structured event list for a transaction'). This clearly distinguishes it from sibling tools like list_transactions or find_transactions, whose scope is listing or searching rather than explaining.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to use this tool versus alternatives such as list_transactions or get_portfolio_overview. It does not state prerequisites, such as needing a specific txhash, or suggest pairing it with other tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_transactionsFind TransactionsC

Find transactions within a specific time range with optional filters

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMax results (default: 200)
offsetNoPagination offset (default: 0)
to_ts_msYesEnd timestamp in milliseconds
tx_hashesNoFilter by transaction hashes
from_ts_msYesStart timestamp in milliseconds
counterpartiesNoFilter by counterparties

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must fully disclose behavioral traits, but it only says 'Find transactions within a specific time range with optional filters'. It does not state that the operation is read-only, how results are ordered or paginated, whether filters are applied as AND/OR, or what happens when the time range is invalid. This leaves the agent to infer basic behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single short sentence with no fluff, front-loading the core purpose (finding transactions) and the key scoping constraint (time range). It could add more useful detail without becoming verbose, but as written it is concise and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having 6 parameters and no output schema or annotations, the description does not cover return value structure, pagination defaults, filter semantics, ordering, or how this tool relates to 'list_transactions'. An agent would need to inspect the schema and make guesses about behavior beyond simple parameter values.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents every parameter. The description adds only the generic phrase 'optional filters' without naming them, so it provides marginal value beyond the schema. Baseline 3 is appropriate because no parameter meaning is missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Find') and resource ('transactions'), and adds a scoping detail (time range) plus the existence of optional filters. However, it does not distinguish this tool from the closely named sibling 'list_transactions' or enumerate which filters are available, so it falls short of full differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this tool is for querying transactions within a time range, which provides some usage context. But it gives no explicit guidance on when to use it versus alternatives like 'list_transactions', no exclusion criteria, and no prerequisites or limitations beyond what the schema provides.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_portfolio_overviewPortfolio OverviewB

Get net worth, allocation, and top positions snapshot.

ParametersJSON Schema
NameRequiredDescriptionDefault
currencyNoTarget currency (default: USD)

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. The 'Get' verb and enumerated contents imply a read-only operation, but the description is silent on how the currency parameter affects results (conversion behavior), how 'top positions' is defined or sorted, whether data is real-time or cached, and the scope of aggregation. These are material gaps for an unannotated tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One 8-word sentence with zero filler. The core concepts (net worth, allocation, top positions) are front-loaded and every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple (one optional parameter, no output schema, no nested objects), and the description names the three return components an agent should expect. However, since there is no output schema and no annotations, the description should clarify how the only parameter (currency) transforms the output and what 'top positions' means. Adequate but with a clear gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the single 'currency' parameter is already documented with its default (USD). The tool description adds no parameter-level detail, but per the rubric, a baseline of 3 applies when schema coverage is high and the schema carries the documentation burden.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and names the resource ('portfolio overview') while enumerating the snapshot contents (net worth, allocation, top positions). The listed content semantically distinguishes it from transaction-focused siblings like list_transactions and find_transactions, and from get_prices, though it never explicitly names a differentiating sibling such as get_positions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to choose this tool over its siblings. The description implies it is a high-level portfolio aggregation entry point, but it never states 'use this for an aggregate snapshot' or 'for detailed holdings use get_positions instead'. An agent must infer the selection context entirely.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_positionsGet PositionsB

Get open positions across exchanges and chains

ParametersJSON Schema
NameRequiredDescriptionDefault
include_protocolsNoInclude DeFi protocol positions (default: false)

TDQS

B3.4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the behavioral burden; it does convey that this is a read-only operation for open positions across exchanges and chains. However, it does not disclose what 'positions' includes, how optional protocol positions affect results, or what the response will look like, leaving a moderate transparency gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler; the core scope is front-loaded and every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a low-complexity tool with one optional parameter and no output schema, the description plus schema gives sufficient context for a basic call: fetch open positions, optionally including DeFi protocols. The lack of output format and sibling differentiation is the main completeness gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% because the single boolean parameter include_protocols is fully described with a default. The description adds no parameter-specific meaning, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource ('Get open positions') and adds scope ('across exchanges and chains'), so an agent can tell what the tool retrieves. It does not explicitly distinguish itself from get_portfolio_overview, which could overlap in meaning, so it loses a point.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to choose this tool over siblings such as get_portfolio_overview or list_transactions, nor any exclusions or prerequisites. The context is implied only by the tool name and scope, so an agent must infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_pricesGet Asset PricesA

Get latest or historical prices for specified assets

ParametersJSON Schema
NameRequiredDescriptionDefault
assetsYesAsset identifiers (e.g., ['BTC', 'ETH'])
currencyNoTarget currency (default: USD)
at_time_msNoHistorical timestamp in milliseconds (optional)

TDQS

A3.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations to carry the safety profile, the description must stand alone. It conveys a read-only retrieval behavior and distinguishes latest vs. historical via phrasing, but it does not mention response format, data source, authentication requirements, or side effects. The core behavior is transparent, yet the description remains thin for a tool lacking annotation-based safety context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that starts with the action verb and immediately communicates the core purpose. There is no filler or repetition, and the most important detail (latest or historical) is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The combination of description and schema fully covers invocation parameters. However, because there is no output schema, the description could have clarified the return shape (e.g., 'returns a mapping from asset to price') or specified how historical lookups are triggered. This is a notable gap, though not fatal for calling the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already has descriptions for all three parameters (assets, currency, at_time_ms) with 100% coverage, so the description does not need to repeat them. It adds only high-level context ('specified assets', 'latest or historical') that aligns with the schema, meaning the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') with a clear resource ('prices') and adds scope modifiers ('latest or historical', 'specified assets'). This makes it unambiguously distinct from siblings like get_portfolio_overview and get_positions, which cover different financial data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies the tool is for retrieving asset prices, both current and historical. There is no explicit exclusion of alternatives, but none of the sibling tools handle raw price data, so the usage context is clear enough. It misses an explicit 'use when' statement but provides sufficient context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_transactionsList Recent TransactionsC

List recent transactions within a time window

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMax results (default: 200)
offsetNoPagination offset (default: 0)
window_daysNoDays to look back (default: 30)

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only states that the tool lists transactions; it does not mention ordering, pagination behavior, whether results are read-only, or any other operational characteristics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no filler or redundancy. It is front-loaded and easy to parse, though it is so brief that it leaves behavioral details undisclosed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a fairly simple tool with optional parameters fully described in the schema, the description is minimally viable. However, with no output schema and no annotations, missing details like sort order, default behavior, and distinction from 'find_transactions' leave notable gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the parameters are already well documented. The description adds the notion of a 'time window', which loosely maps to the 'window_days' parameter, but it does not add meaningful semantics beyond what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear action ('list') on a specific resource ('recent transactions') with a time-window scope. It is easy to understand what the tool does, though it does not explicitly differentiate itself from the sibling 'find_transactions'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives like 'find_transactions' or 'get_portfolio_overview'. The time-window phrasing implies a use case, but no explicit context, exclusions, or alternative selection criteria are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 7 tool updatesv0.1.0
    • First observedcounterparty_summary
    • First observedexplain_transaction
    • First observedfind_transactions
    • First observedget_portfolio_overview
    • First observedget_positions
    • First observedget_prices
    • First observedlist_transactions

TDQS

B3.3/5.0

Scored across 7 tools

Disambiguation2/5

list_transactions and find_transactions are nearly identical in scope, differing only by framing and optional filters, which will cause selection confusion. get_portfolio_overview and get_positions also overlap around positions, so several tools have unclear boundaries.

Naming Consistency4/5

Most tools follow a get_/list_/find_/explain_ verb_noun pattern, but counterparty_summary is a bare noun and uses a different style. The inconsistency is minor and the naming remains predictable overall.

Tool Count5/5

Seven tools is well within the ideal range and each maps to a meaningful facet of the Rotki domain: overview, transactions, positions, prices, and counterparties. There is no feeling of bloat or excessive fragmentation.

Completeness4/5

The set covers core portfolio tracking needs: overview, positions, transactions, prices, and counterparty aggregation. Minor gaps exist, such as asset metadata or per-transaction lookup, but these do not seriously block common workflows.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    A
    quality
    D
    maintenance
    Enables AI agents to retrieve real-time data on wallet DeFi positions, token balances, and NFT holdings across multiple blockchains. It supports hundreds of protocols and provides specialized tools for chain-specific or protocol-specific portfolio analysis.
    8
    14 npm
    3
    MIT
  • A
    license
    A
    quality
    C
    maintenance
    Enables AI assistants to query and analyze local personal finance data from Tusk Ledger through tools for transactions, accounts, investments, and more, without sending data to the internet.
    13
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables AI assistants to read and query a Finanze self-hosted portfolio manager using natural language, including net worth, positions, and financial calculations.
    MIT