---
url: https://docs.ogmabox.com/cs/mcp-setup.md
description: >-
  Připojte AI agenty k Ogma přes Streamable HTTP nebo stdio, nastavte oprávnění
  a používejte místní koncové body pro správu MCP.
---

# Nastavení serveru Ogma MCP {#ogma-mcp-server-setup}

Server Ogma MCP (`ogma-mcp`) umožňuje kompatibilním AI asistentům prohlížet kontext projektu a po povolení také ovládat vestavěný prohlížeč, odesílat požadavky, spouštět pracovní postupy a shromažďovat důkazy. Jeho nástroje pro poznámky a úkoly slouží jako pracovní zápisník relace MCP v paměti, oddělený od trvale ukládané stránky Poznámky v aplikaci.

MCP je určen pro externí nástroje, například Codex, Claude Code, Cursor a další klienty protokolu Model Context Protocol. Jde o jinou funkci než AI asistent v pracovním prostoru přímo v aplikaci.

Úplný seznam zdrojů a nástrojů najdete na stránce [Zdroje a nástroje MCP](./reference/mcp-tools.md).

## Rychlý začátek: desktopová aplikace {#quick-start-desktop-app}

1. Spusťte Ogma a otevřete projekt, který má agent prohlížet.
2. Otevřete **Nastavení > MCP**, vyberte potřebná oprávnění a uložte je. Interakce s prohlížečem vyžaduje **Odesílání opakovaných požadavků**.
3. Klikněte na **Spustit** a zkopírujte zobrazený koncový bod, obvykle `http://127.0.0.1:3000/mcp`.
4. Přidejte jej do klienta MCP jako server **Streamable HTTP**.
5. Požádejte agenta, aby zavolal `ogma_explain_capabilities` a přečetl `ogma://project/current` pro ověření připojení a aktivního projektu.

Tato cesta nevyžaduje samostatné sestavení binárního souboru. Navigaci po stránkách, formuláře, přihlašovací postupy a řešení problémů popisuje [Automatizace prohlížeče pomocí MCP](./guide/mcp-browser.md).

### Adresy připojení {#connection-addresses}

| Rozhraní | Výchozí adresa | Účel |
| --- | --- | --- |
| Transport MCP | `http://127.0.0.1:3000/mcp` | Zde se připojují nativní klienti MCP. |
| Backendové REST API | `http://127.0.0.1:8181` | `--api-url` samostatného MCP a níže uvedené trasy pro správu a přemostění. |
| Naslouchající proxy | `127.0.0.1:8080` | Zachytává provoz prohlížeče; nejde o koncový bod MCP. |

Desktopové instance mohou port backendového API přidělovat dynamicky. Pro integrace stdio/REST používejte adresu skutečně běžící instance a pro nativní MCP koncový bod zobrazený v Nastavení. Cloudová chatovací služba se bez místního klienta či konektoru k vaší adrese zpětné smyčky nedostane.

Koncový bod HTTP je stavový: inicializaci a hlavičky relace ponechte na klientovi. Samostatný starší koncový bod `/sse` neexistuje. Vlastní klienti by měli dodržovat [specifikaci transportu](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports) MCP.

## Kdy používat MCP {#when-to-use-mcp}

Použijte MCP, když vám má externí asistent pomoci:

* Shrnovat zachycený provoz.
* Třídit nálezy podle priority.
* Připravovat text zprávy podložený důkazy.
* Kontrolovat pracovní postupy a relace funkce Opakované odesílání (Replay).
* Připravovat akce v určeném rozsahu, které výslovně schválíte.

Pokud chcete používat vestavěné okno asistenta uvnitř Ogma, použijte místo toho [AI v pracovním prostoru](./guide/workspace-ai.md).

## Požadavky pro samostatné spuštění {#standalone-requirements}

Použijte stdio, pokud váš klient potřebuje spouštět místní spustitelný soubor místo připojení k vestavěnému koncovému bodu HTTP.

* Backend Ogma běžící na své skutečné adrese API (výchozí adresa CLI: `http://127.0.0.1:8181`)
* Binární soubor `ogma-mcp` (sestavený ze zdrojového kódu)

## Sestavení {#build}

```bash
cargo build --locked --bin ogma-mcp --release
```

Výchozím výstupem je `target/release/ogma-mcp` (`ogma-mcp.exe` ve Windows), pokud nemáte upravený cílový adresář Cargo.

