MCP Configuration

This guide explains a developer can connect an MCP-compatible IDE (Cursor / VS Code + Cline) to Cobre’s public API documentation, so the IDE’s AI agent can read the OpenAPI Specification (OAS) and generate accurate code, DTOs, documentation, and more.

What You Get (Why This Matters)

Once MCP is configured, your AI IDE can pull the same API details that appear in Cobre’s documentation and use them to:

Generate client code (SDK snippets, services, controllers)

Create or extend DTOs/models based on schemas

Add field-level documentation comments

Search endpoints, parameters, and error responses

Scaffold full flows for specific endpoints (auth, payouts, webhooks, etc.)

Prerequisites

Before setup, ensure:

Node.js 18+ (latest LTS recommended)

An MCP-compatible IDE, such as:

Cursor

VS Code + Cline

Any MCP-supported editor

Network access to run npx (must reach npm registry)

Step 1 — Add Cobre’s MCP Server Configuration

Add the following MCP configuration in your IDE:

{
  "mcpServers": {
    " - API Documentation": {
      "command": "npx",
      "args": [
        "-y",
        "apidog-mcp-server@latest",
        "--site-id=760877"
      ]
    }
  }
}

This configuration uses Published Documentation data source and points directly to Cobre’s public API documentation using site-id=760877. No token is required.

Cursor Setup (Quick Path)

Open Cursor

Go to Settings → MCP

Click Add new global MCP server

Paste the JSON into the generated mcp.json

Save and restart if required

Test MCP with a simple prompt

VS Code + Cline Setup (Quick Path)

Install and enable the Cline plugin

Locate MCP configuration settings

Add the same mcpServers JSON

Reload VS Code if needed

Test with an MCP-based prompt

Step 2 — Verify MCP Is Working

In your IDE’s AI agent mode, try:

Basic Connectivity Test

“Please fetch API documentation via MCP and tell me how many endpoints exist.”

Endpoint-Based Development

“Using MCP, generate example requests and responses for /v1/... and produce a typed TypeScript client method.”

DTO / Schema Generation

“Use MCP to generate Java/Kotlin/TypeScript models for the schemas used by <endpoint>.”

Schema Sync / Refactoring

“Compare the current DTO in this repository with the MCP schema and add any missing fields with documentation comments.”

Highly Recommended: Combine MCP with Cobre’s LLM Documentation Index

For broader integration guidance (flows, explanations, integration steps), you can also instruct your AI to read:

https://docs.cobre.com/llms.txt

This provides structured documentation navigation in Markdown format.

Best practice:

Use llms.txt for conceptual understanding and flow design.

Use MCP for precise OpenAPI schema validation (fields, enums, required parameters, error codes).

See the following guide for more info: Connect Cobre's Documentation to AI

Here is a prompt example combining both alternatives:

“Usign the MCP and the llms.txt in https://docs.cobre.com/llms.txt with the extended Cobre's documentation, create a flow to demostrate how to send a payment to a Bre-B key.”

Refreshing the Cached API Specification

Your MCP configuration caches the specification locally for performance. If Cobre updates the documentation, you may need to ask the AI to refresh/reload MCP.

If you believe documentation has changed (new field, enum update, parameter change):

Ask your IDE:

“Refresh MCP and reload the latest API specification.”

Since MCP caches the spec locally, a refresh ensures you're working with the latest version.

Common Troubleshooting

Windows `npx` Issues

If Windows fails to execute the default configuration, use:

{
  "mcpServers": {
    " - API Documentation": {
      "command": "cmd",
      "args": [
        "/c",
        "npx",
        "-y",
        "apidog-mcp-server@latest",
        "--site-id=760877"
      ]
    }
  }
}

Corporate Network Restrictions

Ensure your development environment can access:

www.npmjs.com

If behind a firewall, you may need to configure npm proxy settings.

Returning Outdated Fields

If schemas appear outdated:

Ask the AI to refresh MCP

Restart your IDE if needed

Retry the request

Recommended “Golden Workflow” for Cobre Integrations

Start With the Business Goal

Example:

“I need to create beneficiaries and send payouts. What endpoints and sequence should I use?”

Design the Flow (Docs-Driven)

Have the AI propose the integration flow using Cobre’s documentation.

Enforce Correctness With MCP

“Now use MCP to validate required fields, enums, and error responses for each endpoint.”

Enforce Correctness With MCP

“Generate a service class and unit tests using the MCP-derived schemas.”

High-Impact Use Cases for Teams

Keeping DTOs synchronized with evolving API specs

Generating strongly-typed SDK layers

Auto-documenting backend models

Reducing integration errors caused by outdated fields

Accelerating new developer onboarding

MCP Configuration

What You Get (Why This Matters)#

Prerequisites#

Step 1 — Add Cobre’s MCP Server Configuration#

Cursor Setup (Quick Path)#

VS Code + Cline Setup (Quick Path)#

Step 2 — Verify MCP Is Working#

Basic Connectivity Test#

Endpoint-Based Development#

DTO / Schema Generation#

Schema Sync / Refactoring#

Highly Recommended: Combine MCP with Cobre’s LLM Documentation Index#

Refreshing the Cached API Specification#

Common Troubleshooting#

Windows npx Issues#

Corporate Network Restrictions#

Returning Outdated Fields#

Recommended “Golden Workflow” for Cobre Integrations#

High-Impact Use Cases for Teams#