intura-ai

Run the Intura AI models you own on your own CPU.

Intura makes lightweight fine-tuned models for specific tasks, like routing a customer-support ticket to the right team or tagging what a social post is asking for. You buy a model once, which gets you every version of it. This package downloads the model and runs it in your process. After the download there is no network call, no per-request price, and your text never leaves your machine.

from intura_ai import Intura

model = Intura().models.load("chat-customer-support-ticket-en")
model.predict("I was charged twice, please refund me")
# {'labels': ['billing_payment', 'refund_return'],
#  'scores': {'billing_payment': 0.6956, 'refund_return': 0.8482, ...}}

Install

pip install intura-ai
# or
uv add intura-ai

Python 3.10–3.13. This installs everything a prediction needs: onnxruntime (CPU), tokenizers, numpy and httpx for the download. The old local extra still resolves, so pip install "intura-ai[local]" keeps working, but it adds nothing.

Get a download key

Get a model from https://ai.intura.co/models, then create a download key on your account page. Give it to the client as an argument, or in INTURA_API_KEY:

export INTURA_API_KEY=sk_...

from intura_ai import Intura

client = Intura()                  # reads INTURA_API_KEY
client = Intura(api_key="sk_...")  # or pass it explicitly

The key is only used to download. Intura() works without one, and so does loading a model that is already downloaded. The first call that needs the API raises MissingAPIKey and tells you where to get a key.

Load a model, then predict

model = client.models.load("chat-customer-support-ticket-id")

model.predict("kak, saya sudah bayar tapi pesanan belum dikirim")
# {'labels': ['order_delivery'], 'scores': {'billing_payment': 0.0056, 'order_delivery': 0.9932, ...}}

[r["labels"] for r in model.predict_batch(["tidak bisa login, kode OTP tidak masuk", "terima kasih kak"])]
# [['account_access'], []]

On first use, load downloads the model into a local cache. After that it loads from disk in well under a second. Load once per process and keep the model. A loaded model holds no connection and no key, and you can share it across threads.

predict_batch(texts) gives the same result as [model.predict(t) for t in texts], in the same order. It runs one text per forward pass on purpose. The published models are INT8 graphs with dynamic quantization, which scales each activation tensor by its own range. A padded batch is one tensor, so batching would shift every item's logits, sometimes by more than a whole logit, and that can flip a decision near a cut. For throughput, call predict_batch from several threads (onnxruntime releases the GIL while it computes).

You can find each model's slug in client.library.list(), on its page on the website, or by running intura-ai library.

What predict returns

Each model carries its own decision rule and cut-offs in its serving.json. predict applies them, so a new version that moves a threshold gives the right answer as soon as it is downloaded. These are the same five rules as the plain-Python script on each model page:

The rule comes from the model's own files, never from its name, so a model released after your version of this package still works. A decision name the package has never seen is read from the keys the model carries instead (positive_label, risk_labels, otherwise the top class).

Scores are rounded to four decimals. To apply a rule of your own, such as a stricter cut for one label, model.scores(text) gives every label's unrounded probability with no cut applied. model.labels, model.serving (the whole serving.json), model.task and model.version are there too.

posts = client.models.load("chat-threads-post-intent-id")
posts.predict("kecewa banget, paket udah seminggu belum sampai")["labels"]
# ['complaint', 'review_experience']

scores = posts.scores("rekomendasi sunscreen buat kulit berminyak dong")
[label for label, p in scores.items() if p >= 0.9]
# ['ask_recommendation']

Versions and the cache

Buying a model gets you every version of it. load decides which one to use like this:

So once a model is cached, load(slug) works offline and without a key. Nothing updates behind your back. Run with refresh=True (or intura-ai predict --refresh) when you want the latest. Older versions stay in the cache, so you can pin back to one with version=.

The cache is laid out <cache>/<slug>/<version>/. Its location is the first of these that is set:

1. load(..., cache_dir="./models")
2. $INTURA_CACHE_DIR
3. $XDG_CACHE_HOME/intura
4. ~/.cache/intura

