Serveur MCP — connecter n'importe quel client IA

OculiX embarque un serveur MCP (oculixmcp) qui expose le moteur d’automatisation visuelle — clic, frappe, recherche, OCR, capture — à tout client Model Context Protocol. Chaque action est signée (Ed25519) et écrite dans un journal d’audit chaîné par hachage : le serveur est conçu pour des environnements maîtrisés et auditables, pas pour un usage grand public libre.

Lancer le serveur

L’artefact exécutable est oculix-mcp-server.jar. Deux transports :

stdio (clients locaux)
HTTP (Streamable)

# Transport par défaut — Claude Desktop, Cursor, VS Code, Gemini CLI…
java -jar oculix-mcp-server.jar run

# Bind sur loopback par défaut. --host / --port sont optionnels.
java -jar oculix-mcp-server.jar serve --host 127.0.0.1 --port 7337

Variables d’environnement :

Variable	Effet
`OCULIX_MCP_TOKEN`	Jeton client pré-partagé qui garde `initialize` (recommandé pour tout bind non-loopback)
`OCULIX_MCP_MODE`	`open` ou `confidential` — le mode confidentiel range les sorties sensibles dans un coffre
`OCULIX_MCP_VAULT`	Chemin du répertoire coffre (mode confidentiel)
`OCULIX_MCP_TRUST_TLS_TERMINATION`	Acquitter une terminaison TLS en amont pour un bind non-loopback (sinon le HTTP clair sur interface publique est refusé)

Audit / clés : verify, rotate-key, rotate-session-key, recover.

Connecter votre client

Presque tous les clients MCP utilisent l’une de quatre formes de config. Choisissez le vôtre.

Fichier : ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) · %APPDATA%\Claude\claude_desktop_config.json (Windows)

{
  "mcpServers": {
    "oculix": {
      "command": "java",
      "args": ["-jar", "/chemin/absolu/oculix-mcp-server.jar", "run"]
    }
  }
}

Redémarrez Claude Desktop. Les outils apparaissent derrière l’indicateur MCP.

Fichier projet .mcp.json, ou :

claude mcp add oculix -- java -jar /chemin/absolu/oculix-mcp-server.jar run

Fichier : ~/.cursor/mcp.json (global) · .cursor/mcp.json (projet)

{
  "mcpServers": {
    "oculix": {
      "command": "java",
      "args": ["-jar", "/chemin/absolu/oculix-mcp-server.jar", "run"]
    }
  }
}

Fichier : ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "oculix": {
      "command": "java",
      "args": ["-jar", "/chemin/absolu/oculix-mcp-server.jar", "run"]
    }
  }
}

Fichier : ~/.gemini/settings.json (ou .gemini/settings.json du projet)

{
  "mcpServers": {
    "oculix": {
      "command": "java",
      "args": ["-jar", "/chemin/absolu/oculix-mcp-server.jar", "run"]
    }
  }
}

Fichier : .vscode/mcp.json — la clé de premier niveau est servers, pas mcpServers.

{
  "servers": {
    "oculix": {
      "command": "java",
      "args": ["-jar", "/chemin/absolu/oculix-mcp-server.jar", "run"]
    }
  }
}

Fichier : settings.json — Zed utilise la clé context_servers.

{
  "context_servers": {
    "oculix": {
      "command": "java",
      "args": ["-jar", "/chemin/absolu/oculix-mcp-server.jar", "run"],
      "env": {}
    }
  }
}

Fichier : ~/.config/goose/config.yaml — YAML, et le champ est cmd (pas command). Le plus simple est l’assistant : goose configure → Add Extension → Command-line (stdio).

extensions:
  oculix:
    enabled: true
    type: stdio
    cmd: java
    args:
      - "-jar"
      - "/chemin/absolu/oculix-mcp-server.jar"
      - "run"

Pilotez le serveur depuis votre propre code en stdio ou Streamable HTTP. Le SDK accepte un jeton Bearer, donc le mode HTTP d’OculiX fonctionne directement :

# Pseudocode — pointer le SDK sur le transport HTTP
server_url = "http://127.0.0.1:7337/mcp"
headers = {"Authorization": f"Bearer {OCULIX_MCP_TOKEN}"}

La grande majorité des clients MCP utilisent la forme mcpServers ci-dessus (Claude Desktop / Cursor / Windsurf / Gemini). Pointez command sur java, args sur votre jar + run pour le stdio, ou connectez-vous à l’endpoint HTTP http://host:7337/mcp avec un jeton Bearer.

À propos des assistants cloud grand public (ChatGPT, etc.)

Vous ne pouvez pas ajouter le serveur OculiX à un compte ChatGPT grand public comme connecteur, et c’est volontaire.

Un serveur d’automatisation visuelle peut bouger la souris, taper et lire l’écran — c’est, par définition, une surface de télécommande. Le brancher à un assistant cloud tiers transformerait la machine hôte en porte dérobée, atteignable par quiconque contrôle ce compte assistant — un login hameçonné, une session détournée, un navigateur compromis. Nous refusons cette exposition par conception :

Loopback d’abord — le serveur bind sur 127.0.0.1 par défaut. Un service cloud n’a aucune route vers votre localhost.
Pas d’enregistrement dynamique OAuth (DCR) — les connecteurs ChatGPT grand public exigent OAuth 2.1 + DCR et refusent les jetons Bearer. OculiX n’implémente délibérément pas ce flux : un connecteur public ne peut pas s’enregistrer.
TLS imposé sur interface publique — binder du HTTP clair sur une adresse non-loopback est refusé sauf acquittement explicite d’une terminaison TLS en amont.

Pilotez OculiX localement, ou depuis votre propre passerelle auditée — jamais depuis un assistant cloud tiers. Le handshake initialize annonce cette posture in-band : tout client ou auditeur la voit immédiatement.

Outils exposés

Dix outils en mode par défaut (open) :

Outil	Action
`oculix_find_image`	Localiser une image à l’écran
`oculix_click_image`	Trouver une image, puis cliquer dessus
`oculix_click_at_point`	Cliquer à des coordonnées explicites
`oculix_exists_image`	Tester la présence d’une image (sans lever d’échec)
`oculix_wait_for_image`	Attendre l’apparition d’une image
`oculix_type_text`	Taper une chaîne
`oculix_key_combo`	Envoyer une combinaison de touches (ex. `Ctrl+S`)
`oculix_find_text`	Localiser du texte à l’écran via OCR
`oculix_screenshot`	Capturer l’écran
`oculix_read_text_in_region`	OCR d’une région et retour du texte

Chaque appel est filtré (ActionGate), signé en Ed25519 et ajouté à un journal JSONL chaîné SHA-256 que vous pouvez rejouer et vérifier avec oculix-mcp-server.jar verify.

Référence CLI Toutes les sous-commandes et options de oculix-mcp.