# com.getsingularis/singularis (pypi · singularis-mcp)

Unlimited computation for agents. Results depend on your equipment; GPU optional.

- Trust score: 67/100 (medium)
- Change this week: +13
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-04

## Components

- pypi · `singularis-mcp`: 67/100 (this document), [markdown](https://verifymcp.io/servers/com-getsingularis-singularis/singularis-mcp.md), [page](https://verifymcp.io/servers/com-getsingularis-singularis/singularis-mcp)

## Channel facts

- Registry: `pypi`
- Package: `singularis-mcp`
- Version: `0.1.11`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-04.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 1 of 32 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 6/100
  - Repository check failed: the declared repository URL returned HTTP 404.
  - Provenance check failed: no build-provenance attestation is published.
  - Licence could not be checked: the licence is declared in free text we could not match to a standard (SPDX) licence identifier, so we cannot tell whether it is OSI-approved.
  - Actively maintained (last published 6 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 59/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 2756 tokens (~145/item across 19 items; 19 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 67/100
  - Stability observed for 20 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 20 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the com.getsingularis/singularis MCP server?

com.getsingularis/singularis runs locally as a PyPI package, launched with uvx singularis-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-getsingularis-singularis -- uvx singularis-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "com-getsingularis-singularis": {
      "command": "uvx",
      "args": [
        "singularis-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-getsingularis-singularis": {
      "command": "uvx",
      "args": [
        "singularis-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-getsingularis-singularis -- uvx singularis-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-getsingularis-singularis": {
      "type": "local",
      "command": [
        "uvx",
        "singularis-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-getsingularis-singularis --command uvx --arg singularis-mcp
```

### Hermes

```yaml
mcp_servers:
  com-getsingularis-singularis:
    command: "uvx"
    args: ["singularis-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-getsingularis-singularis": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "singularis-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-getsingularis-singularis -t stdio -c uvx -a singularis-mcp
```

### Other

```json
{
  "mcpServers": {
    "com-getsingularis-singularis": {
      "command": "uvx",
      "args": [
        "singularis-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 67, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-02 (score 51, −14)

- [security regression] Malware scan: pass → unverified

### 2026-11-01 (score 65, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-30 (score 50, −14)

- [security regression] Malware scan: pass → unverified
- [functional regression] Security disclosure: fail → unverified

### 2026-10-29 (score 64, +10)

- [security regression] Source repository: pass → fail
- [security improvement] Malware scan: unverified → pass

### 2026-10-28 (score 54, −14)

- [security regression] Malware scan: pass → unverified

### 2026-10-26 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-24 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (19)

### `singularis_register_key` (~151 tokens)

Register a free Singularis key

Get a free Singularis API key for this agent (one call, then it is saved and reused).
Use when any Singularis tool reports error=no_api_key. Needs the operator's country
(ISO code such as US) and a short agent name; operator_contact is optional. Free keys are for
US-based users and agents; the tool solves the quick anti-abuse proof of work for you. Returns the
key's starting credits. Sharing results later is requested, not required. By registering you agree
to the Terms at https://getsingularis.com/terms.

Input parameters:

- `agent_name` (string, required)
- `country` (string, required)
- `operator_contact` (string)

### `singularis_balance` (~58 tokens)

Check Singularis credit balance

Show this key's remaining Singularis credits and the cloud-equivalent dollars of compute
delivered so far. Use before a large job, or when a user asks what Singularis has cost
or saved. Free: no credits are charged.

### `singularis_recipes` (~65 tokens)

List Singularis recipes

List the Singularis recipe library: every job kind the service runs, with its input
schema, the check it returns and how cost is measured. Use when a task is numerical but
not covered by the named tools, then run it with singularis_dispatch. Free.

### `singularis_share_results` (~125 tokens)

Share Singularis results

Share your Singularis results (optional, and appreciated). Give a short review, a post_url if you
published one, what the job cost before (prior_cloud_usd) and with Singularis (singularis_usd), the
speedup you measured, and your hardware. Results depend on your equipment; GPU optional for even greater results.

Input parameters:

- `hardware` (string)
- `post_url` (string)
- `prior_cloud_usd`
- `review` (string)
- `singularis_usd`
- `speedup`

### `singularis_solve_heat` (~230 tokens)

Solve the heat equation

Solve the heat (diffusion) equation u_t = D * laplacian(u) on a 1D or 2D grid, stepping an
initial field forward in time; the same equation prices options after a change of
variables (Black-Scholes) and models thermal spread. Use instead of writing a stencil loop
whenever steps * cells is large. Inputs: initial field inline (nested list) or as a file
path; diffusivity D; time step dt; number of steps; grid spacing dx; boundary 'periodic'
(default), 'neumann' or 'dirichlet' (fixed at the initial boundary values). Returns the
final field (inline or as a .npy path) and a check (mass conservation for periodic/neumann,
discrete residual for dirichlet). Cost scales with steps * cells.

Input parameters:

- `boundary` (string)
- `diffusivity` (number)
- `dt` (number)
- `dx` (number)
- `initial`
- `path`
- `steps` (integer)

### `singularis_matrix_exponential` (~160 tokens)

Matrix exponential

Compute the matrix exponential e^{tA} of a square matrix, or its action e^{tA} v on a
vector when a vector is given: time evolution, continuous-time Markov chains and
generator matrices (rating migration), linear ODE systems, graph diffusion. Use instead
of a dense expm whenever n is in the hundreds or more, or when you need a verifiable
residual. Inputs: matrix inline or path; t (default 1); optional vector. Returns the
matrix (or vector) plus a residual check. Cost scales with n^3.

Input parameters:

- `matrix`
- `path`
- `t` (number)
- `vector`
- `vector_path`

### `singularis_gemm` (~144 tokens)

Matrix multiply (GEMM)

Dense matrix product C = A @ B (optionally A @ B + beta * C0). Use for any large dense
multiply, including batches expressed as one tall matrix. Inputs: a and b inline or as
file paths; optional beta and c0. Returns C (inline or .npy path) with a probe residual
check (Freivalds-style, independent of how C was computed). Cost scales with 2*m*n*k.

Input parameters:

- `a`
- `a_path`
- `b`
- `b_path`
- `beta` (number)
- `c0`
- `c0_path`

### `singularis_fft` (~150 tokens)

Fast Fourier transform

Fast Fourier transform (or inverse) of a 1D signal or 2D field of any size:
spectra, convolution, circulant systems, filtering. Inputs: x inline or path;
inverse flag; optional im, the imaginary part of a complex input, same shape as
x. Returns the transform as separate real and imaginary parts plus a Parseval
energy check. To invert a transform, pass its real part as x and its imaginary
part as im with inverse=true -- a complex signal round-trips exactly, imaginary
part intact. Cost scales with N log N.

Input parameters:

- `im`
- `inverse` (boolean)
- `path`
- `x`

### `singularis_blur` (~117 tokens)

Gaussian blur an image or array

Gaussian blur of a 2D array or an image file (.npy, .png, .jpg) with standard deviation
sigma: smoothing, denoising, scale-space, preprocessing. Inputs: array inline, or a path;
sigma in pixels; optional out_path for image files. Returns the blurred array or the
written file path, with a mass-conservation check. Cost scales with pixels * sigma.

Input parameters:

- `image`
- `out_path`
- `path`
- `sigma` (number)

### `singularis_compress` (~115 tokens)

Compress a file exactly

Compress a file exactly (lossless, bit-exact restore) with Singularis compression.
Use for archives, datasets, logs, model checkpoints, anything that must come back
identical. Input: a local file path; optional out_path (default: path + '.sing').
Returns the output path, bytes in/out, ratio, and an exact-restore check (hash of a trial
restore equals the original). Decompress with singularis_decompress.

Input parameters:

- `out_path`
- `path` (string, required)

### `singularis_decompress` (~57 tokens)

Restore a compressed file

Restore a file compressed by singularis_compress, bit-exact. Input: the .sing path;
optional out_path. Returns the restored path and a hash check.

Input parameters:

- `out_path`
- `path` (string, required)

### `singularis_dispatch` (~165 tokens)

Run any Singularis recipe

Run any job from the Singularis recipe library by name with a JSON payload (see
singularis_recipes for names and schemas): e.g. 'circulant_solve',
'kron_solve', 'kron_matvec'. Use when a numerical task is not one of the named tools.
Returns the recipe's result and its check, with cost. Note: the dispatch services
that keep state between calls (learn, then predict or fuse on the name you taught)
hold that state inside the running shell -- for multi-step learning, run the shell
as the always-on daemon (SINGULARIS_ENGINE_URL) so every call reaches the same shell.

Input parameters:

- `payload` (object, required)
- `recipe` (string, required)
- `size`

### `singularis_fft2` (~127 tokens)

2D Fourier transform

2D fast Fourier transform (or inverse) of a real 2D field of any shape: image
spectra, 2D convolution, field filtering. Inputs: x inline or path; inverse flag.
Returns the transform as a [real, imag] pair plus a Parseval energy check. Cost
scales with N log N. (singularis_fft also accepts a 2D field; this tool is the
explicit 2D entry.)

Input parameters:

- `im`
- `inverse` (boolean)
- `path`
- `x`

### `singularis_mind_combine_v2` (~146 tokens)

Combine trained minds (v2: quarantine + shards)

Combine trained minds (model files) into one by exact addition -- no
retraining, no data leaves this machine. Operations: merge, add, remove,
merge_quarantine (a poisoned or corrupted input is identified and excluded,
and the merge proceeds without it), export_shard / import_shard /
merge_shards (signed portable shards; a tampered shard is refused). Inputs:
op, the mind file paths, an output path; ridge (default 1e-8). Returns the
merged digest and counts. Cost: one job, independent of how the minds were
trained.

Input parameters:

- `op` (string, required)
- `params`

### `singularis_mind_merge_v2` (~145 tokens)

Combine trained minds (alias of singularis_mind_combine_v2)

Combine trained minds (model files) into one by exact addition -- no
retraining, no data leaves this machine. Operations: merge, add, remove,
merge_quarantine (a poisoned or corrupted input is identified and excluded,
and the merge proceeds without it), export_shard / import_shard /
merge_shards (signed portable shards; a tampered shard is refused). Inputs:
op, the mind file paths, an output path; ridge (default 1e-8). Returns the
merged digest and counts. Cost: one job, independent of how the minds were
trained.

Input parameters:

- `op` (string, required)
- `params`

### `singularis_data_carry` (~109 tokens)

Carry minds' knowledge in one small file

Carry many minds' knowledge in one small signed file. Operations: pack
(mind statistic files -> one carry file), verify (check a carry file's seal
and digest), merge (combine carry files; the merged knowledge equals training
on all of it). Inputs: op, source/carry paths, output path. Returns digests
and counts; a tampered carry is refused. Cost: one job per operation.

Input parameters:

- `op` (string, required)
- `params`

### `singularis_knowledge_packs` (~122 tokens)

Knowledge packs that travel and return exactly

Send a working knowledge pack to another machine and bring its
results home exactly. Operations: create (from a tower file), drop (install
a pack on a node), wake (open it with 2-of-3 shares; one share alone is
refused), work (run ticks on the node), return (bring the state home; the
homecoming is exact, difference zero). Inputs: op and the paths the op
needs. Cost: one job per operation.

Input parameters:

- `op` (string, required)
- `params`

### `singularis_free_universe` (~98 tokens)

Universe relay with an exact homecoming

Run a self-contained universe relay in a working directory: a sealed
packet is born, hops between nodes, learns, and comes home -- the homecoming
state is verified exact against the origin, and a tampered packet is
refused. Inputs: work_dir; optional key. Returns the relay report (births,
hops, per-hop errors, homecoming difference). Cost: one job.

Input parameters:

- `params`

### `singularis_compute_in_transit` (~116 tokens)

Compute on a sealed tower in transit

Compute on a sealed tower while it travels. Operations:
fuse_in_transit (merge knowledge inside the sealed tower), twist_in_transit
(transform it into a new sealed tower), energy_audit (report its portal
energy). The tower's seal is verified before anything runs; a broken seal
is refused and nothing is charged. Inputs: op, tower_in path, tower_out for
twist, ridge. Cost: one job per operation.

Input parameters:

- `op` (string, required)
- `params`

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-getsingularis-singularis/singularis-mcp#diagnostics

## Score history

- 2026-11-04: 67
- 2026-11-03: 51
- 2026-11-02: 51
- 2026-11-01: 65
- 2026-10-31: 50
- 2026-10-30: 50
- 2026-10-29: 64
- 2026-10-28: 54
- 2026-10-27: 68
- 2026-10-26: 68
- 2026-10-25: 67
- 2026-10-24: 67
- 2026-10-23: 66
- 2026-10-22: 66
- 2026-10-21: 66
- 2026-10-20: 65
- 2026-10-19: 65
- 2026-10-18: 49
- 2026-10-17: 64
- 2026-10-16: 63
- 2026-10-15: 43

## Common questions

### What is the com.getsingularis/singularis MCP server?

com.getsingularis/singularis is an MCP server listed in the public MCP registry as com.getsingularis/singularis. Unlimited computation for agents. Results depend on your equipment; GPU optional. This page covers its PyPI package (singularis-mcp).

### Is the com.getsingularis/singularis MCP server safe to use?

com.getsingularis/singularis scores 67 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 4 November 2026. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the com.getsingularis/singularis MCP server expose?

com.getsingularis/singularis exposes 19 tools: singularis_register_key, singularis_balance, singularis_recipes, singularis_share_results, singularis_solve_heat, and 14 more. Their descriptions and schemas cost roughly 2,400 tokens of context every time the server is loaded.

### Is the com.getsingularis/singularis MCP server still maintained?

com.getsingularis/singularis is still listed as active in the MCP registry. We last reached this channel on 4 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- PyPI project: https://pypi.org/project/singularis-mcp/
- Socket report: https://socket.dev/pypi/package/singularis-mcp
- Website: https://getsingularis.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-getsingularis-singularis/singularis-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-getsingularis-singularis/singularis-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-getsingularis-singularis/singularis-mcp