Rotki MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Rotki MCP ServerShow me my portfolio overview"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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 buildConfiguration
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-loginROTKI_MCP_PASSWORD- Optional: Rotki password for auto-loginROTKI_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:
Replace
/absolute/path/to/mcp-rotkiwith your actual pathRestart Claude Desktop/Code after updating the config
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 millisecondsto_ts_ms(required): End timestamp in millisecondslimit(optional): Max resultsoffset(optional): Pagination offsettx_hashes(optional): Filter by transaction hashescounterparties(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 timestampto_ts_ms(optional): End timestamptop_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 typecheckTesting
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.jsUsing the Test Scripts
# SDK-based test
pnpm exec tsx scripts/test-stdio.ts
# Bash-based test
./scripts/test-stdio-bash.shArchitecture
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
isErrorflags
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.mdSecurity
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
Check config path: Ensure the path to
dist/server.jsis absoluteRestart Claude: Configuration is only loaded on startup
Check logs: Look for MCP connection errors in Claude's logs
Verify build: Run
pnpm buildto ensure server is compiled
Rotki connection errors
Is Rotki running? Check
http://127.0.0.1:4242/api/1/pingIs Rotki unlocked? Some endpoints require authentication
Check base URL: Verify
ROTKI_MCP_BASE_URLenvironment variableCheck timeout: Increase
ROTKI_MCP_TIMEOUT_MSif 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
inputSchemafor required parametersInvalid 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:
Fork the repository
Create a feature branch
Make your changes with tests
Submit a pull request
License
MIT License - See LICENSE file for details
Related Projects
Rotki - Open source portfolio tracker
Model Context Protocol - MCP specification
Claude Desktop - AI assistant with MCP support
Support
Issues: GitHub Issues
Rotki Docs: rotki.readthedocs.io
MCP Docs: modelcontextprotocol.io
Built with ❤️ for the Rotki and MCP communities
Available Tools
7 toolscounterparty_summaryCounterparty SummaryB
Get aggregated volume and counts by counterparty
| Name | Required | Description | Default |
|---|---|---|---|
| top_n | No | Return top N counterparties (optional) | |
| to_ts_ms | No | End timestamp in milliseconds (optional) | |
| from_ts_ms | No | Start timestamp in milliseconds (optional) |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| txhash | Yes | Transaction hash to explain |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default: 200) | |
| offset | No | Pagination offset (default: 0) | |
| to_ts_ms | Yes | End timestamp in milliseconds | |
| tx_hashes | No | Filter by transaction hashes | |
| from_ts_ms | Yes | Start timestamp in milliseconds | |
| counterparties | No | Filter by counterparties |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| currency | No | Target currency (default: USD) |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| include_protocols | No | Include DeFi protocol positions (default: false) |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| assets | Yes | Asset identifiers (e.g., ['BTC', 'ETH']) | |
| currency | No | Target currency (default: USD) | |
| at_time_ms | No | Historical timestamp in milliseconds (optional) |
TDQS
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.
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.
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.
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.
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.
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
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default: 200) | |
| offset | No | Pagination offset (default: 0) | |
| window_days | No | Days to look back (default: 30) |
TDQS
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.
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.
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.
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.
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.
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.
7 tool updates
v0.1.0- First observed
counterparty_summary - First observed
explain_transaction - First observed
find_transactions - First observed
get_portfolio_overview - First observed
get_positions - First observed
get_prices - First observed
list_transactions
TDQS
Scored across 7 tools
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.
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.
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.
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
Related MCP Connectors
Connect your portfolio to Claude, ChatGPT, or Codex to analyze it and make smarter investments.
Live crypto prices, conversion, gas tracker, portfolio tools, and calculators for AI agents.
- Era ContextOAuthapp.era
Personal finance, bank account, and shared memory connector for Claude, ChatGPT, Gemini Spark & more
Provide AI agents and automation tools with contextual access to blockchain data including balance…
Related MCP Servers
- FlicenseAqualityCmaintenanceConnects AI agents to Real World Asset (RWA) data, enabling queries about tokenized assets, market trends, TVL analytics, token holders, and portfolio tracking across multiple blockchains.181-
- AlicenseAqualityDmaintenanceEnables 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.814 npm3MIT
- AlicenseAqualityCmaintenanceEnables 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.13MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to read and query a Finanze self-hosted portfolio manager using natural language, including net worth, positions, and financial calculations.MIT