Ramp MCP
Interfaces with the Ramp API, allowing access to financial data including credit card transactions from Ramp's expense management platform.
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., "@Ramp MCPshow me my recent credit card transactions"
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.
Ramp MCP
Simple MCP server that interfaces with the Ramp API, allowing you to talk to your Ramp data from any MCP client like Cursor or Claude Desktop.
I am adding more coverage of the Ramp API over time, let me know which tools you need or just open a PR.
Installation
Make sure to go to your Ramp Settings to get a Ramp API Key and Ramp Client ID.
Installing via Smithery
To install mercury-mcp for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @dragonkhoi/mercury-mcp --client claudeTo install mixpanel-mcp for Cursor, go to Settings -> Cursor Settings -> Features -> MCP Servers -> + Add
Select Type: command and paste the below, using the arguments <API_KEY> <CLIENT_ID> from Ramp
npx -y @smithery/cli@latest run @dragonkhoi/mercury-mcp --config "{\"mercury_api_key\":\"YOUR_MERCURY_API_KEY\",}"Clone and run locally
Clone this repo
Run npm run build
Paste this command into Cursor (or whatever MCP Client)
node /ABSOLUTE/PATH/TO/ramp-mcp/build/index.js RAMP_API_KEY RAMP_CLIENT_ID
Related MCP server: Copilot Money MCP
Examples
Ask "What are my latest credit card transactions"
Available Tools
2 toolsget_credit_card_transactionsC
Retrieve information about your Ramp credit card transactions.
| Name | Required | Description | Default |
|---|---|---|---|
| sk_category_id | No | ||
| department_id | No | ||
| limit_id | No | ||
| location_id | No | ||
| merchant_id | No | ||
| card_id | No | ||
| statement_id | No | ||
| state | No | ||
| user_id | No | ||
| sync_ready | No | ||
| from_date | No | ||
| to_date | No | ||
| synced_after | No | ||
| min_amount | No | ||
| has_no_sync_commits | No | ||
| max_amount | No | ||
| trip_id | No | ||
| entity_id | No | ||
| requires_memo | No | ||
| include_merchant_data | No | ||
| order_by_amount_asc | No | ||
| order_by_amount_desc | No | ||
| order_by_date_asc | No | ||
| order_by_date_desc | No | ||
| start | No | ||
| page_size | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a retrieval operation but provides no information about authentication requirements, rate limits, pagination behavior (despite having 'start' and 'page_size' parameters), error conditions, or what format the returned information takes. This leaves significant behavioral unknowns for a tool with 26 parameters.
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 efficiently communicates the core purpose without unnecessary words. It's appropriately sized for a tool description and front-loads the essential information about what the tool does.
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?
Given the high complexity (26 parameters), no annotations, no output schema, and 0% schema description coverage, the description is woefully incomplete. It doesn't address what information is returned, how to use the extensive filtering parameters, pagination behavior, or any constraints. For such a complex tool, the minimal description leaves too many questions unanswered.
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?
With 0% schema description coverage and 26 parameters, the description provides no semantic information about any parameters. It doesn't explain what filtering capabilities exist, what the various ID parameters represent, or how date ranges work. The description fails to compensate for the complete lack of schema documentation.
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 ('Retrieve information') and resource ('Ramp credit card transactions'), making the purpose immediately understandable. It distinguishes from the sibling 'get_ramp_statements' by specifying transactions rather than statements. However, it doesn't specify the scope or format of the retrieved information, keeping it from a perfect score.
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 provides no guidance on when to use this tool versus alternatives, nor any context about prerequisites or constraints. With 26 optional parameters and a sibling tool for statements, the lack of usage guidance leaves the agent to guess when this specific transaction retrieval tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_ramp_statementsB
Retrieve Ramp statements with optional date filtering and pagination.
| Name | Required | Description | Default |
|---|---|---|---|
| from_date | No | Start date in ISO format (YYYY-MM-DD) | |
| to_date | No | End date in ISO format (YYYY-MM-DD) | |
| start | No | Token for pagination | |
| page_size | No | Number of results per page |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'optional date filtering and pagination', which hints at querying behavior, but it doesn't cover critical aspects like rate limits, authentication needs, error handling, or what the return format looks like (e.g., list of statements, total count). This leaves significant gaps for a tool with no annotation support.
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 that front-loads the core purpose and key features without any wasted words. It's appropriately sized for the tool's complexity, making it easy to parse quickly.
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?
Given the tool's moderate complexity (4 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and hints at functionality, but lacks details on behavioral traits, output format, and differentiation from siblings. This makes it minimally viable but with clear gaps that could hinder effective tool selection and invocation.
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 description coverage is 100%, with all parameters well-documented in the input schema (e.g., date formats, pagination details). The description adds value by summarizing the optional features ('date filtering and pagination'), but it doesn't provide additional semantic context beyond what the schema already specifies, such as default behaviors or constraints not in the schema.
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 verb 'Retrieve' and resource 'Ramp statements', making the purpose specific and understandable. However, it doesn't explicitly differentiate from the sibling tool 'get_credit_card_transactions', which might retrieve similar financial data but for different resources, leaving some ambiguity about when to choose one over the other.
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 mentions 'optional date filtering and pagination', which implies some usage context, but it doesn't provide explicit guidance on when to use this tool versus the sibling 'get_credit_card_transactions' or any alternatives. No exclusions or specific scenarios are outlined, leaving the agent with minimal direction.
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.
2 tool updates
- First observed
get_credit_card_transactions - First observed
get_ramp_statements
TDQS
Scored across 2 tools
The two tools have clearly distinct purposes: one retrieves credit card transactions, while the other retrieves statements with filtering capabilities. There is no overlap or ambiguity in their functions, making it easy for an agent to select the correct tool based on the need.
Both tools follow a consistent verb_noun naming pattern (get_credit_card_transactions and get_ramp_statements), using the same verb 'get' and snake_case formatting. This predictability aids in tool identification and usage.
With only two tools, the server feels under-scoped for a financial management domain like Ramp, which typically involves more operations such as creating transactions, updating details, or managing accounts. The limited set may hinder comprehensive agent workflows.
The tool surface is severely incomplete for a Ramp integration, covering only retrieval of transactions and statements. Missing are essential CRUD operations (e.g., create, update, delete), account management, or other financial actions, leading to significant gaps that will cause agent failures in broader tasks.
Maintenance
Related MCP Connectors
The Ramp MCP server enables users to securely connect Ramp with AI assistants like ChatGPT and Claude to query financial data and take actions using natural language. It transforms Ramp's developer API into a SQL interface that LLMs can query, allowing admins to analyze spend trends, identify cost savings, and run complex SQL analyses on comprehensive datasets (transactions, purchase orders, vendors, users), while all users can manage cards, view transactions, request reimbursements, and get expense policy answers.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP server that connects Claude for Desktop with blockchain functionality, allowing users to check balances and send tokens on EVM and Solana chains through natural language interactions.-
- AlicenseAqualityAmaintenanceThis MCP server bridges Copilot Money with AI platforms like Claude and Cursor. It provides tools for fetching transactions, account balances, and automated data cleanup. By enabling secure, programmable access to financial records, it allows agents to perform complex tasks like transaction tagging and spending audits autonomously.1490 npm79MIT
- AlicenseBqualityDmaintenanceAn MCP (Model Context Protocol) server that connects AI assistants like Claude directly to your Razorpay account.1423 npm1MIT
- AlicenseNot gradedqualityDmaintenanceSimple MCP server that interfaces with the Mercury API, allowing you to talk to your Mercury banking data from any MCP client like Cursor or Claude Desktop.4MIT