Configuration du serveur MCP d'Ogma

Le serveur MCP d'Ogma (ogma-mcp) permet aux assistants IA compatibles d'inspecter le contexte du projet et, lorsque les permissions correspondantes sont activées, de piloter le navigateur intégré, d'envoyer des requêtes, d'exécuter des workflows et de recueillir des éléments de preuve. Ses outils de notes et de tâches constituent un bloc-notes en mémoire propre à la session MCP, distinct de la page Notes persistante de l'application.

MCP s'adresse aux outils externes tels que Codex, Claude Code, Cursor et les autres clients du Model Context Protocol. Il s'agit d'une fonctionnalité distincte de l'assistant IA de l'espace de travail (Workspace AI) intégré à l'application.

Pour la liste complète des ressources et des outils, consultez Ressources et outils MCP.

Démarrage rapide : application de bureau

1. Démarrez Ogma et ouvrez le projet que l'agent doit inspecter.
2. Ouvrez Paramètres > MCP, choisissez les permissions requises et enregistrez. Les interactions avec le navigateur nécessitent Envoi de rejeux.
3. Cliquez sur Démarrer et copiez le point de terminaison affiché, normalement http://127.0.0.1:3000/mcp.
4. Ajoutez-le à votre client MCP en tant que serveur Streamable HTTP.
5. Demandez à l'agent d'appeler ogma_explain_capabilities et de lire ogma://project/current pour vérifier la connexion et le projet actif.

Cette méthode ne nécessite aucune compilation d'un binaire distinct. Pour la navigation entre pages, les formulaires, les parcours de connexion et le dépannage, consultez Automatisation du navigateur avec MCP.

Adresses de connexion

Interface	Adresse par défaut	Rôle
Transport MCP	http://127.0.0.1:3000/mcp	Les clients MCP natifs se connectent ici.
API REST du backend	http://127.0.0.1:8181	Adresse utilisée par --api-url en mode MCP autonome et par les routes de gestion et de passerelle ci-dessous.
Écoute du proxy	127.0.0.1:8080	Capture le trafic du navigateur ; ce n'est pas un point de terminaison MCP.

Les instances de bureau peuvent attribuer dynamiquement le port de l'API backend. Pour les intégrations stdio/REST, utilisez l'adresse réelle de l'instance en cours d'exécution ; pour le MCP natif, utilisez le point de terminaison affiché dans les paramètres. Un service de discussion dans le cloud ne peut pas joindre votre adresse de bouclage sans client ou connecteur local.

Le point de terminaison HTTP conserve un état : laissez le client gérer l'initialisation et les en-têtes de session. Il n'existe pas de point de terminaison /sse historique distinct. Les clients personnalisés doivent respecter la spécification du transport MCP.

Quand utiliser MCP

Utilisez MCP lorsqu'un assistant externe doit vous aider à :

• Résumer le trafic capturé.
• Trier et prioriser les constats.
• Rédiger des passages de rapport fondés sur des éléments de preuve.
• Examiner les workflows et les sessions Rejeu.
• Préparer des actions limitées au périmètre que vous approuvez explicitement.

Utilisez plutôt IA de l'espace de travail si vous souhaitez disposer de la fenêtre de l'assistant intégré dans Ogma.

Prérequis du mode autonome

Utilisez stdio lorsque votre client doit lancer un exécutable local plutôt que se connecter au point de terminaison HTTP intégré.

