Documentation›Agents IA via MCP
Intégrations

Agents IA via MCP

Donnez à tout agent IA compatible MCP quatre outils CertOne : une analyse confidentielle, les corrections des agents LLM scellés de CertOne, le contrôle de mise en production et l'attestation signée.

Avant de commencer

  • Python 3.10 ou plus récent sur la machine où l'agent s'exécute.
  • Une clé d'API member.

Dans la console CertOne, ouvrez Developer Hub, puis API keys. Nommez la clé, choisissez le rôle member et sélectionnez New key.

  • Copiez le secret immédiatement : il n'est affiché qu'une fois.
  • Les clés commencent par ck_ et expirent après au plus 365 jours.
  • La création de clés exige le rôle admin dans votre organisation.
  • Une clé viewer peut lire les résultats mais ne peut pas soumettre d'analyses.

Installez le serveur MCP de CertOne, certone-mcp, et rendez la clé disponible :

Terminal
pip install "certone-sdk[mcp]"
export CERTONE_API_KEY=ck_...        # PowerShell: $env:CERTONE_API_KEY = "ck_..."
OutilRôle
certone_scanAnalyse confidentielle d'un dossier de projet dans un bac à sable attesté par le matériel : le verdict et chaque constat avec la loi qu'il enfreint, son fichier et sa ligne.
certone_fixesLes corrections proposées par les agents LLM scellés de CertOne, avec l'examen du vérificateur indépendant. S'ils travaillent encore, il l'indique et l'agent rappelle.
certone_release_gateAutorise une mise en production seulement pour un verdict réussi avec une attestation signée.
certone_attestationL'attestation signée d'un rapport réussi, liée à sa version exacte.

Claude Code

Enregistrez le serveur une fois, puis demandez en langage courant, par exemple Use CertOne to check this service before release.

Terminal
claude mcp add certone --env CERTONE_API_KEY=$CERTONE_API_KEY -- certone-mcp
claude

Claude Desktop

Ajoutez le serveur à claude_desktop_config.json (Settings, Developer, Edit Config), puis redémarrez Claude Desktop. certone-mcp doit être dans le PATH, sinon indiquez son chemin complet comme command.

claude_desktop_config.json
{
  "mcpServers": {
    "certone": {
      "command": "certone-mcp",
      "env": { "CERTONE_API_KEY": "ck_..." }
    }
  }
}

VS Code avec GitHub Copilot

Ajoutez .vscode/mcp.json à l'espace de travail. VS Code demande la clé une fois et la conserve dans son stockage secret. Ouvrez la conversation en mode Agent et sélectionnez Start au-dessus du serveur dans mcp.json.

.vscode/mcp.json
{
  "inputs": [
    { "type": "promptString", "id": "certone-key", "description": "CertOne API key", "password": true }
  ],
  "servers": {
    "certone": {
      "type": "stdio",
      "command": "certone-mcp",
      "env": { "CERTONE_API_KEY": "${input:certone-key}" }
    }
  }
}
Un modèle qui suit bien les instructions en plusieurs étapes donne les rapports les plus complets. Copilot peut aussi utiliser votre propre clé Anthropic ou OpenAI via Manage Language Models.

GitHub Actions

À chaque demande de tirage, un agent analyse le changement, valide la correction de CertOne sur la branche, analyse de nouveau et publie le verdict et l'attestation en commentaire. Ajoutez deux secrets au dépôt, CERTONE_API_KEY et ANTHROPIC_API_KEY, et ce flux de travail :

.github/workflows/certone-mcp.yml
name: CertOne AI agent (MCP)
on:
  pull_request:
    branches: [main]
permissions:
  contents: write        # commit CertOne's fix to the pull request branch
  pull-requests: write   # post the report
jobs:
  certone-agent:
    # branches of this repository only: forks never run the agent or reach the secrets
    if: github.event.pull_request.head.repo.full_name == github.repository
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install Claude Code and the CertOne MCP server
        run: |
          curl -fsSL https://claude.ai/install.sh | bash
          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
          pip install "certone-sdk[mcp]"
      - name: Certify the AI system with CertOne
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          CERTONE_API_KEY: ${{ secrets.CERTONE_API_KEY }}
        run: |
          claude -p "Use CertOne to check my-model/ before release. If it fails, apply CertOne's patch and scan again. Write the full report to certone-report.md. Do not run git." \
            --mcp-config '{"mcpServers":{"certone":{"command":"certone-mcp"}}}' \
            --allowedTools "mcp__certone,Read,Edit,Write,Glob,Grep" --permission-mode acceptEdits
      - name: Commit CertOne's fix to the pull request
        run: |
          git config user.name "certone-agent"
          git config user.email "certone-agent@users.noreply.github.com"
          git add my-model
          git diff --cached --quiet || { git commit -m "Apply CertOne's fix" -m "[skip ci]"; git push; }
      - name: Post the report on the pull request
        env:
          GH_TOKEN: ${{ github.token }}
        run: gh pr comment ${{ github.event.pull_request.number }} --body-file certone-report.md
  • Remplacez my-model par le dossier de votre système d'IA.
  • La ligne if: tient les dépôts dérivés à l'écart de l'agent et des secrets.
  • [skip ci] empêche la validation de la correction de relancer le flux.

Autres clients MCP et vos propres agents

Tout client MCP qui exécute des serveurs locaux peut utiliser CertOne : la commande est certone-mcp (stdio), avec CERTONE_API_KEY dans son environnement. CERTONE_API_URL le dirige vers un autre déploiement de CertOne.

Avec l'OpenAI Agents SDK (pip install openai-agents), pour les modèles d'OpenAI :

Python
import asyncio, os
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async def main():
    async with MCPServerStdio(params={
        "command": "certone-mcp",
        "env": {"CERTONE_API_KEY": os.environ["CERTONE_API_KEY"]},
    }) as certone:
        agent = Agent(name="Release checker", mcp_servers=[certone],
                      instructions="Use CertOne before every release of an AI system.")
        result = await Runner.run(agent, "Use CertOne to check ./my-model before release.")
        print(result.final_output)

asyncio.run(main())

Avec le Claude Agent SDK (pip install claude-agent-sdk) :

Python
import asyncio, os
from claude_agent_sdk import ClaudeAgentOptions, query

options = ClaudeAgentOptions(
    mcp_servers={"certone": {"command": "certone-mcp",
                             "env": {"CERTONE_API_KEY": os.environ["CERTONE_API_KEY"]}}},
    allowed_tools=["mcp__certone", "Read", "Edit"],
)

async def main():
    async for message in query(prompt="Use CertOne to check ./my-model before release.",
                               options=options):
        print(message)

asyncio.run(main())
L'application ChatGPT ne se connecte qu'à des serveurs MCP hébergés; elle ne peut donc pas encore exécuter certone-mcp. Utilisez l'OpenAI Agents SDK ci-dessus avec les mêmes modèles d'OpenAI.

Notes

  • Le serveur n'approuve ni n'applique jamais de correction sur la plateforme : l'agent l'applique dans sa propre arborescence, où votre équipe l'examine, et une nouvelle analyse décide.
  • Les agents LLM scellés prennent quelques minutes après le verdict; l'agent attend et rappelle certone_fixes.
  • Gardez la clé d'API dans le stockage secret de l'agent ou son environnement, jamais dans le dépôt.