Commencer avec un exemple fonctionnel
Lancez l’exemple, puis adaptez-le
Créez l’API Orders, une base PostgreSQL et le serveur MCP de votre choix dans Adios. Nous importons le code, configurons des identifiants JWT distincts et lançons les aperçus de développement.
Lancer sur Adios →Pas encore de compte ? Créez-en un et revenez à cet exemple. Choisissez une équipe et examinez les ressources avant de lancer. L’exemple complet nécessite une offre payante avec une capacité suffisante pour deux espaces et une base de données.
Construisez-le étape par étape
Suivre le guide manuel
Concevez l’API et le schéma, ajoutez l’authentification JWT, écrivez les outils MCP et exécutez-les dans vos espaces de développement. Chaque étape comprend le code et les commandes.
Suivre les étapes manuelles →Explorez d’abord l’exemple en cours d’exécution. OAuth pour la connexion des utilisateurs et le déploiement en production viennent ensuite.
Concevez l’API pour un cas d’usage réel
Commencez par définir l’objectif de l’API. L’exemple permet à un tableau de bord interne, un assistant de support et une automatisation de consulter le statut d’expédition d’une commande. Tous utilisent la même opération métier. L’API contrôle les données et les règles d’accès ; MCP permet au client IA de découvrir et d’appeler cette opération.
Limitez la première version à la lecture : l’appelant autorisé fournit un identifiant de commande et reçoit son identifiant et son statut d’expédition. Excluez les adresses, informations de paiement et notes internes. La création de commandes, les remboursements et la modification d’expéditions nécessitent des endpoints et permissions distincts.
- Qui appelle l’API ? Un utilisateur ou service connu associé à un tenant.
- Que peut-il faire ? Lire les commandes de ce tenant avec la permission orders:read.
- Quel est le rôle de l’API ? Valider la requête, vérifier l’appelant, contrôler la propriété et renvoyer une réponse stable.
- Quel est le rôle de MCP ? Décrire un outil précis, valider son entrée et appeler l’API avec l’identité vérifiée de l’appelant.
Écrivez ce contrat avant de choisir un SDK. Le site, les intégrations et les outils IA conservent ainsi le même modèle de permissions, sans donner au client IA un accès direct à la base.
Concevez le schéma et les règles de propriété
Utilisez PostgreSQL pour cet exemple. Un tenant représente une boutique ou organisation. Une identité associe le sujet d’un jeton vérifié à un tenant et peut être désactivée. Une commande appartient à un tenant. L’API utilise cette relation pour autoriser sa consultation.
| Table | Objectif | Règle d’accès |
|---|---|---|
tenants | Détenir les données de l’organisation | Référencé par les identités et commandes |
principals | Associer un sujet vérifié à un tenant | Seules les identités actives peuvent lire les données |
orders | Stocker le statut d’expédition | Le tenant de l’appelant doit correspondre à celui de la commande |
-- Demo bootstrap only. Use versioned migrations for an existing production DB.
CREATE TABLE IF NOT EXISTS tenants (
id uuid PRIMARY KEY,
name text NOT NULL
);
CREATE TABLE IF NOT EXISTS principals (
subject text PRIMARY KEY,
tenant_id uuid NOT NULL REFERENCES tenants(id),
active boolean NOT NULL DEFAULT true
);
CREATE TABLE IF NOT EXISTS orders (
tenant_id uuid NOT NULL REFERENCES tenants(id),
id varchar(64) NOT NULL CHECK (id ~ '^[A-Za-z0-9-]{1,64}$'),
status text NOT NULL CHECK (status IN ('pending', 'shipped', 'delivered')),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (tenant_id, id)
);
-- Fictional data; ownership comes from the verified subject, not tool input.
INSERT INTO tenants (id, name) VALUES
('11111111-1111-4111-8111-111111111111', 'Demo shop'),
('22222222-2222-4222-8222-222222222222', 'Other shop')
ON CONFLICT DO NOTHING;
INSERT INTO principals (subject, tenant_id) VALUES
('demo-client', '11111111-1111-4111-8111-111111111111'),
('other-client', '22222222-2222-4222-8222-222222222222')
ON CONFLICT DO NOTHING;
INSERT INTO orders (tenant_id, id, status) VALUES
('11111111-1111-4111-8111-111111111111', 'demo-1001', 'shipped'),
('22222222-2222-4222-8222-222222222222', 'other-1002', 'pending')
ON CONFLICT DO NOTHING;La clé composée permet le même identifiant de commande dans plusieurs tenants. Les clés étrangères évitent les enregistrements orphelins et la contrainte de statut interdit les états non pris en charge. La requête relie le sujet vérifié à son tenant et à la commande ; l’appelant ne choisit pas de tenant dans l’entrée de l’outil.
L’initialisation inclut deux tenants fictifs pour tester l’isolation : demo-client peut lire demo-1001, tandis que other-client possède other-1002. La démo exécute une initialisation idempotente au démarrage. Pour une base de production existante, utilisez des migrations versionnées et séparez le provisionnement des requêtes de l’application.
Définissez endpoints, réponses et authentification JWT
L’API publique expose un endpoint de consultation de commande. Une réponse réussie est un petit objet JSON avec id et status. Gardez ce schéma stable pour le site et l’outil MCP.
GET /orders/demo-1001
Authorization: Bearer <API-audience JWT>
200 { "id": "demo-1001", "status": "shipped" }
401 missing, invalid or expired JWT
403 valid JWT without orders:read
404 unknown order, inactive identity or another tenant’s order
503 database unavailableL’authentification JWT est le minimum dans toutes les implémentations suivantes. L’en-tête bearer transporte le jeton ; le comparer à une chaîne aléatoire ou simplement le décoder ne suffit pas. Vérifiez sa signature avec un algorithme autorisé, exigez l’émetteur et l’audience prévus, contrôlez l’expiration et le sujet, puis appliquez le scope avant d’accéder à la base.
{
"iss": "orders-demo",
"aud": "orders-mcp",
"sub": "demo-client",
"scope": "orders:read",
"iat": 1791498000,
"exp": 1791498900
}La démo contrôlée utilise HS256 avec des secrets de signature distincts pour API et MCP. Un script réservé à l’opérateur émet un JWT MCP de courte durée. Le serveur le vérifie, puis signe un nouveau JWT de cinq minutes pour l’audience orders-api avec le même sujet vérifié. L’API vérifie ce second jeton et consulte le tenant du sujet dans PostgreSQL.
MCP devient ainsi une passerelle de confiance autorisée à signer des jetons API. Ne distribuez jamais les secrets de signature aux clients et n’exposez pas l’émetteur comme endpoint public. Hors de ce périmètre, préférez un fournisseur OAuth émettant des JWT asymétriques et vérifiez ses clés publiques ; la section OAuth présente le serveur de ressources. JWT est un format de jeton ; OAuth gère l’autorisation déléguée et les flux de connexion.
N’acceptez pas un identifiant de tenant fourni par le client comme preuve de propriété. Ne transmettez pas un jeton d’audience MCP à l’API. Limitez la durée des jetons, renouvelez les clés et utilisez HTTPS en production. Avec plusieurs fournisseurs d’identité, associez émetteur et sujet à une identité canonique plutôt que de supposer les sujets uniques au niveau global.
Émetteur JWT de démo réservé à l’opérateur
import { createHmac } from "node:crypto";
// Operator-only demo issuer. Never expose this script or its key to end users.
const audience = process.argv[2] || "orders-mcp";
if (!["orders-mcp", "orders-api"].includes(audience))
throw new Error("Unknown audience");
const secret =
process.env[audience === "orders-api" ? "API_JWT_SECRET" : "MCP_JWT_SECRET"];
if (!secret || secret.length < 32)
throw new Error("Set the audience's JWT signing secret");
const encode = (value) =>
Buffer.from(JSON.stringify(value)).toString("base64url");
const now = Math.floor(Date.now() / 1000);
const data = `${encode({ alg: "HS256", typ: "JWT" })}.${encode({ iss: "orders-demo", aud: audience, sub: "demo-client", scope: "orders:read", iat: now, exp: now + 900 })}`;
process.stdout.write(
`${data}.${createHmac("sha256", secret).update(data).digest("base64url")}`,
);Implémentez l’API avant d’ajouter MCP
Décompressez les exemples et ouvrez api/. L’implémentation Node.js utilise jose pour vérifier les JWT et pg pour interroger PostgreSQL. Installez les dépendances verrouillées avec npm ci. La requête paramétrée relie le sujet vérifié à son tenant et ne renvoie que la commande de ce tenant.
Dépendances API et commande de démarrage
{
"name": "orders-api",
"private": true,
"type": "module",
"scripts": {
"start": "node init-db.mjs && node server.mjs"
},
"dependencies": {
"jose": "^6.1.0",
"pg": "8.23.1"
}
}import http from "node:http";
import { jwtVerify } from "jose";
import pg from "pg";
const secret = process.env.API_JWT_SECRET;
if (!secret || secret.length < 32 || !process.env.DATABASE_URL) {
throw new Error(
"Set DATABASE_URL and an API_JWT_SECRET of at least 32 characters",
);
}
const key = new TextEncoder().encode(secret);
const pool = new pg.Pool({
connectionString: process.env.DATABASE_URL,
max: 5,
connectionTimeoutMillis: 5000,
statement_timeout: 5000,
});
pool.on("error", () => console.error("Database connection failed"));
await pool.query("SELECT 1");
const server = http.createServer(async (req, res) => {
const send = (status, data) => {
res.writeHead(status, {
"Content-Type": "application/json",
"Cache-Control": "no-store",
});
res.end(JSON.stringify(data));
};
if (req.url === "/healthz" && req.method === "GET") {
try {
await pool.query("SELECT 1");
return send(200, { ok: true });
} catch {
return send(503, { ok: false });
}
}
let principal;
try {
const match = /^Bearer (\S+)$/.exec(req.headers[(process.env.API_AUTH_HEADER || "Authorization").toLowerCase()] || "");
if (!match) throw new Error("Missing access token");
const { payload } = await jwtVerify(match[1], key, {
issuer: "orders-demo",
audience: "orders-api",
algorithms: ["HS256"],
requiredClaims: ["sub", "exp"],
});
if (typeof payload.sub !== "string" || !payload.sub)
throw new Error("Missing subject");
if (
typeof payload.scope !== "string" ||
!payload.scope.split(" ").includes("orders:read")
) {
return send(403, { error: "orders:read permission required" });
}
principal = payload.sub;
} catch {
res.setHeader("WWW-Authenticate", 'Bearer error="invalid_token"');
return send(401, { error: "Invalid or expired access token" });
}
const match = /^\/orders\/([a-zA-Z0-9-]{1,64})$/.exec(req.url || "");
if (req.method !== "GET" || !match) return send(404, { error: "Not found" });
try {
const result = await pool.query(
`SELECT o.id, o.status FROM orders o
JOIN principals p ON p.tenant_id = o.tenant_id
WHERE p.subject = $1 AND p.active = true AND o.id = $2`,
[principal, match[1]],
);
// The same 404 covers unknown IDs and orders outside the caller's tenant.
return result.rows[0]
? send(200, result.rows[0])
: send(404, { error: "Order not found" });
} catch {
return send(503, { error: "Order service unavailable" });
}
});
server.requestTimeout = 10_000;
server.listen(
Number(process.env.PORT || 8081),
process.env.HOST || "127.0.0.1",
);Initialisez la base de démo
import { readFile } from "node:fs/promises";
import pg from "pg";
if (!process.env.DATABASE_URL) throw new Error("Set DATABASE_URL");
const deadline = Date.now() + 45_000;
let client;
while (true) {
client = new pg.Client({
connectionString: process.env.DATABASE_URL,
connectionTimeoutMillis: 5000,
statement_timeout: 10000,
});
try {
await client.connect();
break;
} catch {
await client.end().catch(() => {});
if (Date.now() >= deadline)
throw new Error(
"Database unavailable. Check its private endpoint and credentials.",
);
await new Promise((resolve) => setTimeout(resolve, 1000));
}
}
try {
await client.query(
await readFile(new URL("./schema.sql", import.meta.url), "utf8"),
);
console.log("Demo database initialized");
} catch {
throw new Error("Could not initialize the demo database");
} finally {
await client.end();
}L’API renvoie le même 404 pour les commandes absentes et inaccessibles, afin de ne pas révéler les identifiants d’un autre tenant. Sa route de santé publique vérifie la connexion à la base sans exposer de données ni exiger un JWT.
Si vous avez déjà une API, conservez son modèle et ses contrôles de propriété. Adaptez l’endpoint et le traitement de la réponse dans MCP. Utilisez une origine et un endpoint fixes plutôt que des URL arbitraires fournies à l’outil.
Ajoutez MCP comme couche d’outils sur l’API
Model Context Protocol (MCP) offre aux clients IA une méthode standard pour découvrir et appeler des outils. Votre serveur décrit un outil, accepte des entrées validées, exécute l’opération et renvoie un résultat. Votre API REST peut continuer à servir votre site et vos autres intégrations.
AI client → HTTPS /mcp → get_order({ order_id: "demo-1001" })
→ GET /orders/demo-1001 → { id: "demo-1001", status: "shipped" }
Client → MCP: MCP_ACCESS_TOKEN, or a user OAuth access token
MCP → API: newly signed API JWT with the verified caller’s subjectLe serveur vérifie le JWT client avant de créer le gestionnaire. Chaque appel API utilise un nouveau JWT avec une autre audience et le sujet vérifié. L’API continue d’appliquer les règles de propriété de la base ; MCP ne les contourne pas.
Utilisez Streamable HTTP pour un serveur distant. Stdio convient lorsqu’un client de bureau lance un processus local. Ces exemples HTTP sont sans état et renvoient du JSON ; ils ne nécessitent ni stockage de sessions ni flux d’événements persistant. Ils exposent /mcp pour le protocole et un endpoint public /healthz pour la sonde du runtime.
Il vous faut PostgreSQL et Node.js 24 pour l’API, ainsi que Node.js 24, Python 3.13 ou Go 1.25 pour le serveur MCP choisi. Installez la CLI Adios et préparez une équipe Adios. Ces exemples utilisent les SDK officiels JavaScript 1.32.1, Python 1.30.0 et Go 1.8.0 ; évitez de les mélanger avec des tutoriels d’autres versions majeures.
Choisissez un guide par langage
Le contrat de l’API et le modèle d’autorisation restent identiques. Continuez avec votre langage : chaque guide contient son code serveur, ses dépendances, ses tests de workspace et son manifeste de déploiement Adios.
JavaScript
Utilisez le SDK JavaScript, des schémas d’outils Zod et Express. Inclut l’exemple facultatif de serveur de ressources OAuth.
Ouvrir le guide JavaScriptPython 3.13Python
Utilisez FastMCP, des outils typés, HTTPX et un contrôle JWT ASGI. Retrouvez la configuration et le déploiement Python dans un seul guide.
Ouvrir le guide PythonGo 1.25Go
Utilisez le SDK Go, des structs typés d’entrée et de sortie et un middleware HTTP. Compilez et déployez un seul binaire de service.
Ouvrir le guide GoLes trois implémentations appellent l’API commune et vérifient les JWT. Le guide JavaScript inclut aussi le contrôle OAuth facultatif du serveur de ressources ; les guides Python et Go décrivent l’autorisation à mettre en place avant de permettre la connexion des utilisateurs.
Développer dans un workspace Adios
Utilisez une équipe de développement Adios et PostgreSQL géré. Votre ordinateur ne fait que téléverser le code et exécuter le test client ; les processus API et MCP s’exécutent dans des workspaces Adios.
adios login
adios teams
adios teams switch YOUR_DEV_TEAM_ID
export POSTGRES_PASSWORD="$(openssl rand -hex 32)"
export API_JWT_SECRET="$(openssl rand -hex 32)"
export MCP_JWT_SECRET="$(openssl rand -hex 32)"
printf '%s' "$POSTGRES_PASSWORD" | adios secrets set ORDERS_DB_PASSWORD --stdin
printf '%s' "$API_JWT_SECRET" | adios secrets set ORDERS_API_JWT_SECRET --stdin
printf '%s' "$MCP_JWT_SECRET" | adios secrets set ORDERS_MCP_JWT_SECRET --stdin
adios databases create orders-dev-db --template postgres:16 \
--region de --database orders --user orders_api \
--password-secret ORDERS_DB_PASSWORDAttendez que la base de données soit prête. Copiez son URL de connexion depuis ses détails dans Console et enregistrez-la sous ORDERS_DEV_DATABASE_URL via la saisie de secret. Utilisez l’hôte attribué et vérifiez qu’il est accessible depuis la région du workspace.
adios secrets set ORDERS_DEV_DATABASE_URL --stdin
# Paste the database connection URL, then finish stdin with Ctrl-D.
cp api/adios.dev.yaml api/adios.yaml
adios ws create --name orders-api-dev --json
# Copy workspace_id from the response:
export API_WORKSPACE_ID=YOUR_API_WORKSPACE_ID
(cd api && adios sync "$API_WORKSPACE_ID")
adios ws run start "$API_WORKSPACE_ID" --wait --json
adios ws get "$API_WORKSPACE_ID"Créez d’abord un workspace indépendant, puis synchronisez le code. La création depuis un chemin de projet peut nécessiter une application déjà déployée ; ce flux indépendant permet de commencer le développement sans publier de version.
name: orders-api-dev
region: de
build_cmd: npm ci
start_cmd: npm start
runtime:
name: node@24
port: 8081
health_path: /healthz
env:
API_AUTH_HEADER: X-Orders-Token
HOST: 0.0.0.0
PORT: "8081"
DATABASE_URL: secret://ORDERS_DEV_DATABASE_URL
API_JWT_SECRET: secret://ORDERS_API_JWT_SECRETL’aperçu de l’API initialise le schéma de démonstration et démarre le processus Node.js. Copiez son origine HTTPS réelle depuis le résultat d’exécution ou Console. Gardez ce terminal ouvert pour que l’émetteur client conserve les clés de signature.
export API_BASE_URL=https://YOUR-API-PREVIEW-HOST
export API_ACCESS_TOKEN="$(node issue-token.mjs orders-api)"
curl --fail "$API_BASE_URL/healthz"
curl --fail -H "Authorization: Bearer $API_ACCESS_TOKEN" \
"$API_BASE_URL/orders/demo-1001"Poursuivez avec le guide de votre langage pour créer le workspace MCP. Mettez à jour les fichiers avec adios sync et redémarrez l’aperçu pour appliquer les changements. Un aperçu est un runtime de développement, pas une version publiée de l’application.
Choisir une implémentation par langage →Arrêtez les aperçus depuis les contrôles du workspace lorsque vous avez terminé. La base de données gérée a son propre cycle de vie ; arrêter un aperçu ne l’arrête ni ne la supprime.
adios ws run stop "$API_WORKSPACE_ID"Ajoutez OAuth pour la connexion et l’accès délégué
Les exemples JWT couvrent une intégration contrôlée avec des jetons émis par l’opérateur. Ils n’implémentent ni connexion utilisateur, ni consentement, ni renouvellement. Ajoutez OAuth pour des comptes personnels ou les clients exigeant le flux MCP. Le mode OAuth de cet exemple accepte des JWT d’accès émis par le fournisseur.
Votre serveur MCP est la ressource protégée. Un serveur d’autorisation gère la connexion, le consentement et l’émission des jetons. Votre fournisseur OAuth peut le faire s’il prend en charge la découverte et l’enregistrement requis par vos clients MCP. Adios héberge l’application et stocke ses secrets ; la connexion à la CLI n’y ajoute pas OAuth automatiquement.
- Publiez les métadonnées de ressource à
/.well-known/oauth-protected-resource/mcp, en indiquant l’URL MCP, le serveur d’autorisation et les permissions prises en charge. - Renvoyez 401 pour une requête non authentifiée avec un en-tête
WWW-Authenticatepointant vers ces métadonnées. - Le client découvre les métadonnées OAuth ou OpenID Connect du serveur d’autorisation. Organisez le préenregistrement, les documents de métadonnées client ou l’enregistrement dynamique selon les capacités du fournisseur et du client.
- L’utilisateur se connecte et autorise l’accès. Le client utilise un flux de code d’autorisation avec PKCE et demande un jeton pour votre ressource MCP.
- Validez la signature du jeton ou son résultat d’introspection, son émetteur, son audience, son expiration et ses permissions. Associez son sujet à votre utilisateur et à son tenant avant d’exécuter un outil.
Commencez par orders:read. Protégez les outils d’écriture avec des permissions distinctes et une confirmation explicite si le client le permet. Un jeton d’identité n’est pas un jeton d’accès API, et une connexion valide ne donne pas accès aux commandes de tous les clients.
Le guide JavaScript inclut un contrôle facultatif complet du serveur de ressources avec JWT RS256. Il publie les métadonnées de ressource et vérifie les jetons du fournisseur, mais n’implémente ni connexion, ni consentement, ni enregistrement des clients, ni émission de jetons.
Suivre l’implémentation OAuth en JavaScript →Python et Go ont besoin d’un vérificateur équivalent de jetons du fournisseur et de métadonnées de ressource avant d’accepter des jetons OAuth utilisateur. Une valeur de jeton seule n’active pas OAuth dans les démonstrations JWT.
Une API tierce peut nécessiter une connexion OAuth distincte. Stockez ses jetons de renouvellement en sécurité, associez-les au bon utilisateur et demandez uniquement les permissions nécessaires. Les secrets client du fournisseur vont dans les secrets Adios ; les URL de l’émetteur et du JWKS public sont une configuration ordinaire.
Référence du protocole : Spécification d’autorisation MCP.
Déployez PostgreSQL, l’API et MCP sur Adios
Déployez deux applications : orders-api et orders-mcp. Elles peuvent être publiées indépendamment. Utilisez la même équipe Adios pour leurs références aux secrets. La région d’exemple est de; choisissez une région disponible adaptée à vos utilisateurs.
Connectez-vous et créez les secrets
Choisissez l’équipe de publication et générez de nouveaux secrets de signature et un mot de passe de base de données. Séparez ses données et identifiants de ceux du développement. Adios login authentifie la CLI auprès de la plateforme.
adios login
adios teams
adios teams switch YOUR_RELEASE_TEAM_ID
export API_JWT_SECRET="$(openssl rand -hex 32)"
export MCP_JWT_SECRET="$(openssl rand -hex 32)"
export POSTGRES_PASSWORD="$(openssl rand -hex 32)"
printf '%s' "$API_JWT_SECRET" | adios secrets set ORDERS_API_JWT_SECRET --stdin
printf '%s' "$MCP_JWT_SECRET" | adios secrets set ORDERS_MCP_JWT_SECRET --stdin
printf '%s' "$POSTGRES_PASSWORD" | adios secrets set ORDERS_DB_PASSWORD --stdinDéployez d’abord l’API
Le manifeste API déclare une ressource Postgres gérée. Adios la provisionne et injecte DATABASE_URL dans le runtime API. Le mot de passe référence un secret. Le démarrage initialise le schéma de démo avant l’API ; utilisez votre procédure de migration habituelle en production.
name: orders-api
region: de
replicas: 1
build_cmd: npm ci
start_cmd: npm start
runtime:
name: node@24
port: 8081
health_path: /healthz
resources:
- name: db
template: postgres:16
database: orders
username: orders_api
password: secret://ORDERS_DB_PASSWORD
env:
HOST: 0.0.0.0
PORT: "8081"
API_JWT_SECRET: secret://ORDERS_API_JWT_SECRET
# Adios injects DATABASE_URL for the managed Postgres resource.(cd api && cp adios.release.yaml adios.yaml && adios up)
adios apps get orders-apiadios up compile, déploie et promeut une version saine. Il s’agit d’un déploiement, pas d’un aperçu local. Copiez la route HTTPS réelle depuis la sortie ou la Console et vérifiez que son /healthz renvoie 200.
Connectez MCP à l’API déployée
Modifiez le manifeste dans le dossier du langage choisi. Remplacez https://api.example.com par l’origine réelle de l’API. Remplacez https://mcp.example.com par l’origine publique du service MCP. Ces valeurs sont des exemples, pas des domaines fournis par Adios.
env:
HOST: 0.0.0.0
PORT: "8080"
API_BASE_URL: https://YOUR-API-HOST
PUBLIC_ORIGIN: https://YOUR-MCP-HOST
API_JWT_SECRET: secret://ORDERS_API_JWT_SECRET
MCP_JWT_SECRET: secret://ORDERS_MCP_JWT_SECRETSi vous ne connaissez pas encore le nom d’hôte MCP par défaut, déployez une fois pour l’obtenir, mettez à jour PUBLIC_ORIGIN, puis redéployez avant de connecter un client. Les sondes de santé fonctionnent pendant cette configuration ; MCP n’accepte que l’origine configurée. Vous pouvez aussi vérifier un domaine personnalisé et ajouter custom_hosts avant la publication finale.
custom_hosts:
- mcp.example.comLes manifestes MCP écoutent sur 0.0.0.0, exposent le port 8080 et utilisent /healthz pour les contrôles de santé. Adios achemine HTTPS vers l’application. Gardez la sonde indépendante de l’authentification JWT MCP.
Exécutez la commande de déploiement depuis le répertoire de l’implémentation choisie. Son guide contient la commande et le manifeste exacts.
Voir les étapes de déploiement de votre langage →Exécutez le test client sur l’URL hébergée :
export MCP_ACCESS_TOKEN="$(node issue-token.mjs)"
export MCP_URL=https://YOUR-MCP-HOST/mcp
.client-venv/bin/python check.pyCe tutoriel utilise une route API HTTPS avec un JWT d’audience API. Si vous placez l’API sur un réseau privé, utilisez l’hôte attribué par Adios et vérifiez la connectivité depuis MCP. Ne déduisez pas un hôte interne du nom de l’app. Consultez la référence du manifeste pour les options de runtime, secrets et routage.
Utilisez les outils hébergés depuis un client IA
Dans un client compatible avec Streamable HTTP distant, ajoutez https://YOUR-MCP-HOST/mcp comme URL du serveur. Pour les exemples privés, configurez un en-tête Authorization: Bearer … via le mécanisme de secrets ou de variables d’environnement du client. Ne collez pas d’identifiants dans un fichier de configuration partagé.
Pour OAuth, ajoutez la même URL et suivez la connexion du client. Il doit découvrir les métadonnées, ouvrir la connexion du fournisseur et recevoir un jeton d’accès. Vérifiez la compatibilité avec le flux d’enregistrement du fournisseur avant de distribuer l’intégration.
Vérifiez que get_order figure dans la liste d’outils. Demandez : « Utilise le serveur Orders MCP pour vérifier le statut d’expédition de la commande demo-1001. » Le client peut appeler l’outil et répondre qu’elle est expédiée. Vérifiez l’appel lui-même, et pas seulement une réponse générée à partir du chat.
check.py illustre l’initialisation et l’appel par script. Avec OAuth, il accepte un jeton d’accès valide dans MCP_ACCESS_TOKEN, mais n’effectue ni connexion ni renouvellement ; utilisez un client compatible OAuth pour cela.
Pour qu’un client IA aide à déployer ce projet, connectez-le à Adios MCP. Cette connexion à la plateforme et votre serveur Orders MCP hébergé sont des intégrations distinctes avec des permissions séparées.
Vérifiez le service avant de le partager
La route de santé API vérifie PostgreSQL ; celle de MCP vérifie son processus. Aucune ne prouve que toutes les permissions JWT ou OAuth sont correctes. Après chaque publication, testez l’initialisation, la découverte et un appel autorisé connu.
- Échec de connexion : vérifiez la route, TLS,
/mcpetPUBLIC_ORIGIN. Le proxy doit conserver l’hôte prévu et prendre en charge le transport choisi. - 401 ou 403 : vérifiez les identifiants. Pour OAuth, vérifiez l’émetteur, l’audience, l’expiration, les permissions et les métadonnées. Testez des jetons expirés et de mauvaise audience en plus d’un jeton valide.
- Erreur d’outil : vérifiez l’URL API, les permissions d’accès, le délai limite et le format de réponse. Gardez les jetons et les réponses privées hors des journaux.
- Utilisateurs réels : ajoutez les contrôles de tenant et de ressources, des limites de requêtes, la rotation des identifiants et des événements d’audit liés à l’appelant. Vérifiez qu’un utilisateur ne peut pas consulter les commandes d’un autre.
- Plus de réplicas : ces exemples n’ont pas d’état de session. Si vous ajoutez des sessions, des notifications ou des flux persistants, prévoyez un état partagé et un routage adapté.
adios logs orders-api --runtime
adios logs orders-mcp --runtime
adios logs orders-mcp --buildFixez les versions des dépendances et répétez le test client après toute modification des routes ou de l’authentification. Définissez les permissions et confirmations avant d’ajouter des outils d’écriture.
Questions fréquentes
Faut-il OAuth pour héberger un serveur MCP ?
Une intégration contrôlée peut utiliser un JWT vérifié de courte durée si le client accepte les en-têtes d’autorisation. Pour la connexion utilisateur, les permissions déléguées ou les clients exigeant le flux MCP, implémentez OAuth. La connexion à la CLI Adios n’authentifie pas les utilisateurs de votre serveur MCP.
Un serveur MCP peut-il utiliser mon API existante ?
Oui. Définissez des outils avec des schémas d’entrée, validez chaque requête, appelez votre API avec un identifiant destiné à cette API et renvoyez des résultats structurés. Vérifiez les droits de l’appelant sur le tenant et les ressources avant d’accéder aux données réelles.
Puis-je héberger des serveurs MCP JavaScript, Python et Go sur Adios ?
Oui. Les guides JavaScript, Python et Go liés incluent chacun un serveur Streamable HTTP complet, des fichiers de dépendances, des endpoints de santé et un manifeste adios.yaml. Choisissez-en un et déployez-le avec l’API REST commune.
Quelle différence avec Adios MCP ?
Ce guide crée votre propre service MCP. Adios MCP permet à un client IA de gérer les espaces de travail et déploiements Adios. Vous pouvez utiliser cette connexion à la plateforme pour créer et déployer ce projet.