SDK Quickstart

Real-time speech enhancement with Quail and Rook on the ai-coustics SDK.

This tutorial will get you started using our SDK with your preferred language bindings.

1. Get an SDK License

   Self-service SDK Keys can be generated on the developer portal.

   These keys are configured to authorize with our backend and collect telemetry.

   To use the SDK without telemetry, please contact us directly to obtain a special offline license that operates without any online authentication.

2. Select a Model

   Models can be either downloaded by the SDK using a model ID (e.g. quail-l-8khz) or manually at artifacts.ai-coustics.io.

3. Pick your language

   Python

   Installation

   Add our SDK to your Python application with native NumPy support.

   Install with uv:

   uv add aic-sdk
   

   Or with pip:

   pip install aic-sdk
   

   Quickstart

   Run with uv:

   uv run quickstart.py
   

   # /// script
   # requires-python = ">=3.10,<3.14"
   # dependencies = [
   #   "aic-sdk",
   #   "numpy"
   # ]
   # ///
   
   # quickstart.py
   
   import aic_sdk as aic
   import numpy as np
   import os
   
   # Get your license key from the environment variable
   license_key = os.environ["AIC_SDK_LICENSE"]
   
   # Download and load a model (or download manually at https://artifacts.ai-coustics.io/)
   model_path = aic.Model.download("quail-vf-2.0-l-16khz", "./models")
   model = aic.Model.from_file(model_path)
   
   # Get optimal configuration
   config = aic.ProcessorConfig.optimal(model, num_channels=2)
   
   # Create and initialize processor in one step
   processor = aic.Processor(model, license_key, config)
   
   # Process audio (2D NumPy array: channels × frames)
   audio_buffer = np.zeros((config.num_channels, config.num_frames), dtype=np.float32)
   processed = processor.process(audio_buffer)
   

   For more examples and documentation, see the Python SDK repository.

   Node.js

   Installation

   Integrate our SDK into your Node.js application with our native bindings.

   npm install @ai-coustics/aic-sdk
   

   Quickstart

   const { Model, Processor } = require("@ai-coustics/aic-sdk");
   
   // Get your license key from the environment variable
   const licenseKey = process.env.AIC_SDK_LICENSE;
   
   // Download and load a model (or download manually at https://artifacts.ai-coustics.io/)
   const modelPath = Model.download("quail-vf-2.0-l-16khz", "./models");
   const model = Model.fromFile(modelPath);
   
   // Get optimal configuration
   const sampleRate = model.getOptimalSampleRate();
   const numFrames = model.getOptimalNumFrames(sampleRate);
   const numChannels = 2;
   
   // Create and initialize processor
   const processor = new Processor(model, licenseKey);
   processor.initialize(sampleRate, numChannels, numFrames, false);
   
   // Process audio (Float32Array, interleaved: [L0, R0, L1, R1, ...])
   const audioBuffer = new Float32Array(numChannels * numFrames);
   processor.processInterleaved(audioBuffer);
   

   For more examples and documentation, see the Node.js SDK repository.

   Rust

   Installation

   Add to your project:

   cargo add aic-sdk --features "download-lib"
   

   Quickstart

   use aic_sdk::{include_model, ProcessorConfig, Model, Processor};
   
   // Embed model at compile time (or use Model::from_file to load at runtime)
   static MODEL: &'static [u8] = include_model!("/path/to/model.aicmodel");
   
   fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Get your license key from the environment variable
       let license_key = std::env::var("AIC_SDK_LICENSE")?;
   
       // Load the embedded model (or download manually at https://artifacts.ai-coustics.io/)
       let model = Model::from_buffer(MODEL)?;
   
       // Get optimal configuration based on the selected model
       let config = ProcessorConfig::optimal(&model).with_num_channels(2);
   
       // Create a processor and initialize in one step
       let mut processor = Processor::new(&model, &license_key)?.with_config(config)?;
   
       // Process audio (interleaved: channels × frames)
       let mut audio_buffer = vec![0.0f32; config.num_channels as usize * config.num_frames];
       processor.process_interleaved(&mut audio_buffer)?;
   
       Ok(())
   }
   

   For more examples and documentation, see the Rust SDK repository.

   C++

   Installation

   The easiest way to integrate the SDK into your C++ project is using CMake FetchContent. This will automatically download the source code and libraries, then link them to your project.

   include(FetchContent)
   
   set(AIC_SDK_ALLOW_DOWNLOAD ON CACHE BOOL "Allow C SDK download at configure time")
   
   FetchContent_Declare(
       aic_sdk
       GIT_REPOSITORY https://github.com/ai-coustics/aic-sdk-cpp.git
       GIT_TAG        0.15.0
   )
   FetchContent_MakeAvailable(aic_sdk)
   
   target_link_libraries(my_app PRIVATE aic-sdk)
   

   Quickstart

   #include "aic.hpp"
   
   #include <vector>
   #include <cstdlib>
   
   int main() {
       // Get your license key from the environment variable
       const char* license_key = std::getenv("AIC_SDK_LICENSE");
   
       // Load a model from file (download models at https://artifacts.ai-coustics.io/)
       auto model = aic::Model::create_from_file("./models/model.aicmodel").take();
   
       // Create configuration with model's optimal settings
       auto sample_rate = model.get_optimal_sample_rate();
       auto num_frames = model.get_optimal_num_frames(sample_rate);
       aic::ProcessorConfig config(sample_rate, num_frames, 2);  // 2 channels (stereo)
   
       // Create and initialize processor
       auto processor = aic::Processor::create(model, license_key).take();
       processor.initialize(config.sample_rate, config.num_channels, config.num_frames,
                            config.allow_variable_frames);
   
       // Process audio (planar layout: separate buffer per channel)
       std::vector<float> left(config.num_frames, 0.0f);
       std::vector<float> right(config.num_frames, 0.0f);
       std::vector<float*> audio = {left.data(), right.data()};
       processor.process_planar(audio.data(), config.num_channels, config.num_frames);
   
       return 0;
   }
   

   For more examples and documentation, see the C++ SDK repository.

   C

   Installation

   Download the SDK binaries from the releases page. We provide:

   • Static libraries (.a, .lib) for linking directly into your application
   • Dynamic libraries (.so, .dll, .dylib) for runtime loading
   • Multiple platforms: Linux, Windows, macOS
   • Multiple architectures: x86_64, ARM64

   Quickstart

   #include <stdlib.h>
   #include "aic.h"
   
   int main() {
       // Get your license key from the environment variable
       const char* license_key = getenv("AIC_SDK_LICENSE");
   
       // Download and load a model (or download manually at https://artifacts.ai-coustics.io/)
       struct AicModel* model = NULL;
       aic_model_create_from_file(&model, "path/to/model.aicmodel");
   
       // Create processor with license key
       struct AicProcessor* processor = NULL;
       aic_processor_create(&processor, model, license_key);
   
       // Get optimal configuration
       uint32_t sample_rate;
       size_t num_frames;
       aic_model_get_optimal_sample_rate(model, &sample_rate);
       aic_model_get_optimal_num_frames(model, sample_rate, &num_frames);
   
       // Initialize processor with optimal settings
       aic_processor_initialize(processor, sample_rate, 2, num_frames, false);
   
       // Process audio (planar layout: separate buffers per channel)
       float* audio_left = (float*) calloc(num_frames, sizeof(float));
       float* audio_right = (float*) calloc(num_frames, sizeof(float));
       float* audio_planar[2] = {audio_left, audio_right};
       aic_processor_process_planar(processor, audio_planar, 2, num_frames);
   
       // Cleanup
       free(audio_left);
       free(audio_right);
       aic_processor_destroy(processor);
       aic_model_destroy(model);
       return 0;
   }
   

   For more examples and documentation, see the C SDK repository.

4. Find out more

   Models Overview

   Explore the different SDK and API models available and their use cases.

   All SDK Language Bindings

   Discover all available SDK bindings for various programming languages.

   AirTen Runtime

   Our Rust-based, no_std, ultra-fast runtime embedded in the SDK.

   Performance

   Learn more about the SDK’s runtime performance.

   SDK Playground

   Test different models in our developer portal.

   Hugging Face Demo

   Try VoiceFocus without an account on HuggingFace.