SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Ramp MCP with Autogen

Connect Autogen to Ramp MCP. Download last month's statement as pdf, list all transactions over $500 this week, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Ramp logoRamp
Oauth2

Ramp is a finance automation platform for tracking business expenses and income. It helps you manage spending and gain actionable insights into your company's finances.

186 Tools

Introduction

This guide walks you through connecting Ramp to AutoGen using the Composio tool router. By the end, you'll have a working Ramp agent that can review card transactions, issue virtual and physical cards, create and update bills, track reimbursements, and adjust spending limits through natural language commands.

This guide will help you understand how to give your AutoGen agent real control over a Ramp account through Composio's Ramp MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Ramp with

Claude CodeClaude CoworkOpenAI Agents SDKClaude Agent SDKCodexOpenClawHermesAtomic AgentGoogle ADKLangChainVercel AI SDKMastra AILlamaIndexCrewAIPydantic AI

TL;DR

Here's what you'll learn:
  • Get and set up your OpenAI and Composio API keys
  • Install the required dependencies for Autogen and Composio
  • Initialize Composio and create a Tool Router session for Ramp
  • Wire that MCP URL into Autogen using McpWorkbench and StreamableHttpServerParams
  • Configure an Autogen AssistantAgent that can call Ramp tools
  • Run a live chat loop where you ask the agent to perform Ramp operations

What is AutoGen?

Autogen is a framework for building multi-agent conversational AI systems from Microsoft. It enables you to create agents that can collaborate, use tools, and maintain complex workflows.

Key features include:

  • Multi-Agent Systems: Build collaborative agent workflows
  • MCP Workbench: Native support for Model Context Protocol tools
  • Streaming HTTP: Connect to external services through streamable HTTP
  • AssistantAgent: Pre-built agent class for tool-using assistants

What is the Ramp MCP server, and what's possible with it?

The Ramp MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Ramp account. It provides structured and secure access to your company's financial data, so your agent can fetch transactions, analyze card activity, generate statements, manage departments, and retrieve detailed expense information on your behalf.

  • Comprehensive transaction tracking: Instantly pull lists of all your business transactions or your own card activity, making it easy to monitor expenses and spot anomalies.
  • Card management and insights: Retrieve details about specific Ramp cards or see all cards assigned to you, including limits, status, and cardholder info for better financial oversight.
  • Automated statement generation: Ask your agent to generate and download account statements in multiple formats (PDF, CSV, JSON) for reporting or bookkeeping.
  • Department and organizational management: Create new departments or fetch detailed department profiles to help structure your expense tracking and categorize spending.
  • Detailed transaction analysis: Dive into specific transactions to get merchant information, receipts, dispute details, and accounting codes for audit and compliance purposes.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step08 STEPS
1

Prerequisites

You will need:

  • A Composio API key
  • An OpenAI API key (used by Autogen's OpenAIChatCompletionClient)
  • A Ramp account you can connect to Composio
  • Some basic familiarity with Autogen and Python async
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

bash
pip install composio python-dotenv
pip install autogen-agentchat autogen-ext-openai autogen-ext-tools

Install Composio, Autogen extensions, and dotenv.

What's happening:

  • composio connects your agent to Ramp via MCP
  • autogen-agentchat provides the AssistantAgent class
  • autogen-ext-openai provides the OpenAI model client
  • autogen-ext-tools provides MCP workbench support

4

Set up environment variables

bash
COMPOSIO_API_KEY=your-composio-api-key
OPENAI_API_KEY=your-openai-api-key
USER_ID=your-user-identifier@example.com

Create a .env file in your project folder.

What's happening:

  • COMPOSIO_API_KEY is required to talk to Composio
  • OPENAI_API_KEY is used by Autogen's OpenAI client
  • USER_ID is how Composio identifies which user's Ramp connections to use
5

Import dependencies and create Tool Router session

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Ramp session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["ramp"]
    )
    url = session.mcp.url
What's happening:
  • load_dotenv() reads your .env file
  • Composio(api_key=...) initializes the SDK
  • create(...) creates a Tool Router session that exposes Ramp tools
  • session.mcp.url is the MCP endpoint that Autogen will connect to
6

Configure MCP parameters for Autogen

