Ramp Mcp

What is Ramp Mcp about?

Retrieves data from Ramp’s Developer API, transforms it through a lightweight ETL process, and stores it temporarily in an in‑memory SQLite database. The server exposes tools that let LLMs query, manipulate, and clear the data, enabling sophisticated data analysis without hitting token or input‑size limits.

How to use Ramp Mcp?

1. Create a Ramp client on the Ramp developer portal and enable the required scopes.
2. Set environment variables:

   export RAMP_CLIENT_ID=your_client_id
   export RAMP_CLIENT_SECRET=your_client_secret
   export RAMP_ENV=demo   # or prd
   

3. Run the server (Python‑based) with the desired scopes:

   uv run ramp-mcp -s transactions:read,reimbursements:read
   

4. Configure Claude Desktop (or any MCP‑compatible client) to point to the running server using the provided JSON snippet in the README.

Key features of Ramp Mcp

• Database tools: process_data, execute_query, clear_table for managing the temporary SQLite store.
• Fetch tools: get_ramp_categories, get_currencies to pull reference data directly.
• Load tools: Wide range of loaders (transactions, reimbursements, bills, locations, etc.) each mapped to a specific Ramp API scope.
• Scope‑driven loading: Only the data you need is fetched, minimizing API calls and token usage.
• In‑memory SQLite: Fast, transient storage suitable for LLM‑driven analysis without persisting data.
• Environment flexibility: Works against Ramp’s demo, QA, or production environments via RAMP_ENV.

Use cases of Ramp Mcp

• Financial reporting: Generate ad‑hoc reports by loading transactions and querying totals.
• Expense analysis: Load reimbursements and run custom LLM‑crafted queries to spot trends.
• Data enrichment: Pull categories and currencies to augment raw transaction data.
• Rapid prototyping: Developers can experiment with Ramp data without building a full backend.
• LLM‑assisted audits: Let an LLM query the SQLite store to verify compliance rules.

FAQ from the Ramp Mcp

• Q: Do I need a persistent database? A: No. All data lives in an in‑memory SQLite instance that is cleared when the server stops.
• Q: How large a dataset can I handle? A: Limited by the Ramp API rate limits and the memory of the host machine; large datasets may require pagination or selective loading.
• Q: Can I use this with other LLMs besides Claude? A: Yes, any client that implements the Model Context Protocol can interact with the server.
• Q: What happens if I exceed token limits? A: The server is designed to keep LLM prompts concise; you can instruct the model not to use REPL for very large results.
• Q: How do I add new scopes? A: Update the -s argument with a comma‑separated list of scopes and ensure the Ramp client has those scopes granted.

ramp-mcp: A Ramp MCP server

Overview

A Model Context Protocol server for retrieving and analyzing data or running tasks for Ramp using Developer API. In order to get around token and input size limitations, this server implements a simple ETL pipeline + ephemeral sqlite database in memory for analysis by an LLM. All requests are made to demo by default, but can be changed by setting RAMP_ENV=prd. Large datasets may not be processable due to API and/or your MCP client limitations.

Tools

Database tools

Tools that can be used to setup, process, query, and delete an ephemeral database in memory.

1. process_data
2. execute_query
3. clear_table

Fetch tools

Tools that can be used to fetch data directly

1. get_ramp_categories
2. get_currencies

Load tools

Loads data to server which the client can fetch. Based on the tools you wish to use, ensure to enable those scopes on your Ramp client and include the scopes when starting the server as a CLI argument.

Tool	Scope
load_transactions	transactions:read
load_reimbursements	reimbursements:read
load_bills	bills:read
load_locations	locations:read
load_departments	departments:read
load_bank_accounts	bank_accounts:read
load_vendors	vendors:read
load_vendor_bank_accounts	vendors:read
load_entities	entities:read
load_spend_limits	limits:read
load_spend_programs	spend_programs:read
load_users	users:read

For large datasets, it is recommended to explicitly prompt Claude not to use REPL and to keep responses concise to avoid timeout or excessive token usage.

Setup

Ramp Setup

1. Create a new client from the Ramp developer page (Profile on top right > Developer > Create app)
2. Grant the scopes you wish (based on tools) to the client and enable client credentials (Click on App > Grant Types / Scopes)
3. Include the client ID and secret in the config file as well as the scopes you wish to use

Local Setup

1. Clone this Github repo via git clone git@github.com:ramp/ramp-mcp.git or equivalent
2. Install uv

Usage

Run the MCP server from your CLI with:

RAMP_CLIENT_ID=... RAMP_CLIENT_SECRET=... RAMP_ENV=<demo|prd> uv run ramp-mcp -s <COMMA-SEPARATED-SCOPES>

Configuration

Usage with Claude Desktop

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "ramp-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/<ABSOLUTE-PATH-TO>/ramp-mcp", // make sure to update this path
        "run",
        "ramp-mcp",
        "-s",
        "transactions:read,reimbursements:read"
      ],
      "env": {
        "RAMP_CLIENT_ID": "<CLIENT_ID>",
        "RAMP_CLIENT_SECRET": "<CLIENT_SECRET>",
        "RAMP_ENV": "<demo|qa|prd>"
      }
    }
  }
}

If this file doesn't exist yet, create one in /<ABSOLUTE-PATH-TO>/Library/Application Support/Claude/

License

Copyright (c) 2025, Ramp Business Corporation All rights reserved. This source code is licensed under the MIT License found in the LICENSE file in the root directory of this source tree.