Brancher une IA

Votre assistant d'IA écrit l'application et la garde sur Git ; Gluonify la construit et la déploie. Avec un jeton d'IA de Prism, ce même assistant peut enregistrer le dépôt, lancer un build, le suivre, demander le passage en production, lire les journaux et endormir l'application, par MCP, avec les rôles que vous lui avez donnés et rien de plus.

Comment ça marche

Prism, la console des clients, sert un point d'accès MCP à https://app.gluonify.io/mcp (JSON-RPC sur HTTP, outils seulement). Chaque outil exécute le même code que l'écran correspondant de Prism, avec les mêmes contrôles : votre organisation seulement, les rôles du jeton et les applications que vous avez choisies. Gauge reste le serveur MCP des exploitants de la plateforme.

Avant de commencer

  • Un compte propriétaire (org:owner) de votre organisation dans Prism : seul un propriétaire crée, liste et révoque les jetons d'IA.
  • Un dépôt que le builder sait construire, ou une application déjà déployée sur la plateforme.
  • Un client MCP qui prend en charge le HTTP « Streamable » et un jeton porteur, comme Claude Code.
  • curl et jq pour échanger le secret du jeton (ou tout autre client HTTP).

1. Créer un jeton d'IA dans Prism

Dans Prism, ouvrez Accès, puis la section Jetons d'IA :

  1. Donnez un nom au jeton (l'assistant ou le projet qu'il sert).
  2. Cochez ses rôles, groupés par dépôts (lire, modifier, poser les jetons Git), pipelines (lire, lancer, valider les promotions), applications (lire, endormir et réveiller, supprimer, revenir à une version, redimensionner), configuration (lire, modifier), secrets (écriture seule), consommation et contrat (lire, sans les prix) et mesures (lire). Ne cochez que ce dont l'assistant a besoin.
  3. Gardez toutes les applications de l'organisation, ou choisissez-en : le jeton n'atteint alors que celles-là, partout.
  4. Choisissez sa durée, de 1 à 90 jours, et laissez cochée « Les actions destructrices attendent ici l'accord d'un propriétaire ».
  5. Créez-le, copiez aussitôt son secret (gai_…) et rangez-le dans le coffre de secrets de votre client : Prism ne le montre qu'une fois.

2. Échanger le secret contre un jeton d'accès

Le secret n'est pas envoyé au point d'accès MCP lui-même : le client l'échange contre un jeton d'accès court (environ dix minutes), puis utilise ce jeton. Prism relaie l'échange à Charm, si bien que le client n'a besoin que de l'adresse de Prism :

