# Driggsby

> The MCP server for your money.

Driggsby is a personal finance MCP (Model Context Protocol) server that securely connects your bank accounts, credit cards, loans, and investment accounts to your AI client, including Claude.ai, Claude Code, ChatGPT, Codex, or any MCP-compatible agent that supports remote OAuth MCP servers. Driggsby is an approved connector in the Claude connector directory.

You connect your accounts once through Plaid (the same service behind Venmo, Robinhood, and Coinbase), and Driggsby keeps your financial data synced and available as structured MCP tools your AI can call directly.

Driggsby's financial institution access is read-only. It cannot move money, initiate transfers, make payments, place trades, or modify your bank, card, loan, or brokerage accounts in any way. Driggsby can only modify Driggsby-managed records you explicitly ask it to manage, such as custom assets and liabilities for net-worth tracking.

## What Driggsby can help you answer

The questions you can ask depend entirely on which accounts you connect and what data your institution makes available through Plaid. Not all institutions provide all data types, and history depth varies (some provide 2+ years, others only a few months).

With the right accounts connected, you can ask questions like:

- **Spending**: "How much did I spend on dining out last month?" or "Find every Amazon charge over $100 this year."
- **Net worth**: "What's my total net worth across all accounts?"
- **Cash flow**: "Am I spending more than I'm earning each month?"
- **Subscriptions**: "List every recurring charge I'm paying for."
- **Investments**: "What's in my 401k and how is it allocated?" or "What are my largest positions by value?"
- **History**: "How have my account balances trended over the past year?" or "How has my portfolio value changed since January?"
- **Debt**: "What are my outstanding balances, interest rates, and minimum payments?"
- **Anomalies**: "Are there any duplicate or unusual charges this month?"
- **Taxes**: "Show me all charitable donations from 2025."
- **Email**: "Email me a summary of my spending last month."
- **Custom assets and liabilities**: You can also manually add items like your home value, car, or private investments to get a complete net worth picture.

## How to set up Driggsby

### Step 1: Add Driggsby to your AI client

#### Claude.ai (and the Claude desktop and mobile apps)

Driggsby is an approved connector in the Claude connector directory, so no custom connector setup is needed. In Claude, go to Customize, then Connectors, and browse for "Driggsby" in the connector directory. Or open the listing directly:

```
https://claude.ai/directory/connectors/driggsby
```

Click Connect, and approve access on Driggsby's secure sign-in page. Claude then opens a new chat with Driggsby already connected. Claude asks for your approval the first time it uses a Driggsby tool. OAuth handles authentication and token refresh automatically; no API keys or manual tokens are required.

#### Local CLI setup (Claude Code and Codex)

The public `driggsby` CLI is the recommended setup helper for local AI clients. It does not run a local MCP server or store Driggsby tokens. It configures your AI client's native MCP settings to connect directly to Driggsby's hosted MCP endpoint:

```
https://app.driggsby.com/mcp
```

Run the interactive setup command:

```
npx driggsby@latest mcp setup
```

The CLI will ask which supported client you want to configure. You can also pass the client explicitly:

For Claude Code:
```
npx driggsby@latest mcp setup claude-code
```

For Codex:
```
npx driggsby@latest mcp setup codex
```

Claude Code defaults to user-scoped MCP config. For project-local Claude Code config, use:

```
npx driggsby@latest mcp setup claude-code -s local
```

To inspect the native client command before running it, use:

```
npx driggsby@latest mcp setup codex --print
```

After setup:

- Claude Code: open Claude Code, run `/mcp`, and authenticate Driggsby when prompted.
- Codex: complete the Driggsby sign-in in the browser window opened by Codex. If no browser window opens, run `codex mcp login driggsby`.

#### ChatGPT and other remote MCP clients

Remote MCP clients connect via OAuth. Add an MCP app or connector in your AI client's settings, and use this URL as the MCP Server URL:

```
https://app.driggsby.com/mcp
```

Your AI client will open an OAuth consent flow where you sign in to Driggsby and authorize access. No API keys or manual tokens are required; OAuth handles authentication and token refresh automatically. If a client does not yet support remote MCP servers with OAuth, use one of the supported local CLI setup paths above.

For ChatGPT, turn on Developer mode (Settings -> Security and login), then go to the Plugins page and select the plus button. In the New Plugin dialog, name it Driggsby, use the MCP URL above as the Server URL, and keep Authentication set to OAuth. Developer mode is only needed to add a new plugin. Developer mode availability can vary by ChatGPT plan and workspace policy.

