Obsah článku / Contents
Synapse: Ovládaj QA automatizáciu hlasom cez Gemini Live API

Synapse: Ovládaj QA automatizáciu hlasom cez Gemini Live API

Predstavte si toto: sedíte pri monitore, sledujete bežiacu aplikáciu a poviete:

"Vygeneruj testovacie scenáre pre login komponent"

A o 30 sekúnd máte hotové JSON scenáre. Bez písania príkazov. Bez prepínania okien. Len hlas.

Synapse je hlasový orchestrátor, ktorý pomocou Google Gemini Live API riadi celý QA automation stack v reálnom čase.

Problém: CLI je fajn, ale...

Máme skvelé nástroje:

  • Marker - pridá data-testid
  • Scout - vygeneruje scenáre z kódu
  • Golem - premení scenáre na testy

Ale každý vyžaduje CLI príkazy:

bash
# Marker
python marker/main.py add --project ./frontend

# Scout  
python scout/main.py generate ./frontend -o scenarios.json

# Golem
python golem/main.py generate scenarios.json -f playwright

# Spusti testy
pytest result/tests/ --base-url http://localhost:4200

4 príkazy. 4× prepnutie terminálu. 4× písanie cesty.

Čo keby ste mohli povedať:

"Pridaj test ID do frontend projektu,
 potom vygeneruj scenáre,
 vytvor Playwright testy
 a spusti ich na localhost:4200"

A AI by to všetko urobila za vás?

Riešenie: Synapse - Voice-Controlled QA Orchestrator

Synapse je hlasový command center pre QA automatizáciu:

┌─────────────────────────────────────────────────────┐
│                      VY                              │
│              (hlas alebo text)                       │
└──────────────────────┬──────────────────────────────┘
                       ↓
┌─────────────────────────────────────────────────────┐
│                   SYNAPSE                            │
│           Google Gemini Live API                     │
│      Real-time bidirectional voice                  │
└──────────────────────┬──────────────────────────────┘
                       ↓
        ┌──────────────┼──────────────┐
        ↓              ↓              ↓
   ┌─────────┐   ┌─────────┐   ┌─────────┐
   │  SCOUT  │   │  GOLEM  │   │ MARKER  │
   │ :50051  │   │ :50052  │   │ :50053  │
   │ gRPC    │   │ gRPC    │   │ gRPC    │
   └─────────┘   └─────────┘   └─────────┘

Synapse počúva váš hlas, pochopí čo chcete, a automaticky zavolá správny microservice.

Ako to funguje?

1. Real-time Voice s Gemini Live API

Synapse používa Gemini 2.0 Flash Live - nie bežné API, ale bidirectional streaming:

Vy hovoríte → mikrofón → Synapse → Gemini Live API
                                         ↓
                               AI rozumie + odpovedá
                                         ↓
Vy počujete ← reproduktor ← Synapse ← audio stream

Nie je to speech-to-text + LLM + text-to-speech. Je to natívna real-time konverzácia s AI.

2. Tool Calling

Gemini Live podporuje function calling v reálnom čase:

python
# Synapse definuje 4 nástroje
tools = [
    {
        "name": "generate_scenarios",
        "description": "Generate test scenarios from frontend code",
        "parameters": {"project_path": "string"}
    },
    {
        "name": "generate_tests",
        "description": "Generate executable tests from scenarios",
        "parameters": {"scenarios_path": "string", "framework": "string"}
    },
    {
        "name": "run_tests",
        "description": "Run generated tests",
        "parameters": {"test_dir": "string", "base_url": "string"}
    },
    {
        "name": "add_test_ids",
        "description": "Add data-testid attributes to components",
        "parameters": {"project_path": "string"}
    }
]

Keď poviete "vygeneruj scenáre pre môj Angular projekt", Gemini:

  1. Pochopí intent
  2. Vyberie správny tool (generate_scenarios)
  3. Pýta sa na chýbajúce parametre ("Aká je cesta k projektu?")
  4. Zavolá tool
  5. Oznámi výsledok hlasom

