Exit Waterfall Workshop, October 15 Save a seat
Hemrock
Sign in

MCP Server

Connect Claude Desktop or Claude.ai to Hemrock's financial modeling. Pull context primers, task prompts, sanity checks, and the methodology behind the math into any AI conversation about your model. Run cap-table, exit-waterfall, and fund-economics calculations directly against the hosted engines with your API key.

Free
Public reference tools; sign in for compute
Connect in Claude.ai

Settings → Connectors → Add MCP Server

Endpoint URLs›

Signed in, for compute:

https://mcp.hemrock.com/mcp/account

Public reference tools only:

https://mcp.hemrock.com/mcp
Claude Desktop config›
json
{
  "mcpServers": {
    "hemrock": {
      "type": "url",
      "url": "https://mcp.hemrock.com/mcp",
      "name": "Hemrock",
      "headers": {
        "Authorization": "Bearer hk_live_YOUR_KEY"
      }
    }
  }
}
Claude.ai connector›

Settings → Connectors → Add MCP Server, then paste:

https://mcp.hemrock.com/mcp/account

Claude opens a Hemrock sign-in window when you add it. Sign in with the account that bought compute. For the free tools without signing in, use https://mcp.hemrock.com/mcp.

ChatGPT / OpenAI›

In ChatGPT, open Settings → Connectors → Add connector, choose MCP Server, then paste:

https://mcp.hemrock.com/mcp

The URL installs the public tools. Compute additionally requires an Authorization: Bearer hk_live_… header. If the connector UI does not support custom headers, use the REST API for compute.

OpenAI's connector docs

Or use the Skill (no connector)

What is MCP?

MCP stands for Model Context Protocol, an open standard that lets AI apps call external tools and data sources over a single, portable API. Instead of copy-pasting primers and cheat sheets every conversation, you connect once and point your AI client at an MCP server and its tools become available as native calls. Claude, Cursor, Open AI, and a growing list of others all speak MCP.

The Hemrock MCP is a public server listed in the MCP registry – free to connect. The reference and discovery tools need no auth; the compute tools use your connected Hemrock account or API key.

What it does

Built to edit means using AI to customize a proven model instead of generating from scratch. For that to work, the AI needs to understand the model's structure, conventions, and guardrails before it starts making changes. Copy-pasting a primer every time is friction.

The MCP server exposes Hemrock's prompt library as tools any MCP-compatible AI client can call. Ask Claude to "use the Hemrock context primer for the cap table model" and it pulls the right orientation, the right format conventions, and the right warnings automatically.

It also exposes Hemrock's library of modeling concept guides — the reasoning behind the numbers. Where the template primers tell the AI where a calculation lives, the concept guides explain how it should work: how an exit waterfall distributes proceeds, how anti-dilution resets conversion prices, how a circular reference resolves. The AI can pull the relevant guide before it builds or audits the math.

Run calculations, not just prompts

Two focused ChatGPT plugins are in development: Cap Table and Exit Waterfall, and Fund Economics. They use OAuth sign-in and existing account access, without subscription sales or upgrade prompts. Installation links will appear after publication.

Beyond the prompt and concept tools, the MCP server runs Hemrock's model engines directly. Ask Claude to compute a cap table, an exit waterfall, or fund economics and it calls the hosted engine to use the exact methodology used on the web models on hemrock.com.

Two of these are open to everyone: list_models shows what's runnable and what it costs, and get_access returns a checkout link. The three compute tools need authenticated access. Each account has 10 lifetime free calculations per product. Cap table and exit waterfall share an allowance; fund economics is independent. Each product is $20/year for 6,000 calculations.

Sign in to Hemrock to use the free calculation allowance. Connect through OAuth, or create a bearer key for an existing API client under Developer access. Copy the hk_live_… value when it appears; it is shown once.

An agent can start the purchase flow itself without a key. It calls get_access for the model, receives the current price and a checkoutUrl, and gives that secure checkout link to you. You sign in and complete payment; the agent never handles your payment credentials. If the agent already has a valid key, a compute call without the required access returns the same checkout link in a 402 payment_required response. Once payment activates, the agent retries the original call with the same key.

To run calculations, add https://mcp.hemrock.com/mcp/account as the connector instead of the public URL. Your AI client asks you to sign in to Hemrock when you add it, and that sign-in is what the compute tools run on. It carries the same free tools as the public URL, so you only need one connector.

If your client can send headers, you can instead keep the public URL and configure it to send Authorization: Bearer hk_live_…. Either way, if Claude reaches for a compute tool before you've signed in or bought access, the tool answers with what's missing and the links to fix it, and Claude should pass those to you instead of skipping the calculation. Full API reference at hemrock.com/docs/api.

Need more calculations? Enterprise pricing is available. Contact me to discuss your API or MCP usage.

Run a cap table through MCP

cap_table_compute takes an ordered list of financing events—founders, option pools, priced rounds, SAFEs, notes, and warrants—and returns the ownership snapshot after every event plus the final cap table. It uses the shared Cap Table & Exit Waterfall annual allowance.

