EVI .NET Quickstart

1
using System;
2
using System.IO;
3
using System.Linq;
4
using System.Threading.Tasks;
5
using DotNetEnv;
6
using Hume;
7
using Hume.EmpathicVoice;

$
HUME_API_KEY=your_api_key_here

1
Env.Load();
2
3
var apiKey = Environment.GetEnvironmentVariable("HUME_API_KEY")
4
    ?? throw new InvalidOperationException("HUME_API_KEY environment variable is required.");
5
var client = new HumeClient(apiKey);

1
// Create a signal to wait for Chat Metadata
2
var chatMetadataReceived = new TaskCompletionSource<bool>();
3
4
// Create the ChatApi instance
5
var chatApi = client.EmpathicVoice.CreateChatApi(new ChatApi.Options
6
{
7
    ApiKey = apiKey,
8
    SessionSettings = new ConnectSessionSettings(),
9
});

1
// Connect to EVI
2
Console.WriteLine("Connecting to EVI...");
3
await chatApi.ConnectAsync();
4
Console.WriteLine("Connected!");
5
6
// Wait for Chat Metadata
7
Console.WriteLine("Waiting for Chat Metadata...");
8
await chatMetadataReceived.Task;
9
Console.WriteLine("Chat Metadata received.");

1
// Subscribe to events
2
chatApi.AssistantMessage.Subscribe(message =>
3
{
4
    Console.WriteLine($"Assistant: {message.Message?.Content}");
5
});
6
7
chatApi.UserMessage.Subscribe(message =>
8
{
9
    Console.WriteLine($"User: {message.Message?.Content}");
10
});
11
12
chatApi.AudioOutput.Subscribe(audio =>
13
{
14
    Console.WriteLine($"Received audio chunk: {audio.Data?.Length ?? 0} bytes");
15
});
16
17
chatApi.ChatMetadata.Subscribe(metadata =>
18
{
19
    Console.WriteLine($"Chat Metadata - Chat ID: {metadata.ChatId}");
20
    chatMetadataReceived.TrySetResult(true);
21
});

1
// Configure audio format (48kHz, 16-bit, mono PCM)
2
const int sampleRate = 48000;
3
const int channels = 1;
4
5
var sessionSettings = new SessionSettings
6
{
7
    Audio = new AudioConfiguration
8
    {
9
        Encoding = "linear16",
10
        SampleRate = sampleRate,
11
        Channels = channels
12
    }
13
};
14
15
await chatApi.Send(sessionSettings);

1
static async Task TransmitTestAudio(ChatApi chatApi, string filePath, int sampleRate, int channels)
2
{
3
    const int chunkDurationMs = 10;
4
    const int bytesPerSample = 2; // 16-bit audio
5
    int bytesPerChunk = sampleRate * bytesPerSample * channels * chunkDurationMs / 1000;
6
7
    // Read PCM file
8
    var audioData = File.ReadAllBytes(filePath);
9
10
    // Split into chunks and send with appropriate timing
11
    for (int offset = 0; offset < audioData.Length; offset += bytesPerChunk)
12
    {
13
        var chunkSize = Math.Min(bytesPerChunk, audioData.Length - offset);
14
        var chunk = audioData.Skip(offset).Take(chunkSize).ToArray();
15
16
        // Pad final chunk if needed
17
        if (chunk.Length < bytesPerChunk)
18
        {
19
            chunk = chunk.Concat(new byte[bytesPerChunk - chunk.Length]).ToArray();
20
        }
21
22
        // Send as base64-encoded audio input
23
        var data = Convert.ToBase64String(chunk);
24
        await chatApi.Send(new AudioInput { Data = data });
25
26
        // Delay to simulate real-time streaming
27
        await Task.Delay(chunkDurationMs);
28
    }
29
}

1
using System;
2
using System.IO;
3
using System.Linq;
4
using System.Threading.Tasks;
5
using DotNetEnv;
6
using Hume;
7
using Hume.EmpathicVoice;
8
9
Env.Load();
10
11
var apiKey = Environment.GetEnvironmentVariable("HUME_API_KEY")
12
    ?? throw new InvalidOperationException("HUME_API_KEY environment variable is required.");
13
var client = new HumeClient(apiKey);
14
15
// Create a signal to wait for Chat Metadata
16
var chatMetadataReceived = new TaskCompletionSource<bool>();
17
18
// Create the ChatApi instance
19
var chatApi = client.EmpathicVoice.CreateChatApi(new ChatApi.Options
20
{
21
    ApiKey = apiKey,
22
    SessionSettings = new ConnectSessionSettings(),
23
});
24
25
// Subscribe to events
26
chatApi.AssistantMessage.Subscribe(message =>
27
{
28
    Console.WriteLine($"Assistant: {message.Message?.Content}");
29
});
30
31
chatApi.UserMessage.Subscribe(message =>
32
{
33
    Console.WriteLine($"User: {message.Message?.Content}");
34
});
35
36
chatApi.AudioOutput.Subscribe(audio =>
37
{
38
    Console.WriteLine($"Received audio chunk: {audio.Data?.Length ?? 0} bytes");
39
});
40
41
chatApi.ChatMetadata.Subscribe(metadata =>
42
{
43
    Console.WriteLine($"Chat Metadata - Chat ID: {metadata.ChatId}");
44
    chatMetadataReceived.TrySetResult(true);
45
});
46
47
// Connect to EVI
48
Console.WriteLine("Connecting to EVI...");
49
await chatApi.ConnectAsync();
50
Console.WriteLine("Connected!");
51
52
// Wait for Chat Metadata
53
await chatMetadataReceived.Task;
54
55
// Configure audio format (48kHz, 16-bit, mono PCM)
56
const int sampleRate = 48000;
57
const int channels = 1;
58
59
var sessionSettings = new SessionSettings
60
{
61
    Audio = new AudioConfiguration
62
    {
63
        Encoding = "linear16",
64
        SampleRate = sampleRate,
65
        Channels = channels
66
    }
67
};
68
69
await chatApi.Send(sessionSettings);
70
71
// Send audio (replace with your audio source)
72
// await TransmitTestAudio(chatApi, "sample_input.pcm", sampleRate, channels);
73
74
// Wait for responses
75
await Task.Delay(5000);
76
77
await chatApi.DisposeAsync();