A partly downloaded model is never mistaken for a complete one. Every download goes into a hidden staging folder next to its destination. That folder is renamed to <version>/ only after every file has arrived at the size the bucket reports. If a download is interrupted (dropped connection, Ctrl-C, full disk), no version folder is left behind, and the next load starts again. To free space, delete a version folder, or the whole cache.

To put a model in a folder of your own choosing, for example in a container image or on a machine with no internet access, use download, then load that folder:

from intura_ai import LocalModel

path = client.models.download("chat-customer-support-ticket-id", "./models", version="v1.0")
# ./models/chat-customer-support-ticket-id/v1.0/
model = LocalModel.load(path)

download is atomic in the same way. It keeps a complete bundle that is already there, unless you pass overwrite=True. client.models.links(slug) returns the signed URLs without downloading anything, if you want to use your own downloader.

The download key only signs the links. It authenticates one call to POST /v1/platform/downloads/models/{slug}/download, which answers with GET URLs on Cloud Storage that are valid for 15 minutes. The files come straight from Cloud Storage, and the key is never sent there. If a link expires partway through a download, it is re-signed once.

Your library

for item in client.library.list():
    print(item.code, item.kind, item.current_version, item.versions)
# chat-customer-support-ticket-id  model     v1.0  ('v1.0',)
# template-support-reply       template  None        ()

This is the same list as the library page on the website: models, templates, courses and apps. For a model, code is the slug you pass to load, and versions lists every build you can pin. Everything the service sent is also on item.data. client.models.list() lists the downloadable models, with the recommended version of each.

Async

from intura_ai import AsyncIntura

async with AsyncIntura() as client:
    model = await client.models.load("chat-customer-support-ticket-id")

model.predict("ongkirnya berapa?")

Only the API calls and the download are awaited. Reading the model from disk happens once and is synchronous, and predict is the same CPU-bound LocalModel method as in the sync client. Inside an event loop, run a large batch with await asyncio.to_thread(model.predict_batch, texts).

CLI

$ export INTURA_API_KEY=sk_...
$ intura-ai library                                   # what your account owns
$ intura-ai predict chat-customer-support-ticket-en "I was charged twice, please refund me"
$ intura-ai predict chat-customer-support-ticket-id "paket belum sampai" "mau refund" --field labels
$ cat posts.txt | intura-ai predict chat-threads-post-intent-id --field labels
$ intura-ai predict ./models/chat-customer-support-ticket-id/v1.0 "..."  # a downloaded folder
$ intura-ai predict chat-threads-post-intent-id "..." --refresh          # fetch the newest
$ intura-ai download chat-customer-support-ticket-id --dir ./models --version v1.0
$ intura-ai models                                    # what you may download

predict loads the model the same way client.models.load does, so the first run downloads it and later runs work offline. With one text, it prints the result as JSON. With several texts, given as arguments or one per line on stdin, it prints one compact JSON value per line. --field labels (or label, decision, 0.type, ...) prints a single value instead. Errors exit non-zero with one line on stderr.

Errors

Everything this package raises descends from InturaError. Once a model is loaded, predict raises nothing from this list, because it runs in your process.

LocalModel.load raises FileNotFoundError for a folder that isn't a downloaded model.

Configuration

For a proxy or a custom transport, bring your own httpx client. The package sets the URL and headers on each request, and never closes a client it did not open:

client = Intura(http_client=httpx.Client(proxy="http://proxy:3128"))

Upgrading from 2.x

3.0 is only "download a model you own and run it". The hosted endpoints are removed, along with their result types:

client.models.list(), links(), download(), client.library.list() and LocalModel.load(path).predict(text) work as they did in 2.2. Pin intura-ai<3 if you still need the 2.x client while you move.

Links

• Models: https://ai.intura.co/models
• Account and download keys: https://ai.intura.co/account
• Issues: https://github.com/intura-co/intura-ai/issues

Help

• Help center: https://ai.intura.co/help
• Discord community: https://discord.gg/mztkZSmJuF
• Email: hello@intura.co

MIT licensed.