# Aura MCP [Health: Active]

**Category:** 🔑 Cryptography  
**Repository:** https://github.com/aurafhe-official/mcp  
**GitHub Stars:** 39  
**npm Downloads (last month):** 781  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/aurafhe-mcp

## Description
Connect assistants to Aura encrypted computation. Explore Aura AI and run public numeric demos.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "aura-mcp": {
    "command": "npx",
    "args": ["-y","@aurafhe/mcp"]
  }
}
```

## Documentation

## What Aura MCP does

The Aura MCP MCP server connects an MCP-compatible assistant to Aura's encrypted computation interface. Its current scope is numeric work with encrypted integers and floating-point values: addition, subtraction, multiplication, and division are supported. It also supports composed sums, products, floating-point averages, and weighted sums on the coprocessor.

This package is an adapter rather than the proprietary computation engine. It does not run Aura's AI model, start the separate Aura AI Chat experience, or expose SQL, retrieval, or model-inference tools. The AI Chat product is invitation-only and is accessed separately from this MCP package.

The project fits the Cryptography category because it provides an interface for exploring fully homomorphic encryption (FHE), where calculations can be performed on encrypted data. The public lesson uses sample values and is intended for learning; it should not be treated as a confidential deployment.

## How it works

An MCP client launches the package and presents its tools or prompts to an assistant. The assistant can use the `aura_demo` prompt to explain the available Aura experiences and MCP capabilities. The optional `aura_learn` prompt starts the public FHE lesson, while `aura_start` can begin an experience such as `learn`.

During the lesson, Aura prepares encrypted public samples, requests a calculation, and saves the encrypted result. One documented example combines 25 and 17, with 42 as the expected numerical result. Additional samples demonstrate an encrypted average using 7.5, 2.5, and 2. The MCP response contains encrypted data; a separate synthetic verifier checks the numerical outcome outside the conversation.

The tools can also help discover available operations, measure request latency, and save encrypted results. Connecting the package alone does not begin a chat or calculation. A status check or learning lesson is needed to check the service connection.

## Setup and configuration

Install Node.js 20 or newer, then install the preview package globally:

```sh
npm install -g @aurafhe/mcp@preview
aura-fhe-mcp --config cursor --demo
```

Replace `cursor` with `claude` or `vscode` when generating settings for those applications. Paste the generated configuration into the client and reconnect. The settings must be generated on the machine that will run the MCP process; paths created in a cloud workspace do not work on a local laptop.

The documented release is `0.5.0-rc.8`, explicitly marked as a preview. To pin that release, install `@aurafhe/mcp@0.5.0-rc.8`. Updating requires reinstalling, regenerating the client settings, and fully restarting the MCP client. The public demo does not require a Git installation, npm account, local computation engine, or demo-key setup.

## Tools and capabilities

The Aura MCP MCP server provides documented access to:

- Encrypted integer and floating-point arithmetic.
- Composed sums, products, averages, and weighted sums.
- Available-operation discovery.
- Request-latency measurement.
- Encrypted-result saving.
- The `aura_demo`, `aura_start`, and `aura_learn` interaction paths.

Use public or invented information when asking an assistant to map an application to the available operations. The adapter does not accept custom plaintext, secret keys, or arbitrary file paths as tool arguments.

## Limitations and notes

The public lesson uses demo keys managed by Aura, and Aura can decrypt the corresponding demo data. Confidential applications require a separate design for key custody, authorization, authenticated service access, and recipient-side processing. Anything entered into the host assistant remains visible to that assistant provider.

Binary-operation support is listed as a future milestone and is not required for the current numeric homomorphic computations. Operator-provisioned encrypted bundles require an authenticated compute-only deployment and are not part of Verified mode. Browser WASM integration is planned. The package also does not provide the proprietary computation engine itself, so production application integration requires additional Aura service arrangements.

_Full upstream README: https://allmcps.com/mcp/aurafhe-mcp/readme_