Hecttor logo
Hecttor SDK Docs
Hermes SDK

Getting Started

Hermes is the Hecttor Speech Enhancer SDK for human listening. For a conceptual tour of the three functionalities (Noise Cancellation, Speech Speed Adjustment, Voice Boost), see the Overview.

Installation

Hermes ships as a platform-specific package matching your SDK language and runtime.

# Install the wheel that matches your Python version and OS, e.g.:
pip install hecttor_sdk-3.0.1-cp311-cp311-macosx_arm64.whl
# Install the .tgz that matches your platform, e.g.:
npm install ./hecttor_sdk-2.0.0-linux-x64-node.tgz
<!-- Maven: add the per-platform fat JAR to your project -->
<dependency>
  <groupId>io.hecttor</groupId>
  <artifactId>hecttor-sdk</artifactId>
  <version>2.0.0</version>
  <scope>system</scope>
  <systemPath>${project.basedir}/lib/hecttor_sdk-2.0.0-macos.jar</systemPath>
</dependency>
# CMakeLists.txt: point CMAKE_PREFIX_PATH at the unpacked SDK and link
list(APPEND CMAKE_PREFIX_PATH "/path/to/hecttor-sdk/lib/cmake")
find_package(HecttorSDK REQUIRED)
target_link_libraries(your_app PRIVATE Hecttor::SDK)
# Add the NuGet package (per-platform RIDs are bundled inside the .nupkg)
dotnet add package Hecttor.SDK --version 2.0.0
// go.mod — point the module at the extracted Go SDK directory
require hecttor.ai/sdk v1.0.0
replace hecttor.ai/sdk => /path/to/extracted/go
# Then make the binding find the native libs at runtime
export HECTTOR_SDK_LIB_DIR=/path/to/extracted/native
go build .

The exact install artifact varies by SDK language, platform, and runtime version. Use the package matching your environment; your license email or onboarding contact has the right link.

Configure your SDK key

Store your SDK key in an environment variable rather than hardcoding it:

export HECTTOR_API_KEY="your_api_key_here"

Then read it from your application:

import os
api_key = os.environ["HECTTOR_API_KEY"]
const apiKey = process.env.HECTTOR_API_KEY;
String apiKey = System.getenv("HECTTOR_API_KEY");
#include <cstdlib>
const char* apiKey = std::getenv("HECTTOR_API_KEY");
string apiKey = Environment.GetEnvironmentVariable("HECTTOR_API_KEY");
import "os"

apiKey := os.Getenv("HECTTOR_API_KEY")

Never expose your SDK key in client-side code or commit it to version control.

Your first enhancement

The full integration: initialize Hermes once with all three functionalities (Noise Cancellation, Voice Boost, and Speech Speed Adjustment), then feed it audio chunks of the configured size.

import numpy as np
from hecttor_sdk import (
    HumanSpeechEnhancer,
    HumanSpeechEnhancerConfig,
    NoiseCancellationConfig,
    SpeedControlConfig,
)

config = HumanSpeechEnhancerConfig(
    api_key="your_api_key_here",
    chunk_size_ms=20,                # Required for speed control
    sample_rate=16000,               # Supported: 4000, 8000, 16000, 24000, 32000, 44100, 48000
    enable_voice_boost=True,
    noise_cancellation_config=NoiseCancellationConfig(
        model_name="your_model",     # "auris-1.0" or "coda-1.0"
        enhancer_weight=1.0          # 0.0 = original, 1.0 = fully enhanced (default)
    ),
    speed_control_config=SpeedControlConfig(
        speed_intensity=1.0,         # 0.7–1.5
        slowdown_capacity_ms=800.0   # recommended 400–1000
    )
)

enhancer = HumanSpeechEnhancer()
success, error = enhancer.initialize(config)

if not success:
    print(f"Initialization failed: {error}")
    exit(1)

chunk_size = enhancer.get_chunk_size_samples()
print(f"Input chunk size: {chunk_size} samples")

audio_chunk = np.random.randn(chunk_size).astype(np.float32)
enhanced, error = enhancer.process_chunk(audio_chunk)

if enhanced is not None:
    print(f"Input: {chunk_size} -> Output: {len(enhanced)} samples (varies with speed control)")
else:
    print(f"Error: {error}")