Use Hemrock's cap_table_compute tool to model two founders with 6,000,000 and 4,000,000 shares, a 10% option pool, a $1 million post-money SAFE at a $10 million cap, and a $5 million Series A at a $20 million pre-money valuation. Show each financing snapshot and summarize final ownership and dilution.

The events must be supplied in chronological order. For exact event shapes, use the API reference.

Run an exit waterfall through MCP

exit_waterfall_compute distributes an exit valuation across common stock, preferred series, options, warrants, SAFEs, and notes. The model determines when preferred holders keep their liquidation preference or convert, including participation, caps, seniority, and in-the-money exercises. It shares the Cap Table & Exit Waterfall annual allowance.

Use Hemrock's exit_waterfall_compute tool to model a $50 million exit with founders holding 8,000,000 common shares and a Series A investor holding 2,000,000 preferred shares purchased for $5 million with a 1x non-participating preference. Show whether Series A converts and summarize proceeds by holder.

Pass the complete waterfall model and an exitValuation. The API reference documents the model shape.

Run the fund model through MCP

The compute tool runs the aggregate Fund Economics engine over the life of a fund. It does not open or recalculate the quarterly Venture Capital Model spreadsheet. API and MCP calls use the independent Fund Economics annual allowance.

Use Hemrock's fund_economics_compute tool to model a $25 million fund with a 2% management fee, 20% carry, a four-year investment period, and 10% recycling. Start from Hemrock's default inputs, change only those assumptions, and summarize gross and net TVPI, IRR, fees, carry, and investable capital.

The public URL enables the prompt, concept, and discovery tools, but not compute. For compute, connect with the signed-in URL above. If your client can't sign in to a connector, call the REST API instead; the request body and result are the same.

Available tools

