---
url: https://docs.ogmabox.com/it/mcp-setup.md
description: >-
  Collega gli agenti IA a Ogma tramite Streamable HTTP o stdio, configura le
  autorizzazioni e usa gli endpoint locali di gestione MCP.
---

# Configurazione del server MCP di Ogma {#ogma-mcp-server-setup}

Il server MCP di Ogma (`ogma-mcp`) consente agli assistenti IA compatibili di esaminare il contesto del progetto e, quando abilitato, controllare il browser integrato, inviare richieste, eseguire flussi di lavoro e raccogliere prove. I suoi strumenti per note e attività sono un blocco appunti in memoria della sessione MCP, separato dalla pagina Note persistente dell'applicazione.

MCP è destinato a strumenti esterni come Codex, Claude Code, Cursor e altri client Model Context Protocol. Non è la stessa funzionalità dell'assistente IA dell'area di lavoro integrato nell'applicazione.

Per l'elenco completo di risorse e strumenti, consulta [Risorse e strumenti MCP](/it/reference/mcp-tools.md).

## Avvio rapido: applicazione desktop {#quick-start-desktop-app}

1. Avvia Ogma e apri il progetto che l'agente deve esaminare.
2. Apri **Impostazioni > MCP**, scegli le autorizzazioni necessarie e salva. L'interazione con il browser richiede **Invio da Ripetizione**.
3. Fai clic su **Avvia** e copia l'endpoint visualizzato, normalmente `http://127.0.0.1:3000/mcp`.
4. Aggiungilo al tuo client MCP come server **Streamable HTTP**.
5. Chiedi all'agente di chiamare `ogma_explain_capabilities` e leggere `ogma://project/current` per verificare la connessione e il progetto attivo.

Questa opzione non richiede la compilazione di un binario separato. Per navigazione delle pagine, moduli, percorsi di accesso e risoluzione dei problemi, consulta [Automazione del browser con MCP](/it/guide/mcp-browser.md).

### Indirizzi di connessione {#connection-addresses}

| Interfaccia | Indirizzo predefinito | Scopo |
| --- | --- | --- |
| Trasporto MCP | `http://127.0.0.1:3000/mcp` | I client MCP nativi si collegano qui. |
| API REST del backend | `http://127.0.0.1:8181` | `--api-url` di MCP autonomo e le rotte di gestione e del bridge descritte sotto. |
| Listener del proxy | `127.0.0.1:8080` | Acquisisce il traffico del browser; non è un endpoint MCP. |

Le istanze desktop possono assegnare dinamicamente la porta dell'API del backend. Usa l'indirizzo effettivo dell'istanza in esecuzione per le integrazioni stdio/REST e l'endpoint visualizzato in Impostazioni per MCP nativo. Un servizio di chat nel cloud non può raggiungere il tuo indirizzo di loopback senza un client o un connettore locale.

L'endpoint HTTP mantiene lo stato: lascia che il client gestisca l'inizializzazione e le intestazioni di sessione. Non esiste un endpoint legacy `/sse` separato. I client personalizzati devono seguire la [specifica di trasporto](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports) MCP.

## Quando usare MCP {#when-to-use-mcp}

Usa MCP quando un assistente esterno deve aiutarti a:

* Riassumere il traffico acquisito.
* Classificare i risultati per priorità.
* Redigere testo di report basato su prove.
* Esaminare flussi di lavoro e sessioni di Ripetizione.
* Preparare azioni entro l'ambito che approvi esplicitamente.

Usa l'[IA dell'area di lavoro](/it/guide/workspace-ai.md) se preferisci la finestra dell'assistente integrata in Ogma.

## Requisiti del server autonomo {#standalone-requirements}

Usa stdio quando il tuo client deve avviare un eseguibile locale invece di collegarsi all'endpoint HTTP integrato.

* Backend di Ogma in esecuzione al suo indirizzo API effettivo (predefinito della CLI: `http://127.0.0.1:8181`)
* Il binario `ogma-mcp` (compilato dal codice sorgente)

