Installation

Connectez n'importe quel client MCP — Claude, Cursor, VS Code, OpenAI Codex, Gemini, Mistral — au serveur MCP Certivant en utilisant votre clé d'API Certivant existante comme jeton Bearer.

Le serveur MCP Certivant parle Streamable HTTP sur un seul point de terminaison, POST /mcp, et s'authentifie avec une clé d'API Certivant envoyée comme jeton Bearer. Il n'existe aucun identifiant MCP distinct à provisionner.

Avant de commencer

Obtenez une clé d'API. Créez-en une dans le tableau de bord, à KYC → Développeur (propriétaire ou administrateur uniquement). Elle commence par kyk_ et n'est affichée qu'une fois : voir Authentification.

Accordez-lui les bonnes portées. kyc:read suffit pour le tri, l'explication et les rapports. Ajoutez kyc:write pour envoyer des formulaires, démarrer des vérifications, relancer, renouveler et soumettre des informations KYB. kyc:submit sert à transmettre une demande au traitement. Le serveur MCP transmet votre clé telle quelle : un outil pour lequel il vous manque la portée renvoie le 403 propre à l'API REST.

Connaissez l'URL de votre serveur. Si Certivant exploite le serveur MCP pour vous, utilisez l'hôte qui vous a été communiqué. Si vous l'exploitez vous-même, il écoute sur MCP_PORT (par défaut 3007) et communique avec l'application à l'adresse CERTIVANT_API_BASE_URL (par défaut http://localhost:3005).

Traitez la clé d'API contenue dans ces fichiers de configuration exactement comme un mot de passe. Quiconque la détient peut agir au nom de votre organisation avec ses portées — y compris envoyer de vrais courriels à vos clients.

Lancer le serveur

Si vous l'hébergez vous-même, aux côtés du reste de la plateforme :

# from the repo root
MCP_PORT=3007 \
CERTIVANT_API_BASE_URL=https://app.certivant.com \
pnpm --filter @repo/mcp start

Vérifiez qu'il fonctionne : ce point de terminaison est volontairement non authentifié et ne signale que le fait que le processus écoute, jamais que l'API REST est en bonne santé :

curl http://localhost:3007/health
# → {"status":"ok","service":"certivant","transport":"streamable-http",…}

Compatible avec tout client MCP

Le serveur MCP Certivant suit le protocole ouvert Model Context Protocol : il n'est lié ni à Claude ni à aucun fournisseur en particulier. Tout assistant, éditeur, CLI ou plateforme qui parle MCP sur Streamable HTTP peut l'utiliser — Claude Desktop et Claude Code, Cursor, VS Code, OpenAI Codex, Google Gemini, Mistral, et de nouveaux clients qui arrivent sans cesse.

Quel que soit celui que vous utilisez, la forme est la même : dirigez le client vers POST https://your-mcp-host/mcp et envoyez votre clé d'API Certivant sous la forme Authorization: Bearer kyk_…. Le reste relève du format de configuration propre à ce client. Les plus courants figurent ci-dessous — si le vôtre n'est pas listé, utilisez la même URL et le même en-tête dans ses paramètres MCP, et cela fonctionnera.

Configurer un hôte natif MCP

Ces hôtes lisent un fichier de configuration (ou une interface de paramètres) et se connectent au serveur pour vous. Collez le point de terminaison et votre clé, et les outils apparaissent dans l'assistant.

Ajoutez-le depuis la CLI :

claude mcp add --transport http certivant https://your-mcp-host/mcp \
  --header "Authorization: Bearer kyk_live_…"

Vérifiez ensuite qu'il est bien connecté :

claude mcp list

Modifiez ~/.cursor/mcp.json (global) ou .cursor/mcp.json dans le projet :

{
  "mcpServers": {
    "certivant": {
      "url": "https://your-mcp-host/mcp",
      "headers": {
        "Authorization": "Bearer kyk_live_…"
      }
    }
  }
}

Créez .mcp.json dans l'espace de travail (ou ajoutez-le à votre mcp.json utilisateur). Demandez la clé plutôt que de la versionner :

{
  "inputs": [
    {
      "id": "certivant-key",
      "type": "promptString",
      "description": "Certivant API key (kyk_…)",
      "password": true
    }
  ],
  "servers": {
    "certivant": {
      "type": "http",
      "url": "https://your-mcp-host/mcp",
      "headers": {
        "Authorization": "Bearer ${input:certivant-key}"
      }
    }
  }
}

Le fichier claude_desktop_config.json de Claude Desktop lance des serveurs locaux ; un point de terminaison HTTP distant est donc relayé avec mcp-remote :