3. gRPC Microservices

Synapse komunikuje so službami cez gRPC:

python
# grpc_clients.py
class ScoutClient:
    def __init__(self, host="localhost", port=50051):
        self.channel = grpc.insecure_channel(f"{host}:{port}")
        self.stub = scout_pb2_grpc.ScoutServiceStub(self.channel)
    
    def generate_scenarios(self, project_path: str) -> ServiceResult:
        request = scout_pb2.GenerateRequest(project_path=project_path)
        response = self.stub.Generate(request)
        return ServiceResult(success=response.success, data=response.scenarios)

Každý nástroj beží ako samostatný server - Synapse ich len orchestruje.

Praktický príklad

Spustenie

bash
# 1. Spustite microservices (každý v samostatnom termináli)
cd scout && python main.py grpc-server --port 50051
cd golem && python main.py grpc-server --port 50052
cd marker && python grpc_server.py --port 50053

# 2. Spustite Synapse
cd synapse && python main.py live

Voice Session

┌────────────────────────────────────────────────────────┐
│  🎤 SYNAPSE - Voice-Controlled QA Automation            │
│  Gemini Live API connected                             │
│  Listening...                                          │
└────────────────────────────────────────────────────────┘

Vy: "Ahoj, potrebujem vygenerovať testy pre môj frontend"

AI: "Ahoj! Rád pomôžem. Aká je cesta k tvojmu frontend projektu?"

Vy: "Je to /projects/my-angular-app"

AI: "Rozumiem. Chceš najprv pridať test ID do komponentov,
     alebo už ich máš?"

Vy: "Pridaj ich prosím"

AI: "Spúšťam Marker na pridanie data-testid atribútov..."
    [Marker beží]
AI: "Hotovo! Pridaných 47 test ID do 12 komponentov.
     Mám teraz vygenerovať testovacie scenáre?"

Vy: "Áno, prosím"

AI: "Spúšťam Scout na analýzu komponentov..."
    [Scout beží]
AI: "Vygenerovaných 23 scenárov pre 8 stránok.
     Uložené do result/scenarios.json.
     Chceš z nich vytvoriť Playwright testy?"

Vy: "Áno, a potom ich spusti na localhost:4200"

AI: "Generujem Playwright testy..."
    [Golem generuje]
AI: "Vytvorených 23 testov. Spúšťam na localhost:4200..."
    [Testy bežia]
AI: "Hotovo! 21 testov prešlo, 2 zlyhali.
     Zlyhané testy: test_login_validation, test_checkout_empty_cart.
     Chceš vidieť detaily?"

Celý workflow = jedna konverzácia. Žiadne príkazy, žiadne cesty, žiadne prepínanie okien.

Tri režimy použitia

1. Live Voice (hlavný režim)

bash
python main.py live
  • Real-time hlasová konverzácia
  • Gemini Live API
  • Odporúčané slúchadlá (aby AI nepočula samu seba)

2. Text Mode (fallback)

bash
python main.py text
  • Pre prostredia bez mikrofónu
  • Interaktívny chat
  • Rovnaká funkcionalita, len písaná
> Vygeneruj scenáre pre ./frontend
AI: Spúšťam Scout...
AI: Hotovo! 15 scenárov vygenerovaných.

> Vytvor Playwright testy
AI: Z akého súboru mám čítať scenáre?

> result/scenarios.json
AI: Generujem testy...

3. Single Command (scripting)

bash
python main.py command "pridaj test ID do ./frontend"
  • Jeden príkaz, jeden výsledok
  • Ideálne pre CI/CD
  • Bez interaktivity

Architektúra

synapse/
├── main.py              # CLI entry point
├── live_voice.py        # Gemini Live API integration
├── agents.py            # Tool handlers + text mode
├── grpc_clients.py      # Scout, Golem, Marker clients
├── config.py            # Configuration
└── proto/
    └── *.proto          # gRPC definitions

