3 posts tagged with "echokit30days"

(And Today I Finally Saw How EchoKit Works Under the Hood)

In the last two days, we powered up the EchoKit, made it talk, and connected it to a local EchoKit server using Docker. But today feels different.

Today, we’re going to build the EchoKit Server from source. No containers. No abstraction layers. Just you… and the real engine that drives EchoKit.

🌱 Why Build EchoKit from Source?​

Using Docker is great for quick setup. But building from source unlocks more possibilities:

• Get the latest code, newest features, and bug fixes
• Modify the server freely — add your own logic, prompts, or integrations
• Compile to any platform you want
• Truly understand how EchoKit works under the hood

If Day 1 was about getting EchoKit to speak, and Day 2 was about hosting your own server, then Day 3 is where you start becoming an EchoKit developer.

Step 1 — Install the Rust Toolchain​

Since the EchoKit server is written in Rust, so all the dependencies is the Rust toolchain.

Refer to the official Rust website to install Rust.

Step 2 — Get the Source Code​

In your terminal:

git clone https://github.com/second-state/echokit_server.git
cd echokit_server

And there it is — the heart of the EchoKit server, right on your machine.

It's recommended to use an IDE like VSCode to open the echokit_server folder.

🔧 Step 3 — Configure the Server​

Open the config.toml file and fill in:

addr = "0.0.0.0:8080"
hello_wav = "hello.wav"

[tts]
platform = "Elevenlabs"
token = "sk_1234"
voice = "pNInz6obpgDQGcFmaJgB"

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
api_key = "gsk_1234"
model = "whisper-large-v3"
lang = "en"
prompt = "Hello\n你好\n(noise)\n(bgm)\n(silence)\n"
vad_url = "http://localhost:8000/v1/audio/vad"

[llm]
llm_chat_url = "https://api.groq.com/openai/v1/chat/completions"
api_key = "gsk_1234"
model = "openai/gpt-oss-20b"
history = 15

[[llm.sys_prompts]]
role = "system"
content = """
You are a helpful assistant. Answer truthfully and concisely. Always answer in English.
"""

Just like yesterday's setup, and remember to bring your own API key for Groq and ElevenLabs.

⚡ Step 4 — Build the Server​

Compile it using Cargo:

cargo build --release

The first build may take a bit, since Rust compiles everything from scratch.

But once you see:

Finished release [optimized] target(s)

you officially have your own EchoKit server binary.

🏃 Step 5 — Run the Server​

Start with debug logging:

export RUST_LOG=debug

Then launch:

nohup target/release/echokit_server &

You should see something like:

[1] 67869
appending output to nohup.out

All logs are saved in nohup.out, so you can monitor everything that happens inside your server.

🏃 Step 6 — Connect the Server​

Next, it's time to connect your EchoKit server to your device following this guide.

The EchoKit Server runs as a WebSocket service.

Your EchoKit device will connect using a URL like:

ws://YOUR_IP_ADDRESS:8080/ws

For example:

ws://192.168.1.23:8080/ws

⚠ Do NOT use localhost or 127.0.0.1. Your EchoKit device connects over Wi-Fi and cannot reach your computer’s local loopback address.

Once you enter this WebSocket URL into the EchoKit web dashboard, your device will connect to the server you built with your own hands.

Today, you didn’t just run EchoKit. You built the server. You opened the code. You compiled it. You took full control.

From now on, you’re not just a user — you’re a builder.

Tomorrow, in Day 4, we’ll dive into one of the most fun parts:

Customizing your EchoKit’s welcome screen. This is the beginning point where EchoKit truly becomes yours.

(Today, I take control of my EchoKit )

Yesterday, after getting started with EchoKit, it could finally talk back to us.

Today, we’re taking it one step further—connecting it to an EchoKit Server running on your own computer to make it truly come alive.

Honestly, this step gave me a really special feeling: "Wow, this little guy is actually talking to my computer." Not an official server, not a third-party platform—just my own local environment, my own AI workflow. It felt a bit like lighting up my first LED: simple, yet surprisingly meaningful.

✨ Why running your own EchoKit Server is so important

Once EchoKit Server is running locally, you can:

• Fully customize ASR, TTS, and LLM
• Swap AI models, change voices, tweak system prompts
• Add an MCP server or integrate your own toolchains
• Later, even enable command control or Home Assistant integration

These features will be covered in more detail in upcoming EchoKit30Days articles. Stay tuned!

At this point, EchoKit stops being just a “factory robot.” It starts becoming your AI companion—with the personality you shape and the skills you create.

There're two ways to run EchoKit server locally. One is Docker, the other one is to use rust compiler. However, Docker is the simplest and most recommended way because you don’t have to worry about environment setup.

Step 1 — Edit your config.toml​

First, we will need to create a config.toml file in your root folder.

The config.toml is the “soul file” of your EchoKit Server. It decides which AI model, which voice, and how your EchoKit talks. Today, we’ll use services from Groq and ElevenLabs for a starter configuration:

