One SDK. Every reasoning engine. Three languages.
Polyglot SDK for 16+ LLM providers, CLIPS rule engines, and Bayesian networks in Community Edition, plus Pro solver, ZEN decision-table, plugin-loading, and trust-policy capabilities — Rust, Go, and Python SDKs plus nxuskit-cli for shell automation and CI.
Current Rust minimum: 1.94 for source builds and Rust SDK consumers. Earlier
compilers are no longer supported. Historical package/test records retain their
actual compiler identities; this declaration does not rebuild or requalify them.
Documentation · Getting Started · Examples Docs · Examples Repo · Website
v2.0.0 rollout: Community Edition works without an SDK license. New Pro purchases are paused; v2.0.0 Launch Party Pricing details will follow.
Download and verify the v2.0.0 SDK archive for Linux x86_64, macOS ARM64, or Windows x86_64. The same bundle runs CE without a token and requires a valid paid entitlement for Pro Solver. Follow the installation guide and try the local first call. Upgrading from v1.0.5? See the migration guide.
Use the language bindings that match your SDK version:
| Language | Package | Install |
|---|---|---|
| Rust | nxuskit | Path dependency from SDK bundle |
| Go | nxuskit-go | Use the matching bundle or source binding |
| Python | nxuskit-py | Use the matching bundle or source binding |
| C ABI | Native library and headers | Use the matching bundle or build CE from source |
The public repository is intended to be buildable as Community Edition source without internal nxusKit infrastructure:
git clone https://github.com/nxus-SYSTEMS/nxusKit.git
cd nxusKit
make build
make qamake build compiles the CE native library, checks the Rust wrapper, builds the
Go SDK, and byte-compiles the Python package. make qa adds the source-build
QA checks that are safe for a fresh public checkout.
nxusKit includes nxuskit-cli, a JSON-first control plane for shell automation, CI, and multi-engine reasoning workflows. The CLI provides machine-facing access to all nxusKit engines — no library code required.
# LLM invocation with structured output
echo '{"prompt":"hello","provider":"claude","model":"claude-sonnet-4-20250514"}' \
| nxuskit-cli call --input - --format json
# Constraint solving (Pro; implementation not shipped in public CE)
nxuskit-cli solver solve --input problem.json --format json
# What-if analysis with base vs. assumed comparison (Pro)
nxuskit-cli solver what-if --input base.json --compare assumed.json --format json
# ZEN decision-table utilities (Pro, v0.9.4): structural validation + fixture testing
nxuskit-cli zen validate --input my_table.jdm.json --format json
nxuskit-cli zen test --input fixtures.json --format json
# Bayesian network parameter learning + evidence validation (v0.9.4)
nxuskit-cli bn learn --input bn_learn.json --format json # learn CPDs from CSV; output is BIF-exportable
nxuskit-cli bn evidence --input observations.json --format json
# List available providers
nxuskit-cli provider list --format json
# CLIPS session management
nxuskit-cli clips session create --input rules.json --format json
nxuskit-cli clips session list --format json
# Multi-engine pipeline
nxuskit-cli pipeline run --input workflow.yaml --format json
# Shell completions (bash / zsh / fish)
nxuskit-cli completions bash >> ~/.bashrc
nxuskit-cli completions zsh > ~/.zfunc/_nxuskit-cli
nxuskit-cli completions fish > ~/.config/fish/completions/nxuskit-cli.fishThe CLI is bundled in the SDK release archive. See the CLI Input Format Reference for all commands and input schemas.
Looking for runnable examples? Start with the nxusKit examples documentation or open the nxusKit Examples repository — 30+ examples across Rust, Go, Python, and CLI/Bash covering streaming, vision, tool calling, CLIPS rules, constraint solving, and more. Each example is labeled by edition so developers can see what works with Community Edition and what requires Pro before they run it.
Stream a response from any provider with three lines of code:
Python
import nxuskit
provider = nxuskit.Provider.openai() # or .claude(), .ollama(), .xai(), .groq(), ...
for chunk in provider.chat_stream([nxuskit.Message.user("Tell me a story")]):
print(chunk.delta, end="", flush=True)Go
resp, _ := nxuskit.Completion(ctx, "gpt-4o", "Tell me a story")
fmt.Println(resp.Content)Rust
let request = ChatRequest::new("gpt-4o").with_message(Message::user("Tell me a story"));
for chunk in provider.chat_stream(request)? {
print!("{}", chunk.delta);
}First-class logprobs / top_logprobs request and typed response across
Rust, Python, and the C ABI. Engine warn-and-drops on unsupported
providers (no silent tunneling through provider_options). Streaming
logprobs (StreamChunk.logprobs) shipped in v0.9.4 - see
logprobs-migration.md.
Rust
let request = ChatRequest::new("gpt-5.4")
.with_message(Message::user("Score the next token."))
.with_logprobs(true)
.with_top_logprobs(5);
let response = provider.chat(request)?;
if let Some(lp) = response.logprobs {
let token = &lp.content[0];
println!("{} (logprob {})", token.token, token.logprob);
for alt in &token.top_logprobs {
println!(" alt: {} ({})", alt.token, alt.logprob);
}
}Python
from nxuskit import ChatRequest
req = ChatRequest(
model="gpt-5.4",
messages=[{"role": "user", "content": "Score the next token."}],
logprobs=True,
top_logprobs=5,
)
# Response logprobs decode into typed LogprobsData / TokenLogprob / TopLogprobRelease builds default to https://nxus.systems/licensing-api/v1 with
the embedded ES256 production key (kid: es256-v1). Activation is
offline-first after the first refresh.
# One-time device-auth login
nxuskit-cli license login
# Activate a real-purchase or leased token
nxuskit-cli license activate --key <purchase-id> --accept-eula --json
# Inspect the current license + endpoint diagnostics
nxuskit-cli license status --jsonSee sdk-packaging/docs/license-activation-guide.md
for the full activation flow and offline-first behavior.
nxusKit SDK uses a dual-edition model.
The public nxusKit repository contains nxusKit SDK Community Edition, which is free and open source. CE is not a trial, teaser, or time-limited evaluation; it is intended to remain useful on its own. We do not move released CE features behind the Pro paywall, and code released as CE remains available under its open-source license.
Community Edition is useful on its own without Pro. The public nxusKit-examples repository labels examples by edition, so developers can see which workflows run with CE alone and which require Pro.
The binary SDK bundles also contain proprietary Pro capabilities. Download access does not grant a Pro entitlement. Solver is the initial supported Pro capability; other compiled capabilities are not launch support promises.
- 16+ LLM Providers (CE) — Claude, OpenAI, Ollama, xAI Grok, Groq, Mistral, Fireworks, Together, OpenRouter, Perplexity, LM Studio, and more
- Per-Request Model Override (CE) — Switch models on any
chat()call without creating new provider instances - Streaming (CE) — First-class SSE and NDJSON streaming with
is_final()completion detection - Tool Calling (CE) — Function definitions, tool choice strategies, response deserialization across all providers
- Vision/Multimodal (CE) — Image inputs via URL, base64, or file path with auto-detected MIME types
- CLIPS Rule Engine (CE) — Session lifecycle, fact assertion, rule execution, and rule-backed validation
- Bayesian Networks (CE) — Structure learning, parameter estimation, inference with evidence
- Z3 Constraint Solver (Pro) — Variables, constraints, objectives, push/pop scoping, streaming solve
- ZEN Decision Tables (Pro) — JSON-in/JSON-out stateless evaluation
- Plugin Loading & Trust Policy (Pro) — Signed shared-library extensions with trust policy enforcement
- Model Discovery (CE) —
list_models()with vision detection, modality introspection, capability metadata - Retry & Rate Limiting (CE) — Configurable backoff, adaptive rate limiting, per-provider error handling
- Cross-Language Parity (CE + Pro where applicable) — Same types, same patterns, same field names (
delta,finish_reason) across Rust, Go, and Python
nxusKit is designed to sit between your application or automation layer and a set of LLM, symbolic, probabilistic, and Pro solver-backed engines.
flowchart TB
subgraph developer["Developer Surfaces"]
app["Your Application<br/>Rust / Go / Python / C ABI"]
automations["Your Automations<br/>CLI/Bash / Python"]
end
subgraph sdk["nxusKit SDK Interfaces"]
rust["nxuskit<br/>Rust wrapper"]
go["nxuskit-go<br/>Go SDK"]
py["nxuskit-py<br/>Python SDK"]
cli["nxuskit-cli<br/>JSON-first CLI"]
cabi["libnxuskit<br/>C ABI"]
end
core["nxuskit-core / nxuskit-engine<br/>provider adapters, native engines, entitlement gates"]
app --> rust
app --> go
app --> py
app --> cabi
automations --> cli
automations --> py
rust --> cabi
go --> cabi
py --> cabi
cli --> core
cabi --> core
core --> llm["LLM providers<br/>cloud + local (CE)"]
core --> clips["CLIPS rules<br/>(CE)"]
core --> bn["Bayesian networks<br/>(CE)"]
core --> solver["Z3 solver<br/>(Pro)"]
core --> zen["ZEN decision tables<br/>(Pro)"]
core --> plugins["Plugin loading<br/>trust policy (Pro)"]
Language SDKs provide idiomatic APIs, mock/loopback testing utilities, and FFI-backed access to native engines where needed. nxuskit-cli exposes the same engine family as JSON-first commands for scripts, CI, and shell pipelines. See ARCHITECTURE.md for developer integration patterns, including LLM routing recipes, audit loops, and creativity-engine designs.
The internal test suite spans Rust, Go, Python, CLI, C ABI, parity fixtures, conformance vectors, provider adapters, reasoning engines, entitlement behavior, and release smoke tests. The public repository will receive the portions of that coverage that can be released without exposing private implementation details, credentials, customer data, or proprietary Pro internals.
Initial public test releases will focus on Community Edition conformance vectors, mock/loopback provider tests, language parity fixtures, CLI JSON contract tests, and safe Pro boundary tests that assert edition behavior without leaking implementation IP. Those releases will begin as nxusKit approaches the end of public beta; the first visible tranche of public tests should be treated as a signal that beta is close to closing.
See TESTING.md for the testing philosophy, current internal coverage snapshot, release boundaries, and open questions for maintainers.
| Provider / Engine | Edition | Auth | Streaming | Vision | Purpose |
|---|---|---|---|---|---|
| Claude | CE | API Key | SSE | Yes | Chat/Completion |
| OpenAI | CE | Bearer | SSE | Yes | Chat/Completion |
| Ollama | CE | None | NDJSON | Yes | Local Inference |
| xAI Grok | CE | API Key | SSE | Yes | Chat/Completion |
| Groq | CE | API Key | SSE | No | Fast Inference |
| Mistral | CE | API Key | SSE | Yes | Chat/Completion |
| Fireworks | CE | API Key | SSE | Yes | Open-weight models |
| Together | CE | API Key | SSE | Yes | Open-weight models |
| OpenRouter | CE | API Key | SSE | Yes | Multi-provider routing |
| Perplexity | CE | API Key | SSE | No | Search-augmented |
| LM Studio | CE | Optional | SSE | Yes | Local Inference |
| CLIPS | CE | None | Custom | No | Expert Systems |
| Bayesian Net | CE | None | JSON | No | Probabilistic Inference |
| Z3 Solver | Pro | None | JSON | No | Constraint Solving |
| ZEN | Pro | None | N/A | No | Decision Tables |
The nxusKit examples documentation catalogs 30+ runnable examples, with source available in the nxusKit-examples repository:
| Category | Examples |
|---|---|
| Patterns | Streaming, retry, cost routing, token budgets, structured output |
| Vision | Image analysis, multimodal chat |
| Tool Calling | Function definitions, tool choice, agent loops |
| CLIPS | Rule loading, fact assertion, LLM+rules hybrid |
| Solver | Constraint satisfaction, what-if analysis (--compare), optimization (Pro) |
| Bayesian | Structure learning, inference, evidence propagation (CE) |
| ZEN | Decision table evaluation (Pro) |
Each example includes Rust, Go, and Python implementations.
nxusKit SDK is currently in public beta (v0.9.x). APIs are stabilized as of v0.9.4.
During beta, support is provided on a best-effort basis through GitHub Issues. We actively monitor and respond to issues, but we cannot guarantee response times or resolution timelines.
Before opening an issue, please:
- Search existing issues to avoid duplicates
- Include your SDK version, language (Rust/Go/Python), and OS
- Provide a minimal reproduction if possible
What to expect during beta:
- APIs are stabilized as of v0.9.4; bug fixes, provider behavior refinements, and additive features may still arrive between releases
- Breaking changes are still possible but not likely from now (v0.9.4) through GA, but will be documented in release notes if they occur
- Bug reports and feature requests are welcome and encouraged
- Community contributions (PRs, docs improvements) are appreciated
Post-GA support tiers will be available when the SDK reaches general availability. Details will be published at nxus.systems/support.
Built with gratitude for the open-source projects that make nxusKit possible. See ACKNOWLEDGEMENTS.md for a curated list of key projects.
nxusKit is dual-licensed under MIT and Apache 2.0. See LICENSE-MIT and LICENSE-APACHE.
Copyright 2025-2026 nxus.SYSTEMS LLC.