Installation

Verbinden Sie jeden MCP-Client — Claude, Cursor, VS Code, OpenAI Codex, Gemini, Mistral — mit dem Certivant-MCP-Server, indem Sie Ihren bestehenden Certivant-API-Schlüssel als Bearer-Token verwenden.

Der Certivant-MCP-Server spricht Streamable HTTP über einen einzigen Endpunkt, POST /mcp, und authentifiziert sich mit einem Certivant-API-Schlüssel, der als Bearer-Token gesendet wird. Es ist keine separate MCP-Zugangsdaten-Bereitstellung nötig.

Bevor Sie beginnen

Einen API-Schlüssel beschaffen. Erstellen Sie einen im Dashboard unter KYC → Entwickler (nur Inhaber oder Administrator). Er beginnt mit kyk_ und wird einmal angezeigt — siehe Authentifizierung.

Die richtigen Berechtigungsbereiche vergeben. kyc:read genügt für Sichtung, Erklärung und Berichte. Fügen Sie kyc:write hinzu, um Formulare zu versenden, Verifizierungen zu starten, zu erinnern, zu erneuern und KYB-Daten zu übermitteln. kyc:submit benötigen Sie, um eine Anfrage zur Verarbeitung freizugeben. Der MCP-Server leitet Ihren Schlüssel unverändert weiter — ein Werkzeug, für das Ihnen der Berechtigungsbereich fehlt, liefert die eigene 403-Antwort der REST-API zurück.

