MCP Servers for Extend Development

Last updated on November 20, 2025

Overview​

Model Context Protocol (MCP) servers are standardized interfaces that enable AI coding assistants to access additional context and tools, making them more effective at answering questions and generating code. In the context of Extend app development, MCP servers provide AI assistants with knowledge about Extend SDK functions, models, and AGS APIs, significantly improving code generation accuracy and development assistance. Pair this guide with the Extend app development workflow and the Dev Containers deep dive so your environment, tooling, and AI integration stay in sync.

This guide covers what MCP servers are, where they can be used within Extend development, the available MCP servers provided by AccelByte, and how to configure and use them in your development workflow.

What are MCP Servers?​

MCP servers are standardized services that expose tools, resources, and context to AI assistants through the Model Context Protocol. They act as bridges between AI coding assistants (like those in VS Code, Cursor, Claude Desktop, etc.) and external data sources or tools.

Key benefits of MCP servers:

  • Enhanced Context: Provide AI assistants with structured information about APIs, SDKs, and codebases
  • Accurate Code Generation: Enable AI assistants to generate code that follows best practices and uses correct APIs
  • Better Documentation Access: Allow AI assistants to search and retrieve relevant documentation and examples
  • Tool Integration: Expose tools that AI assistants can use to perform actions or retrieve information

In Extend development, MCP servers help AI assistants understand Extend SDK patterns, AGS API structures, and generate code that integrates correctly with AccelByte Gaming Services.

Where MCP Servers Can Be Used in Extend​

MCP servers can be integrated into your Extend development workflow in several ways:

1. AI-Powered Code Generation​

When developing Extend apps, AI assistants can use MCP servers to:

  • Generate Extend SDK code with correct function signatures and patterns
  • Create proper API calls to AGS services
  • Understand Extend app structure and best practices
  • Generate boilerplate code for common Extend app patterns

2. Development Environment Integration​

MCP servers are configured in development environments such as:

  • Visual Studio Code: Configured via .vscode/mcp.json or VS Code MCP settings
  • Cursor: Configured via .cursor/mcp.json or through Cursor settings
  • Claude Desktop: Configured through Claude Desktop settings
  • Other MCP-compatible clients: Any client that supports the Model Context Protocol

For step-by-step containerized setup details, refer to Developing with Extend Dev Containers.

3. Extend App Templates​

Many Extend app templates include pre-configured MCP server settings in their .vscode/mcp.json files. When you clone an Extend app template, you can immediately benefit from AI-powered development assistance without additional configuration.

注記

The Extend app templates that support Dev Containers include pre-configured MCP server settings. For more information, see the Dev Containers guide.

ヒント

The shared .vscode/mcp.json lives alongside each template’s .devcontainer folder. This single source is referenced by both the core workflow guide and the Dev Containers article, so update the file in one place and link to it from other docs.

4. Documentation and Learning​

MCP servers help AI assistants answer questions about:

  • Extend SDK functions and their usage
  • AGS API endpoints and authentication
  • Extend app architecture and patterns
  • Best practices for Extend development

Available MCP Servers​

AccelByte provides two MCP servers specifically designed for Extend development:

AGS Extend SDK MCP Server​

The AGS Extend SDK MCP Server exposes Extend SDK functions and models as context to AI assistants. It helps AI coding assistants answer questions and generate Extend SDK code more effectively.

Repository: https://github.com/AccelByte/ags-extend-sdk-mcp-server

Features:

  • search-symbols – Search for symbols (functions and models) by name, tags, or description (fuzzy search)
  • describe-symbols – Get detailed information about specific symbols by their IDs
  • create-extend-app – Prompt template for creating Extend app projects

Supported Extend SDK Languages:

  • Go (config/go)
  • Python (config/python)
  • Java (config/java)
  • C# (config/csharp)

Use Cases:

  • Generating Extend SDK code with correct function signatures
  • Understanding available Extend SDK functions and models
  • Getting detailed information about specific SDK symbols
  • Creating new Extend app projects with proper structure

AGS API MCP Server​

The AGS API MCP Server provides AI assistants with access to AccelByte Gaming Services API information, enabling them to generate correct API calls and understand AGS API structures.

Repository: https://github.com/AccelByte/ags-api-mcp-server

Features:

  • Simplified OAuth 2.1 flow with static client credentials
  • Direct interaction with AccelByte's OAuth server
  • Token validation using AccelByte's JSON Web Key Set (JWKS)
  • API endpoint discovery and documentation

Use Cases:

  • Generating API calls to AGS services
  • Understanding AGS API authentication and authorization
  • Discovering available AGS API endpoints
  • Validating API requests and responses

What You Can Do with MCP Servers​

The most valuable aspect of MCP servers is the set of workflows they unlock for Extend developers. Below are common scenarios and tips for getting the most value out of each server.

1. Speed Up Feature Prototyping​

  • Ask the Extend SDK MCP server for handler skeletons or request/response shapes to reduce context switching while you write code in your IDE.
  • Compare related SDK symbols (for example, different IAM user operations) without digging through multiple repositories.
  • When combining services (e.g., matchmaking plus Cloudsave), request high-level snippets and then verify each call in your project before shipping.

2. Clarify API Behavior Before Coding​

  • Use the AGS API MCP server to recall OAuth flows, token scopes, or endpoint constraints so you can double-check requirements prior to editing code.
  • Summaries of rate limits or payload expectations are useful reminders, but still validate against the official AGS API docs linked in the MCP responses.
  • Ask whether an endpoint exists for a particular need; the MCP answer can point you to the right documentation section to confirm.