## Compilazione {#build}

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

L'output predefinito è `target/release/ogma-mcp` (`ogma-mcp.exe` su Windows), a meno che la directory di destinazione di Cargo non sia personalizzata.

## Esecuzione {#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
```

Il server termina se non può raggiungere l'API di Ogma. Configura il client MCP per avviare questo comando; stdout trasporta i messaggi MCP e stderr contiene la diagnostica. Le autorizzazioni di stdio provengono dai suoi flag, non dalle impostazioni MCP integrate.

## Individuazione degli strumenti {#tool-discovery}

Il server attuale annuncia sempre il suo catalogo completo di strumenti. Non esiste un selettore di profili di strumenti in Impostazioni. I vecchi valori di `--tool-profile`, `--mcp-tool-profile` e `OGMA_MCP_TOOL_PROFILE` sono accettati per compatibilità, ma non nascondono strumenti né concedono autorizzazioni.

Per un catalogo ampio, inizia con `ogma_explain_capabilities` e `ogma_find_tools` invece di indovinare gli input. Cerca parole chiave della tua attività per selezionare gli strumenti, poi consulta il nome esatto di uno strumento per esaminarne il contratto. I dispatcher del browser e della ricerca offrono punti di ingresso pratici; gli strumenti specifici rimangono disponibili direttamente. Consulta [Individuazione e dispatch degli strumenti](/it/reference/mcp-tools.md#tool-discovery-and-dispatch).

## Impostazioni MCP nell'applicazione {#in-app-mcp-settings}

Le versioni di Ogma distribuite come pacchetti possono gestire MCP da **Impostazioni > MCP**. Usa la schermata delle impostazioni quando vuoi che Ogma avvii o arresti il processo MCP integrato dell'istanza attiva.

Usa il binario autonomo `ogma-mcp` quando il tuo client IA prevede di avviare direttamente il server MCP.

Il salvataggio delle impostazioni riavvia automaticamente un processo MCP integrato in esecuzione. Ricollega i client dopo il riavvio; gli ID di sessione e i token di conferma precedenti non possono essere riutilizzati. **Diagnostica di esecuzione** mostra l'output recente del processo.

Ogma espone anche la gestione MCP tramite la sua API REST locale. Queste rotte si trovano sulla **porta dell'API del backend**, non sulla porta dedicata a MCP. Sono usate dalla schermata delle impostazioni e dal bridge IA nell'applicazione:

| Endpoint | Scopo |
| --- | --- |
| `GET /mcp/status` | Restituisce `{ running, pid, endpoint, config, diagnostics }`. `endpoint` è null quando il processo è arrestato; la diagnostica contiene record recenti `{ stream, message }`. |
| `POST /mcp/start` | Avvia MCP integrato con le impostazioni persistenti e restituisce lo stato. Senza corpo. Restituisce un conflitto se è già in esecuzione. |
| `POST /mcp/stop` | Arresta il processo figlio MCP integrato. |
| `GET /settings/mcp` | Restituisce la configurazione MCP persistente. |
| `PUT /settings/mcp` | Accetta un oggetto di configurazione completo, lo salva e riavvia MCP se è in esecuzione. Restituisce la configurazione accettata o un errore. Sono consentiti solo host di associazione di loopback. |
| `GET /mcp/tools` | Restituisce `{ tools, config }`, incluso l'`inputSchema` di ogni strumento. Questo catalogo REST non è paginato. |
| `POST /mcp/tools/call` | Chiama uno strumento con `{ "name": "ogma_explain_capabilities", "arguments": {} }`. Restituisce `{ "result": "..." }`; interpreta quel testo come l'involucro JSON dello strumento. Non è un risultato MCP nativo con blocchi immagine. |

Il bridge REST usa le autorizzazioni persistenti, ma non richiede l'avvio del processo figlio HTTP MCP separato. Condivide una sessione del bridge per il backend e la configurazione. Preferisci MCP nativo per sessioni client isolate e output di immagini.

In caso di errori del bridge, interpretare `result` produce `{ "error": "..." }`, che contiene l'involucro di errore serializzato. Controlla quel valore invece di considerare uno stato HTTP di successo come successo dello strumento.

Configurazione MCP persistente predefinita:

```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"
}
```

Gli host di associazione consentiti sono `127.0.0.1`, `localhost` e `::1`; le porte devono essere comprese tra `1024` e `65535`. Questa versione non configura l'autenticazione per MCP esposto alla rete, quindi gli indirizzi di associazione pubblici vengono rifiutati. I campi legacy `allow_public_bind` e `acknowledge_write_tool_risk` non annullano questa restrizione.

## Claude Code {#claude-code}

Per l'endpoint desktop in esecuzione:

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

Usa l'endpoint mostrato da Ogma se è diverso. Consulta la [configurazione MCP di Claude Code](https://code.claude.com/docs/en/mcp) per gli ambiti di configurazione e le opzioni stdio. Verifica con: "Quali progetti ha Ogma?"

## Cursor {#cursor}

Integra questa voce nel `.cursor/mcp.json` del progetto o nel `~/.cursor/mcp.json` dell'utente:

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

Abilita la connessione nelle impostazioni MCP di Cursor. Consulta la [documentazione MCP di Cursor](https://cursor.com/docs/mcp).

### Configurazione del client stdio {#stdio-client-configuration}

I client che avviano un eseguibile possono usare questa voce del server, adattando la posizione del file di configurazione secondo necessità:

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

Su Windows, usa il percorso completo dell'eseguibile ed esegui l'escape delle barre inverse in JSON. Alcuni client richiedono anche `"type": "stdio"`. Aggiungi flag di autorizzazione a `args` secondo necessità.

## Autorizzazioni {#permissions}

Tutte le sei capacità privilegiate sono disabilitate per impostazione predefinita. Leggi i valori attuali da `ogma://mcp/permissions`. Uno strumento elencato può comunque rifiutare l'esecuzione finché la sua capacità non è abilitata. La tabella completa dei flag e delle variabili d'ambiente è nella [documentazione di riferimento della CLI](/it/reference/cli.md#standalone-ogma-mcp-flags).

