FHEnom for AI™ — Python SDK and CLI

fhenomai is the official client for FHEnom for AI™ by DataKrypto. It lets you encrypt AI models, serve them from a Trusted Execution Environment (TEE), and run inference on them, from the command line or from Python.

Requirements

• Python 3.8 or newer
• Access to a FHEnom for AI node: TEE 1.9.3+ and FHEnom AI Server 1.5.3+ (these are minimums; newer nodes work). fhenomai health live checks your node.

Installation

pip install fhenomai
fhenomai --version

Configuration

Run the setup wizard and answer the prompts (node address, admin token, SFTP credentials, inference server):

fhenomai config init

This writes ~/.fhenomai/config.yaml. Keep that file private: it holds your admin token. Then check the settings and the connection:

fhenomai config show
fhenomai test connection

admin:
  host: "tee.example.com"
  port: 9099
  auth_token: "your-admin-token"

user:                     # inference endpoint
  host: "tee.example.com"
  port: 9999

sftp:
  host: "tee.example.com"
  port: 22
  username: "your-sftp-user"
  key_path: "~/.ssh/fhenom_sftp"   # or: password: "..."

Quick start

To encrypt and serve a Hugging Face model (in .safetensors format):

# 1. Upload the plaintext model to the node
fhenomai sftp upload ./my-model my-model --recursive

# 2. Encrypt it inside the TEE
fhenomai model encrypt my-model --wait

# 3. Copy the encrypted model to the GPU server
fhenomai model transfer my-model-encrypted

# 4. Serve it (starts the serving framework and registers it with the TEE)
fhenomai model serve my-model-encrypted

# 5. Send it a prompt
fhenomai test chat "What is the capital of France?"

To stop serving the model, run fhenomai model stop my-model-encrypted.

model serve starts the first framework in server.engines (vLLM by default). Install SGLang on the GPU server and list it with fhenomai config init --server-engine vllm --server-engine sglang, then pick it with fhenomai model serve my-model-encrypted --engine sglang.

If you run the serving framework yourself, register it with the TEE directly:

fhenomai serve start my-model-encrypted \
  --server-url http://GPU_HOST:8000 \
  --display-model-name my-model-encrypted

Encryption options

Inference

The node exposes an OpenAI-compatible API, so any OpenAI client works:

from openai import OpenAI

client = OpenAI(base_url="http://tee.example.com:9999/v1", api_key="unused")

response = client.chat.completions.create(
    model="my-model-encrypted",
    messages=[{"role": "user", "content": "Explain confidential computing."}],
    max_tokens=200,
)
print(response.choices[0].message.content)

Python SDK

from fhenomai import FHEnomClient, FHEnomConfig

client = FHEnomClient(FHEnomConfig.from_file())   # reads ~/.fhenomai/config.yaml

# Upload, encrypt, wait
client.upload_model("./my-model", "my-model")
job_id = client.admin.encrypt_model("my-model", "my-model-encrypted")
job = client.admin.wait_for_job(job_id, timeout=3600)
model_id = job["result"]["encrypted_model_id"]

# Serve through your vLLM server
client.admin.start_serving(
    encrypted_model_id=model_id,
    server_url="http://GPU_HOST:8000",
    display_model_name="my-model-encrypted",
)

FHEnomConfig.from_env() builds the configuration from environment variables instead of a file.

Verify the endpoint

Before you send it a prompt, check that the inference endpoint is running in a genuine TEE. This check needs no admin token:

fhenomai attest        # exits 0 only if verification succeeds

from fhenomai.inference_attestation import verify_endpoint

result = verify_endpoint("tee.example.com", 9999)
if not result.verified:
    raise SystemExit(result.error)

Node operators can also generate and verify a full attestation report with fhenomai admin attestation and fhenomai admin verify-attestation.

Optional features

Encrypted prompts and responses (thick client)

By default, prompts and responses travel in plaintext. In thick-client mode, each client has its own key, and the node refuses any prompt that is not encrypted with it.

fhenomai model serve my-model-encrypted --thick-client
fhenomai thick-client add my-model-encrypted --label my-app --save my-app.json
fhenomai test chat "Hello" --thick-key-file my-app.json

The node shows each key only once, so store it when you create it. A thick-client model refuses every request until you have added at least one client. In Python, use ThickClientSession.

Sovereign split inference

Split inference keeps part of the model inside the TEE and runs the rest on your own GPU server, in the datakrypto-vllm image. The TEE connects to that server's inference port (50052).

fhenomai model split my-model --first-layers 2 --last-layers 2
fhenomai model transfer my-model --restart
fhenomai model serve my-model --sovereign-host GPU_SERVER_ADDRESS_SEEN_FROM_THE_TEE

The TEE and the sovereign server must use the same dtype and the same max_model_len. model serve starts both with the same values: --dtype (default: the model's own dtype, float16 on a GPU without bfloat16 support) and --max-model-len (default 4096). If you run the sovereign server yourself, pass the same explicit values it was started with:

fhenomai serve start my-model --sovereign-server-host HOST \
  --sovereign-max-model-len 4096 --sovereign-dtype float16

fhenomai serve list shows the values the TEE uses. Thick-client mode (--thick-client) works with sovereign serving too.

Administration

For security, always provision with --admin-token and --rotation-token. Without them provision asks for confirmation, and fhenomai health check warns about the node.

Command reference

Add --help to any command to see its options.

If a command fails, the CLI exits with a non-zero status, so you can safely chain commands in scripts (fhenomai … && next-step).

Support

• Website: datakrypto.ai
• Email: support@datakrypto.ai

License

MIT License. Copyright (c) 2024-2026 DataKrypto. See the LICENSE file for details.