26 posts tagged with "echokit30days"

(Today, your EchoKit learns to understand you—faster and sharper.)

By now, you’ve powered up EchoKit, run your own EchoKit server locally, customized the boot screen, crafted your own welcome voice, and started shaping your very own voice AI companion.

Today, we’re upgrading something fundamental: how your EchoKit listens to you. In any voice AI agent, ASR is the very first step — it’s how your device hears you before it can think or speak back.

One of the best parts of EchoKit being open source voice AI agent is that you can plug in whatever ASR–LLM–TTS pipeline works best for your needs. And for many makers, developers, and tinkerers, Groq has become the go-to for ultra-fast voice recognition.

So on Day 6, you’ll learn how to integrate Groq with EchoKit and feel that speed boost every time you press the K0 button and start talking.

Let’s dive in.

Why Groq? (And Why Today Feels Like a Power-Up)​

If you’ve never tried Groq before, prepare to be surprised. Groq is known for delivering extremely low-latency inference. When we tested it, the difference was obvious — conversations felt snappier, more natural, and closer to real-time.

Adding it to your EchoKit means:

• Faster voice-to-text recognition
• More responsive conversations
• A smoother ASR-LLM-TTS pipeline
• And honestly… it just feels good seeing your device level up

Today is about giving your device better ears.

Step 1 — Get Your Groq API Key​

Head to the Groq console (https://console.groq.com/keys) and sign up if you’re new.

Click + Create API Key, give it a name, and copy it somewhere safe — it won’t be shown again.

This key is what lets your EchoKit talk to Groq securely.

Step 2 — Apply the Groq ASR Settings to Your EchoKit Server​

Open your config.toml file inside your EchoKit Server (Docker or Rust build).

We’re going to tell EchoKit: “Hey, use Groq Whisper as my ASR engine.”

Paste the following:

[asr]
url = "https://api.groq.com/openai/v1/audio/transcriptions"
lang = "en"
api_key = "YOUR_GROQ_API_KEY_HERE"
model = "whisper-large-v3-turbo"

A quick breakdown:

• [asr] — we’re configuring the ASR section
• url — Groq’s Whisper endpoint
• lang — your preferred language (en, zh, ja etc.)
• api_key — the key you generated
• model — Groq’s supported Whisper models (whisper-large-v3 or whisper-large-v3-turbo)

EchoKit follows OpenAI-style specs, so you’re free to replace Groq with other providers later if you want, which we will learn in the upcoming days. This flexibility is part of what makes EchoKit… EchoKit.

Now restart your EchoKit server using Docker or Rust code. You’re done on the server side!

Step 3 — Connect the Updated Server to Your EchoKit Device​

Head to https://echokit.dev/setup/ and rebind the server if needed.

If nothing changed except your ASR configuration, you can simply press the RST button on your EchoKit to restart it and sync the new settings.

If your server URL or WiFi setup changed, you can reconfigure them through the setup page — just like you did on Day 1.

Now comes the fun part.

Press the K0 button and start speaking.

You’ll feel the difference immediately — the Groq Whisper model picks up your words almost as soon as you say them.

Your EchoKit just got better ears. Remember to check the logs to see how long Groq’s Whisper took to transcribe the audio.

Today’s upgrade brings more speed and responsiveness, setting the stage for a deeper dive into the EchoKit server in the upcoming days.

If you want to share your experience or see what others are building with EchoKit + Groq:

• Join the EchoKit Discord
• Or share your latency tests, setups, and experiments — we love seeing them

Want to get your own EchoKit device?

• EchoKit Box
• EchoKit DIY Kit

(And Today, Your EchoKit Greets You in Your Own Voice!)

By now, you’ve powered up EchoKit, run the server (via Docker or from source), and even customized the boot screen.

Today, we’re taking it one step further: giving your EchoKit a personalized welcome voice.

It’s a simple tweak, but it instantly transforms your device into a Voice AI agent with its own character — a tiny AI companion that greets you the way you like.

Create Your Own Voice​

Your welcome sound can be anything you want:

• Your own recorded voice
• A short greeting phrase
• Even a favorite piece of music

Just make sure your audio file meets these requirements:

• WAV format
• 16 kHz sample rate

You can quickly convert audio to 16 kHz using the online tool or FFmpeg:

ffmpeg -i input.mp3 -ar 16000 output.wav

💡 Pro Tip: This is a great opportunity to give your EchoKit a special gift — a voice that makes it uniquely yours!

Set Up Your Custom Welcome Voice​

To apply your custom sound, run your EchoKit Server (Docker or compiled binary).

If your device was previously set up, reset it first:

• Press the RST button
• Immediately press the K0 button until the QR code shows

Then, open your config.toml file and look for:

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

Replace hello.wav with your own file path, for example:

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

Restart your EchoKit server using Docker or [from the Rust source code]((https://echokit.dev/docs/dev/echokit-30-days-day-3-rust).

Then, connect the echokit server and the device via https://echokit.dev/setup/ page.

If your server URL and Wifi setting didn't change, you can simply restart the device by pressing the rst button.

After that, when you press the K0 button to start a conversation, your EchoKit will greet you with your very own welcome sound. 🎶

Why This Matters​

A custom welcome voice turns EchoKit from a generic device into your personal AI companion. Every interaction feels more natural, more fun, and more expressive — like it really knows you.

Whether it’s a playful hello, a soothing greeting, or a quirky sound effect, this is a special gift you give to yourself and your device.

Want to get your EchoKit Device and make it unique?

• EchoKit Box
• EchoKit DIY

Join the EchoKit Discord to share your creative welcome voices and see how others are personalizing their Voice AI agents!

(And Today, EchoKit Gets a Personality of Its Own)

In the last three days, we powered up EchoKit, connected it to a local server, and even built the server from source. But today… we’re making it truly yours.

Today, we’re going to customize the boot screen. Think of it as EchoKit’s wardrobe — the first thing you see when it wakes up. And yes, you can "decorate" it as quirky, cute, or technical as you like.

🌱 Why Customize the Boot Screen?​

Sure, the default boot screen with the EchoKit logo works fine. But customizing it gives you:

• A personal touch — your EchoKit looks exactly how you want it
• An instant “wow” moment every time it starts
• A glimpse into how flexible and hackable your device really is

Step 1 — Design Your GIF​

Depending on your EchoKit model, use your favorite image editor to create a GIF:

• EchoKit Box: 360 × 240 px
• EchoKit DIY: 240 × 240 px

Keep the GIF under 15 KB so it loads smoothly.

Step 2 — Pair Your EchoKit Device​

Go to https://echokit.dev/setup/ and click Connect to Your EchoKit.

Make sure your device shows the QR code page. If it doesn’t:

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

Now your computer and EchoKit are ready to talk.

Step 3 — Upload Your GIF​

Scroll down to Set Background, upload your GIF, and click Set Background.

Pro Tip: It may take a few seconds to apply, so don’t panic if nothing changes instantly.

Step 4 — Save and Restart​

Finally, click Save Configuration. Your EchoKit will restart, and… voilà! Your custom boot screen is now the first thing it shows when it wakes up.

Today, EchoKit isn’t just a voice assistant or a server anymore — it’s your EchoKit.

(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.