L'interazione con il browser, la gestione dei contesti, il cambio di progetto e tutte le chiamate dei percorsi di autenticazione richiedono `--allow-send-requests`. L'osservazione del browser può esaminare un browser già in esecuzione senza abilitarne gli strumenti di controllo. `--allow-read-secrets` (o `OGMA_MCP_ALLOW_READ_SECRETS=true`) consente separatamente valori di variabili d'ambiente non mascherati.

Il server **non ha quote di attività per minuto o per sessione**. I singoli strumenti applicano comunque i propri limiti di input, dimensioni dei batch, controlli dell'ambito e timeout. I vecchi flag delle quote di invio e flussi di lavoro non sono più supportati.

## Modalità di sola lettura {#read-only-mode}

Per impostazione predefinita, il server MCP è di sola lettura. Queste operazioni non sono disponibili se non vengono abilitate esplicitamente:

* Invio di richieste (Ripetizione)
* Controllo del browser integrato, del crawler, dell'acquisizione dell'autenticazione e degli strumenti ausiliari per sonde attive
* Esecuzione di flussi di lavoro
* Creazione o modifica di risultati
* Modifica dell'ambito o delle regole di trova e sostituisci
* Modifica o inoltro del traffico intercettato
* Eliminazione di dati
* Accesso ai valori segreti delle variabili d'ambiente
* Esportazione di dati

Le anteprime dei corpi sono di 512 byte per impostazione predefinita. `--body-preview-bytes` modifica le anteprime e deve essere almeno 1; non limita l'output di ogni strumento. Usa `ogma_get_http_entry_body` per un corpo HTTP completo o una ricerca mirata nel corpo, e `ogma_get_ws_message` per un messaggio WebSocket completo.