live_voice.py - Srdce Synapse

python
class SynapseLive:
    def __init__(self):
        self.client = genai.Client(api_key=config.google_api_key)
        self.model = "gemini-2.0-flash-live-001"
        
    async def run(self):
        async with self.client.aio.live.connect(
            model=self.model,
            config={
                "tools": self.tools,
                "system_instruction": self.system_prompt
            }
        ) as session:
            # Concurrent tasks
            await asyncio.gather(
                self.send_audio(session),    # Mic → Gemini
                self.receive_audio(session), # Gemini → Speaker
                self.handle_tools(session)   # Tool calls
            )

System Instruction

python
system_prompt = """
Si QA automation asistent. Máš k dispozícii 4 nástroje:

1. generate_scenarios(project_path) - Vygeneruje test scenáre z kódu
2. generate_tests(scenarios_path, framework, base_url) - Vytvorí testy
3. run_tests(test_dir, base_url, headed) - Spustí testy
4. add_test_ids(project_path) - Pridá data-testid atribúty

Keď používateľ potrebuje zadať cestu, povedz mu nech ju napíše.
Vždy potvrď čo ideš robiť predtým ako to spravíš.
Hovor slovensky alebo anglicky podľa používateľa.
"""

Podporované príkazy (hlasom)

Čo povieteČo Synapse spraví
"Pridaj test ID do projektu"Zavolá Marker
"Vygeneruj scenáre"Zavolá Scout
"Vytvor Playwright testy"Zavolá Golem generate
"Spusti testy"Zavolá Golem run
"Spusti testy s browserom"Golem run --headed
"Použi Firefox"Golem run --browser firefox
"Analyzuj projekt"Scout analyze
"Preview zmeny"Marker dry-run
"Rollback"Marker rollback

Synapse rozumie kontextu - nemusíte opakovať cesty ak ste ich už zadali.

Prečo Voice Control?

1. Hands-Free Testing

Monitor 1: Bežiaca aplikácia
Monitor 2: DevTools
Vy: Sledujete UI a hovoríte príkazy

"Spusti test pre checkout flow"
[Sledujete ako test beží v browseri]
"Ten button nefunguje, pridaj mu test ID"
[Marker pridá ID]
"Regeneruj test"
[Nový test s lepším selektorom]

2. Rýchlejšie Iteration

bash
# CLI: 4 kroky
python scout/main.py generate ./frontend -o scenarios.json
python golem/main.py generate scenarios.json -f playwright
pytest result/tests/
# Našli ste bug, opravíte, a znovu...

# Voice: 1 veta
"Regeneruj a spusti testy"

3. Nižšia Cognitive Load

Nemusíte si pamätať:

  • Syntax príkazov
  • Cesty k súborom
  • Parametre a flagy
  • Poradie operácií

Poviete čo chcete, AI vyrieši ako.

Konfigurácia

env
# .env
GOOGLE_API_KEY=your-gemini-api-key

# Microservice ports
SCOUT_HOST=localhost
SCOUT_PORT=50051

GOLEM_HOST=localhost
GOLEM_PORT=50052

MARKER_HOST=localhost
MARKER_PORT=50053

# Output
OUTPUT_DIR=result

Audio Setup

Synapse používa prebuilt wheels - žiadna kompilácia:

bash
# Inštalácia (Windows/macOS/Linux)
pip install sounddevice numpy

# Zoznam audio zariadení
python main.py devices

# Output:
# Input devices:
#   0: Microphone (Realtek Audio)
#   1: Headset Microphone
# Output devices:
#   0: Speakers (Realtek Audio)
#   1: Headphones

Tip: Používajte slúchadlá, aby mikrofón nezachytával výstup z reproduktorov.

Kompletný QA Stack s Voice Control

┌─────────────────────────────────────────────────────┐
│                    SYNAPSE                           │
│            Voice Command Center                      │
│         "Vygeneruj a spusti testy"                  │
└──────────────────────┬──────────────────────────────┘
                       ↓