Die Server-URL kennen. Betreibt Certivant den MCP-Server für Sie, verwenden Sie den Host, den Sie erhalten haben. Betreiben Sie ihn selbst, lauscht er auf MCP_PORT (Standard 3007) und spricht mit der Anwendung unter CERTIVANT_API_BASE_URL (Standard http://localhost:3005).

Behandeln Sie den API-Schlüssel in diesen Konfigurationsdateien genauso wie ein Passwort. Wer ihn besitzt, kann mit seinen Berechtigungsbereichen im Namen Ihrer Organisation handeln — einschließlich des Versands echter E-Mails an Ihre Kunden.

Den Server starten

Wenn Sie ihn zusammen mit der übrigen Plattform selbst betreiben:

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

Prüfen Sie, ob er läuft — dieser Endpunkt ist absichtlich ohne Authentifizierung und meldet nur, dass der Prozess lauscht, niemals, dass die REST-API gesund ist:

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

Funktioniert mit jedem MCP-Client

Der Certivant-MCP-Server folgt dem offenen Model Context Protocol und ist daher nicht an Claude oder einen einzelnen Anbieter gebunden. Jeder Assistent, jeder Editor, jede CLI oder Plattform, die MCP über Streamable HTTP spricht, kann ihn nutzen — Claude Desktop und Claude Code, Cursor, VS Code, OpenAI Codex, Google Gemini, Mistral und ständig neue Clients.

Welchen Sie auch verwenden, das Vorgehen ist dasselbe: Richten Sie den Client auf POST https://your-mcp-host/mcp und senden Sie Ihren Certivant-API-Schlüssel als Authorization: Bearer kyk_…. Alles Weitere folgt dem eigenen Konfigurationsformat des Clients. Die gängigsten finden Sie unten — ist Ihrer nicht aufgeführt, verwenden Sie dieselbe URL und denselben Header in seinen MCP-Einstellungen, dann funktioniert es.

Einen MCP-nativen Host konfigurieren

Diese Hosts lesen eine Konfigurationsdatei (oder eine Einstellungsoberfläche) und verbinden sich für Sie mit dem Server. Fügen Sie den Endpunkt und Ihren Schlüssel ein, dann erscheinen die Werkzeuge im Assistenten.

Fügen Sie ihn über die CLI hinzu:

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

Prüfen Sie anschließend, ob die Verbindung steht:

claude mcp list

Bearbeiten Sie ~/.cursor/mcp.json (global) oder .cursor/mcp.json im Projekt:

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

Legen Sie .mcp.json im Arbeitsbereich an (oder ergänzen Sie Ihre benutzerbezogene mcp.json). Lassen Sie den Schlüssel abfragen, statt ihn einzuchecken:

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

Die Datei claude_desktop_config.json von Claude Desktop startet lokale Server. Ein entfernter HTTP-Endpunkt wird daher über mcp-remote angebunden:

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

Starten Sie Claude Desktop nach dem Bearbeiten der Datei neu.

Codex liest ~/.codex/config.toml (oder eine Projektdatei .codex/config.toml in einem vertrauenswürdigen Ordner). Fügen Sie einen Streamable-HTTP-Server hinzu und beziehen Sie den Schlüssel aus einer Umgebungsvariablen, damit er nicht im Klartext gespeichert wird:

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

Oder fügen Sie ihn über die CLI hinzu:

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

Codex sendet den Wert als Authorization: Bearer <token>. Für einen anderen Header als Authorization verwenden Sie http_headers statt bearer_token_env_var.

Fügen Sie den Server in ~/.gemini/settings.json (oder einer Projektdatei .gemini/settings.json) hinzu. Der Schlüssel httpUrl wählt den Transport Streamable HTTP:

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

Einen eigenen Agenten bauen (APIs und Frameworks)

Der Abschnitt oben behandelt die fertigen Clients, auf die Sie den Server einfach zeigen — Claude, Cursor, VS Code, OpenAI Codex, Gemini CLI. Dieser Abschnitt richtet sich an alle, die einen eigenen Agenten im Code bauen. Jede Modellanbieter-API, die entfernte MCP-Server unterstützt, funktioniert — die Responses-API von OpenAI, die Messages-API von Anthropic, Google Gemini, Mistral — ebenso die modellunabhängigen Agenten-Frameworks, das Vercel AI SDK und LangChain, die die Certivant-Werkzeuge dem Modell zur Verfügung stellen, das Sie einsetzen. Alle sprechen dasselbe Streamable-HTTP-Transportprotokoll, daher stehen überall dieselben Werkzeuge bereit.

Wer die Verbindung herstellt, ist entscheidend.

Vom Anbieter gehostete Connectoren — die Responses-API von OpenAI, die Messages-API von Anthropic, Gemini und der Connector von Mistral rufen Ihren MCP-Server aus deren Cloud auf. Der Endpunkt muss daher aus dem Internet erreichbar sein (ein Entwicklungsserver unter http://localhost:3007 funktioniert nicht — nutzen Sie Ihren bereitgestellten HTTPS-Host), und Ihr API-Schlüssel wird an diesen Anbieter übertragen.
Framework-Clients — das Vercel AI SDK und LangChain verbinden sich aus Ihrem eigenen Code, daher bleibt der Schlüssel in Ihrem Prozess, und ein lokaler Endpunkt ist in Ordnung.

In jedem Fall sollten Sie den Schlüssel auf das Minimum beschränken, das der Workflow braucht, und für autonome oder unbeaufsichtigte Läufe einen Schlüssel nur mit kyc:read bevorzugen — ein Schlüssel mit kyc:write erlaubt einem Modell, ohne menschliche Kontrolle echte E-Mails an Ihre Kunden zu senden, sofern Sie dies nicht absichern.

Die Responses-API nimmt einen entfernten MCP-Server direkt in tools entgegen. Sie ruft die Werkzeugliste vom Server ab und lässt das Modell sie aufrufen.

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" überspringt die menschliche Bestätigung bei jedem Werkzeug, einschließlich derjenigen, die Kunden per E-Mail anschreiben, Verifizierungen starten oder Erinnerungen senden. Für unbeaufsichtigten Betrieb sollten Sie entweder "always" beibehalten, ein Objekt übergeben, das nur die Lesewerkzeuge automatisch genehmigt, oder einen Schlüssel mit kyc:read verwenden, damit kein Schreibwerkzeug existiert, das aufgerufen werden könnte.

Derselbe Eintrag tools funktioniert im Node-SDK und bei einem direkten Aufruf von POST https://api.openai.com/v1/responses.

Die eigene Messages-API von Claude bindet einen entfernten MCP-Server direkt an — ein nützlicher Hinweis darauf, dass Certivant ein Standardserver ist und kein Claude-spezifischer.

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"],
)

Der MCP-Connector von Anthropic ist Beta und ändert sich aktiv — sowohl die Version des Beta-Headers als auch die Frage, ob der Server in mcp_servers oder innerhalb des Arrays tools übergeben wird, haben sich bewegt. Behandeln Sie das Beispiel als Veranschaulichung und folgen Sie für die genaue Form der aktuellen Dokumentation zum MCP-Connector.

Das SDK von Google verbindet sich über eine MCP-Client-Sitzung. Öffnen Sie eine Streamable-HTTP-Sitzung zum Server und übergeben Sie sie generate_content als Werkzeug.

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())

