jargo README

The project's README from github.com/gojargo/jargo. As one markdown file: README.md.

jargo

A WebRTC-native, audio-first conversational-AI framework for Go.

CI Coverage Go Reference OpenSSF Scorecard Go version Release License: BSD-2-Clause

jargo is a framework for real-time voice agents in Go: audio in over WebRTC, a streaming transcription → reasoning → speech pipeline with turn-taking and barge-in, and audio back out.

Why?

Pipecat is great, and jargo is a port of it. The architecture and many design decisions are Pipecat's.

Python might not be the way

This port exists for one reason: I'd rather not run a voice agent on Python.

Python is the right tool when you need the AI/data-science ecosystem. A real-time voice server doesn't: the models run as services or as ONNX, and what's left is plumbing: audio framing, WebRTC, concurrency, and shipping a binary. For that, Go is a better fit: one static binary to deploy, low and predictable memory, fast startup, and real concurrency for many simultaneous sessions without a GIL. The heavy numerics stay where they belong (the ONNX Runtime, the remote services), so giving up Python costs little here. See the benchmarks for the honest performance picture.

Features

Providers

Pick any per category; each is a small Config + constructor.

Usage

go get github.com/gojargo/jargo

A bot is an STT → LLM → TTS pipeline over a WebRTC transport. The heart of it:

stt := chat.NewSTT(chat.STTConfig{APIKey: key, SampleRate: opus.SampleRate})
llm := chat.NewLLM(chat.LLMConfig{APIKey: key})
tts := chat.NewTTS(chat.TTSConfig{APIKey: key})

t := rtc.NewTransport(conn, transport.DefaultParams())
agg := aggregators.New(frames.NewLLMContext("You are a helpful voice assistant."))

task := pipeline.NewWorker(pipeline.New(
	t.Input(), stt, agg.User(), llm, tts, t.Output(), agg.Assistant(),
), pipeline.WorkerConfig{})
task.Run(ctx)

examples/voice/openai is that pipeline as a complete server (WebRTC signaling, VAD/turn-taking, barge-in).

Run it in Docker: build on the gojargo/jargo-build base and ship on the distroless gojargo/jargo runtime (it bundles the ONNX Runtime), then:

docker run --rm -p 8080:8080 -e OPENAI_API_KEY=$OPENAI_API_KEY my-bot

See Deploy with Docker for the Dockerfile and the Quickstart for the full setup.

Examples

Runnable bots live in examples/:

The fastest way to try them (locally or with Docker) is the Quickstart.

go run ./examples/echo                 # then open http://localhost:8080

Documentation

gojargo.github.io/jargo is the full documentation. The same pages live in docs/ and read fine on GitHub.

Start with Architecture for the model, or Frames and Processors for the engine. Writing a processor covers extending it. The API reference is the Go reference.

What you need to install

Nothing, to build: the default build is cgo-free, so CGO_ENABLED=0 go build ./... works with no C toolchain and no system packages.

To run a voice bot you need one shared library, and only for turn-taking:

What When you need it How to get it
ONNX Runtime VAD and end-of-turn detection. Without it the bot still runs, on STT endpointing, and loses barge-in. make deps-onnx, or a release
RNNoise Optional input noise reduction. make deps-rnnoise

Both libraries are loaded at run time through purego, so they are never needed at build time. Point jargo at them with JARGO_ONNXRUNTIME_LIB and JARGO_RNNOISE_LIB, or leave them on the loader's default search path. The base images bundle all of them.

License & attribution

jargo is a Go port of Pipecat, distributed under the same BSD 2-Clause License. The upstream copyright (Copyright (c) 2024–2026, Daily) is preserved verbatim in LICENSE; see NOTICE for details. jargo is an independent project, not affiliated with or endorsed by Daily.

jargo (gojargo/jargo)

Searching Database…

102 ·GitHub
Jargo
What is this?Jargo is a WebRTC-native, audio-first conversational-AI framework for Go, used to build real-time voice agents with a streaming STT to LLM to TTS pipeline, turn-taking and barge-in.
Is this a framework I import, or a standalone server I run?It is a Go framework/library of pluggable processors (transports, STT, LLM, TTS services) that you wire together into a bot; the examples directory shows runnable servers built on top of it.
How do I get a voice bot running?Use the Quickstart docs, run one of the examples like 'go run ./examples/voice/openai' and connect from a browser client, or build the Docker images (gojargo/jargo-build base, gojargo/jargo-build runtime) and deploy that way.
Do I need a C toolchain or any system packages to build it?No, the default build is cgo-free so 'CGOENABLED=0 go build ./...' works with no C toolchain; to actually run turn-taking you need the ONNX Runtime shared library (via 'make deps-onnx'), and optionally RNNoise for noise reduction, both loaded at runtime via purego.
What happens if I skip the ONNX Runtime setup?The bot still runs but falls back to STT endpointing and loses barge-in, since ONNX Runtime is what powers VAD and end-of-turn (Smart Turn v3) detection.
Which transports and providers does it actually support?Transports include WebRTC (Pion), WebSockets, LiveKit, local audio and Twilio Media Streams for telephony; you can plug in almost any STT, LLM, or TTS provider (Deepgram, OpenAI, Anthropic, Gemini, ElevenLabs, Cartesia, and many more) behind a small interface.
Why build this in Go instead of just using Pipecat in Python?The author wanted to avoid running a real-time voice server in Python: a voice agent is mostly plumbing (audio framing, WebRTC, concurrency), and Go offers a single static binary, low memory, fast startup, and real concurrency without a GIL, while the heavy ML models still run as external services or ONNX.
Can I try it without any API keys?Yes, the 'echo' example lets you hear yourself back over the pipeline with no API keys required, useful for testing the transport and audio path before wiring in real STT/LLM/TTS providers.
Does it support speech-to-speech models instead of the STT/LLM/TTS chain?Yes, it supports single-model voice agents like OpenAI Realtime, Gemini Live, and AWS Nova Sonic as an alternative to the separate STT to LLM to TTS pipeline.
Can it handle real phone calls?Yes, there is optional telephony support for inbound and outbound phone calls over Twilio Media Streams, including a user-idle watchdog that can re-engage or hang up when the caller goes silent.
What are similar projects?agentscope, pyvideotrans, ten-framework, pipecat, agents, Tel-Agent, VibeVoice, VoiceMem
Which topics is it in?stt, voice-agent, voice-ai, conversational-ai, voice-assistant, webrtc, realtime, speech-to-text, speech-recognition, tts, text-to-speech, telegram
Creator
gojargo
Size
43.4 MB
Stars
102
Updated
CommitOct 06Releasev0.2.0Sep 18
Age
4mo
Commits · 90 Days