What is FundOS MCP?

FundOS is an AI-native operating system for fund managers — covering deal pipeline, LP relationships, virtual data rooms, covenant monitoring, fund accounting, and hedge fund operations. It exposes all of that data to AI agents through a standardised Model Context Protocol (MCP) server, so tools like Claude, Cursor, and custom Python agents can read fund state and propose actions for human approval without any custom API integration work.

The MCP server ships 24 tools across every FundOS module: deal CRM, LP investor management, VDR document intelligence, pricer, risk covenants, CIM generation, CFO waterfall modelling, syndication, and DTCC HF ops. OAuth 2.0 PKCE handles authentication automatically — no API key management, no token rotation scripts. Once connected, your agent can answer questions like "which covenants are in breach?" or "what did our LPs say about transfer rights?" directly from live fund data.

Quick connect

If you're using Claude Code, one command is all you need:

claude mcp add fundos https://www.kela.com/mcp

Claude Code handles the full OAuth PKCE flow — opens your browser, you approve access, token is stored. Done. Try list deals in diligence to verify.

For Cursor, add a .cursor/mcp.json to your project root with the SSE endpoint and a Bearer token. For any other MCP-compatible client, point it at https://www.kela.com/mcp/sse with the same token. Full setup instructions are in the GitHub repo.

Top 10 tools — what you can do once connected

Here are the ten tools most useful for day-to-day fund operations:

fundos_get_pipeline
Returns all deals grouped by stage — sourcing, qualification, diligence, IC, closing. Good starting point for any pipeline briefing.
search_documents
Free-form question over every document in a VDR room, with AI-grounded citations. Ask "what does the LPA say about key-man provisions?" and get an answer with page references.
fundos_list_risk_alerts
Surface all open covenant breaches. Pass open=true to get only unresolved alerts. Essential for daily risk inbox triage.
fundos_check_covenant
Test a covenant value against its threshold — pass a covenant_id to update the stored state and trigger alerts, or omit it for an ephemeral what-if simulation.
fundos_compute_waterfall
European waterfall model. Input distributable proceeds, committed capital, hurdle rate, and carry percentage. Returns LP/GP split at each tier.
fundos_get_lp
Full LP detail — committed capital, KYC status, and the complete capital-call ledger for a single investor. Useful before LP follow-up calls.
fundos_run_pricer
Score a private credit asset: IRR, MOIC, WAL, full cashflow schedule, and waterfall splits. Supports bullet/linear/level amortisation and SOFR+spread pricing.
fundos_vdr_analyze
Red-flag extraction and entity mapping from a document bundle. Pass a deck inline or reference a connected MCP data source. Returns red_flags[] and an entity_map of companies, people, and valuations.
hf_ops_dtcc_get_affirmation_scorecard
T+0 affirmation rate for any trade date — affirmed count, DK count, match/unmatch breakdown, and rate percentage. Use for daily COO / ops health reports.
fundos_generate_odd
Draft ODD answers from an LP or consultant DDQ. Pass documents inline or reference a connected data source. Outputs are ephemeral by default — never persisted without explicit confirmation.

Python example — query the deal pipeline

If you're building a custom agent or integrating FundOS into an existing workflow, the MCP server also accepts standard JSON-RPC over HTTP. Here's a minimal example using httpx: 

import httpx

FUNDOS_MCP_URL = "https://www.kela.com/mcp"
ACCESS_TOKEN   = "vdr_your_api_key_here"  # or an OAuth access token

headers = {
    "Authorization": f"Bearer {ACCESS_TOKEN}",
    "Content-Type": "application/json",
}


def call_tool(name: str, arguments: dict = None) -> dict:
    r = httpx.post(
        f"{FUNDOS_MCP_URL}/message",
        headers=headers,
        json={
            "jsonrpc": "2.0",
            "method": "tools/call",
            "params": {"name": name, "arguments": arguments or {}},
            "id": 1,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()


# Get all deals currently in diligence
deals = call_tool("fundos_list_deals", {"stage": "diligence"})
print(deals)

# Check for open covenant breaches
alerts = call_tool("fundos_list_risk_alerts", {"open": True})
print(alerts)

# Model a $50M exit at 8% hurdle, 20% carry
waterfall = call_tool("fundos_compute_waterfall", {
    "distributable": 50_000_000,
    "committed":     20_000_000,
    "hurdle_pct":    0.08,
    "carry_pct":     0.20,
})
print(waterfall)

The full example — covering all 24 tools including DTCC ops, VDR search, and LP capital calls — is at examples/python-client.py in the GitHub repo.

Authentication — OAuth 2.0 PKCE

FundOS MCP uses the OAuth 2.0 Authorization Code flow with PKCE (RFC 7636). There are no long-lived API keys to rotate — access tokens expire after one hour and refresh tokens rotate automatically. The authorization server exposes standard discovery endpoints:

  • https://kela.com/.well-known/oauth-authorization-server — RFC 8414 metadata
  • https://kela.com/.well-known/oauth-protected-resource — RFC 9728 resource metadata
  • https://kela.com/.well-known/mcp.json — MCP server manifest

Three OAuth clients are pre-registered: claude-code (redirects to localhost during CLI auth), claude-ai (for Claude.ai's Connectors feature), and mcp-generic (for Cursor and custom clients). Claude Code handles the entire PKCE flow transparently — it opens the browser, you approve on the consent screen, and the token is stored in Claude's credential store. No manual token handling required.

Scopes follow the principle of least privilege: read for querying fund state, write for creating and updating records. Admin-level actions — adding room members, issuing capital calls, executing waterfall distributions — require human approval in the agent action queue regardless of OAuth scope.

Every write proposed by an agent lands in an approval queue at /fundos/agent/runs/<id>. The GP clicks Approve. Nothing auto-executes.

Get started

The fastest path is Claude Code. Run one command, approve access in the browser, and your agent can immediately read your fund's live state: 

claude mcp add fundos https://www.kela.com/mcp

If you'd rather use a static API key — no OAuth, no browser, no token rotation — generate one at kela.com/admin/api-keys and pass it as Authorization: Bearer vdr_<key>.

GitHub — fundos-mcp Start free on kela.com