## Strumenti di scrittura dei risultati {#finding-write-tools}

Per abilitare la creazione di risultati assistita dall'IA, riavvia ogma-mcp con autorizzazioni di scrittura:

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

Oppure imposta la variabile d'ambiente:

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

### Strumenti di scrittura disponibili {#write-tools-available}

| Strumento | Descrizione |
|------|-------------|
| `ogma_preview_finding_from_evidence` | Mostra l'anteprima di una bozza di risultato da una voce HTTP (sola lettura, sempre disponibile) |
| `ogma_create_finding` | Crea un risultato con gravità, stato, tag e collegamenti alle prove |
| `ogma_update_finding` | Aggiorna un risultato esistente |
| `ogma_add_finding_tag` | Aggiunge tag a un risultato senza sostituire quelli esistenti |
| `ogma_link_finding_evidence` | Collega una voce HTTP, un tentativo di Ripetizione, un risultato di Automazione o un messaggio WS a un rilievo di sicurezza |
| `ogma_delete_finding` | Elimina un risultato |
| `ogma_export_findings_report` | Genera un report HTML, Markdown o PDF |

L'implementazione attuale usa l'autorizzazione di scrittura dei risultati anche per strumenti di scrittura condivisi, come aggiornamenti delle variabili d'ambiente, annotazioni della cronologia, selezione dell'ambito e modifiche di Trova e sostituisci. Consulta il [catalogo degli strumenti](/it/reference/mcp-tools.md) per queste azioni.

### Esempio: creazione di risultati assistita dall'IA {#example-ai-assisted-finding-creation}

Con `--allow-write-findings`:

1. "Analizza la voce HTTP {id} per individuare problemi di sicurezza. Se trovi un problema reale, usa ogma\_create\_finding per documentarlo."
2. L'IA chiamerà `ogma_get_http_entry` per esaminare la richiesta
3. Se le prove supportano un risultato, chiamerà `ogma_create_finding` con le prove collegate

### Ancora non disponibile con la sola scrittura dei risultati {#still-not-available-with-finding-writes-only}

* Invio da Ripetizione
* Esecuzione di flussi di lavoro
* Creazione di esportazioni
* Controllo della coda di intercettazione
* Cambio di progetto

## Strumenti di esportazione {#export-tools}

Per abilitare la creazione di processi di esportazione assistita dall'IA, riavvia ogma-mcp con autorizzazioni di esportazione:

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

Oppure imposta la variabile d'ambiente:

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

### Strumenti di esportazione disponibili {#export-tools-available}

| Strumento | Autorizzazione richiesta | Descrizione |
|------|--------------------|-------------|
| `ogma_preview_export_plan` | Nessuna (sola lettura) | Mostra l'anteprima di ciò che sarebbe incluso in un'esportazione |
| `ogma_list_export_jobs` | Nessuna (sola lettura) | Elenca i processi di esportazione recenti |
| `ogma_get_export_job` | Nessuna (sola lettura) | Verifica lo stato di un processo di esportazione |
| `ogma_get_export_download_info` | Nessuna (sola lettura) | Ottiene l'URL di download di un'esportazione completata |
| `ogma_create_export_job` | export\_data | Crea un processo di esportazione |

### Tipi e formati di esportazione supportati {#supported-export-kinds-and-formats}

| Tipo | Descrizione | Formati |
|------|-------------|---------|
| `http_history` | Tutte le richieste HTTP che passano dal proxy | json, csv, raw\_http |
| `search` | Richieste HTTP filtrate | json, csv, raw\_http |
| `findings` | Risultati di sicurezza | json, csv |
| `automate_results` | Risultati delle sessioni di Automazione | json, csv |

Nota: il formato `raw_http` è valido solo per i tipi `http_history` e `search`.

### Avvertenza di sicurezza {#security-warning}

I file di esportazione possono contenere i corpi completi delle richieste e risposte HTTP, che possono includere password, token e dati personali. Gestisci i file di esportazione con la dovuta attenzione.