### Step 2: Connect your accounts through Plaid

Sign in at https://app.driggsby.com with Google (your Driggsby account is created on first sign-in), then connect your financial institutions through Plaid. This takes about two minutes. Your bank credentials go directly to your bank through Plaid; they never touch Driggsby's servers.

### Step 3: Ask about your money

Once connected, your AI client can call Driggsby's MCP tools directly. Start with a broad question like "Give me an overview of my finances." Driggsby's `get_overview` tool is designed as the first call for zero-context agents: it returns rollups, balances, linked accounts, account-scoped queryable datasets, user-managed net-worth items, and recommended next tools.

If a response includes `freshness.datasets[]` or account `available_account_data[]`, use these fields as the rulebook for whether a dataset is currently usable:

- `is_queryable_now = true`: the dataset can be queried.
- `sync_health_status = healthy`: recent syncs are healthy.
- `current_data_completeness_status = complete`: the dataset is complete enough to use normally.
- `important_current_limitations`: mention these limitations before relying on the data.

## How it works technically

Driggsby is an MCP server. When your AI client connects, it receives a set of structured tools (like `get_overview`, `search_cash_transactions`, `list_investment_holdings`, etc.) with full schemas and descriptions. Your AI calls these tools to retrieve your financial data, then reasons over the results to answer your questions.

Data flows like this:

```
your financial institution
  -> Plaid
  -> Driggsby
  -> your AI client
```

The CLI setup flow is separate from the data path. It only configures your AI client:

```
npx driggsby@latest mcp setup
  -> native client MCP config
  -> https://app.driggsby.com/mcp
  -> client-managed OAuth sign-in
```

The `get_overview` tool is the recommended starting point. It returns a summary of all connected accounts, available data types, balances, and suggestions for which tool to call next based on common questions.

## Tool guidance for agents

Use Driggsby's tools by intent:

- **Start here**: `get_overview` summarizes the user's financial state and tells the agent what data is available.
- **Accounts and freshness**: `list_accounts` lists linked accounts with stable `account_refs`, balances, and account-scoped queryable datasets.
- **History over time**: `get_history` shows how linked-account balances, investment holdings, or liabilities changed over time. Choose one `history_type` per call: `account_balances`, `investment_holdings`, or `liabilities`. Results follow account lineages across reconnects and return at most 120 points. Custom net-worth items have no historical snapshots, so account-balance totals cover linked accounts only. For `account_balances`, every point includes `includes_every_current_account`; start change-over-time series at the first point where it is true, because earlier points predate the linking of at least one current account.
- **Net worth**: `list_assets_and_liabilities` returns one normalized balance-sheet view across linked accounts and custom net-worth items.
- **Custom net-worth items**: `create_custom_asset_or_liability`, `update_custom_asset_or_liability`, and `archive_custom_asset_or_liability` manage Driggsby-only custom assets and liabilities. For updates and archives, call `list_assets_and_liabilities` first and copy the exact `custom_item_ref`.
- **Cash transactions**: `search_cash_transactions` searches bank and card transaction history. Use `category_primary` and `category_detailed` for Driggsby's PFC-derived category taxonomy plus Driggsby extensions. Use `transaction_semantic_type`, `counts_as_spend`, and `subtracts_from_spending` for Driggsby's overview cashflow buckets. Driggsby spending totals are net of refunds: `counts_as_spend` rows minus `subtracts_from_spending` refund rows.
- **Cash exports**: `export_cash_transactions` creates a short-lived downloadable CSV for a required date window. Return the link to the user unless they explicitly ask the agent to fetch and parse the CSV.
- **Email**: `email_me` sends email to the authenticated account owner's verified address. No recipient fields, CC/BCC, attachments, HTML/CSS, or images. Link rule: no websites, raw URLs, or email addresses; only exact Driggsby export download URLs from `export_cash_transactions` for this account may appear, and only in the body.
- **Recurring cashflows**: `list_recurring_transactions` lists recurring inflows and outflows inferred from transaction history, with enriched categories and clean merchant names, predicted next dates, and typical amounts.
- **Findings**: `list_findings` computes a short list of likely duplicate charges, recurring-price changes, and newly detected subscriptions from settled transaction history. Call it once and read `status` first. There is no pagination or finding lifecycle to manage. An empty list means Driggsby did not detect anything worth showing from the stated data window; it is not a guarantee that every transaction is correct. Findings are not real-time fraud alerts.
- **Debts**: `list_outstanding_debts` lists linked debts with positive balances, payment fields, and due dates.
- **Investments now**: `list_investment_holdings` answers present-tense ownership questions like "What do I own right now?"
- **Investment history**: `search_investment_activity` answers past-tense portfolio-event questions like "When did I buy BTC?"
- **Ad hoc cash analysis**: `query_cash_sql` supports one read-only `SELECT` over the published `cash_transactions` schema. Use it when aggregation is easier than paginating search results.
- **Ad hoc investment analysis**: `query_investment_sql` supports one read-only `SELECT` over the published `investment_activity` schema.

For questions that reconcile to `get_overview` 30-day cashflow buckets, use the last 30 calendar days ending today, `status = posted`, the matching `direction`, and then:

- `transaction_semantic_type = spend | fee | transfer | debt_payment | income | interest | inflow | unknown`
- `counts_as_spend = true` for ordinary spend plus bank-fee outflows
- `subtracts_from_spending = true` for the refund rows behind `past_30_days_spending_refunds_total`; the net spending total equals the `counts_as_spend = true` rows minus these refund rows

## Security and infrastructure

Driggsby is built to the standard of an internet-facing consumer finance application.

- **Rust backend.** The entire backend is written in Rust for memory safety and reliability.
- **Encrypted everywhere.** All data is encrypted in transit (TLS) and at rest using customer-managed encryption keys with automatic rotation.
- **Plaid access tokens encrypted with Cloud KMS.** Plaid access tokens are encrypted at the application layer using dedicated Cloud KMS keys before being stored, separate from database-level encryption.
- **Isolated service architecture.** Driggsby uses a multi-service architecture where each service has the minimum database and API access it needs. Plaid API credentials are confined to a dedicated internal service that is not reachable from the public internet. The public-facing application server has no access to Plaid secrets.
- **Database-level access separation.** Each service connects to the database with its own role-specific credentials. The application server cannot access Plaid token storage. The Plaid service cannot access user financial data. Services that only need to read data cannot write.
- **Per-service identity and dual-layer verification.** Each service runs under its own identity with least-privilege access. Service-to-service calls are verified at both the infrastructure level and in the application.
- **Plaid-secured account linking.** Your bank credentials go directly to your bank through Plaid's infrastructure. Driggsby never sees, stores, or transmits your bank passwords.
- **Read-only financial institution access by design.** Driggsby requests read-only permissions from Plaid. It can view balances, transactions, liabilities, holdings, and investment activity, but cannot initiate transfers, payments, or trades.
- **OAuth 2.0 for MCP clients.** MCP clients authenticate to Driggsby's hosted MCP endpoint via OAuth. No Driggsby API keys are required.
- **Small public CLI surface.** The `driggsby` CLI is a setup helper only. It adds the hosted MCP URL to supported local clients and leaves authentication to the client-managed OAuth flow.
- **User control.** Disconnect any account or delete all your data at any time. No waiting period, no retention tricks.

## Important caveats

- **Data availability varies by institution.** Not every bank provides every data type. Some institutions provide 2+ years of transaction history; others provide only a few months. Investment data, liability details, and recurring transaction detection depend on what your specific institution supports through Plaid.
- **Read-only financial institution access only.** Driggsby cannot move money, make payments, place trades, or modify your linked financial accounts. It can manage Driggsby-only custom net-worth items if you explicitly ask it to.
- **Data freshness.** Balances and transactions sync automatically through Plaid, but there may be a delay of minutes to hours depending on your institution.
- **Findings cadence.** Findings analyze settled transaction data when requested and intentionally ignore the newest three days. They are not real-time monitoring or fraud alerts.
- **Not financial advice.** Driggsby provides your financial data to your AI client. Any analysis or recommendations come from your AI, not from Driggsby. Consult a qualified financial professional for financial advice.

## Links

- Website: https://driggsby.com
- App: https://app.driggsby.com
- Claude connector directory listing: https://claude.ai/directory/connectors/driggsby
- MCP Server URL (for ChatGPT and other remote MCP clients): https://app.driggsby.com/mcp
- Privacy Policy: https://driggsby.com/privacy