# Occam MCP server

Finds the simplest equation consistent with your data. SINDy and PySR symbolic regression via MCP.

## Links
- Registry page: https://www.getdrio.com/mcp/fit-occam-occam
- Website: https://occam.fit

## Install
- Endpoint: https://occam.fit/mcp/
- Auth: Not captured

## Setup notes
- Remote endpoint: https://occam.fit/mcp/

## Tools
- feature_request - Request a feature that Occam doesn't support yet.

    Use this when you need a capability that Occam doesn't currently
    offer. Requests are logged and used to prioritize development.

    Rate limit: 5 requests/hour per IP, 50/hour global — stricter than
    the compute tools' 10/hour to prevent log flooding. Descriptions
    longer than 500 characters are truncated.
     Endpoint: https://occam.fit/mcp/
- sindy_run - Sparse Identification of Nonlinear Dynamics (SINDy).

    Recovers governing differential equations (dx/dt = f(x)) from time
    series data. Returns human-readable sparse expressions. Fast (seconds).
    For algebraic y = f(x) relationships without time structure, use
    pysr_run instead.

    Pricing: free tier up to 100 rows and 8 variables. Beyond that,
    $0.05 + $0.01 per 100 extra rows + $0.01 per extra variable squared,
    via x402 (USDC on Base) or MPP/Stripe. MPP/Stripe adds a flat $0.35
    per-transaction fee (Stripe processing), so the MPP challenge amount
    in a `payment_required` response is $0.35 higher than the x402 amount
    for the same base price; x402 gets the lower rate. Omit `payment`
    for free-tier requests; paid requests without a valid credential
    receive a `payment_required` result with pricing and accepted schemes.
    Full pricing table as structured JSON: occam://pricing

    Advisory limits: jobs over 500,000 rows or 50 variables are accepted
    but may not converge within the time budget; the response carries a
    top-level `warning` the agent should surface and treat as tentative.

    If `feature_names` is supplied, its length must equal the number of
    data columns; a mismatch is rejected with a validation error.

    Rate limit: 10 requests/hour per IP, 200/hour global, max queue
    depth 20 (shared with pysr_run and pysr_uncertainty).

    Response (success) includes `equations[]` (each with `variable`,
    `equation`, `expression`, `expression_latex`, `r2`), `library_terms`,
    `nonzero_terms`, `elapsed_seconds`, `canonical_match` (dict with
    `system`, `form`, `variable_map`, `parameter_map`, `confidence` if
    the discovered system matches one of Lorenz / Lotka-Volterra /
    Van der Pol / Duffing; `null` otherwise), optional `warning`,
    optional `_meta` (MPP receipt on paid calls). Full response and
    payment-required schemas: occam://tool-schemas

    Example request:
      data=[[1.0, 0.0], [0.95, -0.31], [0.81, -0.59]], t=[0.0, 0.1, 0.2],
      feature_names=["x", "y"], poly_degree=2, threshold=0.1

    Policy: occam://privacy-policy — Citation: occam://citation-info
     Endpoint: https://occam.fit/mcp/
- pysr_run - Evolutionary Symbolic Regression (PySR).

    Discovers algebraic equations y = f(x1, x2, ...) from feature/target
    data. Returns a Pareto front ranked by the complexity/accuracy
    tradeoff. Slower than SINDy (10-60s); searches often terminate early
    on convergence. For differential equations from time series, use
    sindy_run instead.

    Pricing: free tier up to 100 rows × 8 features, 60s timeout. Beyond
    that, $0.25 + $0.03 per 100 extra rows + $0.01 per extra feature
    squared, timeout up to 300s (5 min), via x402 (USDC on Base) or
    MPP/Stripe. MPP/Stripe adds a flat $0.35 per-transaction fee (Stripe
    processing), so the MPP challenge amount in a `payment_required`
    response is $0.35 higher than the x402 amount for the same base
    price; x402 gets the lower rate. Omit `payment` for free-tier
    requests; paid requests without a valid credential receive a
    `payment_required` result with pricing and accepted schemes. Full
    pricing: occam://pricing

    Advisory limits: jobs over 50,000 rows or 20 features are accepted
    but may not converge; response carries a top-level `warning`.

    Operators: fixed supported set only — custom operators (e.g.
    'inv(x) = 1/x') are rejected. Unary: sin, cos, tan, exp, log, log2,
    log10, sqrt, abs, sinh, cosh, tanh. Binary: +, -, *, /, ^.
    See also prompt `supported_operators`.

    Loss metric: `loss` (in `pareto_front[].loss` and `best_loss`) is
    mean squared error between model prediction and `y` on the full
    training set — not RMSE, and not normalized by Var(y). A threshold
    appropriate for one dataset scales with y's magnitude, so set
    `loss_threshold` with that in mind (e.g. for y values near 1.0,
    1e-6 is a tight fit; for y near 1000, the equivalent is 1.0).

    Early termination: set `loss_threshold` to stop at your noise floor.
    The server also stops when the search stalls (<1% improvement in the
    last third of the budget); disable with `stall_detection=false`.
    Response `stop_reason` is one of: loss_threshold, stall, timeout,
    natural.

    If `feature_names` is supplied, its length must equal the number of
    columns in `X`; a mismatch is rejected with a validation error.

    Follow-up: call `pysr_uncertainty` with a chosen expression and the
    same dataset for bootstrap confidence intervals on its fit constants
    and optional prediction bands.

    Rate limit: 10 requests/hour per IP, 200/hour global, max queue
    depth 20 (shared with sindy_run and pysr_uncertainty).

    Response (success) includes `pareto_front[]` (each with `complexity`,
    `loss`, `expression`, `expression_latex`), `best_expression`,
    `best_expression_latex`, `best_loss`, `best_complexity`, `stop_reason`,
    `elapsed_seconds`, `queue_seconds` (>0 = server saturated; use as
    backoff signal), optional `warning`, optional `_meta` (MPP receipt).
    Full response and payment-required schemas: occam://tool-schemas

    Example request:
      X=[[0.0], [1.0], [2.0], [3.0]], y=[1.0, 3.0, 5.0, 7.0],
      feature_names=["x"], max_complexity=10, timeout_seconds=15

    Policy: occam://privacy-policy — Citation: occam://citation-info
     Endpoint: https://occam.fit/mcp/