### Ancora non disponibile con le sole autorizzazioni di esportazione {#still-not-available-with-export-permissions-only}

* Eliminazione di file di esportazione
* Ridenominazione di file di esportazione
* Trasmissione del contenuto di esportazione tramite MCP
* Invio da Ripetizione
* Esecuzione di flussi di lavoro

## Invio di richieste da Ripetizione {#replay-request-sending}

Avvertenza: questa opzione abilita l'invio di traffico HTTP reale in uscita tramite Ripetizione di Ogma.

Per abilitare:

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

Oppure tramite variabili d'ambiente:

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

### Prerequisiti {#prerequisites}

1. Il proxy di Ogma deve essere in esecuzione
2. Un ambito attivo deve essere configurato in **Ambiti** per gli invii protetti da Ripetizione
3. L'host di destinazione deve rientrare nell'ambito attivo

### Strumenti di invio {#send-tools}

| Strumento | Autorizzazione | Descrizione |
|------|-----------|-------------|
| `ogma_preview_replay_send` | send\_requests | Prepara un invio e ottiene un token di conferma |
| `ogma_send_replay_request` | send\_requests | Esegue l'invio con un token di conferma |
| `ogma_create_replay_session_from_history` | send\_requests | Crea una sessione di Ripetizione |
| `ogma_create_replay_session_raw` | send\_requests | Crea una sessione di Ripetizione da una definizione di richiesta grezza |
| `ogma_browser_form_to_replay` | send\_requests | Crea una sessione di Ripetizione da un modulo nella pagina attiva |
| `ogma_create_scope_preset` | send\_requests | Memorizza un profilo di ambito; attivalo separatamente con `ogma_set_active_scope` |
| `ogma_repeat_request` | send\_requests | Ripete una richiesta acquisita con modifiche facoltative |
| `ogma_replay_with_modifications` | send\_requests | Ripete una richiesta acquisita con sostituzioni a livello di campo |
| `ogma_http_request` | send\_requests | Invia una richiesta HTTP diretta |
| `ogma_fetch_url` | send\_requests | Recupera un URL e restituisce stato, intestazioni e anteprima |
| `ogma_follow_redirect` | send\_requests | Segue una catena di reindirizzamenti e riporta ogni passaggio |
| `ogma_bulk_send_requests` | send\_requests | Invia un batch limitato di richieste |
| `ogma_fuzz_parameter` | send\_requests | Sostituisce un segnaposto `{{FUZZ}}` con valori di una lista di parole |
| `ogma_multipart_upload` | send\_requests | Invia richieste multipart form-data per test di caricamento |
| `ogma_websocket_connect` | send\_requests | Si collega a un URL WebSocket e scambia messaggi |
| `ogma_login_replay_auto` | send\_requests | Invia un modulo di accesso del browser e acquisisce un profilo di autenticazione |
| `ogma_auth_capture_profile` | send\_requests | Acquisisce cookie, archiviazione, token di autenticazione e candidati CSRF del browser |
| `ogma_auth_apply_profile` | send\_requests | Applica un profilo di autenticazione acquisito al browser |
| `ogma_auth_refresh_csrf` | send\_requests | Aggiorna i candidati CSRF dallo stato del browser |
| `ogma_authz_matrix_test` | send\_requests | Ripete una richiesta con più profili di autenticazione |
| `ogma_run_active_probe_workflow` | send\_requests | Esegue sonde attive limitate e specifiche per vulnerabilità |
| `ogma_test_race` | send\_requests | Invia una richiesta in modo concorrente e riporta le risposte con un codice di stato diverso da quello più frequente |
| `ogma_test_smuggling` | send\_requests | Invia sonde di desincronizzazione delle richieste CL.TE e TE.CL tramite TCP grezzo |
| `ogma_test_hpp` | send\_requests | Invia varianti di inquinamento dei parametri HTTP |
| `ogma_run_nuclei` | send\_requests | Esegue un modello dello scanner basato su modelli, incluso o fornito, contro un URL di destinazione |
| `ogma_browser_navigate` e strumenti di interazione con il browser | send\_requests | Controllano il browser integrato e acquisiscono il traffico risultante |
| `ogma_crawl_site` | send\_requests | Esplora una destinazione nell'ambito tramite il browser integrato |
| `ogma_get_replay_session` | Nessuna | Visualizza i metadati di una sessione di Ripetizione |
| `ogma_get_replay_attempt` | Nessuna | Visualizza i metadati di un tentativo di Ripetizione |
| `ogma_list_replay_sessions` | Nessuna | Elenca le sessioni di Ripetizione |