addr = "0.0.0.0:8080"
hello_wav = "hello.wav"

[tts]
platform = "Elevenlabs"
token = "sk_1234"
voice = "pNInz6obpgDQGcFmaJgB"

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
api_key = "gsk_1234"
model = "whisper-large-v3"
lang = "en"
prompt = "Hello\n你好\n(noise)\n(bgm)\n(silence)\n"
vad_url = "http://localhost:8000/v1/audio/vad"

[llm]
llm_chat_url = "https://api.groq.com/openai/v1/chat/completions"
api_key = "gsk_1234"
model = "openai/gpt-oss-20b"
history = 15

[[llm.sys_prompts]]
role = "system"
content = """
You are a helpful assistant. Answer truthfully and concisely. Always answer in English.
"""

Remember to replace the API keys with your own.

Step 2 — Launch EchoKit Server with Docker​

Make sure you have Docker Desktop installed and the Docker engine running.

docker run --rm \
  -p 8080:8080 \
  -v $(pwd)/config.toml:/app/config.toml \
  secondstate/echokit:latest-server-vad &

This command will run the server on the 8080 port.

Step 3 — Connect EchoKit to your Server**​

Next, connect your EchoKit device to the server. If you’ve followed Day 1 to make your EchoKit speak, you will need to reset your device.

1. Press the RST button
2. Hold K0 until the QR code reappears

Then, go to the setup page and enter your Wi-Fi name, password, and server URL in the format of ws://789.123.3.45:8080/ws.

The server URL should be your IP address starting with 192.168. Go to WiFi setting to get the IP address.

Suddenly, your little AI starts working exactly the way you configured it: Your Groq model, your ElevenLabs voice, your system prompt.

That moment really feels like… you’ve trained it yourself.

Many of our customers have already received their EchoKit, ready to explore the fascinating world of voice AI. To help you become a Voice AI agent master, we’re kicking off the First 30 Days with EchoKit journey, which works for both EchoKit DIY and EchoKit Box users.

Day 1 is all about one exciting milestone: hearing your EchoKit speak for the very first time. That small device in your hands, quiet and unassuming just moments ago, is about to come alive.

Wondering about Day 0? If you have a DIY EchoKit, assemble it first.

Step 1: Power Up Your EchoKit​

The adventure begins the moment you connect your EchoKit to power:

1. Use the USB Type-C data cable to connect EchoKit to your computer or a power source.

2. Watch as the device awakens — you should see a QR code appear on the screen.

3. Can’t see the QR code? Don’t worry:

   • Click the RST button to restart.
   • Immediately press and hold the K0 button until the QR code appears.

There it is—the first sign that your EchoKit is coming to life. That tiny screen, those subtle lights—they mark the start of a new AI companion ready to talk to you.

Step 2: Connect EchoKit to Your Computer​

Next, it’s time to introduce your EchoKit to the digital world:

1. Open a web browser (Chrome is recommended) on your desktop and go to: 👉 https://echokit.dev/setup/
2. Click Connect to EchoKit to start pairing.

With this connection, your EchoKit AI assistant is ready to listen, respond, and learn. This small device is no longer just hardware—it’s now a voice AI companion that can interact with you in real time.

Step 3: Configure Wi-Fi and Server​

Once paired, the setup interface will appear. This is where your EchoKit truly becomes yours:

1. Enter the following details:

   • Wi-Fi Network: Your 2.4G Wi-Fi name

   • Wi-Fi Password: Your access code

   • EchoKit Server: Choose a pre-set server for a fast connection:

     • 🇺🇸 US: ws://indie.echokit.dev/ws
     • 🇪🇺 EU: ws://eu.echokit.dev/ws (Outside these regions? The response may be slower, but it will still work.)

2. Click Write for each field.

3. Once finished, press the K0 button on EchoKit.

With every step, you’re not just configuring a device—you’re preparing for your first conversation with your AI companion.

Step 4: Confirm Setup on EchoKit​

After configuration, your EchoKit will:

• Display a welcome screen
• Play a voice greeting: “Hi there”

This is the moment you’ve been waiting for. Your EchoKit voice AI is now awake and ready. Take a moment to appreciate it—it’s listening, responding, and ready to become part of your daily life.

Step 5: Start Chatting​

Now comes the fun part: your first conversation with EchoKit.

1. Press the K0 button to start. The status bar will show “Listening …”.
2. Speak to your EchoKit and enjoy its responses.
3. If the status shows “Idle” or “Speaking”, use the K0 button to start or interrupt as needed.

Every question, every command, every interaction is a small discovery. This is the start of your voice AI journey, where your EchoKit learns, adapts, and surprises you with each conversation.

💡 Tip for Day 1: Today is about enjoying your first interaction and getting familiar with your AI companion. Tomorrow, we’ll explore customizing EchoKit’s voice and personality, making it uniquely yours.