vibes-plug 2.5.0 → 2.11.0

package/skills/vector-db-rag-expert/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: vector-db-rag-expert
-description: "Expert guide for high-performance Vector Databases, RAG architectures, pgvector HNSW indexing, hybrid search (Dense + BM25), and semantic chunking / Panduan ahli Vector DB, arsitektur RAG, pgvector HNSW, dan hybrid search."
+description: "Expert guide for high-performance Vector Databases, Deep RAG architectures, pgvector 0.8+ HNSW, Reciprocal Rank Fusion (RRF), Cross-Encoder Re-ranking, and Late Chunking / Panduan ahli Vector DB, arsitektur Deep RAG, pgvector HNSW, RRF, dan Re-ranking."
 author: "Roedy Rustam"
 ---
 
-# Vector DB & Deep RAG Expert
+# Vector DB & Deep RAG Expert (2026 Edition)
 
 [English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
 
@@ -14,39 +14,195 @@ author: "Roedy Rustam"
 ## English
 
 ### Purpose & Overview
-Production-grade guidelines for Vector Databases (pgvector, Qdrant, Pinecone, Milvus), RAG indexing strategies, HNSW vector search, hybrid retrieval (dense vector embeddings + BM25 sparse keyword ranking), semantic document chunking, and RAG evaluation frameworks.
+Production-grade architectural guide for Vector Databases (PostgreSQL `pgvector 0.8+`, Qdrant, LanceDB, Pinecone), Deep RAG indexing strategies, HNSW iterative search, **Reciprocal Rank Fusion (RRF)** hybrid retrieval, **Cross-Encoder Re-ranking** (Cohere Rerank v3, FlashRank, BGE-Reranker-v2), and **Late Chunking** to eliminate context fragmentation.
 
 ### Key Capabilities
-- **pgvector & Hybrid Search**: PostgreSQL `pgvector` HNSW indexing, cosine/L2 distance metric tuning, and BM25 hybrid re-ranking.
-- **RAG Architecture**: Parent-Document retrieval, Hypothetical Document Embeddings (HyDE), and contextual compression.
-- **RAG Evaluation**: Automated retrieval quality scoring using Ragas and TruLens.
+1. **pgvector 0.8+ & HNSW Indexing**: High-dimensional vector storage, cosine/inner-product/L2 distance metric tuning, and iterative HNSW index scans with metadata filtering.
+2. **Reciprocal Rank Fusion (RRF)**: Combining sparse keyword BM25 ranks with dense semantic vector ranks using $RRF(d) = \sum \frac{1}{k + rank(d)}$, far outperforming naive linear score weighting.
+3. **Cross-Encoder Re-ranking**: Two-stage retrieval pipeline: retrieve Top-50 candidates via fast hybrid search, then re-rank down to Top-5 using a cross-encoder model to maximize NDCG@10.
+4. **Late Chunking & Contextual Retrieval**: Embed long-context documents in full before pooling token embeddings into individual chunks, preserving document-level semantics across boundaries.
+5. **RAG Evaluation**: Continuous retrieval precision and hallucination scoring using automated eval harnesses (Ragas, TruLens, DeepEval).
 
+---
+
+### Production Implementation Recipes
+
+#### Recipe 1: Reciprocal Rank Fusion (RRF) Hybrid Search with Drizzle ORM
 ```typescript
 import { sql } from 'drizzle-orm';
+import { db } from '@/lib/db';
+
+export interface SearchResult {
+  id: string;
+  content: string;
+  score: number;
+}
+
+/**
+ * Executes Reciprocal Rank Fusion (RRF) combining BM25 keyword search and pgvector HNSW
+ * k = 60 is the industry standard constant
+ */
+export async function reciprocalRankFusionSearch(
+  queryVector: number[],
+  queryText: string,
+  limit = 10,
+  k = 60
+): Promise<SearchResult[]> {
+  const formattedVector = JSON.stringify(queryVector);
 
-// Hybrid Search: Vector Cosine Similarity + Full Text Search
-export async function hybridSearch(queryVector: number[], queryText: string, limit = 10) {
-  const result = await db.execute(sql`
-    SELECT id, title, content,
-           (1 - (embedding <=> ${JSON.stringify(queryVector)}::vector)) * 0.7 +
-           ts_rank(fts, websearch_to_tsquery('english', ${queryText})) * 0.3 AS score
-    FROM documents
-    ORDER BY score DESC
+  const results = await db.execute(sql`
+    WITH vector_matches AS (
+      SELECT id, ROW_NUMBER() OVER (ORDER BY embedding <=> ${formattedVector}::vector) AS rank
+      FROM documents
+      WHERE status = 'published'
+      ORDER BY embedding <=> ${formattedVector}::vector
+      LIMIT 50
+    ),
+    text_matches AS (
+      SELECT id, ROW_NUMBER() OVER (ORDER BY ts_rank_cd(fts, websearch_to_tsquery('english', ${queryText})) DESC) AS rank
+      FROM documents
+      WHERE fts @@ websearch_to_tsquery('english', ${queryText})
+      LIMIT 50
+    )
+    SELECT
+      d.id,
+      d.content,
+      COALESCE(1.0 / (${k} + v.rank), 0.0) +
+      COALESCE(1.0 / (${k} + t.rank), 0.0) AS rrf_score
+    FROM documents d
+    LEFT JOIN vector_matches v ON d.id = v.id
+    LEFT JOIN text_matches t ON d.id = t.id
+    WHERE v.id IS NOT NULL OR t.id IS NOT NULL
+    ORDER BY rrf_score DESC
     LIMIT ${limit};
   `);
-  return result;
+
+  return results.rows as unknown as SearchResult[];
 }
 ```
 
+#### Recipe 2: Two-Stage Re-Ranking Pipeline with FlashRank (Node.js / TypeScript)
+```typescript
+import { FlashRankRegistry } from 'flashrank';
+
+const ranker = new FlashRankRegistry();
+
+export async function rerankCandidates(query: string, candidates: { id: string; text: string }[], topN = 5) {
+  const passages = candidates.map(c => ({ id: c.id, text: c.text }));
+  
+  // Ultra-fast client/server cross-encoder re-ranking
+  const reranked = await ranker.rerank({
+    query,
+    passages,
+    model: 'ms-marco-TinyBERT-L-2-v2', // Lightweight, 2ms latency
+  });
+
+  return reranked.slice(0, topN);
+}
+```
+
+---
+
+### Implementation Checklist
+- [ ] Create `HNSW` index in PostgreSQL: `CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64);`
+- [ ] Configure `hnsw.ef_search = 100` for high-recall queries during production traffic.
+- [ ] Implement Reciprocal Rank Fusion (RRF) with constant `k = 60` instead of arbitrary linear weighting.
+- [ ] Add a Cross-Encoder Re-ranker step before injecting retrieved chunks into the LLM system prompt.
+- [ ] Apply Late Chunking or Contextual Chunking to retain parent document continuity.
+
+## Orchestration & Integration
+- Integrates with: `ai-llm-integration-expert`, `database-orm-expert`, `ai-cost-token-optimizer`, `app-analyzer-optimizer`.
+
 ---
 
 <a name="bahasa-indonesia"></a>
 ## Bahasa Indonesia
 
 ### Deskripsi
-Panduan tingkat produksi untuk Vector Database (pgvector, Qdrant, Pinecone, Milvus), arsitektur RAG, indeks pgvector HNSW, hybrid search (dense + BM25 sparse re-ranking), semantic chunking, dan evaluasi RAG.
+Panduan arsitektur tingkat produksi untuk Vector Database (PostgreSQL `pgvector 0.8+`, Qdrant, LanceDB, Pinecone), arsitektur Deep RAG modern, pencarian HNSW iteratif, **Reciprocal Rank Fusion (RRF)** hybrid retrieval, **Cross-Encoder Re-ranking** (Cohere Rerank v3, FlashRank, BGE-Reranker-v2), dan **Late Chunking** untuk mencegah fragmentasi konteks.
 
 ### Fitur Utama
-- **pgvector & Hybrid Search**: PostgreSQL `pgvector` HNSW indexing, tuning jarak cosine/L2, dan re-ranking BM25.
-- **Arsitektur RAG**: Retrieval Parent-Document, HyDE (Hypothetical Document Embeddings), dan kompresi kontekstual.
-- **Evaluasi RAG**: Scoring kualitas retrieval otomatis menggunakan Ragas dan TruLens.
+1. **pgvector 0.8+ & Indeks HNSW**: Penyimpanan vektor dimensi tinggi, tuning metrik jarak (cosine/inner-product/L2), dan pemindaian HNSW iteratif dengan filter metadata.
+2. **Reciprocal Rank Fusion (RRF)**: Menggabungkan peringkat kata kunci BM25 dengan peringkat semantik vektor menggunakan rumus $RRF(d) = \sum \frac{1}{k + rank(d)}$, jauh lebih akurat daripada pembobotan linear biasa.
+3. **Cross-Encoder Re-ranking**: Pipeline retrieval 2 tahap: ambil 50 kandidat teratas melalui pencarian hybrid, lalu urutkan ulang menjadi 5 dokumen paling relevan menggunakan model cross-encoder.
+4. **Late Chunking**: Melakukan embedding dokumen secara utuh dalam transformer sebelum memecahnya menjadi chunk-chunk terpisah, mempertahankan makna global dokumen.
+5. **Evaluasi RAG**: Pengukuran presisi retrieval dan deteksi halusinasi secara otomatis (Ragas, TruLens, DeepEval).
+
+---
+
+### Resep Implementasi Produksi
+
+#### Resep 1: Pencarian Hybrid RRF dengan Drizzle ORM
+```typescript
+import { sql } from 'drizzle-orm';
+import { db } from '@/lib/db';
+
+export async function cariDokumenRRF(
+  queryVector: number[],
+  queryText: string,
+  limit = 10,
+  k = 60
+) {
+  const vectorStr = JSON.stringify(queryVector);
+
+  const hasil = await db.execute(sql`
+    WITH vector_matches AS (
+      SELECT id, ROW_NUMBER() OVER (ORDER BY embedding <=> ${vectorStr}::vector) AS rank
+      FROM documents
+      WHERE status = 'published'
+      ORDER BY embedding <=> ${vectorStr}::vector
+      LIMIT 50
+    ),
+    text_matches AS (
+      SELECT id, ROW_NUMBER() OVER (ORDER BY ts_rank_cd(fts, websearch_to_tsquery('english', ${queryText})) DESC) AS rank
+      FROM documents
+      WHERE fts @@ websearch_to_tsquery('english', ${queryText})
+      LIMIT 50
+    )
+    SELECT
+      d.id,
+      d.content,
+      COALESCE(1.0 / (${k} + v.rank), 0.0) +
+      COALESCE(1.0 / (${k} + t.rank), 0.0) AS skor_rrf
+    FROM documents d
+    LEFT JOIN vector_matches v ON d.id = v.id
+    LEFT JOIN text_matches t ON d.id = t.id
+    WHERE v.id IS NOT NULL OR t.id IS NOT NULL
+    ORDER BY skor_rrf DESC
+    LIMIT ${limit};
+  `);
+
+  return hasil.rows;
+}
+```
+
+#### Resep 2: Pipeline Re-Ranking dengan FlashRank (Node.js / TypeScript)
+```typescript
+import { FlashRankRegistry } from 'flashrank';
+
+const ranker = new FlashRankRegistry();
+
+export async function susunUlangKandidat(kueri: string, kandidat: { id: string; text: string }[], topN = 5) {
+  const passages = kandidat.map(c => ({ id: c.id, text: c.text }));
+  
+  const hasilRerank = await ranker.rerank({
+    query: kueri,
+    passages,
+    model: 'ms-marco-TinyBERT-L-2-v2',
+  });
+
+  return hasilRerank.slice(0, topN);
+}
+```
+
+---
+
+### Checklist Implementasi
+- [ ] Buat indeks `HNSW` di PostgreSQL: `CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64);`
+- [ ] Konfigurasikan `hnsw.ef_search = 100` untuk kueri dengan recall tinggi di lingkungan produksi.
+- [ ] Terapkan Reciprocal Rank Fusion (RRF) dengan konstanta `k = 60` alih-alih pembobotan linear manual.
+- [ ] Tambahkan langkah Cross-Encoder Re-ranker sebelum menyuntikkan konteks ke prompt LLM.
+- [ ] Terapkan Late Chunking agar konteks dokumen utuh tidak hilang saat dipotong.
+
+## Integrasi Orkestrasi
+- Terintegrasi dengan: `ai-llm-integration-expert`, `database-orm-expert`, `ai-cost-token-optimizer`, `app-analyzer-optimizer`.

package/skills/vibe-code-gardener/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: vibe-code-gardener
 description: "Purger of AI slop, code bloat, context drift, and architectural decay in vibe-coded projects / Pembersih AI slop, kode membengkak, konteks drift, dan pembusukan arsitektur pada proyek vibe coding."
-author: vibes-plug-swarm
+author: "Roedy Rustam"
 ---
 
 # Vibe Code Gardener (2026 Edition)

package/skills/visual-qa-vision-agent/SKILL.md

@@ -1,65 +1,71 @@
----
-name: visual-qa-vision-agent
-description: "Equips the AI agent with visual QA capabilities using Playwright/Puppeteer and the agent's innate Vision capabilities to self-correct UI layout, CSS alignment, and visual regressions."
+---
+name: visual-qa-vision-agent
+description: "Equips the AI agent with visual QA capabilities using Playwright/Puppeteer and the agent's innate Vision capabilities to self-correct UI layout, CSS alignment, and visual regressions."
 author: "Roedy Rustam"
----
-
-# Visual QA & Vision Agent
-
-[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
-
----
-
-<a name="english"></a>
-## English
-
-### Description
-This skill transforms the agent from a blind code generator into a visual designer. Instead of hoping the CSS looks correct, the agent is instructed to write a script that takes a screenshot of the newly created component, analyzes the screenshot using its own Vision AI capabilities, and iteratively tweaks the CSS until it matches the design intent perfectly.
-
-### Trigger Conditions
-Activate this skill when the user says:
-- "Fix the CSS, the button is misaligned."
-- "Make it look exactly like this mockup."
-- "Ensure the UI is responsive on mobile screens."
-
-### Core Concepts
-
-#### 1. The Visual QA Loop
-1. **Code:** The agent writes the HTML/CSS/React component.
-2. **Serve:** The agent starts a local dev server in the background.
-3. **Capture:** The agent runs a quick Playwright/Puppeteer script to take screenshots at various viewports (Mobile, Tablet, Desktop).
-4. **Analyze:** The agent receives the screenshot (via the `view_file` tool on the image) and analyzes the visual hierarchy, contrast, and alignment.
-5. **Correct:** The agent fixes margin, padding, or flexbox issues based on what it *saw*, not just what the code says.
-
-#### 2. Agent Constraints (Mandatory Visual Verification)
-- **NO BLIND CSS GUESSING**: You are strictly prohibited from finalizing a frontend component without verifying it visually first. You MUST use a `browser_subagent` to capture a screenshot of your work.
-- **Pixel-Perfect Validation**: Compare the screenshot against the initial design spec or generic UI/UX best practices. Iterate on the CSS until the visual output is flawless.
-- Always check contrast ratios visually if design tokens are overridden.
-
----
-
-### Integration with Other Skills (MANDATORY)
-- `browser-automation-expert` — Provides the Playwright code needed to capture the screenshots.
-- `tailwind-expert` — Provides the CSS utility classes used to fix the alignment issues discovered by Vision.
-- `ui-components-expert` — Defines the correct visual standards (spacing, sizing) the agent should look for.
-
-### Referenced By Orchestrators (MANDATORY)
-- `brainstorming` — Add to "UI/UX & Design Systems".
-- `zero-to-prod-orchestrator` — Phase 5 (Frontend / UI Validation).
-
----
-
-<a name="bahasa-indonesia"></a>
-## Bahasa Indonesia
-
-### Deskripsi
-Skill ini memanfaatkan kemampuan *Vision* (penglihatan) bawaan AI untuk melakukan *Quality Assurance* (QA) visual. Agen tidak lagi sekadar menebak CSS secara buta, melainkan mengambil *screenshot* dari halaman yang dibuatnya, melihat hasilnya, dan mengkoreksi *margin/padding* secara mandiri.
-
-### Kondisi Pemicu
-- Saat pengguna meminta untuk merapikan UI yang berantakan.
-- Saat melakukan *cloning* desain dari gambar *mockup*.
-
-### Panduan Singkat
-- **Gunakan Mata Anda (Wajib Verifikasi Visual):** Anda dilarang keras memfinalisasi atau menyelesaikan tugas frontend tanpa melihat hasilnya terlebih dahulu. Anda WAJIB mengambil *screenshot*, melihatnya menggunakan tool `view_file`, dan memverifikasi layout secara visual (*pixel-perfect*).
-- **Siklus Visual:** Tulis Kode ➔ Ambil Screenshot ➔ Analisis dengan *Vision* ➔ Perbaiki Tailwind/CSS ➔ Selesai.
-- **Jangan Menebak:** Terkadang `justify-center` tidak berfungsi karena ada pembungkus (*wrapper*) absolut. Jangan menebak-nebak di dalam kode; lihat hasil akhirnya secara visual!
+---
+
+# Visual QA & Vision Agent
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
+### Description
+This skill transforms the agent from a blind code generator into a visual designer. Instead of hoping the CSS looks correct, the agent is instructed to write a script that takes a screenshot of the newly created component, analyzes the screenshot using its own Vision AI capabilities, and iteratively tweaks the CSS until it matches the design intent perfectly.
+
+### Trigger Conditions
+Activate this skill when the user says:
+- "Fix the CSS, the button is misaligned."
+- "Make it look exactly like this mockup."
+- "Ensure the UI is responsive on mobile screens."
+
+### Core Concepts
+
+#### 1. The Visual QA Loop
+1. **Code:** The agent writes the HTML/CSS/React component.
+2. **Serve:** The agent starts a local dev server in the background.
+3. **Capture:** The agent runs a quick Playwright/Puppeteer script to take screenshots at various viewports (Mobile, Tablet, Desktop).
+4. **Analyze:** The agent receives the screenshot (via the `view_file` tool on the image) and analyzes the visual hierarchy, contrast, and alignment.
+5. **Correct:** The agent fixes margin, padding, or flexbox issues based on what it *saw*, not just what the code says.
+
+#### 2. Agent Constraints (Mandatory Visual Verification)
+- **NO BLIND CSS GUESSING**: You are strictly prohibited from finalizing a frontend component without verifying it visually first. You MUST use a `browser_subagent` to capture a screenshot of your work.
+- **Pixel-Perfect Validation**: Compare the screenshot against the initial design spec or generic UI/UX best practices. Iterate on the CSS until the visual output is flawless.
+- Always check contrast ratios visually if design tokens are overridden.
+
+---
+
+### Integration with Other Skills (MANDATORY)
+- `browser-automation-expert` — Provides the Playwright code needed to capture the screenshots.
+- `tailwind-expert` — Provides the CSS utility classes used to fix the alignment issues discovered by Vision.
+- `ui-components-expert` — Defines the correct visual standards (spacing, sizing) the agent should look for.
+
+### Referenced By Orchestrators (MANDATORY)
+- `brainstorming` — Add to "UI/UX & Design Systems".
+- `zero-to-prod-orchestrator` — Phase 5 (Frontend / UI Validation).
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
+### Deskripsi
+Skill ini memanfaatkan kemampuan *Vision* (penglihatan) bawaan AI untuk melakukan *Quality Assurance* (QA) visual. Agen tidak lagi sekadar menebak CSS secara buta, melainkan mengambil *screenshot* dari halaman yang dibuatnya, melihat hasilnya, dan mengkoreksi *margin/padding* secara mandiri.
+
+### Kondisi Pemicu
+- Saat pengguna meminta untuk merapikan UI yang berantakan.
+- Saat melakukan *cloning* desain dari gambar *mockup*.
+
+### Panduan Singkat
+- **Gunakan Mata Anda (Wajib Verifikasi Visual):** Anda dilarang keras memfinalisasi atau menyelesaikan tugas frontend tanpa melihat hasilnya terlebih dahulu. Anda WAJIB mengambil *screenshot*, melihatnya menggunakan tool `view_file`, dan memverifikasi layout secara visual (*pixel-perfect*).
+- **Siklus Visual:** Tulis Kode ➔ Ambil Screenshot ➔ Analisis dengan *Vision* ➔ Perbaiki Tailwind/CSS ➔ Selesai.
+- **Jangan Menebak:** Terkadang `justify-center` tidak berfungsi karena ada pembungkus (*wrapper*) absolut. Jangan menebak-nebak di dalam kode; lihat hasil akhirnya secara visual!

package/skills/voice-ai-realtime-agent/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: voice-ai-realtime-agent
+description: "Expert guide for Ultra-Low Latency Conversational Voice AI (<300ms), WebRTC bidirectional streaming, OpenAI Realtime API, Gemini Multimodal Live Audio, LiveKit Agents, and Semantic VAD / Panduan ahli AI suara percakapan real-time berlatensi ultra-rendah."
+author: "Roedy Rustam"
+---
+
+# Voice AI Realtime Agent (2026 Edition)
+
+Expert guide for building ultra-low-latency (<300ms), bi-directional conversational voice AI applications. Covers WebRTC, full-duplex WebSocket audio streaming (PCM 24kHz), OpenAI Realtime API, Gemini Multimodal Live API, LiveKit Agents SDK, and smart interruption (barge-in) handling.
+
+*Panduan ahli untuk membangun aplikasi AI suara percakapan dua arah berlatensi ultra-rendah (<300ms) menggunakan WebRTC, WebSocket full-duplex, OpenAI Realtime API, Gemini Multimodal Live API, LiveKit Agents SDK, dan penanganan interupsi (barge-in).*
+
+---
+
+## 1. Core Architecture: Full-Duplex Speech-to-Speech
+
+Traditional voice pipelines chain STT ➔ LLM ➔ TTS with cumulative latency exceeding 1,200ms–2,500ms. Modern 2026 voice agents use **native speech-to-speech** or **streamable full-duplex WebRTC pipelines** achieving natural, human-like reaction times (~250–350ms).
+
+```
+User Mic ──► [WebRTC / WebSocket] ──► [VAD: Silero / WebRTC VAD]
+                                                │
+                                                ▼
+User Speaks <── [Audio Output] ◄── [Native Audio Stream / Cartesia] ◄── [OpenAI Realtime / Gemini Live]
+     │
+     └── User Interrupts (Barge-in) ──► Instant Buffer Flush & Cancel Audio Frame Emission
+```
+
+---
+
+## 2. Production Recipe: LiveKit Agents + OpenAI Realtime (Python)
+
+```python
+# agent.py - Production Voice Agent Worker with LiveKit & OpenAI Realtime
+import asyncio
+import os
+from livekit import rtc
+from livekit.agents import (
+    AutoSubscribe,
+    JobContext,
+    JobProcess,
+    WorkerOptions,
+    cli,
+    llm,
+)
+from livekit.agents.pipeline import VoicePipelineAgent
+from livekit.plugins import deepgram, openai, silero
+
+async def entrypoint(ctx: JobContext):
+    # Connect to room with audio only to minimize bandwidth & latency
+    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)
+    
+    # Wait for the user participant to join
+    participant = await ctx.wait_for_participant()
+    
+    # Define agent instructions and tools
+    initial_ctx = llm.ChatContext().append(
+        role="system",
+        text=(
+            "You are a helpful, concise voice assistant. "
+            "Respond naturally in 1-2 short sentences. Never output markdown, bullet points, or emojis."
+        )
+    )
+
+    # Realtime Voice Pipeline: Deepgram (STT) + OpenAI (LLM) + Cartesia/OpenAI (TTS)
+    # Or use native OpenAI Realtime Model: gpt-4o-realtime-preview
+    agent = VoicePipelineAgent(
+        vad=silero.VAD.load(
+            min_speech_duration=0.1,
+            min_silence_duration=0.3, # Snappy turn-taking
+            prefix_padding_duration=0.2,
+        ),
+        stt=deepgram.STT(model="nova-2", language="id"), # Multi-language support
+        llm=openai.LLM(model="gpt-4o-mini"),
+        tts=openai.TTS(voice="alloy"),
+        chat_ctx=initial_ctx,
+        allow_interruptions=True, # Barge-in capability
+        interrupt_speech_duration=0.3, # Immediate cutoff when user talks
+    )
+
+    agent.start(ctx.room, participant)
+    
+    # Greet user immediately
+    await agent.say("Halo! Ada yang bisa saya bantu hari ini?", now=True)
+
+if __name__ == "__main__":
+    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint))
+```
+
+---
+
+## 3. Production Recipe: Gemini Multimodal Live Audio (TypeScript / Node.js)
+
+```typescript
+// gemini-live-audio.ts - Bidirectional WebSocket PCM 24kHz
+import WebSocket from 'ws';
+
+interface GeminiAudioConfig {
+  apiKey: string;
+  model?: string;
+  systemInstruction?: string;
+}
+
+export class GeminiVoiceAgent {
+  private ws: WebSocket | null = null;
+  private isConnected = false;
+
+  constructor(private config: GeminiAudioConfig) {}
+
+  public async connect(): Promise<void> {
+    const url = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContent?key=${this.config.apiKey}`;
+    
+    this.ws = new WebSocket(url);
+
+    this.ws.on('open', () => {
+      this.isConnected = true;
+      this.sendInitialHandshake();
+    });
+
+    this.ws.on('message', (data: WebSocket.Data) => {
+      this.handleIncomingAudio(data);
+    });
+  }
+
+  private sendInitialHandshake(): void {
+    const setupMessage = {
+      setup: {
+        model: `models/${this.config.model || 'gemini-2.0-flash-exp'}`,
+        generationConfig: {
+          responseModalities: ["AUDIO"],
+          speechConfig: {
+            voiceConfig: {
+              prebuiltVoiceConfig: { voiceName: "Puck" }
+            }
+          }
+        },
+        systemInstruction: {
+          parts: [{ text: this.config.systemInstruction || "You are a conversational voice agent. Keep answers brief." }]
+        }
+      }
+    };
+    this.ws?.send(JSON.stringify(setupMessage));
+  }
+
+  // Stream raw PCM 16-bit 24kHz mono audio from mic
+  public sendAudioChunk(pcm16Chunk: Buffer): void {
+    if (!this.isConnected || !this.ws) return;
+
+    const base64Audio = pcm16Chunk.toString('base64');
+    const msg = {
+      realtimeInput: {
+        mediaChunks: [
+          {
+            mimeType: "audio/pcm;rate=24000",
+            data: base64Audio
+          }
+        ]
+      }
+    };
+    this.ws.send(JSON.stringify(msg));
+  }
+
+  private handleIncomingAudio(data: WebSocket.Data): void {
+    try {
+      const response = JSON.parse(data.toString());
+      const parts = response.serverContent?.modelTurn?.parts;
+      if (parts) {
+        for (const part of parts) {
+          if (part.inlineData?.data) {
+            const pcmBuffer = Buffer.from(part.inlineData.data, 'base64');
+            this.playAudioSpeaker(pcmBuffer);
+          }
+        }
+      }
+    } catch {
+      // Binary PCM frame handler
+    }
+  }
+
+  private playAudioSpeaker(pcmChunk: Buffer): void {
+    // Send to WebRTC audio track or audio output device
+  }
+}
+```
+
+---
+
+## 4. Key 2026 Performance Guardrails
+
+1. **Barge-in Latency Budget (<150ms)**: When the user speaks while the bot is talking, cancel outgoing audio immediately. Do not wait for the LLM to finish streaming its chunk.
+2. **Audio Sample Rates**:
+   - Mic Input: 16kHz or 24kHz 16-bit Linear PCM Mono.
+   - Bot Output: 24kHz PCM for crystal-clear natural prosody.
+3. **Turn-Taking Jitter Prevention**: Use minimum silence thresholds between `300ms` and `450ms`. Lower thresholds cause the bot to interrupt users when they pause to think; higher thresholds make the conversation feel robotic.
+
+---
+
+## Orchestration & Integration
+
+- **`ai-llm-integration-expert`**: For base LLM prompt routing and function calling during conversation.
+- **`realtime-collaboration-expert`**: For syncing WebRTC tracks and room states with client applications.
+- **`gemini-agent-booster`**: Connects Gemini 3.x / 2.0 Flash thinking models to live voice agents.
+- **`mobile-expo-expert`**: Audio streaming implementation in React Native with `expo-av` and WebRTC shim.