Échange (le secret dans GLUONIFY_AI_TOKEN, le jeton d'accès dans GLUONIFY_ACCESS_TOKEN)

export GLUONIFY_ACCESS_TOKEN=$(curl -s -X POST https://app.gluonify.io/api/v1/ai/exchange \
  -H 'Content-Type: application/json' \
  -d "{\"refreshToken\":\"$GLUONIFY_AI_TOKEN\"}" | jq -r .access_token)

Quand le jeton d'accès expire (401), échangez de nouveau le secret. Un jeton d'IA révoqué ou expiré ne s'échange plus. Prism ne journalise jamais le secret.

3. Brancher votre client MCP

Déclarez Prism comme serveur MCP HTTP, avec le jeton d'accès dans l'en-tête Authorization :

Configuration du client MCP (par exemple .mcp.json pour Claude Code)

{ "mcpServers": { "gluonify": { "type": "http", "url": "https://app.gluonify.io/mcp", "headers": { "Authorization": "Bearer ${GLUONIFY_ACCESS_TOKEN}" } } } }

Pour vérifier la connexion, listez les outils à la main : seuls les outils permis par les rôles du jeton sont listés.

Lister les outils

curl -s https://app.gluonify.io/mcp -H "Authorization: Bearer $GLUONIFY_ACCESS_TOKEN" \
  -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Ce que l'assistant peut faire

  • Dépôts : repos_list, repo_get, repo_set (URL, branche, sous-dossier), repo_git_token_set (en écriture seule, jamais relu), workflows_standard_copy (copie les workflows standard Build et Promotion dans votre dépôt, sur une nouvelle branche à fusionner).
  • Pipelines : pipelines_list, pipeline_set (Build ou Promotion, référence Git, quatre yeux), build_start, build_cancel, builds_list, build_logs, executions_list, execution_get, approval_decide (de QUA à PRD).
  • Applications : apps_list, app_status, app_logs, app_sleep (gelée ou arrêtée), app_wake, app_sleep_settings, app_delete.

Les outils MCP propres à votre application

Une application cliente peut exposer ses propres outils MCP. La plateforme les relaie à votre assistant IA par le point d'accès MCP de Prism, sous la forme <code>app__&lt;application&gt;__&lt;outil&gt;</code>.

Java (Quarkus)

Ajoutez la dépendance <code>io.gluonify.plasma:gluonify-plasma-mcp</code>, puis annotez une méthode publique d'un bean qui implémente <code>McpToolbox</code> avec <code>@McpTool(name, description, write = false)</code>. Les arguments forment un record.

// pom.xml: io.gluonify.plasma:gluonify-plasma-mcp
@ApplicationScoped
public class OrdersToolbox implements McpToolbox {
    public record OrderQuery(String customer, int limit) {}

    @McpTool(name = "orders_list", description = "List the latest orders of a customer", write = false)
    public List<Order> ordersList(OrderQuery query) {
        return orders.latest(query.customer(), query.limit());
    }
}

Python

Importez <code>mcp_tool</code> depuis <code>gluonify.fastapi</code>, décorez une fonction et appelez <code>create_app(..., mcp=True)</code>.

from gluonify.fastapi import create_app, mcp_tool

@mcp_tool(name="orders_list", description="List the latest orders of a customer", write=False)
def orders_list(customer: str, limit: int = 10) -> list[dict]:
    return latest_orders(customer, limit)

app = create_app(__name__, mcp=True)
  • Le builder détecte le SDK et déploie l'application avec le MCP activé.
  • Les outils de lecture demandent la permission d'IA de lire les applications. Les outils d'écriture sont proposés à un propriétaire pour accord (en production).
  • L'application n'accepte que les appels relayés par la plateforme.
  • Limites : 50 outils, arguments de 64 Kio, réponse de 256 Kio, 10 s par appel.
  • Les outils apparaissent dans la console (vue de l'application, « Outils MCP ») et un propriétaire peut les actualiser.

Les garde-fous

Un jeton d'IA n'est pas une personne : Prism le borne davantage.

  • Jamais un pouvoir de propriétaire : un jeton d'IA ne gère ni les accès, ni les jetons d'IA, ni l'audit, ni les domaines, ne voit jamais un prix, et il ne fonctionne que sur le point d'accès MCP.
  • Votre organisation seulement, et seulement les applications choisies : tout le reste répond comme s'il n'existait pas.
  • Pas d'auto-validation : un jeton ne valide jamais la promotion d'une exécution qu'il a lancée.
  • Une limite d'appels par jeton (60 par minute et 1000 par heure par défaut) ; au-delà, le client doit patienter.
  • Mode accord : supprimer une application, valider une promotion, poser un jeton Git, écrire ou supprimer un secret, revenir à une version ou redimensionner une application devient une proposition qu'un propriétaire accepte ou refuse dans Accès ; acceptée, elle s'exécute avec les rôles du jeton lui-même.

Audit

Chaque appel d'un jeton d'IA est inscrit dans le module Audit de Prism : quel jeton (son nom), quel outil, quelle application et le résultat, jamais un secret. Cochez « Jetons d'IA seulement » pour ne voir qu'eux. La liste des jetons montre leur dernier usage.

Bonnes pratiques

  • Un jeton par assistant et par projet, avec le moins de rôles possible, et une durée courte.
  • Commencez par les rôles de lecture, puis ajoutez les changements que vous voulez vraiment.
  • Gardez le mode accord pour les actions destructrices, et validez vous-même les promotions.
  • Révoquez un jeton dès qu'il ne sert plus, ou si son secret a pu fuiter.

Partir de gluonify-source

gluonify-source est l'application de départ des clients : un service Quarkus dont chaque choix est expliqué, avec un CLAUDE.md qui résume les règles de la plateforme pour un assistant d'IA. Lancez votre assistant à partir de lui, puis branchez-le sur Prism pour construire et déployer ce qu'il écrit.

Et Gauge ?

Gauge est le serveur MCP des exploitants de la plateforme, avec leurs propres rôles et politiques. En tant que client, vous branchez votre assistant sur Prism, qui garde tout dans votre organisation.

Limites

Le mode accord, les propositions et les compteurs d'appels sont gardés en mémoire par chaque réplica de Prism : après un redémarrage, un jeton repasse en mode accord. La consommation, le contrat et les quotas portent sur toute l'organisation : un jeton limité à quelques applications ne peut pas les lire. Le point d'accès MCP ne répond qu'en JSON (pas de flux d'évènements).