# Passare MCP

**MCP server for the Passare Public API** - talk to your funeral-home case data from Claude, Cursor, or any MCP client. First MCP for the Passare platform, MIT-licensed, no vendor relationship required to run.

## What you can do with it

Passare is the leading cloud-based funeral home management software in the US. The Public API gives 3rd parties read access to cases (deceased, services, status), acquaintances (next of kin), addresses, and contact info. With this MCP, you can ask:

```
You:   "Show me every case that was updated this week and group them by service status."
Claude: *calls list_updated_cases, summarises*

You:   "Pull up the family contacts for case 7f3a1bcd-... and give me phone + email for the next of kin."
Claude: *calls list_case_acquaintances, then get_phone_number and get_email*

You:   "Any new cases come in since yesterday?"
Claude: *calls list_new_cases*
```

Use cases for funeral directors, family-services agencies, and adjacent SaaS:
- Auto-summarise a day's new cases into a daily digest
- Sync case status to a CRM, Google Sheet, or Slack channel
- Pull service addresses into a routing / dispatch tool
- Drive a follow-up call list from next-of-kin phone numbers

## Install

```bash
pip install -e .
```

## Configure

```bash
export PASSARE_API_KEY="<your-bearer-token>"
export PASSARE_ORGANIZATION_ID="<your-organization-uuid>"
```

Both are issued by Passare after you submit the [Public API access form](https://www.passare.com/api). The org UUID scopes every call to your funeral home.

### Who uses this?

1. **Funeral homes** running Passare who want to bring their case data into Claude / Cursor / a custom agent workflow.
2. **Adjacent SaaS** (CRM, dispatch, family-portal, monument companies) building B2B integrations to Passare without waiting on a partner agreement.
3. **AI engineers** prototyping vertical workflows for the deathcare industry.

## Use with Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "passare_mcp": {
      "command": "passare_mcp",
      "env": {
        "PASSARE_API_KEY": "your-api-key",
        "PASSARE_ORGANIZATION_ID": "your-organization-uuid"
      }
    }
  }
}
```

## Use with Claude Code

```bash
claude mcp add passare_mcp -- passare_mcp \
  --env PASSARE_API_KEY=your-key \
  --env PASSARE_ORGANIZATION_ID=your-uuid
```

## Tools

| Tool | Type | What it does |
| --- | --- | --- |
| `health_check` | Diagnostic | Verifies credentials by calling the cheapest list endpoint |
| `list_cases` | Read | List every case in the org (paginated by `limit`/`offset`) |
| `get_case` | Read | Retrieve one case by its Passare UUID |
| `list_case_acquaintances` | Read | List family / next-of-kin contacts for a case |
| `list_new_cases` | Read | Incremental sync: cases created since the last poll |
| `list_updated_cases` | Read | Incremental sync: cases updated since the last poll |
| `get_address` | Read | Retrieve one address by its Passare UUID |
| `get_phone_number` | Read | Retrieve a contact's phone by the contact UUID |
| `get_email` | Read | Retrieve a contact's email by the contact UUID |

## Why this exists

The Passare Public API has been live since 2018 and is documented at
[passare.com/api](https://www.passare.com/api). The endpoint surface is
listed in [Cyclr's Passare connector docs](https://cyclr.com/integrate/passare):
Cases, Address, Contacts. But no first-party MCP server exists, no
Zapier / Composio / mcp.so wrapper covers Passare specifically, and the
only DIY options are buried in Tribute/Frazer/Passare's funeral-home-lead
aggregators (which only surface "what software does this funeral home
run?", not actual case data).

This MCP is the missing layer: same auth, same endpoints, no vendor
lock-in, MIT-licensed, 9 tools covering the entire read surface of the
Public API.

## Development

```bash
pip install -e ".[dev]"
pytest
ruff check src tests
ruff format --check src tests
mypy src tests
passare_mcp
```

## Architecture

Built on the patterns documented in `~/.mavis/agents/mavis/memory/engineering-playbook.md`:

- `httpx.AsyncClient` with pooling + transport retries
- Typed exception hierarchy with structured fields
- Application-level retry with exponential backoff + Retry-After
- Bare `raise` inside `@mcp.tool` handlers (FastMCP sets `isError=true`)
- JSONL audit logging per tool call with secret redaction
- `py.typed` marker; `mypy --strict` clean
- `respx` + `hypothesis` for unit and property tests

## License

MIT.

## See also

- [Model Context Protocol spec](https://modelcontextprotocol.io)
- [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
- [Passare Public API page](https://www.passare.com/api)
- [Cyclr Passare connector docs](https://cyclr.com/integrate/passare)
- [awesome-mcp-servers](https://github.com/punkpeye/awesome-mcp-servers)
- [Other sanjibani MCPs](https://github.com/sanjibani?q=-mcp)
- [Custom MCP engagements](https://sanjibani.github.io/mcp-services/)