- pysr_uncertainty - Bootstrap confidence intervals for the numeric constants of a
    frozen expression, plus optional prediction bands on an x-grid.

    Typical flow: call pysr_run, pick an expression from the response
    (best_expression or a pareto_front entry), pass it back here with
    the same dataset to get CIs on its fit constants.

    Returns frequentist bootstrap confidence intervals, not Bayesian
    credible intervals — posterior inference over expression structures
    is an open research problem. This tool freezes the expression
    chosen by the caller and bootstraps only its numeric constants;
    uncertainty about *which* expression is correct is not quantified.

    Bootstrap semantics:
      - If y_sigma is supplied, uses parametric bootstrap
        (y_b = y + Normal(0, y_sigma)). CI reflects user-stated
        measurement noise.
      - Otherwise uses residual bootstrap: fit once, resample residuals.
        CI reflects estimated-from-residuals noise.

    Only Float constants in the expression become free parameters.
    Integers stay structural (the 2 in x**2 is a function-class choice,
    not a fit constant). Expressions with no Float constants
    (e.g. "x + y") will be rejected with a validation error.

    Expression grammar: the `expression` string is parsed by sympy.
    Accepted operators are the same set pysr_run emits: unary `sin`,
    `cos`, `tan`, `exp`, `log`, `log2`, `log10`, `sqrt`, `abs`, `sinh`,
    `cosh`, `tanh`; binary `+`, `-`, `*`, `/`, `^` (or `**`). Whitespace
    and parenthesization are free. Every free symbol in the expression
    must correspond to an entry in `feature_names` — an unrecognised
    symbol is silently treated as a fresh sympy Symbol and the fit will
    fail downstream rather than reject early. Parse failures (syntax
    errors, malformed operators) surface as tool errors.

    If `feature_names` is supplied, its length must equal the number of
    columns in `X`; a mismatch is rejected with a validation error.

    Pricing: always free, regardless of dataset size. This tool has no
    `payment` parameter and is never subject to the x402/Stripe gate.
    Large bootstrap jobs still count against the shared rate limit
    below, so budget `n_resamples` accordingly.

    Rate limit: 10 requests/hour per IP, 200/hour global, max queue
    depth 20 (shared with sindy_run and pysr_run).
     Endpoint: https://occam.fit/mcp/

## Resources
- occam://privacy-policy - Occam's data handling policy. Describes what is logged, what is not stored, and permitted use of results. MIME type: text/plain
- occam://citation-info - Citation information for Occam and the methods it uses (SINDy, PySINDy, PySR). Includes BibTeX entries. MIME type: text/plain
- occam://tool-schemas - Full JSON Schemas for sindy_run, pysr_run, pysr_uncertainty, and the shared payment_required response. Auto-derived from the Pydantic response models used by the server itself. MIME type: text/plain
- occam://pricing - Structured pricing and limits for all compute tools (JSON). Free-tier thresholds, per-tool formula parameters, advisory warn thresholds, rate limits. MIME type: text/plain

## Prompts
- getting_started - Guide for choosing between SINDy and PySR based on your data and goals.
- supported_operators - List of operators available for PySR evolutionary search.

## Metadata
- Owner: fit.occam
- Version: 0.1.1
- Runtime: Streamable Http
- Transports: HTTP
- License: Not captured
- Language: Not captured
- Stars: Not captured
- Updated: Apr 2, 2026
- Source: https://registry.modelcontextprotocol.io