gojargo/jargo
gojargo/jargo has 111 GitHub stars and 11 forks. GitHot measured 0 stars in 24 hours. Last checked 2026-11-17 18:45 UTC. Last push 2026-11-15.
What you can do
- Transports: WebRTC (Pion), WebSockets, LiveKit and local audio.
- Audio, pure Go: Opus encode and decode via pion/opus, resampling via go-resample. No cgo, and no build tag that adds any.
- Streaming voice pipeline: STT → LLM → TTS, with prompt caching.
- Speech-to-speech: single-model voice agents (OpenAI Realtime, Gemini Live, AWS Nova Sonic).
Measured star growth
- in 24h
- 0
- in 7 days
- Collecting history
- in 15 days
- Collecting history
- in 1 month
- Collecting history
Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.
About
Conversational-AI framework for Go.
AIREADME.md
Originaljargo 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
- Transports: WebRTC (Pion), WebSockets, LiveKit and local audio.
- Audio, pure Go: Opus encode and decode via pion/opus, resampling via go-resample. No cgo, and no build tag that adds any.
- Streaming voice pipeline: STT → LLM → TTS, with prompt caching.
- Speech-to-speech: single-model voice agents (OpenAI Realtime, Gemini Live, AWS Nova Sonic).
- Turn-taking & barge-in: Silero VAD + Smart Turn v3, local ONNX. Both models are embedded in the binary.
- Telephony (optional): inbound/outbound phone calls over Twilio Media Streams.
- User-idle watchdog: re-engage or hang up when the caller goes silent.
- RTVI data channel: works with existing RTVI clients.
- Pluggable services: swap any STT/LLM/TTS behind a small interface.
- Concurrent by design: independent processors; interruptions are frames.
Providers
Pick any per category; each is a small Config + constructor.
- STT: Deepgram, AssemblyAI, Gladia, Speechmatics, Soniox, Whisper (OpenAI/Groq/local), Azure, xAI, ElevenLabs, Cartesia, NVIDIA.
- LLM: Anthropic (direct + Bedrock), OpenAI (chat + Responses), Google Gemini (direct + Vertex), Groq, Together, Fireworks, DeepSeek, Cerebras, Perplexity, OpenRouter, xAI, Ollama, NVIDIA, Mistral, Nebius, SambaNova, Qwen, Azure OpenAI.
- TTS: ElevenLabs, Cartesia, Rime, Kokoro, Piper, Pocket TTS, Deepgram, OpenAI, Azure, Hume, Fish, MiniMax, xAI, NVIDIA, Soniox, AssemblyAI.
- Speech-to-speech: OpenAI Realtime (direct + Azure), Gemini Live (direct + Vertex), AWS Nova Sonic, xAI Realtime.
- Memory: mem0.
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/getting-started/06-voice-agent
is a complete voice agent on the dev runner (WebRTC signaling, a browser client,
VAD and 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/. Start with the
getting-started series, which builds up from one
spoken sentence to a voice agent with tools, each step a short bot function on
the development runner:
CARTESIA_API_KEY=... go run ./examples/getting-started/01-say-one-thing
# then open http://localhost:7860
The others:
- echo: hear yourself back, no API keys.
- voicebot: the full voice agent (STT → LLM → TTS over WebRTC) with turn-taking, long-term memory, and tracing.
- voice/: the voice agent on each provider's STT, LLM and TTS, wired
explicitly on the dev runner. Run with
go run ./examples/voice/voice-<provider>(e.g.voice-deepgram-flux,voice-cartesia,voice-openai) and open http://localhost:7860. - twiliobot: a phone agent over Twilio Media Streams, with the idle watchdog.
The fastest way to try them (locally or with Docker) is the Quickstart.
go run ./examples/echo # then open http://localhost:8080
Documentation
gojargo.dev 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.
Benchmarks
1,000 concurrent sessions served on 3 CPUs: one jargo process, against one Pipecat 1.15 process per CPU (the GIL holds each to one core).
| jargo | Pipecat | |
|---|---|---|
| Memory, idle | 8.6 MiB | 162 MiB |
| Memory, 1,000 sessions | 124 MiB | 357 MiB |
| Throughput | 96k frames/s | 10.8k frames/s |
| Startup per session | 0.12 ms | 1.08 ms |
Medians of 6 runs on a GitHub-hosted runner (AMD EPYC 7763), every difference significant. This is framework overhead only: provider round trips dominate what a caller hears, and cost the same on both. Method.
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.