• Le backend Ogma en cours d'exécution à son adresse d'API réelle (valeur par défaut en ligne de commande : http://127.0.0.1:8181)
• Le binaire ogma-mcp (compilé depuis les sources)

Compilation

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

Le fichier produit par défaut est target/release/ogma-mcp (ogma-mcp.exe sous Windows), sauf si le répertoire cible de Cargo est personnalisé.

Exécution

# 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

Ces commandes se connectent respectivement au port par défaut, à une adresse personnalisée et avec un aperçu du corps plus volumineux.

Le serveur s'arrête s'il ne peut pas joindre l'API d'Ogma. Configurez le client MCP pour qu'il lance cette commande ; stdout transporte les messages MCP et stderr les diagnostics. Les permissions stdio proviennent de ses propres options de lancement, et non des paramètres du MCP intégré.

Découverte des outils

Le serveur actuel annonce toujours son catalogue complet d'outils. Les paramètres ne proposent aucun sélecteur de profil d'outils. Les anciennes valeurs --tool-profile, --mcp-tool-profile et OGMA_MCP_TOOL_PROFILE sont acceptées pour assurer la compatibilité, mais elles ne masquent aucun outil et n'accordent aucune permission.

Pour un catalogue volumineux, commencez par ogma_explain_capabilities et ogma_find_tools plutôt que de deviner les paramètres des outils. Recherchez des mots-clés liés à la tâche pour sélectionner des outils, puis interrogez le nom exact d'un outil afin d'examiner son contrat. Les répartiteurs du navigateur et de recherche offrent des points d'entrée pratiques ; les outils spécialisés restent directement accessibles. Consultez Découverte et répartition des outils.

Paramètres MCP dans l'application

Les versions empaquetées d'Ogma peuvent gérer MCP depuis Paramètres > MCP. Utilisez cet écran de paramètres pour qu'Ogma démarre ou arrête le processus MCP intégré de l'instance active.

Utilisez le binaire autonome ogma-mcp lorsque votre client IA doit lancer directement le serveur MCP.

L'enregistrement des paramètres redémarre automatiquement un processus MCP intégré en cours d'exécution. Reconnectez ensuite les clients ; les anciens identifiants de session et jetons de confirmation ne peuvent pas être réutilisés. Diagnostic d’exécution affiche les sorties récentes du processus.

Ogma expose également la gestion de MCP via son API REST locale. Ces routes utilisent le port de l'API backend, et non le port MCP dédié. Elles sont utilisées par l'écran des paramètres et la passerelle IA intégrée :

Point de terminaison	Rôle
GET /mcp/status	Renvoie { running, pid, endpoint, config, diagnostics }. endpoint vaut null à l'arrêt ; les diagnostics contiennent des enregistrements récents { stream, message }.
POST /mcp/start	Démarre le MCP intégré avec les paramètres enregistrés et renvoie son état. Aucun corps. Renvoie un conflit s'il est déjà en cours d'exécution.
POST /mcp/stop	Arrête le processus enfant MCP intégré.
GET /settings/mcp	Renvoie la configuration MCP enregistrée.
PUT /settings/mcp	Accepte un objet de configuration complet, l'enregistre et redémarre MCP s'il est en cours d'exécution. Renvoie la configuration acceptée ou une erreur. Seuls les hôtes d'écoute de bouclage sont autorisés.
GET /mcp/tools	Renvoie { tools, config }, avec l'inputSchema de chaque outil. Ce catalogue REST n'est pas paginé.
POST /mcp/tools/call	Appelle un outil avec { "name": "ogma_explain_capabilities", "arguments": {} }. Renvoie { "result": "..." } ; analysez ce texte comme l'enveloppe JSON de l'outil. Il ne s'agit pas d'un résultat MCP natif contenant des blocs d'image.

La passerelle REST utilise les permissions enregistrées, mais ne nécessite pas le démarrage du processus enfant MCP HTTP distinct. Elle partage une seule session de passerelle pour le backend et sa configuration. Privilégiez le MCP natif pour disposer de sessions clientes isolées et de sorties sous forme d'images.

En cas d'échec de la passerelle, l'analyse de result produit { "error": "..." }, qui contient l'enveloppe d'erreur sérialisée. Vérifiez cette valeur plutôt que de considérer un statut HTTP de réussite comme la réussite de l'outil.

Configuration MCP enregistrée par défaut :

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

Les hôtes d'écoute autorisés sont 127.0.0.1, localhost et ::1 ; les ports doivent être compris entre 1024 et 65535. Cette version ne configure pas d'authentification pour un MCP exposé sur le réseau : les adresses d'écoute publiques sont donc refusées. Les anciens champs allow_public_bind et acknowledge_write_tool_risk ne permettent pas de contourner cette restriction.

Claude Code

Pour le point de terminaison de l'application de bureau en cours d'exécution :

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

Utilisez le point de terminaison affiché par Ogma s'il est différent. Consultez la configuration MCP de Claude Code pour les portées de configuration et les options stdio. Vérifiez la connexion en demandant : « Quels sont les projets disponibles dans Ogma ? »

Cursor

Fusionnez cette entrée dans le fichier .cursor/mcp.json de votre projet ou dans le fichier utilisateur ~/.cursor/mcp.json :

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

Activez la connexion dans les paramètres MCP de Cursor. Consultez la documentation MCP de Cursor.

Configuration d'un client stdio

Les clients qui lancent un exécutable peuvent utiliser cette entrée de serveur, en adaptant l'emplacement de leur fichier de configuration si nécessaire :

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

Sous Windows, utilisez le chemin complet de l'exécutable et échappez les barres obliques inverses dans le JSON. Certains clients exigent également "type": "stdio". Ajoutez les options de permission à args selon vos besoins.

Permissions

Les six capacités privilégiées sont désactivées par défaut. Consultez leurs valeurs actuelles dans ogma://mcp/permissions. Un outil répertorié peut encore refuser de s'exécuter tant que sa capacité n'est pas activée. Le tableau complet des options et des variables d'environnement figure dans la référence CLI.

Les interactions avec le navigateur, la gestion des contextes, le changement de projet et tous les appels liés aux parcours d'authentification nécessitent --allow-send-requests. Les fonctions d'observation peuvent inspecter un navigateur déjà en cours d'exécution sans activer ses outils de contrôle. --allow-read-secrets (ou OGMA_MCP_ALLOW_READ_SECRETS=true) autorise séparément l'accès aux valeurs non masquées des variables d'environnement.

Le serveur n'applique aucun quota d'activité par minute ou par session. Chaque outil impose néanmoins ses limites de taille des entrées et des lots, ses contrôles de périmètre et ses délais d'expiration. Les anciennes options de quota d'envoi ou de workflow ne sont plus prises en charge.

Mode lecture seule

Par défaut, le serveur MCP fonctionne en lecture seule. Les opérations suivantes ne sont pas disponibles sans activation explicite :

• Envoyer des requêtes (Rejeu)
• Piloter le navigateur intégré, le robot d'exploration, la capture d'authentification et les assistants de sondage actif
• Exécuter des workflows
• Créer ou modifier des constats
• Modifier le périmètre ou les règles Rechercher et remplacer
• Modifier ou transmettre le trafic intercepté
• Supprimer des données
• Accéder aux valeurs secrètes des variables d'environnement
• Exporter des données

Les aperçus des corps sont limités à 512 octets par défaut. --body-preview-bytes ajuste les aperçus et doit valoir au moins 1 ; cette option ne limite pas la sortie de tous les outils. Utilisez ogma_get_http_entry_body pour obtenir un corps HTTP complet ou effectuer une recherche ciblée dans le corps, et ogma_get_ws_message pour obtenir un message WebSocket complet.

Outils d'écriture de constats

Pour activer la création de constats assistée par IA, redémarrez ogma-mcp avec les permissions d'écriture :

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

Ou définissez la variable d'environnement :

OGMA_MCP_ALLOW_WRITE_FINDINGS=true ./ogma-mcp

Outils d'écriture disponibles

Outil	Description
ogma_preview_finding_from_evidence	Prévisualiser un brouillon de constat à partir d'une entrée HTTP (lecture seule, toujours disponible)
ogma_create_finding	Créer un constat avec gravité, statut, étiquettes et liens vers les éléments de preuve
ogma_update_finding	Mettre à jour un constat existant
ogma_add_finding_tag	Ajouter des étiquettes à un constat sans remplacer les étiquettes existantes
ogma_link_finding_evidence	Associer une entrée HTTP, une tentative Rejeu, un résultat Automatisation ou un message WS à un constat
ogma_delete_finding	Supprimer un constat
ogma_export_findings_report	Générer un rapport HTML, Markdown ou PDF

L'implémentation actuelle utilise également la permission d'écriture de constats pour des outils d'écriture partagés, tels que la mise à jour des variables d'environnement, les annotations de l'historique, la sélection du périmètre et les modifications de Rechercher et remplacer. Consultez le catalogue des outils pour ces actions.

Exemple : création de constats assistée par IA

Avec --allow-write-findings :

1. « Analyse l'entrée HTTP {id} pour rechercher des problèmes de sécurité. Si tu trouves un problème réel, utilise ogma_create_finding pour le documenter. »
2. L'IA appelle ogma_get_http_entry pour inspecter la requête.
3. Si les éléments de preuve étayent un constat, elle appelle ogma_create_finding en y associant ces éléments.

Opérations toujours indisponibles avec la seule permission d'écriture de constats

• Envoi via Rejeu
• Exécution de workflows
• Création d'exportations
• Contrôle de la file d'interception
• Changement de projet

Outils d'exportation

Pour activer la création de tâches d'exportation assistée par IA, redémarrez ogma-mcp avec les permissions d'exportation :

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

Ou définissez la variable d'environnement :

OGMA_MCP_ALLOW_EXPORT_DATA=true ./ogma-mcp

Outils d'exportation disponibles

Outil	Permission requise	Description
ogma_preview_export_plan	Aucune (lecture seule)	Prévisualiser les données qui seraient incluses dans une exportation
ogma_list_export_jobs	Aucune (lecture seule)	Lister les tâches d'exportation récentes
ogma_get_export_job	Aucune (lecture seule)	Vérifier l'état d'une tâche d'exportation
ogma_get_export_download_info	Aucune (lecture seule)	Obtenir l'URL de téléchargement d'une exportation terminée
ogma_create_export_job	export_data	Créer une tâche d'exportation

Types et formats d'exportation pris en charge

Type	Description	Formats
http_history	Toutes les requêtes HTTP passant par le proxy	json, csv, raw_http
search	Requêtes HTTP filtrées	json, csv, raw_http
findings	Constats de sécurité	json, csv
automate_results	Résultats des sessions Automatisation	json, csv

Remarque : le format raw_http n'est valable que pour les types http_history et search.

Avertissement de sécurité

Les fichiers d'exportation peuvent contenir les corps complets des requêtes et des réponses HTTP, susceptibles d'inclure des mots de passe, des jetons et des données personnelles. Manipulez ces fichiers avec les précautions appropriées.

Opérations toujours indisponibles avec les seules permissions d'exportation

• Suppression de fichiers d'exportation
• Renommage de fichiers d'exportation
• Diffusion en continu du contenu des exportations via MCP
• Envoi via Rejeu
• Exécution de workflows

Envoi de requêtes Rejeu

Attention : cette permission active l'envoi de trafic HTTP sortant réel via Ogma Rejeu.

Pour l'activer :

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

Ou via les variables d'environnement :

OGMA_MCP_ALLOW_SEND_REQUESTS=true ./ogma-mcp

Prérequis

1. Le proxy Ogma doit être en cours d'exécution.
2. Un périmètre actif doit être configuré dans Périmètres pour les envois Rejeu soumis aux contrôles de sécurité.
3. L'hôte cible doit appartenir au périmètre actif.

Outils d'envoi

Outil	Permission	Description
ogma_preview_replay_send	send_requests	Préparer un envoi et obtenir un jeton de confirmation
ogma_send_replay_request	send_requests	Effectuer l'envoi avec un jeton de confirmation
ogma_create_replay_session_from_history	send_requests	Créer une session Rejeu
ogma_create_replay_session_raw	send_requests	Créer une session Rejeu à partir d'une définition de requête brute
ogma_browser_form_to_replay	send_requests	Créer une session Rejeu à partir d'un formulaire de la page ouverte
ogma_create_scope_preset	send_requests	Enregistrer un préréglage de périmètre ; l'activer séparément avec ogma_set_active_scope
ogma_repeat_request	send_requests	Répéter une requête capturée avec des modifications facultatives
ogma_replay_with_modifications	send_requests	Rejouer une requête capturée en remplaçant des champs précis
ogma_http_request	send_requests	Envoyer directement une requête HTTP
ogma_fetch_url	send_requests	Récupérer une URL et renvoyer le statut, les en-têtes et un aperçu
ogma_follow_redirect	send_requests	Suivre une chaîne de redirections et rendre compte de chaque étape
ogma_bulk_send_requests	send_requests	Envoyer un lot de requêtes de taille limitée
ogma_fuzz_parameter	send_requests	Remplacer un marqueur par les valeurs d'une liste de mots
ogma_multipart_upload	send_requests	Envoyer des requêtes multipart form-data pour tester les téléversements
ogma_websocket_connect	send_requests	Se connecter à une URL WebSocket et échanger des messages
ogma_login_replay_auto	send_requests	Soumettre un formulaire de connexion dans le navigateur et capturer un profil d'authentification
ogma_auth_capture_profile	send_requests	Capturer les cookies, le stockage, les jetons d'authentification et les candidats CSRF du navigateur
ogma_auth_apply_profile	send_requests	Appliquer au navigateur un profil d'authentification capturé
ogma_auth_refresh_csrf	send_requests	Actualiser les candidats CSRF depuis l'état du navigateur
ogma_authz_matrix_test	send_requests	Rejouer une requête avec plusieurs profils d'authentification
ogma_run_active_probe_workflow	send_requests	Exécuter des sondes actives limitées, propres à une vulnérabilité
ogma_test_race	send_requests	Envoyer une même requête simultanément et signaler les réponses dont le code de statut diffère du code le plus fréquent
ogma_test_smuggling	send_requests	Envoyer des sondes de désynchronisation de requêtes CL.TE et TE.CL sur TCP brut
ogma_test_hpp	send_requests	Envoyer des variantes de pollution des paramètres HTTP
ogma_run_nuclei	send_requests	Exécuter un modèle du scanner à modèles, intégré ou fourni, sur une URL cible
ogma_browser_navigate et outils d'interaction avec le navigateur	send_requests	Piloter le navigateur intégré et capturer le trafic généré
ogma_crawl_site	send_requests	Explorer une cible du périmètre via le navigateur intégré
ogma_get_replay_session	Aucune	Consulter les métadonnées d'une session Rejeu
ogma_get_replay_attempt	Aucune	Consulter les métadonnées d'une tentative Rejeu
ogma_list_replay_sessions	Aucune	Lister les sessions Rejeu

Processus en deux étapes

La paire d'outils Rejeu fondée sur la confirmation utilise deux appels :

1. ogma_preview_replay_send - examiner la requête et obtenir un jeton de confirmation
2. ogma_send_replay_request - confirmer et envoyer avec le jeton

Les jetons de confirmation expirent au bout de 5 minutes, sont à usage unique et appartiennent à la session MCP qui les a créés. Générez un nouvel aperçu après avoir modifié la requête ou redémarré MCP. Cette règle en deux étapes ne s'applique pas à tous les outils d'envoi : les outils HTTP directs, les assistants de répétition et les actions du navigateur peuvent envoyer immédiatement lorsqu'ils sont activés.

Exemple de session

Utilisateur : Renvoie l'entrée HTTP abc123 et vérifie la réponse
IA : (appelle ogma_preview_replay_send avec http_entry_id="abc123")
     - affiche l'aperçu de la requête, le jeton de confirmation et l'état du périmètre --
IA : (appelle ogma_send_replay_request avec confirmation_token et request_hash)
     - affiche le statut de la réponse, le temps écoulé et l'aperçu de la réponse --

Opérations toujours indisponibles avec les seules permissions d'envoi de requêtes

• Exécution de workflows
• Création ou mise à jour de constats
• Suppression

Gardez un périmètre actif restreint avant d'activer ces outils. Les contrôles de périmètre s'appliquent aux chemins d'envoi protégés ; ne considérez pas le périmètre comme un pare-feu universel pour du JavaScript arbitraire dans le navigateur ou pour chaque assistant de récupération directe.

Contrôle de l'interception

Attention : le contrôle de l'interception permet à un client MCP de transmettre, de bloquer ou de modifier le trafic en cours actuellement retenu dans la file d'interception d'Ogma.

Pour l'activer :

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

Ou via la variable d'environnement :

OGMA_MCP_ALLOW_INTERCEPT_CONTROL=true ./ogma-mcp

Outils d'interception

Outil	Permission	Description
ogma_get_intercept_status	intercept_control	Lire l'état d'interception des requêtes, des réponses et des WebSockets
ogma_set_intercept_enabled	intercept_control	Activer ou désactiver les modes d'interception
ogma_list_intercept_queue	intercept_control	Lister les éléments actuellement retenus
ogma_get_intercept_item	intercept_control	Inspecter un élément de la file
ogma_forward_intercept_item	intercept_control	Transmettre un élément de la file, éventuellement modifié
ogma_drop_intercept_item	intercept_control	Bloquer un élément de la file
ogma_intercept_and_modify	intercept_control	Attendre un élément correspondant aux critères, le modifier et le transmettre

Exécution des workflows

Attention : l'exécution d'un workflow applique sa logique. Certains workflows envoient du trafic HTTP ou créent des constats.

Pour l'activer :

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

Outils d'exécution des workflows

Outil	Permission	Description
ogma_get_workflow_safety	Aucune (lecture seule)	Classer les effets de bord d'un workflow
ogma_preview_workflow_run	run_workflows	Prévisualiser et obtenir un jeton de confirmation
ogma_run_workflow	run_workflows	Exécuter avec un jeton de confirmation
ogma_cancel_workflow_run	run_workflows	Annuler un workflow actif en cours d'exécution

Générez l'aperçu avec workflow_id, plus input pour un workflow de conversion ou trigger_entry_id pour l'entrée capturée d'un workflow actif. Lancez l'exécution avec les valeurs confirmation_token et definition_hash renvoyées ; les workflows de conversion nécessitent également input_hash et la même valeur input. Les jetons expirent au bout de cinq minutes et sont à usage unique. Consultez l'exécution obtenue avec ogma_get_workflow_run.

L'exécution d'Automatisation est accessible via ses outils de session et d'exécution avec la permission d'envoi de requêtes, et non celle d'exécution de workflows. Lister et inspecter les exécutions existantes ne nécessite pas de permission d'envoi.

Permissions supplémentaires requises

Les workflows qui utilisent sdk.requests.send nécessitent également --allow-send-requests. Les workflows qui utilisent sdk.findings.create nécessitent également --allow-write-findings.

La détection repose sur une analyse statique du texte ; consultez l'avertissement ci-dessous.

Avertissement sur la classification de sécurité

La classification de sécurité des workflows recherche dans le texte du code source JavaScript des motifs tels que sdk.requests.send. Cette détection n'est pas exhaustive : les appels aux méthodes du SDK qui sont obscurcis ou construits dynamiquement peuvent ne pas être détectés. Examinez toujours le code source JavaScript avant d'exécuter un workflow non fiable.

Opérations toujours indisponibles avec les seules permissions de workflow

• Déclenchement manuel des workflows passifs
• Suppression
• Modification des variables d'environnement

Exemples de demandes

Une fois la connexion établie :

• « Affiche les 20 dernières requêtes HTTP vers example.com »
• « Ce projet contient-il des constats de gravité élevée ou critique ? »
• « Quels workflows sont actuellement activés ? »
• « Vérifie si la requête HTTPQL req.method.eq:\"POST\" est valide »
• « Résume l'état de sécurité du projet actuel »
• « Analyse l'entrée HTTP {id} pour rechercher des problèmes de sécurité »

Dépannage

Connexion refusée : démarrez d'abord Ogma (ogma --data-dir ./ogma-data).

Le client MCP n'affiche aucun outil : vérifiez l'URL du transport ou le chemin de l'exécutable. Les clients doivent suivre tous les curseurs de tools/list ; chaque page contient jusqu'à 40 outils. Vérifiez le filtrage côté client et assurez-vous que votre version installée inclut l'outil manquant.

Session ou jeton de confirmation invalide : reconnectez-vous après un redémarrage et générez un nouveau jeton d'aperçu.

Navigateur indisponible ou action échouée : laissez l'application de bureau en cours d'exécution. Vérifiez ogma_browser_health, les boîtes de dialogue et le guide de rétablissement du navigateur. Un backend sans interface graphique ne fournit pas, à lui seul, la passerelle du navigateur de bureau.

La capture d'écran ne contient aucun texte lisible : utilisez un client prenant en charge le contenu image MCP natif ou inspectez l'instantané sémantique.

Résultats vides : Ogma doit d'abord capturer du trafic. Naviguez avec votre proxy configuré pour faire passer le trafic par Ogma.