Die MCP-Unterstützung von Gemini ist experimentell und ruft zum Zeitpunkt des Schreibens nur Werkzeuge auf — die Ressourcen und Prompts des Servers werden ignoriert. Die Werkzeuge sind der tragende Teil, daher ist dies in der Praxis selten ein Problem.

Mistral verbindet sich über einen Connector, den Sie in Le Chat oder in La Plateforme hinzufügen, und nicht im Code. Mistral verlangt dasselbe Streamable-HTTP-Transportprotokoll und dieselbe Bearer-Authentifizierung, die der Server bereits verwendet.

Öffnen Sie Connectors in Le Chat (oder die Einstellungen von Studio / Agents).

Fügen Sie einen MCP-Connector hinzu und fügen Sie Ihre Server-URL ein, https://your-mcp-host/mcp.

Wählen Sie HTTP Bearer token als Authentifizierungsmethode und fügen Sie Ihren kyk_…-Schlüssel ein. Mistral unterstützt außerdem OAuth 2.1 für Server, die es anbieten — siehe den Hinweis am Ende dieser Seite.

Speichern. Mistral führt den MCP-initialize-Handshake aus und listet die Werkzeuge auf.

Der Connector von Mistral verlangt HTTPS mit einem gültigen TLS-Zertifikat und einen Server, der mit 200 antwortet und den Aufruf initialize beantwortet. Der bereitgestellte Certivant-Host erfüllt dies; ein Entwicklungsserver ohne TLS oder mit selbstsigniertem Zertifikat nicht.

Das AI SDK verbindet sich mit dem Server und stellt seine Werkzeuge jedem Modell zur Verfügung, das Sie mit generateText / streamText ansteuern — eine Integration, jedes Modell.

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 ist im AI SDK noch mit experimental_ gekennzeichnet.

langchain-mcp-adapters wandelt die Werkzeuge des Servers in LangChain-Werkzeuge um, für jeden LangChain- oder LangGraph-Agenten auf jedem Modell.

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

Die Verbindung prüfen

Fragen Sie den Assistenten: „Was steht heute in meiner Verifizierungswarteschlange an?“ Er sollte get_todays_queue aufrufen und mit Zählwerten antworten. Sehen Sie stattdessen einen Authentifizierungsfehler, teilt Ihnen der Server mit, welcher der drei Fehlerfälle vorliegt:

Antwort	Ursache
`Missing Authorization header…`	Der Host sendet den Header überhaupt nicht — prüfen Sie Schreibweise und Anführungszeichen in der Konfiguration.
`Malformed Authorization header…`	Der Wert hat nicht die Form `Bearer <token>`.
`Bearer token does not look like a Certivant API key…`	Dem Token fehlt das Präfix `kyk_`.
Eine 401/403-Antwort bei einem Werkzeugaufruf	Der Schlüssel selbst ist ungültig, widerrufen oder hat nicht den nötigen Berechtigungsbereich. Der MCP-Server prüft Schlüssel nicht selbst — dieses Urteil stammt von der REST-API.

Alle vier kommen als JSON-RPC-Fehler mit einem Header WWW-Authenticate an.

Zu OAuth

Ein Ablauf nach OAuth 2.1 mit Dynamic Client Registration ist implementiert, damit in Verzeichnissen gelistete Connectoren Certivant installieren können, ohne dass ein Schlüssel eingefügt werden muss: Der Server beantwortet eine nicht authentifizierte Anfrage mit einem Verweis WWW-Authenticate auf seine Metadaten der geschützten Ressource, und die Anmeldung, die Auswahl der Organisation und die Zustimmung erfolgen in Certivant. Die ausgestellten Token verhalten sich wie API-Schlüssel. Die oben beschriebenen Anleitungen verwenden den Bearer- API-Schlüssel, der in jedem Host funktioniert.