Ramp Financial Data Analysis MCP Server

Finance & FintechPython

Access and analyze Ramp financial data through an ETL pipeline with in-memory SQLite database

Available Tools

process_data

Sets up and processes data into an ephemeral SQLite database in memory

execute_query

Executes SQL queries against the in-memory database

clear_table

Deletes data from a specified table in the database

get_ramp_categories

Fetches available Ramp transaction categories

get_currencies

Fetches available currencies from Ramp

load_transactions

Loads transaction data into the server (requires transactions:read scope)

load_reimbursements

Loads reimbursement data into the server (requires reimbursements:read scope)

load_bills

Loads bill data into the server (requires bills:read scope)

load_locations

Loads location data into the server (requires locations:read scope)

load_departments

Loads department data into the server (requires departments:read scope)

load_bank_accounts

Loads bank account data into the server (requires bank_accounts:read scope)

load_vendors

Loads vendor data into the server (requires vendors:read scope)

load_vendor_bank_accounts

Loads vendor bank account data into the server (requires vendors:read scope)

load_entities

Loads entity data into the server (requires entities:read scope)

load_spend_limits

Loads spend limit data into the server (requires limits:read scope)

load_spend_programs

Loads spend program data into the server (requires spend_programs:read scope)

load_users

Loads user data into the server (requires users:read scope)

Ramp Financial Data Analysis provides a powerful interface to retrieve, process, and analyze data from Ramp's financial platform. It implements an ETL pipeline with an ephemeral SQLite database in memory, allowing LLMs to efficiently query and analyze financial data without token or input size limitations. This tool connects to the Ramp Developer API, enabling access to transactions, reimbursements, bills, users, vendors, and other financial data. It's designed to work with both demo and production environments, making it suitable for testing and real-world financial analysis.

Installation and Setup

To use the Ramp Financial Data Analysis MCP, you'll need to complete both Ramp API setup and local configuration.

Ramp API Setup

Create a new client application in Ramp:
- Log in to your Ramp account
- Navigate to Profile (top right) > Developer > Create app
- Grant the necessary scopes based on which data you need to access
- Enable client credentials authentication
- Save your client ID and secret for later use

Local Setup

Install the required dependencies:
- Install uv package manager
- Clone the repository: git clone git@github.com:ramp-public/ramp_mcp.git
- Navigate to the project directory

Running the MCP Server

You can run the server directly from the command line with:

RAMP_CLIENT_ID=your_client_id RAMP_CLIENT_SECRET=your_client_secret RAMP_ENV=demo uv run ramp-mcp -s transactions:read,reimbursements:read

Replace your_client_id and your_client_secret with your actual Ramp API credentials. The -s flag specifies which scopes to enable, separated by commas.

Environment options:

RAMP_ENV=demo - Use Ramp's demo environment (default)
RAMP_ENV=prd - Use Ramp's production environment

Configuration with Claude Desktop

To use this MCP with Claude Desktop, add the following to your claude_desktop_config.json file (located at ~/Library/Application Support/Claude/ on macOS):

{
  "mcpServers": {
    "ramp-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/ramp-mcp",
        "run",
        "ramp-mcp",
        "-s",
        "transactions:read,reimbursements:read"
      ],
      "env": {
        "RAMP_CLIENT_ID": "your_client_id",
        "RAMP_CLIENT_SECRET": "your_client_secret",
        "RAMP_ENV": "demo"
      }
    }
  }
}

Be sure to replace /absolute/path/to/ramp-mcp with the actual path where you cloned the repository, and update the credentials and scopes as needed.

Usage Tips

For large datasets, explicitly prompt Claude to keep responses concise to avoid timeout or excessive token usage
When working with financial data, start by loading the relevant data tables using the load tools
Use the database tools to query and analyze the loaded data
Clear tables when you're done with them to free up memory

Available Scopes

Different tools require different API scopes. Here's a mapping of tools to required scopes:

| Tool | Required 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 |

Make sure to include all necessary scopes when starting the server.