diff --git a/checkout/POWER.md b/checkout/POWER.md index 801a462b..a004ed43 100644 --- a/checkout/POWER.md +++ b/checkout/POWER.md @@ -2,7 +2,7 @@ name: "checkout-api-reference" displayName: "Checkout.com Global Payments" description: "Access Checkout.com's comprehensive API documentation with intelligent search and detailed operation information for payments, customers, disputes, and more." -version: "2.0.0" +version: "2.3.0" author: "Checkout.com" keywords: - "checkout" @@ -17,24 +17,30 @@ keywords: - "issuing" - "workflows" - "identity verification" + - "support" + - "troubleshooting" - "mcp" - "reference" --- # Checkout.com Global Payments -This power provides access to Checkout.com's comprehensive API documentation. It enables AI assistants to search, explore, and understand Checkout.com's payment processing APIs covering payments, customers, disputes, issuing, platforms, workflows, and identity verification. +This power provides access to Checkout.com's comprehensive API documentation. It enables AI assistants to search, explore, and understand Checkout.com's payment processing APIs covering payments, customers, disputes, issuing, platforms, workflows, and identity verification, plus developer documentation and support content. ## What This Power Does This power acts as an intelligent documentation assistant that can: - **Search API Operations**: Find relevant endpoints using Lucene full-text search with fuzzy matching and typo tolerance -- **Search Documentation**: Find relevant guides, tutorials, and conceptual content +- **Search Documentation**: Find relevant guides, tutorials, and conceptual content (returns document pointers) +- **Read Documentation Pages**: Fetch the full text of a documentation page, one chunk at a time +- **Search Support Content**: Find troubleshooting guides, FAQs, and account management topics from the support site - **Explore API Structure**: Browse operations by tags and categories - **Get Operation Details**: Retrieve simplified, token-efficient information about specific endpoints - **Access Schema Definitions**: Get detailed schema information for request/response objects +All tools are read-only: this power searches and reads Checkout.com's documentation and API reference. It never creates, modifies, or deletes anything, and it does not process live payments. + ## Important: Understand the Integration Path First Before diving into API operations, determine which integration path the user needs: @@ -56,7 +62,7 @@ If the user wants to accept payments with minimal effort, steer them towards **F - [Get started with Flow](https://www.checkout.com/docs/get-started) - [Customize Flow](https://www.checkout.com/docs/payments/accept-payments/accept-a-payment-on-your-website/customize-your-flow-integration) - npm package: `@checkout.com/checkout-web-components` -- The main API call creates a Payment Session - use `ApiSearch` for "payment session" then `GetOperation` and `GetSchema` to explore it +- The main API call creates a Payment Session - use `api_search` for "payment session" then `get_operation` and `get_schema` to explore it ### API-to-API (Direct Integration) If the user needs full control over the payment experience, they should use the payment API endpoints directly. This is for: @@ -65,7 +71,7 @@ If the user needs full control over the payment experience, they should use the - Complex payment flows (split payments, marketplace payouts, recurring billing) - Backend-only integrations with no frontend -**Start with:** `ApiSearch` for "payment" or `ListOperations` with tag "Payments" to explore available endpoints. +**Start with:** `api_search` for "payment" or `list_operations` with tag "Payments" to explore available endpoints. ## Key Features @@ -84,12 +90,13 @@ Access to all Checkout.com API operations including: - Handles 1-character typos (e.g. "paymnt" finds "payment") - Relevance-ranked results with scoring - Tag-based filtering for specific API domains +- Separate indexes for the API reference, developer documentation, and the support site ### Token-Efficient Responses -- `GetOperation` returns simplified responses (~300 tokens vs ~1,200 previously) -- Parameters show only essential info: name, location, required, type -- Request bodies show schema names with hints to use `GetSchema()` for details +- `get_operation` returns simplified responses: parameters show only essential info (name, location, required, type) +- Request bodies show schema names with hints to use `get_schema` for details - Responses grouped into success/error categories +- `docs_search` returns compact document pointers; full page text is fetched on demand with `docs_fetch` ## When to Use This Power @@ -98,11 +105,13 @@ This power is ideal for: - **API Integration Planning**: Understanding available endpoints and their capabilities - **Development Support**: Getting detailed parameter and response information during coding - **API Exploration**: Discovering new functionality and understanding API structure -- **Troubleshooting**: Finding relevant endpoints for specific use cases +- **Troubleshooting**: Finding relevant endpoints, documentation, and support articles for specific use cases ## Available Tools -### Guide +The server exposes eight tools. Tool names are shown exactly as they appear over the wire (snake_case). + +### `guide` Get integration guidance for Checkout.com's payment APIs. Call this first to understand the two integration paths: Flow (prebuilt payment UI with minimal code) or API-to-API (direct REST integration with full control). Returns structured recommendations, getting-started steps, and links to relevant documentation for each path. **Use Cases:** @@ -112,8 +121,8 @@ Get integration guidance for Checkout.com's payment APIs. Call this first to und **When to use:** At the start of any conversation about integrating with Checkout.com, before exploring specific endpoints. -### ApiSearch -Search the Checkout.com OpenAPI specification using Lucene full-text search with fuzzy matching, typo tolerance, and relevance ranking. Searches across operationId, path, summary, description, and tags. +### `api_search` +Search the Checkout.com OpenAPI specification using Lucene full-text search with fuzzy matching, typo tolerance, and relevance ranking. Searches across operationId, path, summary, description, and tags, and also returns matching schemas. **Use Cases:** - Find payment-related endpoints: "payment", "charge", "transaction" @@ -123,17 +132,7 @@ Search the Checkout.com OpenAPI specification using Lucene full-text search with **When to use:** You need to find specific API endpoints, operation IDs, HTTP methods, paths, or schema definitions. -### DocsSearch -Search through Checkout.com documentation using Lucene full-text search with fuzzy matching, typo tolerance, and relevance ranking. Returns relevant sections with context. - -**Use Cases:** -- Find implementation guides: "Flow integration", "3D Secure setup" -- Locate best practices: "payment security", "error handling" -- Discover integration patterns: "webhook configuration", "authentication" - -**When to use:** You need to understand how to implement features, follow tutorials, or learn about concepts and best practices. - -### ListOperations +### `list_operations` List all API operations from the Checkout.com OpenAPI specification, with optional filtering by tag or text. **Use Cases:** @@ -141,16 +140,16 @@ List all API operations from the Checkout.com OpenAPI specification, with option - Find operations containing specific terms - Get an overview of available functionality -### GetOperation +### `get_operation` Get detailed information about a specific API operation by operationId. Returns a simplified, token-efficient response with parameters, request body schema names, grouped response codes, and required scopes. **Use Cases:** - Understand parameters required for an endpoint -- See which schemas are used in request bodies (use `GetSchema` for full details) +- See which schemas are used in request bodies (use `get_schema` for full details) - Check success/error response codes - Learn about authentication requirements -### GetSchema +### `get_schema` Get a schema definition by name from the Checkout.com OpenAPI specification (components/schemas). **Use Cases:** @@ -158,26 +157,59 @@ Get a schema definition by name from the Checkout.com OpenAPI specification (com - Validate request/response formats - Generate client code with proper type definitions +### `docs_search` +Search Checkout.com's developer documentation (guides, tutorials, webhooks, authentication, 3D Secure, and more) using Lucene full-text search with fuzzy matching and relevance ranking. Returns a ranked list of **document pointers**, not page content: each result has a `urlPath`, `whyMatched` (a short preview snippet, not the full answer), `summary`, `totalChunks`, and `matchedChunk`. + +**Use Cases:** +- Find implementation guides: "Flow integration", "3D Secure setup" +- Locate best practices: "payment security", "error handling" +- Discover integration patterns: "webhook configuration", "authentication" + +**When to use:** You need to find the right documentation page. This is the first half of a two-step contract — pick the best result, then call `docs_fetch` to read the page. Do not answer from the `whyMatched` snippet alone. + +### `docs_fetch` +Read the actual content of a documentation page. This is the only docs tool that returns full page text. Pass the `urlPath` from a `docs_search` result (start with its `matchedChunk`), and page through additional chunks (1..`totalChunks`, following `hasMore`) when you need more context. Returns `{ urlPath, chunk, totalChunks, hasMore, content }`; most pages are a single chunk. + +**Use Cases:** +- Read the page behind a `docs_search` result before quoting or answering +- Page through longer guides one chunk at a time + +**When to use:** Immediately after `docs_search`, whenever you need to read or quote documentation content. + +### `support_search` +Search Checkout.com's support site using Lucene full-text search with fuzzy matching. Find troubleshooting guides, FAQs, account management topics, and common error resolutions. + +**Use Cases:** +- Resolve common errors and integration issues +- Answer account management and operational questions +- Find troubleshooting steps that live on the support site rather than in the developer docs + +**When to use:** The question is operational or troubleshooting-oriented, or the answer is more likely on the support site than in the API reference or developer docs. + ## Example Workflows ### Starting a New Integration -1. Call `Guide` to understand the two integration paths (Flow vs API-to-API) +1. Call `guide` to understand the two integration paths (Flow vs API-to-API) 2. Based on the user's needs, follow the recommended path ### Finding Payment Processing Endpoints -1. Use `ApiSearch` with query "payment process" to find relevant API operations -2. Use `GetOperation` to get information about specific endpoints -3. Use `GetSchema` to understand request/response structures +1. Use `api_search` with query "payment process" to find relevant API operations +2. Use `get_operation` to get information about specific endpoints +3. Use `get_schema` to understand request/response structures ### Understanding Customer Management -1. Use `ListOperations` with tag "Customers" to see all customer-related endpoints +1. Use `list_operations` with tag "Customers" to see all customer-related endpoints 2. Explore specific operations like customer creation, updates, and retrieval 3. Get schema definitions for customer objects and related data structures -### Learning About Integration Patterns -1. Use `DocsSearch` with query "Flow integration" to find implementation guides -2. Search for "webhook" to understand event notification setup -3. Look for "3D Secure" to learn about authentication flows +### Reading a Documentation Guide +1. Use `docs_search` with query "Flow integration" to find the right page (returns pointers) +2. Call `docs_fetch` with the best result's `urlPath` and `matchedChunk` to read the page +3. Page through further chunks while `hasMore` is true if you need more of the guide + +### Troubleshooting an Issue +1. Use `support_search` with a description of the error or account question +2. Fall back to `docs_search` + `docs_fetch` for deeper implementation detail if needed --- diff --git a/checkout/steering/advanced-usage.md b/checkout/steering/advanced-usage.md index a1e6a743..62cf2424 100644 --- a/checkout/steering/advanced-usage.md +++ b/checkout/steering/advanced-usage.md @@ -2,6 +2,8 @@ This guide covers advanced techniques and patterns for maximizing the value of the Checkout.com Developer Experience MCP in complex integration scenarios. +Tool names are shown exactly as they appear over the wire (snake_case). The server exposes eight read-only tools: `guide`, `api_search`, `list_operations`, `get_operation`, `get_schema`, `docs_search`, `docs_fetch`, and `support_search`. + ## Official Resources Before diving into advanced usage, familiarize yourself with Checkout.com's official resources: @@ -19,24 +21,24 @@ For complex integrations, use a systematic approach to discover and understand r 1. **Domain Exploration** ``` - ListOperations with tag "Payments" - ListOperations with tag "Workflows" - ApiSearch for "webhook" + list_operations with tag "Payments" + list_operations with tag "Workflows" + api_search for "webhook" ``` 2. **Relationship Mapping** ``` - GetOperation for createPayment - GetSchema for PaymentRequest - GetSchema for PaymentResponse - ApiSearch for "payment capture" + get_operation for createPayment + get_schema for PaymentRequest + get_schema for PaymentResponse + api_search for "payment capture" ``` 3. **Error Scenario Planning** ``` - ApiSearch for "void" - ApiSearch for "refund" - GetOperation for disputePayment + api_search for "void" + api_search for "refund" + get_operation for disputePayment ``` ### Schema Deep Diving @@ -45,14 +47,14 @@ Understanding complex data structures requires systematic schema exploration: 1. **Identify Core Schemas** ``` - GetSchema for PaymentRequest - GetSchema for CustomerRequest - GetSchema for WebhookEvent + get_schema for PaymentRequest + get_schema for CustomerRequest + get_schema for WebhookEvent ``` 2. **Explore Nested Objects** - - `GetOperation` shows schema names referenced in request bodies - - Use `GetSchema` to follow those references and understand full structures + - `get_operation` shows schema names referenced in request bodies + - Use `get_schema` to follow those references and understand full structures - Map required vs optional fields across related schemas 3. **Validate Data Flow** @@ -68,24 +70,24 @@ For sophisticated payment processing: 1. **Authorization and Capture Pattern** ``` - GetOperation for authorizePayment - GetOperation for capturePayment - GetSchema for AuthorizationRequest - GetSchema for CaptureRequest + get_operation for authorizePayment + get_operation for capturePayment + get_schema for AuthorizationRequest + get_schema for CaptureRequest ``` 2. **Payment Instrument Management** ``` - ApiSearch for "instrument" - GetOperation for createPaymentInstrument - GetOperation for updatePaymentInstrument + api_search for "instrument" + get_operation for createPaymentInstrument + get_operation for updatePaymentInstrument ``` 3. **Recurring Payment Setup** ``` - ApiSearch for "recurring" - ApiSearch for "subscription" - GetSchema for RecurringPaymentRequest + api_search for "recurring" + api_search for "subscription" + get_schema for RecurringPaymentRequest ``` ### Platform and Marketplace Integrations @@ -94,23 +96,23 @@ For multi-entity scenarios: 1. **Sub-Entity Management** ``` - ListOperations with tag "Platforms" - GetOperation for createSubEntity - GetSchema for SubEntityRequest + list_operations with tag "Platforms" + get_operation for createSubEntity + get_schema for SubEntityRequest ``` 2. **Split Payment Scenarios** ``` - ApiSearch for "split" - ApiSearch for "marketplace" - GetSchema for SplitPaymentRequest + api_search for "split" + api_search for "marketplace" + get_schema for SplitPaymentRequest ``` 3. **Onboarding Workflows** ``` - ApiSearch for "onboard" - GetOperation for uploadDocument - GetSchema for OnboardingRequest + api_search for "onboard" + get_operation for uploadDocument + get_schema for OnboardingRequest ``` ### Advanced Dispute Management @@ -119,19 +121,46 @@ For comprehensive dispute handling: 1. **Dispute Lifecycle Management** ``` - GetOperation for getDispute - GetOperation for acceptDispute - GetOperation for provideDisputeEvidence - GetSchema for DisputeEvidence + get_operation for getDispute + get_operation for acceptDispute + get_operation for provideDisputeEvidence + get_schema for DisputeEvidence ``` 2. **Chargeback Prevention** ``` - ApiSearch for "alert" - ApiSearch for "prevention" - GetOperation for getDisputeAlert + api_search for "alert" + api_search for "prevention" + get_operation for getDisputeAlert + ``` + +## Working With Documentation and Support Content + +### The docs_search / docs_fetch Two-Step Contract + +`docs_search` returns document pointers (`urlPath`, `whyMatched`, `summary`, `totalChunks`, `matchedChunk`), never full page text. Always follow up with `docs_fetch` to read the page. + +1. **Find the Page** + ``` + docs_search for "3D Secure setup" ``` +2. **Read the Page** + ``` + docs_fetch with the best result's urlPath, starting at its matchedChunk + ``` + +3. **Page Through Longer Guides** + - Read `totalChunks` and `hasMore` from the response + - Fetch chunks 1..totalChunks while `hasMore` is true + - Most pages are a single chunk, so one fetch is usually the whole page + +### Choosing the Right Search Tool + +- `api_search` - the OpenAPI reference (operations and schemas) +- `docs_search` + `docs_fetch` - developer documentation (guides, tutorials, concepts) +- `support_search` - the support site (troubleshooting, FAQs, account and operational topics) + ## Workflow Automation Patterns ### Event-Driven Architecture @@ -140,16 +169,16 @@ Understanding webhook and event patterns: 1. **Event Type Discovery** ``` - DocsSearch for "webhook events" - GetSchema for WebhookEvent - ApiSearch for "event" + docs_search for "webhook events", then docs_fetch the best page + get_schema for WebhookEvent + api_search for "event" ``` 2. **Workflow Configuration** ``` - ListOperations with tag "Workflows" - GetOperation for createWorkflow - GetSchema for WorkflowRequest + list_operations with tag "Workflows" + get_operation for createWorkflow + get_schema for WorkflowRequest ``` ### Identity Verification Workflows @@ -158,36 +187,37 @@ For KYC and compliance: 1. **Verification Process Discovery** ``` - ListOperations with tag "Identity Verification" - GetOperation for createIdentityVerification - GetSchema for IdentityVerificationRequest + list_operations with tag "Identity Verification" + get_operation for createIdentityVerification + get_schema for IdentityVerificationRequest ``` 2. **Document Management** ``` - ApiSearch for "document" - GetOperation for uploadDocument - GetSchema for DocumentRequest + api_search for "document" + get_operation for uploadDocument + get_schema for DocumentRequest ``` ## Performance and Optimization ### Efficient Tool Usage -1. **Start with Search** - Use `ApiSearch` or `DocsSearch` to find relevant operations first -2. **Get Simplified Details** - `GetOperation` returns token-efficient responses (~300 tokens) -3. **Drill into Schemas** - Only call `GetSchema` when you need full data structure details -4. **Use Tag Filtering** - `ListOperations` with a tag is more efficient than broad searches +1. **Start with Search** - Use `api_search` or `docs_search` to find relevant operations or pages first +2. **Get Simplified Details** - `get_operation` returns token-efficient responses +3. **Drill into Schemas** - Only call `get_schema` when you need full data structure details +4. **Use Tag Filtering** - `list_operations` with a tag is more efficient than broad searches +5. **Fetch Docs on Demand** - `docs_search` returns compact pointers; only `docs_fetch` the pages you actually need ### Token-Efficient Workflows -The `GetOperation` tool returns simplified responses by default: +The `get_operation` tool returns simplified responses by default: - Parameters show only name, location, required status, and type -- Request bodies show schema names with hints to use `GetSchema()` +- Request bodies show schema names with hints to use `get_schema` - Responses are grouped into success/error code arrays - Security shows only required scopes -This means a typical workflow uses ~300 tokens per operation lookup instead of ~1,200. +Similarly, `docs_search` keeps result payloads small by returning pointers plus short preview snippets, deferring full page text to `docs_fetch`. ## Security and Compliance @@ -195,29 +225,29 @@ This means a typical workflow uses ~300 tokens per operation lookup instead of ~ 1. **Auth Method Discovery** ``` - DocsSearch for "authentication" - DocsSearch for "authorization" + docs_search for "authentication", then docs_fetch the page + docs_search for "authorization", then docs_fetch the page ``` 2. **Token Management** ``` - ApiSearch for "token" - GetOperation for createToken - GetSchema for TokenRequest + api_search for "token" + get_operation for createToken + get_schema for TokenRequest ``` ### PCI and Compliance 1. **Secure Data Handling** ``` - DocsSearch for "PCI compliance" - DocsSearch for "sensitive data" + docs_search for "PCI compliance", then docs_fetch the page + docs_search for "sensitive data", then docs_fetch the page ``` 2. **Audit and Logging** ``` - ApiSearch for "audit" - ApiSearch for "log" + api_search for "audit" + api_search for "log" ``` ## Best Practices for Power Usage diff --git a/checkout/steering/getting-started.md b/checkout/steering/getting-started.md index ea468652..f98d4d18 100644 --- a/checkout/steering/getting-started.md +++ b/checkout/steering/getting-started.md @@ -33,24 +33,24 @@ Flow manages the entire payment experience: tokenization, payment method display - [Customize Flow](https://www.checkout.com/docs/payments/accept-payments/accept-a-payment-on-your-website/customize-your-flow-integration) - [Add localization](https://www.checkout.com/docs/payments/accept-payments/accept-a-payment-on-your-website/add-localization-to-your-flow-integration) -Use `ApiSearch` with "payment session" to find the relevant operationId, then `GetOperation` and `GetSchema` for `PaymentSessionRequest` to explore the server-side setup. +Use `api_search` with "payment session" to find the relevant operationId, then `get_operation` and `get_schema` for `PaymentSessionRequest` to explore the server-side setup. #### API-to-API (Direct Integration) -If the user needs full control, custom UI, or server-to-server processing, they should use the payment API endpoints directly. Start exploring with `ApiSearch` for "payment" or `ListOperations` with tag "Payments". +If the user needs full control, custom UI, or server-to-server processing, they should use the payment API endpoints directly. Start exploring with `api_search` for "payment" or `list_operations` with tag "Payments". --- -Once the integration path is clear, you have access to six tools for exploring the API: +Once the integration path is clear, you have access to eight tools for exploring the API, documentation, and support content. Tool names are shown exactly as they appear over the wire (snake_case). -### 1. Get Integration Guidance (`Guide`) +### 1. Get Integration Guidance (`guide`) -Start here. The `Guide` tool returns structured guidance on the two integration paths (Flow vs API-to-API), including getting-started steps, relevant documentation links, and suggested next tools to call. +Start here. The `guide` tool returns structured guidance on the two integration paths (Flow vs API-to-API), including getting-started steps, relevant documentation links, and suggested next tools to call. ``` -Call Guide to understand integration options +Call guide to understand integration options ``` -### 2. Search for API Operations (`ApiSearch`) +### 2. Search for API Operations (`api_search`) The fastest way to find relevant API endpoints is through keyword search: @@ -58,12 +58,12 @@ The fastest way to find relevant API endpoints is through keyword search: Search for payment processing endpoints ``` -This will use the `ApiSearch` tool to find operations related to payments. Supports fuzzy matching so typos like "paymnt" still find results. You can search for: +This will use the `api_search` tool to find operations related to payments. Supports fuzzy matching so typos like "paymnt" still find results. You can search for: - **Business functions**: "payment", "refund", "customer", "dispute" - **Technical terms**: "webhook", "authentication", "token" - **Specific operations**: "create", "update", "delete", "list" -### 3. Browse Operations by Category (`ListOperations`) +### 3. Browse Operations by Category (`list_operations`) To explore operations in a specific domain: @@ -73,7 +73,7 @@ List all customer-related operations This helps you understand the full scope of functionality available in each API domain. -### 4. Get Operation Information (`GetOperation`) +### 4. Get Operation Information (`get_operation`) Once you find an interesting operation, get its details: @@ -84,11 +84,11 @@ Get details for the createPayment operation This provides a simplified, token-efficient response including: - HTTP method and path - Parameter names, locations, and types -- Request body schema names (with hints to use `GetSchema` for full details) +- Request body schema names (with hints to use `get_schema` for full details) - Success and error response codes - Required authentication scopes -### 5. Understand Data Structures (`GetSchema`) +### 5. Understand Data Structures (`get_schema`) To understand the data structures used in requests and responses: @@ -102,7 +102,7 @@ This is essential for: - Generating client code - Creating proper API requests -### 6. Search Documentation (`DocsSearch`) +### 6. Search Documentation (`docs_search`) For additional context and implementation guidance: @@ -110,6 +110,28 @@ For additional context and implementation guidance: Search for webhook implementation examples ``` +`docs_search` returns **document pointers**, not page content. Each result has a `urlPath`, a short `whyMatched` preview snippet, a `summary`, `totalChunks`, and `matchedChunk`. Use it to pick the right page, then read it with `docs_fetch`. Do not answer from the `whyMatched` snippet alone. + +### 7. Read a Documentation Page (`docs_fetch`) + +To read the actual content of a page found via `docs_search`: + +``` +Fetch the documentation page returned by docs_search +``` + +Pass the `urlPath` from a `docs_search` result and start with its `matchedChunk`. The response is `{ urlPath, chunk, totalChunks, hasMore, content }`. Most pages are a single chunk; page through the rest (1..`totalChunks`) while `hasMore` is true when you need more context. `docs_search` and `docs_fetch` are a two-step contract: search to find the page, fetch to read it. + +### 8. Search Support Content (`support_search`) + +For troubleshooting, FAQs, and account or operational questions: + +``` +Search support for a failed payment error +``` + +`support_search` queries Checkout.com's support site (troubleshooting guides, FAQs, account management, common error resolutions). Reach for it when the question is operational rather than an API-reference or developer-docs question. + ## Common Use Cases ### Planning a Payment Integration @@ -168,14 +190,26 @@ Search for webhook implementation examples 1. **Find Webhook Information** ``` - Search documentation for webhook setup + Search documentation for webhook setup, then fetch the best page Search for webhook-related operations ``` 2. **Understand Event Types** ``` Get schema for WebhookEvent - Search documentation for event types + Search documentation for event types, then fetch the page to read it + ``` + +### Troubleshooting a Problem + +1. **Check Support Content First** + ``` + Search support for the error message or account question + ``` + +2. **Go Deeper in the Docs if Needed** + ``` + Search documentation for the underlying feature, then fetch the page ``` ## Tips for Effective Usage @@ -184,14 +218,19 @@ Search for webhook implementation examples - Start with broad terms like "payment" or "customer" - Fuzzy matching handles 1-character typos automatically - Use specific operation names when you know them +- Match the tool to the source: `api_search` for the API reference, `docs_search` for developer guides, `support_search` for support articles + +### Reading Documentation +- `docs_search` finds pages; `docs_fetch` reads them - always fetch before quoting +- Start `docs_fetch` at the `matchedChunk`, then follow `hasMore` for longer pages ### Understanding Relationships - Operations often work together in workflows -- Use `GetSchema` to understand data flow between operations +- Use `get_schema` to understand data flow between operations - Look for common parameters that link operations ### Schema Exploration -- `GetOperation` shows schema names in request bodies - use `GetSchema` to get full details +- `get_operation` shows schema names in request bodies - use `get_schema` to get full details - Pay attention to required vs optional fields - Look for nested objects and their schemas @@ -200,7 +239,8 @@ Search for webhook implementation examples If you need assistance: - Use broad search terms to discover relevant operations - Check schema definitions for data structure questions -- Search documentation for implementation guidance +- Search documentation for implementation guidance (then fetch the page to read it) +- Search support content for troubleshooting and account questions - Explore related operations to understand complete workflows For additional resources and detailed implementation guides, visit: