Construire des intégrations d'IA avec les LLM et MCP de Yuno

Yuno propose des outils qui vous aident à créer des expériences de paiement adaptées à l'IA et conviviales pour les commerçants. Notre documentation prête à l'emploi facilite la compréhension des API et de la documentation de Yuno par les grands modèles linguistiques (LLM), tandis que notre protocole MCP (Model Context Protocol) offre un moyen transparent d'intégrer les fonctionnalités de Yuno à votre produit.

Ce guide explique comment travailler avec ces deux composants. Vous apprendrez comment la couche LLM permet aux outils d'intelligence artificielle de fournir un support d'intégration plus précis et contextuel, et comment le MCP peut intégrer des fonctionnalités clés de paiement et de commerce directement dans votre environnement, permettant des constructions plus rapides avec moins de friction.

Contenu prêt à l'emploi en texte clair

Pour aider les grands modèles linguistiques à comprendre et à prendre en charge les intégrations Yuno, nous fournissons un ensemble dédié de fichiers Markdown (.md) spécialement conçus pour être lisibles par les machines. Ces fichiers décrivent les API, le comportement des produits et les détails de mise en œuvre de Yuno dans un format facile à analyser et à interpréter par les LLM.

Les fichiers .md font partie de Yuno Docs. Vous pouvez y accéder en ajoutant .md à la fin de n'importe quelle URL de Yuno Docs (cela fonctionne à la fois pour les guides et les pages de référence API). Le contenu est fourni en texte clair, ce qui facilite l'extraction et le traitement des connaissances sous-jacentes par les machines, sans nécessiter d'interprétation humaine.

Cette configuration permet aux assistants IA, aux outils de développement et aux agents basés sur le chat de répondre aux questions, d'expliquer les fonctionnalités et de guider les intégrations automatiquement. C'est un moyen léger mais puissant d'ouvrir la documentation de Yuno à un large éventail d'applications intelligentes.

📘
Vous recherchez un endpoint MCP géré, accessible via le réseau, endpoint liaison IP, limites de débit et TTL de session ? Découvrez le serveur distant Yuno MCP.

Modèle de protocole contextuel (MCP) de Yuno

Ce paquet fournit un serveur MCP qui expose l'API de la plateforme de paiement Yuno en tant qu'outils de protocole de contexte de modèle. Il permet un accès programmatique pour les agents d'intelligence artificielle, les systèmes d'automatisation et d'autres flux de travail avancés qui s'appuient sur un contexte structuré et lisible par la machine.

Caractéristiques

Expose endpoints de l'API Yuno endpoints outils MCP: chaque endpoint modélisé comme un outil que les agents peuvent appeler par programmation, avec des structures d'entrée et de sortie claires.
Permet l'IA et l'automatisation des flux de travail avec Yuno: Intégrer Yuno dans les agents locaux ou les flux de travail personnalisés sans logique complexe et artisanale.
Intégration facile avec Cursor et d'autres agents compatibles MCP: Fonctionne d'emblée avec des outils tels que Cursor, Claude Desktop et d'autres environnements qui prennent en charge le protocole Model Context.

Outils disponibles

Le serveur Yuno MCP met les outils suivants à la disposition des agents d'IA et de l'automatisation :