const { HumanSpeechEnhancer } = require('hecttor_sdk');

async function main() {
  const enhancer = new HumanSpeechEnhancer();

  await enhancer.initialize({
    apiKey: 'your_api_key_here',
    chunkSizeMs: 20,                 // Required for speed control
    sampleRate: 16000,               // Supported: 4000, 8000, 16000, 24000, 32000, 44100, 48000
    enableVoiceBoost: true,
    noiseCancellationConfig: {
      modelName: 'your_model',       // "auris-1.0" or "coda-1.0"
      enhancerWeight: 1.0,           // 0.0 = original, 1.0 = fully enhanced (default)
    },
    speedControlConfig: {
      speedIntensity: 1.0,           // 0.7-1.5
      slowdownCapacityMs: 800.0,     // recommended 400-1000
    },
  });

  const chunkSize = enhancer.getChunkSizeSamples();
  console.log(`Input chunk size: ${chunkSize} samples`);

  const audioChunk = new Float32Array(chunkSize);  // ... fill with audio data ...

  const enhanced = await enhancer.processChunk(audioChunk);
  console.log(`Input: ${chunkSize} -> Output: ${enhanced.length} samples (varies with speed control)`);
}

main().catch((err) => console.error(err.message));
import io.hecttor.sdk.*;

public class FullExample {
    public static void main(String[] args) {
        HumanSpeechEnhancerConfig config = HumanSpeechEnhancerConfig.builder("your_api_key_here")
            .chunkSizeMs(20)                          // Required for speed control
            .sampleRate(16000)                        // Supported: 4000, 8000, 16000, 24000, 32000, 44100, 48000
            .enableVoiceBoost(true)
            .noiseCancellation(new HumanSpeechEnhancerConfig.NoiseCancellationConfig(
                "your_model",                         // "auris-1.0" or "coda-1.0"
                1.0f                                  // enhancerWeight: 0.0 = original, 1.0 = fully enhanced
            ))
            .speedControl(new HumanSpeechEnhancerConfig.SpeedControlConfig(
                1.0f,                                 // speedIntensity: 0.7-1.5
                800.0f                                // slowdownCapacityMs: recommended 400-1000
            ))
            .build();

        try (HumanSpeechEnhancer enhancer = new HumanSpeechEnhancer()) {
            enhancer.initialize(config);

            int chunkSize = enhancer.getChunkSizeSamples();
            System.out.println("Input chunk size: " + chunkSize + " samples");

            float[] audioChunk = new float[chunkSize];   // ... fill with audio data ...

            float[] enhanced = enhancer.processChunk(audioChunk);
            System.out.println("Input: " + chunkSize + " -> Output: " + enhanced.length
                + " samples (varies with speed control)");

        } catch (HecttorInitializationException e) {
            System.err.println("Initialization failed: " + e.getMessage());
            System.exit(1);
        } catch (HecttorProcessingException e) {
            System.err.println("Processing failed: " + e.getMessage());
            System.exit(1);
        }
    }
}
#include <hecttor/human_speech_enhancer.hpp>

#include <iostream>
#include <vector>

int main() {
    try {
        hecttor::HumanSpeechEnhancerConfig config;
        config.apiKey = "your_api_key_here";
        config.chunkSizeMs = 20;                 // Required for speed control
        config.sampleRate = 16000;               // Supported: 4000, 8000, 16000, 24000, 32000, 44100, 48000
        config.enableVoiceBoost = true;
        config.noiseCancellationConfig = hecttor::NoiseCancellationConfig{
            "your_model",                        // "auris-1.0" or "coda-1.0"
            1.0f                                 // enhancerWeight: 0.0 = original, 1.0 = fully enhanced
        };
        config.speedControlConfig = hecttor::SpeedControlConfig{
            1.0f,                                // speedIntensity: 0.7-1.5
            800.0f                               // slowdownCapacityMs: recommended 400-1000
        };

        hecttor::HumanSpeechEnhancer enhancer;
        enhancer.initialize(config);

        const size_t chunkSize = enhancer.getChunkSizeSamples();
        std::cout << "Input chunk size: " << chunkSize << " samples\n";

        std::vector<float> audioChunk(chunkSize, 0.0f);  // ... fill with audio data ...

        std::vector<float> enhanced = enhancer.processChunk(audioChunk);
        std::cout << "Input: " << chunkSize << " -> Output: " << enhanced.size()
                  << " samples (varies with speed control)\n";

    } catch (const hecttor::InitializationException& e) {
        std::cerr << "Initialization failed: " << e.what() << "\n";
        return 1;
    } catch (const hecttor::ProcessingException& e) {
        std::cerr << "Processing failed: " << e.what() << "\n";
        return 1;
    }

    return 0;
}
using System;
using Hecttor.SDK;

