Skip to content
Projects

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.

How these counts are measured

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.

AI

README.md

Original
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

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