Criando integrações de IA com LLMs e MCP da Yuno

A Yuno oferece ferramentas para ajudá-lo a criar experiências de pagamento amigáveis para comerciantes e com reconhecimento de IA. Nossa documentação pronta para máquina facilita a compreensão das APIs e da documentação do Yuno por grandes modelos de linguagem (LLMs), enquanto nosso protocolo de contexto de modelo (MCP) oferece uma maneira perfeita de integrar os recursos do Yuno ao seu produto.

Este guia apresenta como trabalhar com ambos os componentes. Você aprenderá como a camada LLM capacita as ferramentas de IA para fornecer suporte de integração mais preciso e contextual, e como o MCP pode incorporar as principais funcionalidades de pagamento e comerciante diretamente em seu ambiente, permitindo construções mais rápidas com menos atrito.

Conteúdo pronto para a máquina em texto simples

Para ajudar os grandes modelos de linguagem a entender e suportar as integrações do Yuno, fornecemos um conjunto dedicado de arquivos Markdown (.md) projetados especificamente para legibilidade por máquina. Esses arquivos descrevem as APIs do Yuno, o comportamento do produto e os detalhes da implementação em um formato que é fácil para os LLMs analisarem.

Os arquivos .md fazem parte do Yuno Docs. Você pode acessá-los adicionando .md ao final de qualquer URL do Yuno Docs (isso funciona tanto para Guias quanto para páginas de Referência de API). O conteúdo é apresentado em texto simples, facilitando a extração e o processamento do conhecimento subjacente pelas máquinas, sem a necessidade de interpretação humana.

Essa configuração permite que assistentes de IA, ferramentas de desenvolvedor e agentes baseados em bate-papo respondam a perguntas, expliquem recursos e orientem integrações automaticamente. É uma maneira leve, mas poderosa, de abrir a documentação do Yuno para uma ampla gama de aplicativos inteligentes.

📘
Procurando um endpoint MCP gerenciado e acessível pela rede com vinculação de IP, limites de taxa e TTLs de sessão? Consulte o servidor Yuno MCP remoto.

Protocolo de contexto de modelo (MCP) da Yuno

Esse pacote fornece um servidor MCP que expõe a API da plataforma de pagamento Yuno como ferramentas de protocolo de contexto de modelo. Ele permite o acesso programático a agentes de IA, sistemas de automação e outros fluxos de trabalho avançados que dependem de contexto estruturado e legível por máquina.

Recursos

Expõe endpoints da API Yuno como ferramentas MCP: Cada endpoint é modelado como uma ferramenta que os agentes podem chamar programaticamente, com estruturas claras de entrada e saída
Permite fluxos de trabalho de IA e automação com o Yuno: integre o Yuno a agentes locais ou fluxos de trabalho personalizados sem lógica complexa e artesanal
Fácil integração com o Cursor e outros agentes compatíveis com o MCP: Funciona imediatamente com ferramentas como o Cursor, o Claude Desktop e outros ambientes que suportam o Model Context Protocol

Ferramentas disponíveis

O servidor Yuno MCP disponibiliza as seguintes ferramentas para agentes de IA e automação:

Nome da ferramenta	Descrição
`customer.create`	Criar um novo cliente
`customer.retrieve`	Recuperar um cliente por ID
`customer.retrieveByExternalId`	Recuperar um cliente por id externo (`merchant_customer_id`)
`customer.update`	Atualizar um cliente existente por ID
`paymentMethod.enroll`	Registrar ou criar um método de pagamento para um cliente
`paymentMethod.retrieve`	Recuperar método de pagamento
`paymentMethod.retrieveEnrolled`	Recuperar todos os métodos de pagamento registrados para um cliente
`paymentMethod.unenroll`	Cancelar o registro do método de pagamento
`checkoutSession.create`	Criar uma sessão de checkout
`checkoutSession.retrievePaymentMethods`	Recuperar métodos de pagamento para checkout
`payments.create`	Criar um pagamento com vários fluxos de trabalho
`payments.retrieve`	Recuperar informações de pagamento
`payments.retrieveByMerchantOrderId`	Recuperar pagamento(s) por `merchant_order_id`
`payments.refund`	Reembolsar um pagamento (total ou parcial) por ID de pagamento e transação
`payments.cancelOrRefund`	Cancelar ou reembolsar um pagamento por ID de pagamento (detecta automaticamente a ação)
`payments.cancelOrRefundWithTransaction`	Cancelar ou reembolsar um pagamento por ID de pagamento e transação (detecta automaticamente a ação)
`payments.cancel`	Cancelar um pagamento pendente por ID de pagamento e transação
`payments.authorize`	Autorizar um pagamento (`capture: false`)
`payments.captureAuthorization`	Capturar um pagamento previamente autorizado
`paymentLinks.create`	Criar um novo link de pagamento
`paymentLinks.retrieve`	Recuperar um link de pagamento por ID
`paymentLinks.cancel`	Cancelar um link de pagamento por ID
`subscriptions.create`	Criar uma nova assinatura
`subscriptions.retrieve`	Recuperar uma assinatura por ID
`subscriptions.pause`	Pausar uma assinatura por ID
`subscriptions.resume`	Retomar uma assinatura por ID
`subscriptions.update`	Atualizar uma assinatura por ID
`subscriptions.cancel`	Cancelar uma assinatura por ID
`recipients.create`	Criar um novo destinatário
`recipients.retrieve`	Recuperar um destinatário por ID
`recipients.update`	Atualizar um destinatário por ID
`recipients.delete`	Excluir um destinatário por ID
`recipients.createOnboarding`	Criar integração para um destinatário
`installmentPlans.create`	Criar um novo plano de parcelamento
`installmentPlans.retrieve`	Recuperar um plano de parcelamento por ID
`installmentPlans.retrieveAll`	Recuperar todos os planos de parcelamento de uma conta
`installmentPlans.update`	Atualizar um plano de parcelamento por ID
`installmentPlans.delete`	Excluir um plano de parcelamento por ID
`documentation.read`	Acesse a documentação e os guias da API do Yuno

Usando a MCP com o Cursor ou o Claude Desktop

Você pode usar esse servidor MCP com o Cursor ou o Claude Desktop para habilitar fluxos de pagamento orientados por IA, criação de clientes e muito mais.

1. Configure suas credenciais de API da Yuno

Defina suas credenciais de API do Yuno usando variáveis de ambiente (consulte os exemplos de configuração abaixo).

2. Adicione o servidor MCP ao Cursor

Abra as configurações do cursor (Cmd+Shift+P → "Configurações do cursor")
Vá para a seção MCP e clique em Add new global MCP server (Adicionar novo servidor MCP global)
Adicione a seguinte configuração (substitua o caminho pela saída real da compilação):

{
  "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. Adicione o servidor MCP ao Claude Desktop

Abra as configurações do Claude Desktop → guia "Desenvolvedor" → Editar configuração.
Adicione a seguinte configuração:

{
  "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. Teste a integração

No Cursor ou no Claude, selecione um arquivo Markdown ou um bate-papo e peça ao agente para criar uma sessão de pagamento, cliente ou checkout usando a ferramenta yuno-mcp
Certifique-se de que suas variáveis de ambiente estejam definidas corretamente

Variáveis de ambiente

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

O asterisco (*) marca a necessidade.

Suporte

Para obter suporte oficial ao Yuno, visite a documentação oficial do Yuno