{
  "mcpServers": {
    "certivant": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://your-mcp-host/mcp",
        "--header",
        "Authorization: Bearer kyk_live_…"
      ]
    }
  }
}

Redémarrez Claude Desktop après avoir modifié le fichier.

Codex lit ~/.codex/config.toml (ou un fichier .codex/config.toml de projet dans un dossier de confiance). Ajoutez un serveur Streamable HTTP et récupérez la clé depuis une variable d'environnement afin qu'elle ne soit pas stockée en clair :

[mcp_servers.certivant]
url = "https://your-mcp-host/mcp"
bearer_token_env_var = "CERTIVANT_API_KEY"

Ou ajoutez-le depuis la CLI :

export CERTIVANT_API_KEY=kyk_live_…
codex mcp add certivant \
  --url https://your-mcp-host/mcp \
  --bearer-token-env-var CERTIVANT_API_KEY

Codex envoie la valeur sous la forme Authorization: Bearer <token>. Pour un en-tête autre que Authorization, utilisez http_headers à la place de bearer_token_env_var.

Ajoutez le serveur à ~/.gemini/settings.json (ou à un fichier .gemini/settings.json de projet). La clé httpUrl sélectionne le transport Streamable HTTP :

{
  "mcpServers": {
    "certivant": {
      "httpUrl": "https://your-mcp-host/mcp",
      "headers": {
        "Authorization": "Bearer kyk_live_…"
      }
    }
  }
}

Créer votre propre agent (API et frameworks)

La section ci-dessus couvre les clients prêts à l'emploi que vous n'avez qu'à pointer vers le serveur : Claude, Cursor, VS Code, OpenAI Codex, Gemini CLI. Cette section concerne la création de votre propre agent en code. Toutes les API de fournisseurs de modèles qui prennent en charge MCP distant fonctionnent — l'API Responses d'OpenAI, l'API Messages d'Anthropic, Google Gemini, Mistral — tout comme les frameworks d'agents indépendants des modèles, le Vercel AI SDK et LangChain, qui exposent les outils Certivant au modèle de votre choix. Tous parlent le même transport Streamable HTTP : les mêmes outils sont donc disponibles partout.

Qui établit la connexion compte.

Connecteurs hébergés par le fournisseur — l'API Responses d'OpenAI, l'API Messages d'Anthropic, Gemini et le connecteur de Mistral appellent votre serveur MCP depuis leur cloud. Le point de terminaison doit donc être accessible depuis Internet (un serveur de développement http://localhost:3007 ne fonctionnera pas : utilisez votre hôte HTTPS déployé), et votre clé d'API est transmise à ce fournisseur.
Clients de framework — le Vercel AI SDK et LangChain se connectent depuis votre propre code : la clé reste dans votre processus, et un point de terminaison local convient.

Dans tous les cas, limitez la clé au minimum dont le workflow a besoin, et privilégiez une clé kyc:read seule pour les exécutions autonomes ou sans surveillance : une clé kyc:write permet à un modèle d'envoyer de vrais courriels à vos clients sans qu'aucun humain n'intervienne, sauf si vous l'encadrez.

L'API Responses accepte un serveur MCP distant directement dans tools. Elle récupère la liste des outils auprès du serveur et permet au modèle de les appeler.

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-4.1",
    tools=[
        {
            "type": "mcp",
            "server_label": "certivant",
            "server_url": "https://your-mcp-host/mcp",
            "headers": {"Authorization": "Bearer kyk_live_…"},
            # Gate write tools rather than skipping every prompt — see below.
            "require_approval": "always",
        }
    ],
    input="What's in my verification queue today?",
)

print(resp.output_text)

require_approval: "never" supprime la confirmation humaine pour chaque outil, y compris ceux qui envoient des courriels aux clients, démarrent des vérifications ou envoient des rappels. Pour une utilisation sans surveillance, conservez "always", passez un objet qui n'approuve automatiquement que les outils de lecture, ou utilisez une clé kyc:read seule afin qu'aucun outil d'écriture n'existe à appeler.

La même entrée tools fonctionne depuis le SDK Node et depuis un appel brut POST https://api.openai.com/v1/responses.

L'API Messages de Claude attache directement un serveur MCP distant — un rappel utile : Certivant est un serveur standard, et non propre à Claude.

import anthropic

client = anthropic.Anthropic()

resp = client.beta.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What's in my verification queue today?"}],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://your-mcp-host/mcp",
            "name": "certivant",
            "authorization_token": "kyk_live_…",  # sent as Authorization: Bearer
        }
    ],
    betas=["mcp-client-2025-04-04"],
)

Le connecteur MCP d'Anthropic est en bêta et évolue activement : la version de l'en-tête bêta, et le fait que le serveur soit passé dans mcp_servers ou dans le tableau tools, ont tous deux changé. Considérez cet extrait comme illustratif et suivez la documentation actuelle du connecteur MCP pour la forme exacte.