Nom de l'outil	Description
`customer.create`	Créer un nouveau client
`customer.retrieve`	Récupérer un client par son numéro d'identification
`customer.retrieveByExternalId`	Récupérer un client par identifiant externe (`merchant_customer_id`)
`customer.update`	Mise à jour d'un client existant par ID
`paymentMethod.enroll`	Inscription ou création d'un mode de paiement pour un client
`paymentMethod.retrieve`	Récupérer le mode de paiement
`paymentMethod.retrieveEnrolled`	Récupérer tous les modes de paiement inscrits pour un client
`paymentMethod.unenroll`	Désinscription du mode de paiement
`checkoutSession.create`	Créer une Session de Paiement
`checkoutSession.retrievePaymentMethods`	Récupérer les méthodes de paiement pour la caisse
`payments.create`	Créer un paiement avec différents flux de travail
`payments.retrieve`	Récupérer les informations relatives au paiement
`payments.retrieveByMerchantOrderId`	Récupérer le(s) paiement(s) par `merchant_order_id`
`payments.refund`	Remboursement d'un paiement (total ou partiel) par l'identifiant du paiement et de la transaction
`payments.cancelOrRefund`	Annuler ou rembourser un paiement par identifiant de paiement (détection automatique de l'action)
`payments.cancelOrRefundWithTransaction`	Annuler ou rembourser un paiement par identifiant de paiement et de transaction (détection automatique de l'action)
`payments.cancel`	Annulation d'un paiement en attente par l'identifiant du paiement et de la transaction
`payments.authorize`	Autoriser un paiement (`capture: false`)
`payments.captureAuthorization`	Capturer un paiement déjà autorisé
`paymentLinks.create`	Créer un nouveau lien de paiement
`paymentLinks.retrieve`	Récupérer un lien de paiement par ID
`paymentLinks.cancel`	Annuler un lien de paiement par ID
`subscriptions.create`	Créer un nouvel abonnement
`subscriptions.retrieve`	Récupérer un abonnement par identifiant
`subscriptions.pause`	Interrompre un abonnement par ID
`subscriptions.resume`	Reprendre un abonnement par ID
`subscriptions.update`	Mise à jour d'un abonnement par ID
`subscriptions.cancel`	Annuler un abonnement par ID
`recipients.create`	Créer un nouveau destinataire
`recipients.retrieve`	Récupérer un destinataire par son numéro d'identification
`recipients.update`	Mise à jour d'un destinataire par ID
`recipients.delete`	Supprimer un destinataire par son identifiant
`recipients.createOnboarding`	Créer un onboarding pour un destinataire
`installmentPlans.create`	Créer un nouvel accord de paiement échelonné
`installmentPlans.retrieve`	Récupérer un plan de paiement échelonné par ID
`installmentPlans.retrieveAll`	Récupérer tous les plans de paiement échelonné pour un compte
`installmentPlans.update`	Mise à jour d'un plan de paiement échelonné par ID
`installmentPlans.delete`	Supprimer un plan de paiement échelonné par ID
`documentation.read`	Accéder à la documentation et aux guides de l'API Yuno

Utilisation du MCP avec le curseur ou le bureau Claude

Vous pouvez utiliser ce serveur MCP avec Cursor ou Claude Desktop pour permettre des flux de paiement pilotés par l'IA, la création de clients, et plus encore.

1. Configurez vos informations d'identification pour l'API de Yuno

Définissez vos identifiants API Yuno à l'aide de variables d'environnement (voir les exemples de configuration ci-dessous).

2. Ajouter le serveur MCP au curseur

Ouvrir les paramètres du curseur (Cmd+Shift+P → "Réglages du curseur")
Allez dans la section MCP et cliquez sur Ajouter un nouveau serveur MCP global.
Ajoutez la configuration suivante (remplacez le chemin par votre sortie de compilation) :

{
  "mcpServers": {
    "yuno-mcp": {
      "type": "command",
      "command": "npx @yuno-payments/yuno-mcp@latest",
      "env": {
        "YUNO_ACCOUNT_CODE": "your_account_code",
        "YUNO_PUBLIC_API_KEY": "your_public_api_key",
        "YUNO_PRIVATE_SECRET_KEY": "your_private_secret_key",
        "YUNO_COUNTRY_CODE": "your_country_code",
        "YUNO_CURRENCY": "your_currency"
      }
    }
  }
}

3. Ajouter le serveur MCP à Claude Desktop

Ouvrez les paramètres de Claude Desktop → onglet "Developer" → Editer la configuration.
Ajouter la configuration suivante :

{
  "mcpServers": {
    "yuno-mcp": {
      "command": "npx",
      "args": ["@yuno-payments/yuno-mcp@latest"],
      "env": {
        "YUNO_ACCOUNT_CODE": "your_account_code",
        "YUNO_PUBLIC_API_KEY": "your_public_api_key",
        "YUNO_PRIVATE_SECRET_KEY": "your_private_secret_key",
        "YUNO_COUNTRY_CODE": "your_country_code",
        "YUNO_CURRENCY": "your_currency"
      }
    }
  }
}

4. Tester l'intégration

Dans Cursor ou Claude, sélectionnez un fichier Markdown ou un chat et demandez à l'agent de créer une session de paiement, de client ou de caisse à l'aide de l'outil yuno-mcp.
Assurez-vous que vos variables d'environnement sont correctement définies

Variables d'environnement

YUNO_ACCOUNT_CODE*
YUNO_PUBLIC_API_KEY*
YUNO_PRIVATE_SECRET_KEY*
YUNO_COUNTRY_CODE (facultatif)
YUNO_CURRENCY (facultatif)

L'astérisque (*) indique qu'il est nécessaire.

Soutien

Pour le support officiel de Yuno, veuillez consulter la documentation officielle de Yuno