### Flusso di lavoro in due passaggi {#two-step-workflow}

La coppia di strumenti di Ripetizione basata sulla conferma usa due chiamate:

1. `ogma_preview_replay_send` - esamina la richiesta e ottieni un token di conferma
2. `ogma_send_replay_request` - conferma e invia con il token

I token di conferma scadono dopo 5 minuti, sono monouso e appartengono alla sessione MCP che li ha creati. Genera di nuovo l'anteprima dopo aver modificato la richiesta o riavviato MCP. Questa regola in due passaggi non si applica a ogni strumento di invio: strumenti HTTP diretti, strumenti ausiliari di ripetizione e azioni del browser possono inviare immediatamente quando abilitati.

### Sessione di esempio {#example-session}

```
Utente: Reinvia la voce HTTP abc123 e verifica la risposta
IA: (chiama ogma_preview_replay_send con http_entry_id="abc123")
    - mostra l'anteprima della richiesta, il token di conferma e lo stato dell'ambito --
IA: (chiama ogma_send_replay_request con confirmation_token e request_hash)
    - mostra lo stato della risposta, i tempi e l'anteprima della risposta --
```

### Ancora non disponibile con le sole autorizzazioni di invio delle richieste {#still-not-available-with-request-sending-permissions-only}

* Esecuzione di flussi di lavoro
* Creazione o aggiornamento di risultati
* Eliminazione

Mantieni l'ambito attivo ristretto prima di abilitare questi strumenti. I controlli dell'ambito si applicano ai percorsi di invio protetti; non considerare l'ambito un firewall universale per JavaScript arbitrario del browser o per ogni strumento ausiliario di recupero diretto.

## Controllo dell'intercettazione {#intercept-control}

Avvertenza: il controllo dell'intercettazione consente a un client MCP di inoltrare, scartare o modificare traffico in tempo reale attualmente trattenuto nella coda di intercettazione di Ogma.

Per abilitare:

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

Oppure tramite variabile d'ambiente:

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

### Strumenti di intercettazione {#intercept-tools}

| Strumento | Autorizzazione | Descrizione |
|------|-----------|-------------|
| `ogma_get_intercept_status` | intercept\_control | Legge lo stato di intercettazione di richieste, risposte e WebSocket |
| `ogma_set_intercept_enabled` | intercept\_control | Abilita o disabilita le modalità di intercettazione |
| `ogma_list_intercept_queue` | intercept\_control | Elenca gli elementi attualmente trattenuti |
| `ogma_get_intercept_item` | intercept\_control | Esamina un elemento in coda |
| `ogma_forward_intercept_item` | intercept\_control | Inoltra un elemento in coda, eventualmente modificato |
| `ogma_drop_intercept_item` | intercept\_control | Scarta un elemento in coda |
| `ogma_intercept_and_modify` | intercept\_control | Attende un elemento corrispondente, lo modifica e lo inoltra |

## Esecuzione dei flussi di lavoro {#workflow-execution}

Avvertenza: l'esecuzione dei flussi di lavoro esegue la loro logica. Alcuni flussi inviano traffico HTTP o creano risultati.

Per abilitare:

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

### Strumenti di esecuzione dei flussi di lavoro {#workflow-execution-tools}