python
# Configure MCP server parameters for Streamable HTTP
server_params = StreamableHttpServerParams(
    url=url,
    timeout=30.0,
    sse_read_timeout=300.0,
    terminate_on_close=True,
    headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
)

Autogen expects parameters describing how to talk to the MCP server. That is what StreamableHttpServerParams is for.

What's happening:

  • url points to the Tool Router MCP endpoint from Composio
  • timeout is the HTTP timeout for requests
  • sse_read_timeout controls how long to wait when streaming responses
  • terminate_on_close=True cleans up the MCP server process when the workbench is closed
7

Create the model client and agent

python
# Create model client
model_client = OpenAIChatCompletionClient(
    model="gpt-5",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Use McpWorkbench as context manager
async with McpWorkbench(server_params) as workbench:
    # Create Ramp assistant agent with MCP tools
    agent = AssistantAgent(
        name="ramp_assistant",
        description="An AI assistant that helps with Ramp operations.",
        model_client=model_client,
        workbench=workbench,
        model_client_stream=True,
        max_tool_iterations=10
    )

What's happening:

  • OpenAIChatCompletionClient wraps the OpenAI model for Autogen
  • McpWorkbench connects the agent to the MCP tools
  • AssistantAgent is configured with the Ramp tools from the workbench
8

Run the interactive chat loop

python
print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Ramp related question or task to the agent.\n")

# Conversation loop
while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ["exit", "quit", "bye"]:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    print("\nAgent is thinking...\n")

    # Run the agent with streaming
    try:
        response_text = ""
        async for message in agent.run_stream(task=user_input):
            if hasattr(message, "content") and message.content:
                response_text = message.content

        # Print the final response
        if response_text:
            print(f"Agent: {response_text}\n")
        else:
            print("Agent: I encountered an issue processing your request.\n")

    except Exception as e:
        print(f"Agent: Sorry, I encountered an error: {str(e)}\n")
What's happening:
  • The script prompts you in a loop with You:
  • Autogen passes your input to the model, which decides which Ramp tools to call via MCP
  • agent.run_stream(...) yields streaming messages as the agent thinks and calls tools
  • Typing exit, quit, or bye ends the loop

Complete Code

Here's the complete code to get you started with Ramp and AutoGen:

python
import asyncio
import os
from dotenv import load_dotenv
from composio import Composio

from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import McpWorkbench, StreamableHttpServerParams

load_dotenv()

async def main():
    # Initialize Composio and create a Ramp session
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    session = composio.create(
        user_id=os.getenv("USER_ID"),
        toolkits=["ramp"]
    )
    url = session.mcp.url

    # Configure MCP server parameters for Streamable HTTP
    server_params = StreamableHttpServerParams(
        url=url,
        timeout=30.0,
        sse_read_timeout=300.0,
        terminate_on_close=True,
        headers={"x-api-key": os.getenv("COMPOSIO_API_KEY")}
    )

    # Create model client
    model_client = OpenAIChatCompletionClient(
        model="gpt-5",
        api_key=os.getenv("OPENAI_API_KEY")
    )

    # Use McpWorkbench as context manager
    async with McpWorkbench(server_params) as workbench:
        # Create Ramp assistant agent with MCP tools
        agent = AssistantAgent(
            name="ramp_assistant",
            description="An AI assistant that helps with Ramp operations.",
            model_client=model_client,
            workbench=workbench,
            model_client_stream=True,
            max_tool_iterations=10
        )

        print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
        print("Ask any Ramp related question or task to the agent.\n")

        # Conversation loop
        while True:
            user_input = input("You: ").strip()

            if user_input.lower() in ['exit', 'quit', 'bye']:
                print("\nGoodbye!")
                break

            if not user_input:
                continue

            print("\nAgent is thinking...\n")

            # Run the agent with streaming
            try:
                response_text = ""
                async for message in agent.run_stream(task=user_input):
                    if hasattr(message, 'content') and message.content:
                        response_text = message.content

                # Print the final response
                if response_text:
                    print(f"Agent: {response_text}\n")
                else:
                    print("Agent: I encountered an issue processing your request.\n")

            except Exception as e:
                print(f"Agent: Sorry, I encountered an error: {str(e)}\n")

if __name__ == "__main__":
    asyncio.run(main())

Conclusion

You now have an Autogen assistant wired into Ramp through Composio's Tool Router and MCP. From here you can:
  • Add more toolkits to the toolkits list, for example notion or hubspot
  • Refine the agent description to point it at specific workflows
  • Wrap this script behind a UI, Slack bot, or internal tool
Once the pattern is clear for Ramp, you can reuse the same structure for other MCP-enabled apps with minimal code changes.
TOOLS

Supported Tools

Every Ramp action and event your agent gets out of the box.

Add Purchase Order Line Items

Add line items to an existing Ramp Plus purchase order.

Add Receipt Integration Opt Out Email

Add an email to a business's receipt integrations opt-out list.

Archive Bill

Archive a bill, cancelling inflight payments or terminating its one-time card where possible.

Archive Purchase Order

Archive a Ramp Plus purchase order.

Archive Vendor Bank Account

Archive a vendor bank account by vendor ID and bank account ID.

Create Accounting Field Option Filter Rules

Create accounting field option filter rules in bulk.

Create Bill

Create a Ramp bill.

Create Card Embed Token

Create an embed initialization token for an activated, currently active card.

Create Card Vault

Create a spend limit and virtual card synchronously, returning sensitive card details.

Create Department

Tool for creating a new department in your Ramp organization.

Create Draft Bill (Beta)

Beta: create a Ramp draft bill for a vendor without submitting it.

Create Draft Spend Request Via OCR

Create a draft spend request by extracting information from an uploaded document.

Create Inventory Item Accounting Field

Tool to create a new inventory item accounting field for tracking inventory categories.

Create Item Receipt

Create an item receipt for purchase order lines.

Create Location

Create a named location in the Ramp organization, optionally under a business entity.

Create Transaction Memo

Tool for uploading a new memo for a transaction in Ramp.

Create Mileage Reimbursement

Tool to create a mileage reimbursement in Ramp.

Create Mock Webhook Event

Create a mock webhook event for active subscriptions matching its event type.

Create New Custom Accounting Field

Tool for creating a new custom accounting field.

Create Procurement Request

Create a procurement request for a purchase-order or approval-only spend program.

Create Purchase Order

Create a purchase order.

Create Spend Program

Create a Ramp spend program with spending limits and optional issuance rules.

Create Tax Code Accounting Field

Tool to create a new tax code accounting field in Ramp.

Create User Invite

Tool to create a user invite for onboarding new employees to Ramp.

Create Vendor

Create an approved Ramp vendor, bypassing existing vendor approval policies.

Create Vendor Contact

Create a contact for an existing Ramp vendor.

Create Webhook Subscription

Tool to create a new webhook subscription for receiving event notifications from Ramp.

Deactivate User

Tool to deactivate a user in your Ramp organization.

Delete Accounting GL Account

Tool to delete a general ledger account from Ramp.

Delete Accounting Connection

Tool to disconnect the current active API-based accounting connection.

Delete Accounting Field Option Filter Rules

Bulk delete specific accounting field option filter rules (Ramp Plus required).

Delete Custom Accounting Field

Tool to delete a custom accounting field from Ramp.

Delete Accounting Inventory Item Option

Tool to delete an accounting inventory item option from Ramp.

Delete Tax Code Accounting Field

Tool to delete the tax code accounting field from Ramp.

Delete Accounting Tax Code Option

Tool to delete a tax code option from Ramp.

Delete Accounting Tax Rate

Tool to delete an accounting tax rate from Ramp.

Delete Accounting Vendor

Tool to delete an accounting vendor from Ramp.

Delete Custom Field Option

Tool to delete a custom accounting field option from Ramp.

Delete Inventory Item Field

Tool to delete the inventory item accounting field from Ramp.

Delete Item Receipt

Delete an item receipt by its ID.

Delete Procurement Request

Delete a procurement request by its unified request ID.

Delete Purchase Order Line Item

Delete one line item from an approved Ramp Plus purchase order.

Remove Users from Shared Limit

Tool to remove users from a shared spend limit in Ramp.

Delete Vendor

Delete a Ramp vendor by ID.

Delete Webhook Subscription

Delete a Ramp webhook subscription by ID.

Download Bill Remittance Receipt

Download the remittance receipt PDF for a Ramp bill.

Fetch General Ledger Account

Tool to fetch a specific general ledger account by ID from Ramp.

Fetch Accounting Vendor

Tool to fetch a specific accounting vendor by ID from Ramp.

Fetch Custom Accounting Field

Tool for fetching a custom accounting field.

List General Ledger Accounts

Tool to list general ledger accounts from Ramp.

Fetch All Accounting Connections

Tool to fetch all accounting connections for the current Ramp business.

Get Accounting Connection

Tool to fetch the current active accounting connection for a Ramp account.

Fetch Accounting Connection By ID

Tool to fetch a specific accounting connection by ID from Ramp.

List Custom Accounting Fields

Tool to list custom accounting fields for coding transactions.

Get Accounting Tax Code

Fetch the tax code accounting field for the current Ramp accounting connection.

List Accounting Vendors

Tool to list accounting vendors from Ramp.

Get All Transactions

List a page of Ramp transactions, with optional filters and sorting.

Get Bank Account

Get one connected Ramp bank account by UUID.

Get Banking Balance History

Get daily available balance history for one Ramp banking account.

Get Bill

Fetch one Ramp bill by ID, including its coding, line items, and payment.

Get Business

Fetch the connected Ramp company's information, including names, billing address and approved credit limit.

Get Business Balance

Fetch the current Ramp business's balances, available card and flex limits, overall spending limit, and billing dates.

Get Card

Tool for retrieving detailed information about a specific card.

Get Card Vault Resource

Tool to fetch a card's sensitive details from the vault.

Get Cashback

Fetch one Ramp cashback payment by ID, including its amount and sync status.

Get Custom Field Option

Tool to fetch a custom accounting field option by its ID.

Get Custom Form Collection Response

Fetch one custom form collection response by its response ID, including question labels, typed answers, comments, mappings and conditional workflows.

Get Department

Retrieve a specific Ramp department by ID, returning its ID and name.

Get Draft Bill (Beta)

Beta: retrieve one Ramp draft bill by its unique identifier.

Get Entity

Get one Ramp business entity by UUID, including accounts and locations.

Get Inventory Item Field

Tool to fetch inventory item accounting field for the current accounting connection.

Get Item Receipt

Fetch an item receipt by UUID, including its purchase order, line items and document URLs.

Get Location

Fetch one Ramp location by its UUID, returning its name and business entity ID.

Get Memo

Tool to fetch a transaction memo.

Get Procurement Request

Retrieve one unified procurement or spend request by its unified request ID, including ownership, amounts, status, approval history and memos.

Get Purchase Order

Fetch a Ramp Plus purchase order and its detailed line items.

Get Receipt

Fetch a Ramp receipt by UUID, returning a temporary image URL and optional structured OCR data.

Get Reimbursement Details

Retrieve details of a specific reimbursement, including amount, status, user information, accounting details, and receipts, for approval workflows or analysis.

Get Spend Limit

Tool to fetch detailed information about a specific spend limit.

Get Spend Program

Retrieve one Ramp spend program by ID, including restrictions and request forms.

Get Statement

Retrieve a statement in JSON or request PDF or CSV format.

Get Transaction Details

Tool for retrieving complete details of a specific transaction.

Get Transfer

Fetch one Ramp transfer payment by its transfer identifier.

Get Trip

Fetch an existing Ramp trip by UUID, including locations, spend events and totals.

Get User

Tool to retrieve detailed information about a specific Ramp user by their ID.

Get Users Deferred Status

Tool for fetching the status of a deferred user task.

Get Vendor Details

Tool for retrieving detailed information about a specific vendor.

Get Vendor Bank Account

Fetch one vendor bank account by its vendor ID and bank account ID.

Get Vendor Contact

Fetch one vendor contact by vendor ID and contact ID.

Get Webhook

Tool to retrieve detailed information about a specific webhook subscription by ID.

Hold Bill

Beta: place a Ramp bill on hold, blocking all payment rails and descheduling payments.

Hold Vendor

Block payments to a vendor by placing a vendor-scoped hold.

Issue Virtual Card

Request asynchronous issuance of a virtual card for a user, with optional spending limits and restrictions.

List Accounting Field Option Filter Rules

List rules determining which target accounting field options are available based on selected trigger field options.

List Accounting Inventory Item Options

Tool to list accounting inventory item options from Ramp.

List Accounting Tax Code Options

List one page of accounting tax code options, including external tax rate IDs and entity availability.

List Accounting Tax Rates

Tool to list tax rates from Ramp's accounting integration.

List Audit Log Events

List one page of Ramp audit log events (requires Ramp Plus).

List Bank Accounts

List connected Ramp bank accounts, one page at a time.

List Banking Accounts

List the business's Ramp checking, brokerage, and investment accounts.

List Bills

List Ramp bills using payment, status, accounting, date, and amount filters.

List All Cards

Tool for listing all cards across the organization with optional filters.

List Cashbacks

List one page of cashback payments, optionally filtered by entity, statement, dates, or accounting sync status.

List Child Vendors

List child vendors of a parent Ramp vendor.

List Departments

List Ramp departments with pagination, returning department IDs and names.

List Draft Bills (Beta)

Beta: list Ramp draft bills with filters and cursor pagination.

List Entities

List Ramp business entities, one page at a time.

List Item Receipts

List one page of item receipts, optionally filtered by entity or purchase order.

List Locations

List one page of Ramp locations, optionally filtered by business entity.

List Memos

Tool for listing memos associated with transactions in your Ramp organization.

List Merchants

List one page of Ramp merchants, optionally filtered by URL, name, or transaction dates.

List Procurement Request Attachments

List all non-deleted attachments on a unified procurement request, oldest first, including supporting documents and purchase order PDF attachments.

List Procurement Requests

List unified procurement and spend requests visible to the connected user, with filters and cursor pagination.

List Purchase Orders

List and filter Ramp Plus purchase orders using cursor pagination.

List Receipt Integration Opt Out Emails

List emails opted out of receipt integrations.

List Receipts

List one page of receipts filtered by creation dates, transaction dates or linked IDs.

List Reimbursements

List reimbursements with filtering options.

List Repayments

List one page of repayments, newest creation date first.

List Roles

List the business's custom roles and their product capabilities.

List Spend Programs

List Ramp spend programs and their spending restrictions, one page at a time.

List Spend Program Workflow Nodes

List External Approval Request nodes for one Ramp spend program.

List Statements

Tool for listing all statements with filtering options.

List Syncable Banking Transactions

List banking transactions available to sync to an accounting provider.

List Transfers

List one page of transfer payments filtered by status, entity, statement, dates, or accounting sync status.

List Trips

List one page of business trips filtered by travelers, status, dates, amount or name.

List Users

Tool for listing users in your Ramp organization with flexible filtering.

List Vendors

Tool for listing vendors with their spending information.

List Vendor Bank Accounts

Tool for listing bank accounts associated with a specific vendor.

List Vendor Contacts

Tool for listing contacts associated with a specific vendor.

List Vendor Credits

Tool to list all vendor credits for all vendors of a business.

List Webhooks

List webhook subscriptions for the organization, including endpoint URLs, event types, and status.

Mark Accounting Connection Ready to Migrate

Mark an inactive API accounting connection ready for the customer's ERP migration flow.

Mark Accounting Objects Ready to Sync

Mark Ramp transactions or reimbursements reviewed and ready for accounting sync.

Options for Custom Accounting Field

Tool for listing options for a given accounting field.

Update Accounting Connection

Tool to update an accounting connection's settings.

Update Card

Tool to update a card's properties including owner, display name, and spending restrictions.

Update Custom Field Option

Tool to update a custom accounting field option.

Update General Ledger Account

Tool to update a general ledger account in Ramp.

Update Inventory Item Field

Tool to update the inventory item accounting field for a Ramp connection.

Upload Accounting GL Accounts

Tool to batch upload general ledger accounts to Ramp.

Post Accounting Codings

Post accounting coding selections to an existing Ramp card transaction.

Create Accounting Connection

Tool to register a new API-based accounting connection between Ramp and an accounting provider.

Post Accounting Syncs

Report successful and failed ERP sync results for Ramp objects.

Upload Accounting Vendors

Tool to batch upload vendors to Ramp for coding transactions, bills, and purchase orders.

Upload Inventory Item Options

Tool to upload inventory item options for an active inventory item accounting field.

Create Physical Card

Tool to create a physical card asynchronously.

Reactivate Accounting Connection

Tool to reactivate a previously unlinked accounting connection by changing its status back to linked.

Reactivate User

Tool to reactivate a suspended user in your Ramp organization.

Release Bill Hold

Beta: release a Ramp bill hold so payments can be scheduled again.

Release Vendor

Release the active vendor-scoped hold to allow new payments to be scheduled.

Remove Receipt Integration Opt Out Email

Remove an email from the receipt integration opt-out list by its entry ID.

Resolve External Approval

Approve or reject a blank canvas external approval workflow step.

Submit Draft Bill (Beta)

Beta: submit a Ramp draft bill and return the resulting standard bill.

Submit Procurement Request

Submit a procurement draft for approval and return its request detail.

Submit Reimbursement Receipt

Tool to upload a receipt for a reimbursement.

Suspend Card

Tool to suspend a card by creating an async task that locks the card from use.

Terminate Card

Tool to permanently terminate a Ramp card.

Update Custom Accounting Field

Tool to update a custom accounting field.

Update Accounting Inventory Item Option

Update the name of an existing inventory item option in Ramp's accounting system.

Update Accounting Tax Code

Update the tax code accounting field's name and optionally its display name in Ramp's accounting system.

Update Accounting Tax Code Option

Tool to update a tax code option in Ramp.

Update Accounting Tax Rate

Tool to update an accounting tax rate in Ramp.

Update Accounting Vendor

Tool to update an accounting vendor in Ramp.

Update Bill

Update an approved Ramp bill.

Update Card Spending Limit

Retrieve a card's details, including its current spending restrictions, after querying limits for the card.

Update Custom Accounting Field Option

Update an existing custom accounting field option by ID.

Update Department

Tool for updating an existing department in your Ramp organization.

Update Draft Bill (Beta)

Beta: update only explicitly supplied fields on a Ramp draft bill.

Update External Approval Metadata

Update display metadata for a Ramp blank canvas external approval request.

Update Spending Limit

Update a Ramp spending limit, including its display name, spending restrictions, permitted spend types, or user assignment.

Update Location

Update a Ramp location's name and optionally its business entity.

Update Procurement Request

Edit an owned native draft or submitted Ramp Plus procurement request.

Update Purchase Order

Update an approved Ramp Plus purchase order; unapproved orders are rejected by Ramp.

Update Purchase Order Line Item

Update one line item on an approved Ramp Plus purchase order.

Update User

Tool to update an existing user in your Ramp organization.

Update Vendor

Update an existing Ramp vendor by UUID.

Update Vendor Bank Accounts

Add vendor payment details through Ramp's approval workflow.

Upload Bill Attachment

Upload an invoice or supporting file to an existing Ramp bill.

Upload Draft Bill Attachment

Upload an invoice or supporting file to an existing Ramp draft bill.

Upload External Approval Document

Upload a document for a blank canvas external approval workflow step.

Upload New Options for Custom Accounting Field

Tool for uploading new options for a given accounting field.

Upload Procurement Request Attachment

Upload a supporting document or purchase-order attachment to a procurement request.

Upload Receipt

Upload a receipt image or PDF for a Ramp user.

Upload Tax Code Options

Tool to upload tax code options to Ramp.

Upload Accounting Tax Rates

Tool to batch upload tax rates to Ramp.

Verify Webhook

Verify a pending webhook subscription using its delivered challenge.

FRAMEWORKS

How to build Ramp MCP Agent with another framework

Claude Code logo

Claude Code

Use Ramp MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Ramp MCP with Claude Cowork

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Ramp MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Ramp MCP with Claude Agent SDK

Codex logo

Codex

Use Ramp MCP with Codex

OpenClaw logo

OpenClaw

Use Ramp MCP with OpenClaw

Hermes logo

Hermes

Use Ramp MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Ramp MCP with Atomic Agent

Google ADK logo

Google ADK

Use Ramp MCP with Google ADK

LangChain logo

LangChain

Use Ramp MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Ramp MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Ramp MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Ramp MCP with LlamaIndex

CrewAI logo

CrewAI

Use Ramp MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Ramp MCP with Pydantic AI

FAQ

Frequently asked questions

With a standalone Ramp MCP server, the agents and LLMs can only access a fixed set of Ramp tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Ramp and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. Autogen fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Ramp tools.

Yes, absolutely. You can configure which Ramp scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Ramp data and credentials are handled as safely as possible.

Start with Ramp.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Ramp tool your agent needs.Free to start.

Start building