3. Draft Documentation and Runbooks​

  • Generate brief symbol descriptions, parameter notes, or usage examples to seed README updates; polish the language afterwards to match your team’s style.
  • For internal runbooks, have the assistant outline “request → SDK → AGS API” flows so you can annotate them with environment-specific details.
  • Create onboarding cheat sheets by pulling references to frequently used helpers or middleware; double-check accuracy before sharing.

4. Support Debugging and Regression Checks​

  • Request a textual mapping of how a given Extend handler talks to AGS; use that map to guide log searches or hypothesis building.
  • Combine MCP summaries with your actual logs/tests to produce follow-up steps—avoid treating the summaries as definitive root-cause analysis.

5. Coordinate Multi-Language Implementations​

  • Because the Extend SDK MCP server includes multiple language configs, you can ask for equivalent snippets in another language to compare approaches.
  • Use “translate this Go example into Python” prompts as a baseline, then adapt the generated code to your project conventions and linting rules.

6. Reference Dev Container and IDE Context​

  • In templates that already ship .vscode/mcp.json, the assistant can remind you which Make task or VS Code command to run next without switching windows.
  • Request lightweight automation snippets (e.g., additions to tasks.json or CI scripts) and verify the syntax before committing.
  • Use the AGS API MCP server to refresh your memory on required scopes or claims when rotating OAuth clients or configuring machine-to-machine flows.
  • Ask for a checklist of namespace or tenancy validations relevant to Extend overrides, then confirm each item against the latest SDK guidance.

High-Level Setup Guidance​

Once you know which workflows you want to unlock, follow the detailed setup instructions in each repository:

  • Extend SDK MCP server: see the setup guide and transport options for container images, config files, and environment variables.
  • AGS API MCP server: follow the repository README for OAuth client requirements, environment variables, and deployment approaches (Docker, pnpm, etc.).

At a minimum, you will need:

  • An MCP-compatible IDE or client (VS Code, Cursor, Claude Desktop, etc.)
  • Docker or another runtime to start the MCP server processes
  • (For the API MCP server) valid AGS OAuth client credentials with the required scopes

After the MCP servers are running, point your IDE’s .vscode/mcp.json or .cursor/mcp.json to the server endpoints. The Extend app templates already include sample configurations you can copy.

Using MCP Servers in Development​

Once configured, you can use MCP servers in your development workflow:

Example: Searching for Extend SDK Symbols​

In VS Code or Cursor, you can ask your AI assistant:

Search for symbols related to 'user' in the Extend SDK

The AI assistant will use the search-symbols tool from the Extend SDK MCP Server to find relevant functions and models.

Example: Getting Symbol Details​

Ask your AI assistant:

Describe the 'AdminCreateUser@iam' and 'User@iam' symbols

The AI assistant will use the describe-symbols tool to retrieve detailed information about these symbols.

Example: Generating Extend SDK Code​

When writing Extend app code, ask your AI assistant to:

Generate code to create a user using the Extend SDK

The AI assistant will use the MCP server context to generate code with correct function signatures and patterns.

ヒント

When coding with MCP servers, start from an Extend SDK getting started sample project or an Extend app template project instead of a blank project. Adding specific source code files as context helps get better results.

Configuration in Extend App Templates​

Many Extend app templates include pre-configured MCP server settings. For example, the extend-service-extension-go template includes an .vscode/mcp.json file with MCP server configuration.

To use these pre-configured settings:

  1. Clone an Extend app template that includes MCP configuration
  2. Ensure Docker is running
  3. Open the project in VS Code or Cursor
  4. The MCP servers should be automatically available (you may need to enable them in your IDE settings)

Example MCP configuration from Extend app templates:

{
  "mcpServers": {
    "extend-sdk-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "CONFIG_DIR",
        "ghcr.io/accelbyte/ags-extend-sdk-mcp-server:2025.8.0"
      ],
      "env": {
        "CONFIG_DIR": "config/go"
      }
    }
  }
}

Troubleshooting​

MCP Server Not Available​

  • Ensure Docker is running
  • Verify the MCP server container image is pulled: docker images | grep ags-extend-sdk-mcp-server
  • Check that the MCP server is enabled in your IDE settings
  • Review the MCP server logs for errors

Incorrect Code Generation​

  • Ensure you're using the correct CONFIG_DIR for your Extend SDK language
  • Verify the MCP server version matches your AGS version
  • Provide more context to the AI assistant by including relevant source files
  • Start from an Extend app template rather than a blank project

Connection Issues with HTTP Transport​

  • Verify the MCP server container is running: docker ps | grep mcp-server
  • Check that the port is not already in use
  • Ensure firewall settings allow connections to the MCP server port
  • Review the ALLOWED_ORIGINS environment variable if using HTTP transport

AGS API MCP Server Authentication Errors​

  • Verify your AB_BASE_URL, AB_CLIENT_ID, and AB_CLIENT_SECRET are correct
  • Ensure your OAuth client is of type "confidential"
  • Check that your OAuth client has the necessary permissions in AGS Admin Portal
  • Verify your AGS environment is accessible

Best Practices​

  1. Use Matching Versions: Always use the MCP server image tag that matches your AGS version to ensure compatibility.

  2. Start from Templates: Begin with Extend app templates that include MCP configuration rather than setting up from scratch.

  3. Provide Context: When asking AI assistants to generate code, include relevant source files as context for better results.

  4. Regular Updates: Keep your MCP server images updated to match your AGS version and get the latest features.

Next Steps​

After setting up MCP servers:

  1. Explore Extend app development with AI assistance:

  2. Learn about other development tools:

  3. Check the MCP server repositories for updates and examples:

With MCP servers configured, you can leverage AI-powered development assistance to accelerate your Extend app development and ensure code quality and correctness.

に最終更新
On this page