| Strumento | Autorizzazione | Descrizione |
|------|-----------|-------------|
| `ogma_get_workflow_safety` | Nessuna (sola lettura) | Classifica gli effetti collaterali dei flussi di lavoro |
| `ogma_preview_workflow_run` | run\_workflows | Mostra un'anteprima e ottiene un token di conferma |
| `ogma_run_workflow` | run\_workflows | Esegue con un token di conferma |
| `ogma_cancel_workflow_run` | run\_workflows | Annulla un flusso di lavoro attivo in esecuzione |

Genera l'anteprima con `workflow_id`, più `input` per un flusso di conversione o `trigger_entry_id` per un input acquisito di un flusso attivo. Esegui con il `confirmation_token` e il `definition_hash` restituiti; i flussi di conversione richiedono anche `input_hash` e lo stesso `input`. I token scadono dopo cinque minuti e sono monouso. Leggi l'esecuzione risultante con `ogma_get_workflow_run`.

L'esecuzione di Automazione è disponibile tramite i suoi strumenti di sessione ed esecuzione con **autorizzazione di invio delle richieste**, non con l'autorizzazione di esecuzione dei flussi di lavoro. Elencare ed esaminare esecuzioni esistenti non richiede l'autorizzazione di invio.

### Requisiti tra autorizzazioni {#cross-permission-requirements}

I flussi di lavoro che usano `sdk.requests.send` richiedono anche `--allow-send-requests`.
I flussi di lavoro che usano `sdk.findings.create` richiedono anche `--allow-write-findings`.

Il rilevamento si basa sull'analisi statica del testo; consulta la nota informativa sotto.

### Nota informativa sulla classificazione di sicurezza {#safety-classification-advisory-note}

La classificazione di sicurezza dei flussi di lavoro esamina il testo del codice sorgente JavaScript per individuare schemi come `sdk.requests.send`. Questo rilevamento non è esaustivo: le chiamate a metodi SDK offuscate o costruite dinamicamente potrebbero non essere rilevate. Esamina sempre il codice sorgente JavaScript prima di eseguire flussi di lavoro non attendibili.

### Ancora non disponibile con le sole autorizzazioni dei flussi di lavoro {#still-not-available-with-workflow-permissions-only}

* Attivazione manuale dei flussi di lavoro passivi
* Eliminazione
* Modifica delle variabili d'ambiente

## Prompt di esempio {#example-prompts}

Una volta collegato:

* "Mostrami le ultime 20 richieste HTTP a example.com"
* "Ci sono risultati di gravità alta o critica in questo progetto?"
* "Quali flussi di lavoro sono attualmente abilitati?"
* "Verifica se la query HTTPQL `req.method.eq:\"POST\"` è valida"
* "Riassumi lo stato di sicurezza del progetto attuale"
* "Analizza la voce HTTP {id} per individuare problemi di sicurezza"

## Risoluzione dei problemi {#troubleshooting}

**Connessione rifiutata:** avvia prima Ogma (`ogma --data-dir ./ogma-data`).

**Il client MCP non mostra strumenti:** verifica l'URL di trasporto o il percorso dell'eseguibile. I client devono seguire tutti i cursori di `tools/list`; ogni pagina contiene fino a 40 strumenti. Verifica il filtro lato client e se la versione installata include lo strumento mancante.

**Sessione o token di conferma non valido:** ricollegati dopo un riavvio e genera un nuovo token di anteprima.

**Browser non disponibile o azione non riuscita:** mantieni l'applicazione desktop in esecuzione. Verifica `ogma_browser_health`, i dialoghi e il [ripristino del browser](/it/guide/mcp-browser.md#recover-from-errors). Un backend senza interfaccia grafica da solo non fornisce il bridge del browser desktop.

**La cattura di schermata non contiene testo leggibile:** usa un client che supporti contenuti immagine MCP nativi oppure esamina l'istantanea semantica.

**Risultati vuoti:** Ogma deve prima acquisire traffico. Naviga con il proxy configurato per inoltrare il traffico attraverso Ogma.