# 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 Code, Codex, ChatGPT, or any MCP-compatible agent that supports remote OAuth MCP servers.

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?"
- **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."
- **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: Create an account and connect your banks

Visit https://app.driggsby.com to 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 2: Add Driggsby to your AI client

#### 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`.

#### Remote MCP clients (ChatGPT and other web or hosted clients)

Remote MCP clients connect via OAuth. Add a custom connector or MCP app 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.

### 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.
- **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 Plaid PFC v2 category analysis. Use `transaction_semantic_type` and `counts_as_spend` for Driggsby's overview cashflow buckets.
- **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.
- **Recurring cashflows**: `list_recurring_transactions` lists Plaid-inferred recurring inflows and outflows, including predicted next dates and typical amounts.
- **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`
- `counts_as_spend = true` for ordinary spend plus bank-fee outflows

## 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.
- **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
- MCP Server URL (for remote MCP clients): https://app.driggsby.com/mcp
- Privacy Policy: https://driggsby.com/privacy