┌─────────────────────────────────────────────────────┐
│                    MARKER                            │
│   "Pridaj test ID" → data-testid atribúty           │
└──────────────────────┬──────────────────────────────┘
                       ↓
┌──────────────────────┴──────────────────────────────┐
│                                                      │
│  ┌─────────────┐              ┌─────────────┐       │
│  │   SCOUT     │              │  SENTINEL   │       │
│  │ "Analyzuj   │              │ "Prehľadaj  │       │
│  │  kód"       │              │  UI"        │       │
│  └──────┬──────┘              └──────┬──────┘       │
│         └──────────┬─────────────────┘              │
│                    ↓                                 │
│           JSON Scenáre                              │
└────────────────────┬────────────────────────────────┘
                     ↓
┌─────────────────────────────────────────────────────┐
│                    GOLEM                             │
│   "Vytvor testy" → Playwright/Cypress/Robot         │
│   "Spusti testy" → pytest execution                 │
└─────────────────────────────────────────────────────┘

Voice-first workflow:

Vy: "Kompletný test workflow pre frontend"

Synapse:
1. Zavolá Marker → pridá test ID
2. Zavolá Scout → vygeneruje scenáre
3. Zavolá Golem → vytvorí testy
4. Zavolá Golem → spustí testy
5. Reportuje výsledky hlasom

Vy: [Počúvate výsledky, sledujete browser]

Quick Start

bash
# 1. Získajte Gemini API key
# https://aistudio.google.com/apikey

# 2. Nakonfigurujte
cp .env.example .env
# Upravte GOOGLE_API_KEY

# 3. Nainštalujte
pip install google-genai sounddevice numpy grpcio protobuf python-dotenv pydantic

# 4. Spustite microservices
# (V samostatných termináloch)
cd scout && python main.py grpc-server
cd golem && python main.py grpc-server
cd marker && python grpc_server.py

# 5. Spustite Synapse
cd synapse && python main.py live

# 6. Hovorte!
"Ahoj, pomôž mi s testami pre môj Angular projekt"

Use Cases

1. QA Engineer - Daily Workflow

Ráno: "Spusti regresné testy pre staging"
Po bug fixe: "Regeneruj testy pre login modul"
Pred PR: "Pridaj test ID do nových komponentov"

2. Developer - Quick Validation

"Vygeneruj smoke testy pre komponent ktorý som práve napísal"
[Pokračuje v kódovaní, testy bežia na pozadí]
"Ako dopadli testy?"

3. CI/CD Integration

yaml
# Voice command cez single mode
- name: Generate and run tests
  run: |
    python synapse/main.py command "generate tests for ./frontend"
    python synapse/main.py command "run tests on $STAGING_URL"

4. Demo / Prezentácia

"Ukáž mi ako funguje test automation"
[Synapse ukazuje celý workflow hlasom]

Záver

Synapse mení paradigmu QA automatizácie:

Tradičný prístupSo Synapse
CLI príkazyHlasové povely
Pamätať syntaxAI rozumie intent
Prepínať terminályJedna konverzácia
Manuálna orchestráciaAI koordinuje služby
Keyboard-firstVoice-first

Kedy použiť Synapse:

  • ✅ Chcete hands-free testing
  • ✅ Potrebujete rýchlu iteráciu
  • ✅ Máte running QA microservices (Scout, Golem, Marker)
  • ✅ Preferujete konverzáciu pred príkazmi

Synapse nie je len voice interface. Je to inteligentný asistent, ktorý rozumie QA workflow, pamätá si kontext, a koordinuje celý automation stack.

Povedzte mu čo potrebujete. On sa postará o zvyšok.

Synapse je orchestrátor pre QA automation ecosystem: Marker, Scout, Sentinel a Golem. Všetky nástroje komunikujú cez gRPC a môžu byť ovládané jedným hlasom.

Všetky články