## Spuštění {#run}

```bash
# Connect to Ogma running on the default port
./ogma-mcp

# Connect to a custom address
./ogma-mcp --api-url http://127.0.0.1:9090

# Use a larger body preview
./ogma-mcp --body-preview-bytes 2048
```

Pokud server nemůže navázat spojení s API Ogma, ukončí se. Nastavte klienta MCP tak, aby spouštěl tento příkaz; stdout přenáší zprávy MCP a stderr diagnostiku. Oprávnění stdio vycházejí z jeho vlastních přepínačů, nikoli z nastavení vestavěného MCP.

## Vyhledávání nástrojů {#tool-discovery}

Současný server vždy zveřejňuje celý katalog nástrojů. V Nastavení není volba profilu nástrojů. Starší hodnoty `--tool-profile`, `--mcp-tool-profile` a `OGMA_MCP_TOOL_PROFILE` jsou přijímány kvůli kompatibilitě, ale neskrývají nástroje ani neudělují oprávnění.

U rozsáhlého katalogu začněte nástroji `ogma_explain_capabilities` a `ogma_find_tools`, místo abyste vstupy odhadovali. Vyhledáním klíčových slov úkolu zúžíte výběr nástrojů a dotazem na přesný název nástroje pak prozkoumáte jeho kontrakt. Dispečery pro prohlížeč a vyhledávání poskytují pohodlné vstupní body; specializované nástroje zůstávají přímo dostupné. Viz [vyhledávání a směrování nástrojů](./reference/mcp-tools.md#tool-discovery-and-dispatch).

## Nastavení MCP v aplikaci {#in-app-mcp-settings}

Distribuovaná sestavení Ogma umožňují spravovat MCP přes **Nastavení > MCP**. Tuto obrazovku použijte, pokud chcete, aby Ogma spouštěla nebo zastavovala vestavěný proces MCP pro aktivní instanci.

Pokud váš AI klient očekává přímé spouštění serveru MCP, použijte samostatný binární soubor `ogma-mcp`.

Uložení nastavení automaticky restartuje běžící vestavěný proces MCP. Poté klienty znovu připojte; stará ID relací ani potvrzovací tokeny nelze znovu použít. **Diagnostika běhu** zobrazuje nedávný výstup procesu.

Ogma také poskytuje správu MCP prostřednictvím místního REST API. Tyto trasy jsou na **portu backendového API**, nikoli na vyhrazeném portu MCP. Používá je obrazovka nastavení a přemostění AI v aplikaci:

| Koncový bod | Účel |
| --- | --- |
| `GET /mcp/status` | Vrací `{ running, pid, endpoint, config, diagnostics }`. Při zastavení je `endpoint` null; diagnostika obsahuje nedávné záznamy `{ stream, message }`. |
| `POST /mcp/start` | Spustí vestavěné MCP s uloženým nastavením a vrátí stav. Bez těla. Pokud již běží, vrátí konflikt. |
| `POST /mcp/stop` | Zastaví podřízený proces vestavěného MCP. |
| `GET /settings/mcp` | Vrátí uloženou konfiguraci MCP. |
| `PUT /settings/mcp` | Přijme úplný objekt konfigurace, uloží jej a restartuje MCP, pokud běží. Vrátí přijatou konfiguraci nebo chybu. Povoleny jsou pouze hostitelské adresy zpětné smyčky pro naslouchání. |
| `GET /mcp/tools` | Vrátí `{ tools, config }` včetně `inputSchema` každého nástroje. Tento katalog REST není stránkovaný. |
| `POST /mcp/tools/call` | Zavolá jeden nástroj pomocí `{ "name": "ogma_explain_capabilities", "arguments": {} }`. Vrací `{ "result": "..." }`; tento text zpracujte jako JSON obálku nástroje. Nejde o nativní výsledek MCP s obrazovými bloky. |

Přemostění REST používá uložená oprávnění, ale nevyžaduje spuštění samostatného podřízeného procesu HTTP MCP. Sdílí jednu relaci přemostění pro backend a konfiguraci. Pro izolované klientské relace a obrazový výstup upřednostňujte nativní MCP.

Při selhání přemostění získáte zpracováním `result` hodnotu `{ "error": "..." }` obsahující serializovanou chybovou obálku. Kontrolujte tuto hodnotu; úspěšný stav HTTP sám o sobě neznamená úspěch nástroje.

Výchozí uložená konfigurace MCP:

```json
{
  "bind_host": "127.0.0.1",
  "port": 3000,
  "allow_write_findings": false,
  "allow_export_data": false,
  "allow_read_secrets": false,
  "allow_send_requests": false,
  "allow_run_workflows": false,
  "allow_intercept_control": false,
  "tool_profile": "full"
}
```

Povolené hostitelské adresy pro naslouchání jsou `127.0.0.1`, `localhost` a `::1`; porty musí být v rozmezí `1024` až `65535`. Toto sestavení nenastavuje autentizaci MCP vystaveného do sítě, proto veřejné adresy pro naslouchání odmítá. Starší pole `allow_public_bind` a `acknowledge_write_tool_risk` toto omezení nepřebíjejí.

## Claude Code {#claude-code}

Pro koncový bod běžící desktopové aplikace:

```bash
claude mcp add --transport http ogma http://127.0.0.1:3000/mcp
```

Pokud Ogma zobrazuje jiný koncový bod, použijte jej. Rozsahy konfigurace a možnosti stdio popisuje [konfigurace MCP v Claude Code](https://code.claude.com/docs/en/mcp). Ověřte ji dotazem: „Jaké projekty má Ogma?“

## Cursor {#cursor}

Začleňte tuto položku do projektového souboru `.cursor/mcp.json` nebo uživatelského souboru `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "ogma": {
      "url": "http://127.0.0.1:3000/mcp"
    }
  }
}
```

Povolte připojení v nastavení MCP v Cursoru. Viz [dokumentace MCP pro Cursor](https://cursor.com/docs/mcp).

### Konfigurace klienta stdio {#stdio-client-configuration}

Klienti, kteří spouštějí spustitelný soubor, mohou použít tuto položku serveru a podle potřeby upravit umístění svého konfiguračního souboru:

```json
{
  "mcpServers": {
    "ogma": {
      "command": "/absolute/path/to/ogma-mcp",
      "args": ["--api-url", "http://127.0.0.1:8181"]
    }
  }
}
```

Ve Windows použijte úplnou cestu ke spustitelnému souboru a v JSON escapujte zpětná lomítka. Někteří klienti také vyžadují `"type": "stdio"`. Podle potřeby přidejte do `args` přepínače oprávnění.

## Oprávnění {#permissions}

Všech šest privilegovaných funkcí je ve výchozím stavu zakázáno. Jejich aktuální hodnoty načtěte z `ogma://mcp/permissions`. Nástroj uvedený v seznamu může stále odmítnout spuštění, dokud jeho funkce není povolena. Úplná tabulka přepínačů a proměnných prostředí je v [referenční dokumentaci CLI](./reference/cli.md#standalone-ogma-mcp-flags).

Interakce s prohlížečem, správa kontextů, přepínání projektů a všechna volání přihlašovacích postupů vyžadují `--allow-send-requests`. Pozorování prohlížeče umožňuje prohlížet již běžící prohlížeč bez povolení nástrojů pro jeho ovládání. `--allow-read-secrets` (nebo `OGMA_MCP_ALLOW_READ_SECRETS=true`) samostatně povoluje nemaskované hodnoty proměnných prostředí.

Server nemá **žádné kvóty aktivity na minutu ani na relaci**. Jednotlivé nástroje nadále vynucují velikosti vstupů, velikosti dávek, kontroly rozsahu a časové limity. Starší přepínače kvót pro odesílání a pracovní postupy již nejsou podporovány.

## Režim pouze pro čtení {#read-only-mode}

Ve výchozím stavu je server MCP pouze pro čtení. Následující operace nejsou dostupné, pokud je výslovně nepovolíte:

* Odesílání požadavků (Opakované odesílání)
* Ovládání vestavěného prohlížeče, crawleru, zachytávání autentizace a pomocných nástrojů aktivního sondování
* Spouštění pracovních postupů
* Vytváření či úpravy nálezů
* Úpravy rozsahu nebo pravidel funkce Vyhledat a nahradit (Match & Replace)
* Úpravy nebo předávání zadrženého provozu
* Mazání dat
* Přístup k tajným hodnotám proměnných prostředí
* Export dat

Náhledy těla mají ve výchozím stavu 512 bajtů. `--body-preview-bytes` upravuje velikost náhledů a musí být alespoň 1; neurčuje horní mez výstupu každého nástroje. Pro úplné tělo HTTP nebo cílené vyhledávání v těle použijte `ogma_get_http_entry_body` a pro úplnou zprávu WebSocket použijte `ogma_get_ws_message`.

## Nástroje pro zápis nálezů {#finding-write-tools}

Pro povolení vytváření nálezů s pomocí AI restartujte ogma-mcp s oprávněním k zápisu:

```bash
./ogma-mcp --allow-write-findings
```

Nebo nastavte proměnnou prostředí:

```bash
OGMA_MCP_ALLOW_WRITE_FINDINGS=true ./ogma-mcp
```

### Dostupné nástroje pro zápis {#write-tools-available}

| Nástroj | Popis |
|------|-------------|
| `ogma_preview_finding_from_evidence` | Zobrazí náhled návrhu nálezu ze záznamu HTTP (pouze pro čtení, vždy dostupný) |
| `ogma_create_finding` | Vytvoří nález se závažností, stavem, štítky a odkazy na důkazy |
| `ogma_update_finding` | Aktualizuje existující nález |
| `ogma_add_finding_tag` | Přidá štítky k nálezu bez nahrazení existujících štítků |
| `ogma_link_finding_evidence` | Propojí s nálezem záznam HTTP, pokus opakovaného odesílání, výsledek funkce Automatizace (Automate) nebo zprávu WS |
| `ogma_delete_finding` | Smaže jeden nález |
| `ogma_export_findings_report` | Vygeneruje zprávu HTML, Markdown nebo PDF |

Současná implementace používá oprávnění k zápisu nálezů také pro sdílené nástroje zápisu, například aktualizace proměnných prostředí, anotace historie, výběr rozsahu a úpravy pravidel funkce Vyhledat a nahradit. Tyto akce popisuje [katalog nástrojů](./reference/mcp-tools.md).

### Příklad: vytváření nálezů s pomocí AI {#example-ai-assisted-finding-creation}

S `--allow-write-findings`:

1. „Analyzujte záznam HTTP {id} z hlediska bezpečnostních problémů. Pokud najdete skutečný problém, zdokumentujte jej pomocí ogma\_create\_finding.“
2. AI zavolá `ogma_get_http_entry`, aby prozkoumala požadavek
3. Pokud důkazy podporují nález, zavolá `ogma_create_finding` s propojenými důkazy

### Nadále nedostupné pouze s oprávněním k zápisu nálezů {#still-not-available-with-finding-writes-only}

* Odesílání přes funkci Opakované odesílání
* Spouštění pracovních postupů
* Vytváření exportů
* Ovládání fronty funkce Zachytávání (Intercept)
* Přepínání projektů

## Nástroje exportu {#export-tools}

Pro povolení vytváření exportních úloh s pomocí AI restartujte ogma-mcp s oprávněním k exportu:

```bash
./ogma-mcp --allow-export-data
```

Nebo nastavte proměnnou prostředí:

```bash
OGMA_MCP_ALLOW_EXPORT_DATA=true ./ogma-mcp
```

### Dostupné nástroje exportu {#export-tools-available}

| Nástroj | Požadované oprávnění | Popis |
|------|--------------------|-------------|
| `ogma_preview_export_plan` | Žádné (pouze pro čtení) | Zobrazí náhled toho, co by export obsahoval |
| `ogma_list_export_jobs` | Žádné (pouze pro čtení) | Vypíše nedávné exportní úlohy |
| `ogma_get_export_job` | Žádné (pouze pro čtení) | Zkontroluje stav exportní úlohy |
| `ogma_get_export_download_info` | Žádné (pouze pro čtení) | Získá URL pro stažení dokončeného exportu |
| `ogma_create_export_job` | export\_data | Vytvoří exportní úlohu |

### Podporované druhy a formáty exportu {#supported-export-kinds-and-formats}

| Druh | Popis | Formáty |
|------|-------------|---------|
| `http_history` | Všechny požadavky HTTP procházející proxy | json, csv, raw\_http |
| `search` | Filtrované požadavky HTTP | json, csv, raw\_http |
| `findings` | Bezpečnostní nálezy | json, csv |
| `automate_results` | Výsledky relací funkce Automatizace | json, csv |

Poznámka: formát `raw_http` je platný pouze pro druhy `http_history` a `search`.

### Bezpečnostní upozornění {#security-warning}

Exportované soubory mohou obsahovat úplná těla požadavků a odpovědí HTTP, ve kterých mohou být hesla, tokeny a osobní údaje. S exportovanými soubory zacházejte s náležitou opatrností.

### Nadále nedostupné pouze s oprávněním k exportu {#still-not-available-with-export-permissions-only}

* Mazání exportovaných souborů
* Přejmenování exportovaných souborů
* Streamování obsahu exportu přes MCP
* Odesílání přes funkci Opakované odesílání
* Spouštění pracovních postupů

## Odesílání požadavků přes funkci Opakované odesílání {#replay-request-sending}

Varování: toto povoluje odesílání skutečného odchozího provozu HTTP přes funkci Opakované odesílání v Ogma.

Pro povolení:

```bash
./ogma-mcp --allow-send-requests
```

Nebo prostřednictvím proměnných prostředí:

```bash
OGMA_MCP_ALLOW_SEND_REQUESTS=true ./ogma-mcp
```

### Předpoklady {#prerequisites}

1. Proxy Ogma musí běžet
2. Pro opakované odesílání s kontrolou rozsahu musí být v sekci **Rozsahy testování** nastaven aktivní rozsah
3. Cílový hostitel musí být v aktivním rozsahu

### Nástroje odesílání {#send-tools}

| Nástroj | Oprávnění | Popis |
|------|-----------|-------------|
| `ogma_preview_replay_send` | send\_requests | Připraví odeslání a získá potvrzovací token |
| `ogma_send_replay_request` | send\_requests | Provede odeslání s potvrzovacím tokenem |
| `ogma_create_replay_session_from_history` | send\_requests | Vytvoří relaci opakovaného odesílání |
| `ogma_create_replay_session_raw` | send\_requests | Vytvoří relaci opakovaného odesílání ze surové definice požadavku |
| `ogma_browser_form_to_replay` | send\_requests | Vytvoří relaci opakovaného odesílání z formuláře na aktuální stránce |
| `ogma_create_scope_preset` | send\_requests | Uloží předvolbu rozsahu; aktivujte ji zvlášť pomocí `ogma_set_active_scope` |
| `ogma_repeat_request` | send\_requests | Zopakuje zachycený požadavek s volitelnými změnami |
| `ogma_replay_with_modifications` | send\_requests | Zopakuje zachycený požadavek s přepsáním jednotlivých polí |
| `ogma_http_request` | send\_requests | Odešle přímý požadavek HTTP |
| `ogma_fetch_url` | send\_requests | Načte URL a vrátí stav, hlavičky a náhled |
| `ogma_follow_redirect` | send\_requests | Sleduje řetězec přesměrování a uvede každý krok |
| `ogma_bulk_send_requests` | send\_requests | Odešle dávku požadavků s omezenou velikostí |
| `ogma_fuzz_parameter` | send\_requests | Nahradí zástupný výraz `{{FUZZ}}` hodnotami ze seznamu slov |
| `ogma_multipart_upload` | send\_requests | Odešle požadavky multipart form-data pro testování nahrávání |
| `ogma_websocket_connect` | send\_requests | Připojí se k URL WebSocket a vymění zprávy |
| `ogma_login_replay_auto` | send\_requests | Odešle přihlašovací formulář v prohlížeči a zachytí autentizační profil |
| `ogma_auth_capture_profile` | send\_requests | Zachytí cookies, úložiště, autentizační tokeny a kandidáty CSRF z prohlížeče |
| `ogma_auth_apply_profile` | send\_requests | Použije zachycený autentizační profil v prohlížeči |
| `ogma_auth_refresh_csrf` | send\_requests | Obnoví kandidáty CSRF ze stavu prohlížeče |
| `ogma_authz_matrix_test` | send\_requests | Zopakuje jeden požadavek pod více autentizačními profily |
| `ogma_run_active_probe_workflow` | send\_requests | Spustí omezené aktivní sondy pro konkrétní zranitelnosti |
| `ogma_test_race` | send\_requests | Odešle jeden požadavek souběžně a uvede odpovědi, které se odchylují od nejčastějšího stavového kódu |
| `ogma_test_smuggling` | send\_requests | Odešle sondy desynchronizace požadavků CL.TE a TE.CL přes surové TCP |
| `ogma_test_hpp` | send\_requests | Odešle varianty znečištění parametrů HTTP |
| `ogma_run_nuclei` | send\_requests | Spustí skener šablon proti cílové URL s jednou přibalenou nebo dodanou šablonou |
| `ogma_browser_navigate` a nástroje interakce s prohlížečem | send\_requests | Ovládají vestavěný prohlížeč a zachytávají výsledný provoz |
| `ogma_crawl_site` | send\_requests | Prochází cílový web v určeném rozsahu přes vestavěný prohlížeč |
| `ogma_get_replay_session` | Žádné | Zobrazí metadata relace opakovaného odesílání |
| `ogma_get_replay_attempt` | Žádné | Zobrazí metadata pokusu opakovaného odesílání |
| `ogma_list_replay_sessions` | Žádné | Vypíše relace opakovaného odesílání |

### Dvoukrokový postup {#two-step-workflow}

Dvojice nástrojů opakovaného odesílání vyžadující potvrzení používá dvě volání:

1. `ogma_preview_replay_send` – zkontrolujte požadavek a získejte potvrzovací token
2. `ogma_send_replay_request` – potvrďte a odešlete pomocí tokenu

Potvrzovací tokeny vyprší za 5 minut, jsou jednorázové a patří relaci MCP, která je vytvořila. Po změně požadavku nebo restartu MCP vytvořte náhled znovu. Toto dvoukrokové pravidlo se nevztahuje na všechny nástroje odesílání: přímé nástroje HTTP, pomocné nástroje opakování a akce prohlížeče mohou po povolení odesílat okamžitě.

### Příklad relace {#example-session}

```
Uživatel: Znovu odešlete záznam HTTP abc123 a zkontrolujte odpověď
AI: (zavolá ogma_preview_replay_send s http_entry_id="abc123")
    - zobrazí náhled požadavku, potvrzovací token a stav rozsahu --
AI: (zavolá ogma_send_replay_request s confirmation_token a request_hash)
    - zobrazí stav odpovědi, časování a náhled odpovědi --
```

### Nadále nedostupné pouze s oprávněním k odesílání požadavků {#still-not-available-with-request-sending-permissions-only}

* Spouštění pracovních postupů
* Vytváření nebo aktualizace nálezů
* Mazání

Před povolením těchto nástrojů udržujte aktivní rozsah úzký. Kontroly rozsahu se uplatňují u způsobů odesílání, které je vynucují; nepovažujte rozsah za univerzální firewall kolem libovolného JavaScriptu v prohlížeči nebo každého pomocného nástroje přímého načítání.

## Ovládání funkce Zachytávání {#intercept-control}

Varování: ovládání funkce Zachytávání umožňuje klientovi MCP předávat, zahazovat nebo upravovat živý provoz právě zadržovaný v její frontě v Ogma.

Pro povolení:

```bash
./ogma-mcp --allow-intercept-control
```

Nebo prostřednictvím proměnné prostředí:

```bash
OGMA_MCP_ALLOW_INTERCEPT_CONTROL=true ./ogma-mcp
```

### Nástroje funkce Zachytávání {#intercept-tools}

| Nástroj | Oprávnění | Popis |
|------|-----------|-------------|
| `ogma_get_intercept_status` | intercept\_control | Přečte stav zadržování požadavků, odpovědí a WebSocket |
| `ogma_set_intercept_enabled` | intercept\_control | Povolí nebo zakáže režimy zadržování |
| `ogma_list_intercept_queue` | intercept\_control | Vypíše aktuálně zadržované položky |
| `ogma_get_intercept_item` | intercept\_control | Prozkoumá jednu položku ve frontě |
| `ogma_forward_intercept_item` | intercept\_control | Předá položku ve frontě, volitelně upravenou |
| `ogma_drop_intercept_item` | intercept\_control | Zahodí položku ve frontě |
| `ogma_intercept_and_modify` | intercept\_control | Počká na odpovídající položku, upraví ji a předá |

## Spouštění pracovních postupů {#workflow-execution}

Varování: spouštění pracovních postupů provádí jejich logiku. Některé pracovní postupy odesílají provoz HTTP nebo vytvářejí nálezy.

Pro povolení:

```bash
./ogma-mcp --allow-run-workflows
```

### Nástroje spouštění pracovních postupů {#workflow-execution-tools}

| Nástroj | Oprávnění | Popis |
|------|-----------|-------------|
| `ogma_get_workflow_safety` | Žádné (pouze pro čtení) | Klasifikuje vedlejší účinky pracovního postupu |
| `ogma_preview_workflow_run` | run\_workflows | Zobrazí náhled a získá potvrzovací token |
| `ogma_run_workflow` | run\_workflows | Provede spuštění s potvrzovacím tokenem |
| `ogma_cancel_workflow_run` | run\_workflows | Zruší běžící aktivní pracovní postup |

Náhled vytvořte pomocí `workflow_id` a navíc `input` pro konverzní pracovní postup nebo `trigger_entry_id` pro zachycený vstup aktivního pracovního postupu. Spusťte jej pomocí vrácených `confirmation_token` a `definition_hash`; konverzní pracovní postupy také potřebují `input_hash` a stejný `input`. Tokeny vyprší po pěti minutách a jsou jednorázové. Výsledný běh načtěte pomocí `ogma_get_workflow_run`.

Spouštění funkce Automatizace je dostupné prostřednictvím jejích nástrojů relací a běhů s **oprávněním k odesílání požadavků**, nikoli s oprávněním ke spouštění pracovních postupů. Výpis a prohlížení existujících běhů nevyžaduje oprávnění k odesílání.

### Požadavky na kombinaci oprávnění {#cross-permission-requirements}

Pracovní postupy používající `sdk.requests.send` vyžadují také `--allow-send-requests`.
Pracovní postupy používající `sdk.findings.create` vyžadují také `--allow-write-findings`.

Detekce vychází ze statické analýzy textu – viz níže uvedené upozornění.

### Upozornění ke klasifikaci bezpečnosti {#safety-classification-advisory-note}

Klasifikace bezpečnosti pracovního postupu prohledává text zdrojového kódu JavaScriptu a hledá vzory jako `sdk.requests.send`. Tato detekce není úplná – obfuskovaná nebo dynamicky sestavená volání metod SDK nemusí být odhalena. Před spuštěním nedůvěryhodných pracovních postupů vždy zkontrolujte jejich zdrojový kód JavaScriptu.

### Nadále nedostupné pouze s oprávněním k pracovním postupům {#still-not-available-with-workflow-permissions-only}

* Ruční spouštění pasivního pracovního postupu
* Mazání
* Úpravy proměnných prostředí

## Příklady zadání {#example-prompts}

Po připojení:

* „Zobrazte posledních 20 požadavků HTTP na example.com“
* „Jsou v tomto projektu nějaké nálezy s vysokou nebo kritickou závažností?“
* „Které pracovní postupy jsou právě povoleny?“
* „Ověřte, zda je dotaz HTTPQL `req.method.eq:\"POST\"` platný“
* „Shrňte bezpečnostní stav aktuálního projektu“
* „Analyzujte záznam HTTP {id} z hlediska bezpečnostních problémů“

## Řešení problémů {#troubleshooting}

**Připojení odmítnuto:** Nejprve spusťte Ogma (`ogma --data-dir ./ogma-data`).

**Klient MCP nezobrazuje žádné nástroje:** Zkontrolujte URL transportu nebo cestu ke spustitelnému souboru. Klienti musí sledovat všechny kurzory `tools/list`; každá stránka obsahuje až 40 nástrojů. Zkontrolujte filtrování na straně klienta a zda vaše nainstalovaná verze obsahuje chybějící nástroj.

**Neplatná relace nebo potvrzovací token:** Po restartu se znovu připojte a vygenerujte nový token náhledu.

**Prohlížeč není dostupný nebo akce selhala:** Nechte desktopovou aplikaci běžet. Zkontrolujte `ogma_browser_health`, dialogy a [obnovu prohlížeče](./guide/mcp-browser.md#recover-from-errors). Samotný backend bez grafického rozhraní neposkytuje přemostění desktopového prohlížeče.

**Snímek obrazovky nemá čitelný text:** Použijte klienta podporujícího nativní obrazový obsah MCP nebo prozkoumejte sémantický snímek.

**Prázdné výsledky:** Ogma nejprve potřebuje zachytit provoz. Procházejte web s proxy nastavenou tak, aby provoz předávala přes Ogma.