Le SDK de Google se connecte via une session client MCP. Ouvrez une session Streamable HTTP avec le serveur et transmettez-la à generate_content comme outil.

import asyncio
from google import genai
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

client = genai.Client()

async def main():
    async with streamablehttp_client(
        "https://your-mcp-host/mcp",
        headers={"Authorization": "Bearer kyk_live_…"},
    ) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            resp = await client.aio.models.generate_content(
                model="gemini-2.0-flash",
                contents="What's in my verification queue today?",
                config=genai.types.GenerateContentConfig(tools=[session]),
            )
            print(resp.text)

asyncio.run(main())

La prise en charge de MCP par Gemini est expérimentale et, au moment de la rédaction, n'appelle que les outils : les ressources et invites du serveur sont ignorées. Les outils constituent la partie essentielle, de sorte que cela pose rarement problème en pratique.

Mistral se connecte via un connecteur que vous ajoutez dans Le Chat ou dans La Plateforme, plutôt que dans du code. Mistral exige le même transport Streamable HTTP et la même authentification Bearer que celles déjà utilisées par le serveur.

Ouvrez Connecteurs dans Le Chat (ou dans les paramètres Studio / Agents).

Ajoutez un connecteur MCP et collez l'URL de votre serveur, https://your-mcp-host/mcp.

Choisissez HTTP Bearer token comme méthode d'authentification et collez votre clé kyk_…. Mistral prend aussi en charge OAuth 2.1 pour les serveurs qui le proposent — voir la note en bas de cette page.

Enregistrez. Mistral effectue la poignée de main initialize de MCP et liste les outils.

Le connecteur de Mistral exige du HTTPS avec un certificat TLS valide et un serveur qui répond 200 et répond à l'appel initialize. L'hôte Certivant déployé satisfait à cette exigence ; un serveur de développement en HTTP simple ou auto-signé ne la satisfait pas.

L'AI SDK se connecte au serveur et expose ses outils à tout modèle que vous pilotez avec generateText / streamText — une seule intégration, tous les modèles.

import { experimental_createMCPClient as createMCPClient } from "ai";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const mcp = await createMCPClient({
  transport: new StreamableHTTPClientTransport(
    new URL("https://your-mcp-host/mcp"),
    { requestInit: { headers: { Authorization: "Bearer kyk_live_…" } } },
  ),
});

const tools = await mcp.tools();
// hand `tools` to generateText({ model, tools, prompt }) with any provider's model

createMCPClient est encore signalé comme experimental_ dans l'AI SDK.

langchain-mcp-adapters transforme les outils du serveur en outils LangChain, utilisables par n'importe quel agent LangChain ou LangGraph, avec n'importe quel modèle.

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient(
    {
        "certivant": {
            "transport": "streamable_http",
            "url": "https://your-mcp-host/mcp",
            "headers": {"Authorization": "Bearer kyk_live_…"},
        }
    }
)

tools = await client.get_tools()
# give `tools` to any LangGraph / LangChain agent

Vérifier la connexion

Demandez à l'assistant « Qu'y a-t-il dans ma file de vérification aujourd'hui ? ». Il doit appeler get_todays_queue et revenir avec des totaux. Si vous obtenez plutôt une erreur d'authentification, le serveur vous indique lequel des trois modes d'échec vous avez rencontré :

Réponse	Cause
`Missing Authorization header…`	L'hôte n'envoie pas du tout l'en-tête — vérifiez l'orthographe et les guillemets dans la configuration.
`Malformed Authorization header…`	La valeur n'a pas la forme `Bearer <token>`.
`Bearer token does not look like a Certivant API key…`	Le jeton n'a pas le préfixe `kyk_`.
Une erreur 401/403 lors d'un appel d'outil	La clé elle-même est invalide, révoquée, ou ne possède pas la portée requise. Le serveur MCP ne valide pas les clés : ce verdict provient de l'API REST.

Les quatre arrivent sous forme d'erreurs JSON-RPC accompagnées d'un en-tête WWW-Authenticate.

À propos d'OAuth

Un flux OAuth 2.1 + enregistrement dynamique de client est implémenté afin que les connecteurs référencés dans les annuaires puissent installer Certivant sans qu'une clé soit collée : le serveur répond à une requête non authentifiée par un WWW-Authenticate qui pointe vers ses métadonnées de ressource protégée, et la connexion, le choix de l'organisation et le consentement ont lieu dans Certivant. Les jetons émis se comportent comme des clés d'API. Les guides ci-dessus utilisent la clé d'API Bearer, qui fonctionne sur tous les hôtes.