class Program
{
    static void Main()
    {
        try
        {
            var config = new HumanSpeechEnhancerConfig
            {
                ApiKey = "your_api_key_here",
                ChunkSizeMs = 20,                // Required for speed control
                SampleRate = 16000,              // Supported: 4000, 8000, 16000, 24000, 32000, 44100, 48000
                EnableVoiceBoost = true,
                NoiseCancellation = new NoiseCancellationConfig
                {
                    ModelName = "your_model",    // "auris-1.0" or "coda-1.0"
                    EnhancerWeight = 1.0f,       // 0.0 = original, 1.0 = fully enhanced
                },
                SpeedControl = new SpeedControlConfig
                {
                    SpeedIntensity = 1.0f,       // 0.7-1.5
                    SlowdownCapacityMs = 800.0f, // recommended 400-1000
                },
            };

            using var enhancer = new HumanSpeechEnhancer();
            enhancer.Initialize(config);

            int chunkSize = enhancer.ChunkSizeSamples;
            Console.WriteLine($"Input chunk size: {chunkSize} samples");

            float[] audioChunk = new float[chunkSize];   // ... fill with audio data ...

            float[] enhanced = enhancer.ProcessChunk(audioChunk);
            Console.WriteLine($"Input: {chunkSize} -> Output: {enhanced.Length} samples (varies with speed control)");
        }
        catch (HecttorInitializationException ex)
        {
            Console.WriteLine($"Initialization failed: {ex.Message}");
            Environment.Exit(1);
        }
        catch (HecttorProcessingException ex)
        {
            Console.WriteLine($"Processing failed: {ex.Message}");
            Environment.Exit(1);
        }
    }
}
package main

import (
	"fmt"
	"log"
	"os"

	hecttor "hecttor.ai/sdk"
)

func main() {
	enh, err := hecttor.NewHumanSpeechEnhancer()
	if err != nil {
		log.Fatal(err)
	}
	defer enh.Close()

	nc := hecttor.NewNoiseCancellationConfig("your_model") // "auris-1.0" or "coda-1.0"
	nc.EnhancerWeight = 1.0                                 // 0.0 = original, 1.0 = fully enhanced

	if err := enh.Initialize(hecttor.HumanSpeechEnhancerConfig{
		APIKey:           os.Getenv("HECTTOR_API_KEY"),
		ChunkSizeMs:      20,    // Required for speed control
		SampleRate:       16000, // Supported: 4000, 8000, 16000, 24000, 32000, 44100, 48000
		EnableVoiceBoost: true,
		NoiseCancellation: nc,
		SpeedControl: &hecttor.SpeedControlConfig{
			SpeedIntensity:     1.0,   // 0.7-1.5
			SlowdownCapacityMs: 800.0, // recommended 400-1000
		},
	}); err != nil {
		log.Fatalf("Initialization failed: %v", err)
	}

	chunkSize, err := enh.ChunkSizeSamples()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Input chunk size: %d samples\n", chunkSize)

	audioChunk := make([]float32, chunkSize) // ... fill with audio data ...

	enhanced, err := enh.ProcessChunk(audioChunk)
	if err != nil {
		log.Fatalf("Processing failed: %v", err)
	}
	fmt.Printf("Input: %d -> Output: %d samples (varies with speed control)\n",
		chunkSize, len(enhanced))
}

That's the full integration shape: initialize once, then call the per-chunk enhancement function repeatedly with audio buffers sized to Hermes's configured chunk length.

What to do next

  • See Examples for common configurations (denoise only, voice boost only, full stack with speed control).
  • Read the SDK Overview if you haven't already; it'll help you decide whether Hermes alone is enough, or whether you also need Orpheus for an ASR pipeline.

Overview

Previous Page

Examples

Next Page

On this page

Getting StartedInstallationConfigure your SDK keyYour first enhancementWhat to do next