Thirteen tools in four groups: the prompt library (context, task prompts, checks, best practices), the concept guides (browse and read the methodology behind the math), the model engines (discover what's available and run cap-table, exit-waterfall, and fund-economics calculations), and your account (access and usage). The reference and discovery tools are open; the compute and account tools need a signed-in connection.

The server also adds four slash commands to clients that support MCP prompts. In Claude they show up as /hemrock:model_a_round, /hemrock:exit_waterfall, /hemrock:fund_returns and /hemrock:review_my_model. The first three gather what the calculation needs, ask about anything that changes the answer, then run the engine. The review works through Hemrock's sanity checks against your model and is free.

get_context

Orient your AI before it touches a spreadsheet. Pulls universal modeling context plus any template-specific primer.

  • template_namestring, optional- One of standard, saas, ecommerce, unit_economics, cap_table, venture_fund, fund_economics, venture_valuation, runway. Omit for universal context only.
get_prompts

Task-specific prompts for a given template.

  • template_namestring, required- One of standard, saas, ecommerce, unit_economics, cap_table, venture_fund, fund_economics, venture_valuation, runway.
  • task_typestring, optional- One of orientation, revenue, expenses, fundraising, analysis, presentation. Omit to return all task types for the template.
get_checks

Sanity-check prompts to catch hallucinated formulas, hard-coded values, confused metrics, and other common AI mistakes.

  • template_namestring, required- One of standard, saas, ecommerce, unit_economics, cap_table, venture_fund, fund_economics, venture_valuation, runway. Use "all" for universal checks only.
get_best_practices

Modeling best practices, organized by topic.

  • topicstring, optional- One of formatting, structure, inputs, assumptions, review, sharing. Omit to return all topics.
list_concepts

Browse Hemrock's financial-modeling concept guides — the methodology behind the math: exit waterfalls, anti-dilution, convertible notes, cohorts, circular references, unit economics, and more. Returns a compact index to pair with get_concept.

  • template_namestring, optional- One of standard, saas, ecommerce, unit_economics, cap_table, venture_fund, fund_economics, venture_valuation, runway. Filters to concepts relevant to that template.
  • tagstring, optional- Filter to a topic tag, e.g. "cap tables". Omit to list everything.
get_concept

Read the full text of a single concept guide — how a calculation actually works, not just where it lives in the template. Pull it before building or auditing the math.

  • slugstring, required- A concept slug from list_concepts, e.g. "waterfall" or "anti-dilution".
list_models

List the Hemrock model engines callable over the API, with pricing and checkout links. No key needed — discover what you can run before authenticating.

get_access

How to get access to a model engine: free or paid, the price, and a checkout URL. Use when a compute tool says payment is required.

  • modelstring, required- One of "cap-table", "exit-waterfall", "fund-economics".
cap_table_compute

Run a cap-table calculation from a list of events (founders, priced rounds, SAFEs/notes, pools, warrants). Returns per-round snapshots and final ownership. Needs a Hemrock API key with the Cap Table & Exit Waterfall product.

  • eventsarray, required- Ordered cap-table events. See the API reference at hemrock.com/docs/api for each event's shape.
exit_waterfall_compute

Run an exit-waterfall calculation: distribute an exit valuation across the cap stack. Needs a Hemrock API key with the Cap Table & Exit Waterfall product.

  • modelobject, required- The waterfall model: common, preferred, options, warrants, convertibles.
  • exitValuationnumber, required- Total exit proceeds to distribute.
fund_economics_compute

Run a fund-economics forecast from a set of inputs: capital calls, fees, deployment, NAV, and returns. Uses the independent Fund Economics annual allowance.

  • inputsobject, required- Fund inputs: committed capital, fees, portfolio construction, carry tiers.

Use cases

Four concrete scenarios where the MCP changes the quality of what Claude can do for you. Paste any prompt straight into Claude (Desktop or claude.ai) once the connector is added.

1. Set up a new financial model from scratch

A founder just opened the Standard template and wants Claude to walk them through configuring it for a B2B SaaS business with annual contracts.

“I just bought Hemrock's Standard template and I'm building a model for a B2B SaaS business with annual contracts. Use the Hemrock MCP to get the universal context plus the standard-template primer, then pull the orientation and revenue prompts and walk me through setting up Get Started and the Revenues tab.”

What the connector contributes: get_context(template_name="standard") + get_prompts(template_name="standard", task_type="orientation") + get_prompts(template_name="standard", task_type="revenue").

Value: Without the connector, Claude gives generic modeling advice that doesn't map to Hemrock's specific sheet structure. With it, Claude knows which cells exist, which assumptions drive them, and the order to configure them in.

2. Audit an AI-generated model for common errors

A VC analyst let Claude edit a portfolio model last week and wants a second pass to catch the typical mistakes AI makes in financial modeling.

“I've been working with Claude on this venture fund model for the past week. Use the Hemrock MCP to pull the sanity-check prompts for the venture_fund template, then run them against the model I've shared and flag anything that looks wrong.”

What the connector contributes: get_checks(template_name="venture_fund") returns the universal checks plus template-specific validation prompts – e.g. “does management fee step-down happen at the right vintage year,” “are distributions net of carry,” etc.

Value: Claude doesn't natively know where AI-generated financial models tend to break. The checks tool encodes Hemrock's institutional knowledge of those failure modes so Claude can find them.

3. Build a cap table for a SAFE-then-priced-round scenario

A founder has raised on SAFEs and is planning a priced Series A. They want Claude to model dilution correctly using Hemrock's cap table template.

“I've raised $2M on post-money SAFEs at $15M cap and I'm about to do a Series A at $40M pre. Use the Hemrock MCP to pull the cap_table context and the fundraising prompts, then help me set up the scenario so I can see founder dilution, option pool top-up impact, and SAFE conversion.”

What the connector contributes: get_context(template_name="cap_table") + get_prompts(template_name="cap_table", task_type="fundraising"), optionally with get_best_practices(topic="assumptions") for assumption-layering guidance.

Value: SAFE conversion math is a well-known place Claude gets wrong (pre vs post-money, option pool shuffle, most-favored-nation clauses). The cap_table prompts give Claude the exact input fields and conversion logic Hemrock's template uses, so the answer matches what the spreadsheet will actually compute.

4. Learn how a calculation works before trusting it

An operator is building an exit waterfall and wants to understand how proceeds actually flow — liquidation preferences, participation, conversion — not just which cells to fill in.

“I'm working in the cap table and exit waterfall tool. Use the Hemrock MCP to pull the concept guide on exit waterfalls, explain in plain terms how proceeds get distributed across preferred and common, then check whether participating preferred is handled correctly in the model I've shared.”

What the connector contributes: list_concepts(template_name="cap_table") to find the relevant guides, then get_concept(slug="waterfall") for the full methodology.

Value: Template primers tell the AI which cells exist; the concept guides tell it how the finance is supposed to work. With both, Claude can explain the math in plain terms and catch logic errors the sheet map alone would miss.

Why this matters

AI without context makes plausible-looking mistakes. Wrong cell references, hard-coded values where formulas should be, confused metrics, silent breakage. The context primer and prompts catch most of that before the AI ever touches a cell.

If you're editing a Hemrock model with AI, connect the MCP. If you're editing something else, the patterns still apply: orient first, prompt with guardrails, verify before trusting the output.

Troubleshooting

If Claude shows “couldn't reach MCP server” or the tool list is empty after adding the connector, remove the connector, fully restart the Claude app (not just close the window – quit it), then re-add it. The reference and discovery tools are public, so connection failures are almost always a stale client-side state. If Claude says the compute tools aren't signed in, the connector was added with the public URL. Remove it and add https://mcp.hemrock.com/mcp/account, which asks you to sign in to Hemrock; or configure the public URL with an API key. The tool's reply includes the sign-in and purchase links, so you can also ask Claude to show you them. If problems persist, confirm https://mcp.hemrock.com/mcp loads in a browser (you should see a JSON response, not an error page).

Related