Lattica Studio

Build, deploy, and serve fully homomorphic encryption (FHE) models on the Lattica platform, from a PyTorch-style pipeline definition to an encrypted inference endpoint.

Your data is encrypted before it leaves the client and stays encrypted throughout inference. The server computes on ciphertext and never sees the plaintext input, the plaintext output, or your secret key.

Inference runs on cloud-hosted GPU accelerators, which can significantly reduce latency versus many CPU-only FHE setups. You also avoid managing custom CUDA kernel compilation yourself.

This repository contains three Python packages:

Package	Role
lattica-build	Define a homomorphic computation graph, bind weights, plan FHE parameters, and emit a deployable artifact. Runs entirely locally.
lattica-studio	Deploy and compile that artifact on the platform, then manage models, workers, and query tokens.
lattica-query	Generate keys, encrypt inputs, execute encrypted queries, and decrypt results locally.

Both require Python 3.11+.

How it fits together

       ┌─────────────────────────┐
       │      lattica-build      │   define pipeline + FHE params
       │        (local)          │   →  artifact.zip
       └────────────┬────────────┘
                    │
                    ▼
       ┌─────────────────────────┐
       │     lattica-studio      │   deploy → compile → start GPU worker
       │   (control plane API)   │   →  model_id, query token
       └────────────┬────────────┘
                    │
                    ▼
       ┌─────────────────────────┐
       │      lattica-query      │   keygen, encrypt, query, decrypt
       │  (client, holds the SK) │   →  plaintext result
       └─────────────────────────┘

The secret key never leaves the client. Only the evaluation key and ciphertexts are sent to the server.

Installation

pip install lattica-studio

This pulls in lattica-build (pipeline construction) and lattica-query (client-side encryption and querying) as dependencies.

To work from a checkout of this repository:

pip install -e ./lattica_build_src
pip install -e ./lattica_query_src
pip install -e ./lattica_studio_src

Quickstart

1. Build an artifact locally

No account needed for this step. Build the packaged MNIST example:

lattica-build --pipeline-module lattica_build.examples.advanced.mnist_fc --out mnist.zip

On success the command writes mnist.zip and prints a JSON summary listing hom_pipeline.json and hom_pipeline.safetensors.

Add --print_graph to inspect the computation graph, or point at your own file:

lattica-build my_pipeline.py --out my_pipeline.zip

Any pipeline module or file just needs to expose two callables:

def build_pipeline() -> HomomorphicPipeline: ...
def build_params() -> HomParams: ...

2. Deploy, serve, and query

The remaining steps need a Lattica account license key. Set it once:

export LATTICA_LICENSE_KEY="..."

import os

import torch

from lattica_build import build
from lattica_build.examples.advanced import mnist_fc
from lattica_query import QueryClient
from lattica_studio import LatticaStudio

x = torch.zeros(mnist_fc.INPUT_SHAPE)

# Build locally, then deploy and compile on the platform.
mnist = mnist_fc.Pipeline()
artifact = build(
    mnist.build_pipeline(),
    mnist.build_params(),
    "mnist.zip",
)
with LatticaStudio(os.environ["LATTICA_LICENSE_KEY"]) as studio:
    model_id = studio.deploy(artifact, "my-mnist-model")

    # A GPU worker must be running to serve encrypted queries.
    with studio.workers.running(model_id, stop_on_exit=True):
        token = studio.tokens.create(model_id, name="my-mnist-model", save=True)

        with QueryClient(token) as client:
            # Generates FHE keys and uploads the evaluation key.
            # The secret key never leaves this machine.
            sk = client.keys.ensure()

            # x is a plain torch tensor shaped like the pipeline's input.
            result = client.query.encrypted(x, key=sk)
            print(result.argmax(dim=-1))

studio.deploy_pipeline(...) combines the build and deploy steps if you don't need the artifact on disk:

model_id = studio.deploy_pipeline(
    mnist.build_pipeline(),
    mnist.build_params(),
    "my-mnist-model",
)

Deploying under a name that already exists redeploys into that model rather than creating a duplicate. Active workers are stopped and the model is recompiled.

A complete, runnable version of the flow above lives in lattica_studio_src/lattica_studio/example.py.

Display tables quickly

If you just want to inspect resources in a printable table, use the helper script:

cd lattica_studio_src
python -m lattica_studio.list_and_display models
python -m lattica_studio.list_and_display workers
python -m lattica_studio.list_and_display tokens
python -m lattica_studio.list_and_display all

It uses LATTICA_LICENSE_KEY by default (or pass --license-key ...).

Working efficiently

Worker runtime is billed while a worker is up, so keep workers running only as long as you are actually serving queries. The studio.workers.running(model_id, stop_on_exit=True) context manager stops the worker on exit, including when the block raises.

Two things to keep in mind while iterating:

• Changing the pipeline architecture invalidates the key context. Redeploy, then create a fresh token and regenerate keys before querying again.
• Reuse a compiled model across sessions. Deployment and key setup only need to happen when the pipeline changes. To query an existing model, look it up by name with studio.models.get_id_by_name(...) and reuse a saved token with studio.tokens.load(...).

This is the beginning of the README. Read the rest at the original. Read the full README ↗