ASO AI Companion (MCP): Connect and Configure AI for ASO.dev

In Development  Coming Soon

AI Companion is a tool for automating app metadata management in ASO.dev using external AI assistants (Claude, ChatGPT, and others).
The MCP server lets AI see and edit your metadata in real time via a secure local API.

MCP (AI Companion) is a tool that lets you connect any AI assistant (like ChatGPT, Claude, Gemini) to your ASO.dev project. MCP helps automate app metadata management: titles, descriptions, keywords, screenshots, and more. Everything happens locally and securely—your data never leaves your computer.

• Quickly fill and edit metadata for App Store and Google Play
• Automate routine tasks with AI
• Bulk update localizations and fields
• Work easily via the interface or with your AI assistant

1. Open ASO.dev settings → AI Companion
2. Click “Run” to start the MCP server
3. Copy the ready config for AI connection (button on the editor page)
4. In your AI assistant settings (ChatGPT, Claude, etc.), add a new server:
   • Address: http://localhost:42111
   • Secret key: not required for local connection
   • OpenAPI: http://localhost:42111/openapi.json (if supported)
5. Save settings and restart your AI assistant

• On editor pages, there is an AI Companion launch button
• You can copy the config for connection
• All actions are done via simple forms and buttons

• Ask AI: “Fill descriptions for all languages via MCP”
• “Show current app metadata”
• “Update screenshots for App Store and Google Play”

• Check status:

  curl http://localhost:42111/status

• Get metadata:

  curl -X POST -H "Content-Type: application/json" -d '{"action": "get_editor_data"}' http://localhost:42111/apple/metadata/editor/get

• Bulk fill:

  curl -X POST -H "Content-Type: application/json" -d '{"localizations": {"en-US": {"title": "New Title"}}}' http://localhost:42111/google/metadata/editor/bulk-fill

• Default port: 42111 (can be changed)
• Secret key: not required for local connection
• All data stays on your computer
• AI cannot publish changes directly—only suggests, final save is always manual
• For remote access, use tunnels (ngrok, Cloudflare Tunnel)

How do I connect AI to MCP?
On editor pages, there is an AI Companion launch button—a window with ready config will appear.

Is the secret key required?
For local connections—no, for scripts and API requests it is recommended.

How do I change the port?
In Global Settings → AI Companion → Port.

What if I can’t connect?
Check that the service is running, the port is free, and (if needed) the secret is correct.

The service runs locally, your data never leaves your computer and is only available to the AI assistant you choose.

Option 1. Via Settings:

1. Go to Global Settings → AI Companion.
2. Click Run (if the service is not already running).
3. Here you can also copy the secret key and change the port (default is 42111).

Option 2.Via the button on Editor/Bulk Editor/Cross-Locales pages:

1. On the pages Editor, Bulk Editor, or Cross-Locales, there is a separate “Start” button - it starts or stops the MCP server directly from the interface.
2. If needed, this button also lets you copy the ready-to-use MCP JSON config with one click.

1. Open the Claude Desktop app.
2. Go to the settings menu (usually a gear icon or “Settings”).
3. Find the “Configuration” or “Configuration file” section. If you can’t find it, open the folder:

• macOS: Open Finder, press Cmd+Shift+G and paste: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: Open Explorer and paste: %APPDATA%\Claude\claude_desktop_config.json

4. Open the file in any text editor (Notepad, TextEdit, etc).
5. Copy the ready-made JSON config from ASO.dev (button on the Editor/Bulk Editor/Cross-Locales page) and paste it into the mcpServers section.
6. Save the file and restart Claude Desktop.
7. Done! Claude can now connect to MCP.

1. Open your Custom GPT settings (usually “Actions” or “API” in the interface).
2. Find the section to add an external API.
3. Enter:

• Address: http://localhost:42111
• API Key: (optional) copy from ASO.dev settings, paste into the “X-Client-Secret” field.
• OpenAPI spec: import from http://localhost:42111/openapi.json (or manually add endpoints /apple/metadata/editor/get and /apple/metadata/editor/bulk_fill).

4. Save your settings.
5. Now ChatGPT can access MCP and work with your metadata.

1. Open your AI tool’s settings.
2. Find the section for connecting an external API or HTTP requests.
3. Enter the MCP address: http://localhost:42111
4. If there is a field for a key, copy the secret from ASO.dev and paste it (optional for localhost).
5. If OpenAPI is supported, import the spec from http://localhost:42111/openapi.json.
6. Save and restart the tool if needed.

• You can always copy the ready config with one click on the Editor/Bulk Editor/Cross-Locales pages.
• If you can’t find the right settings, check your AI tool’s documentation or contact ASO.dev support.
• For cloud/browser-based AI tools, you may need a tunnel (ngrok, Cloudflare Tunnel) to give access to your MCP.

1. Оpen VS Code and click the Extensions icon (on the left sidebar).
2. Find and open the extension you use (for example, Cline or Roo Code).
3. In the extension’s sidebar, look for MCP Servers and click Configure MCP Servers (the button may look like a gear or say “Configure”).
4. Click Add or + to add a new server.
5. Fill in the fields:

• Type: command (stdio)
• Command: npx -y @modelcontextprotocol/server-http —url http://localhost:42111

6. Leave the secret field empty (for localhost) or copy it from ASO.dev settings if needed.
7. Click Save or OK.
8. Make sure the new server appears in the list and is enabled (toggle or checkmark).
9. Done! Now you can use MCP in VS Code.

1. Open Cursor and click the Settings icon (usually a gear in the bottom left or top right).
2. Go to Features and find the MCP section.
3. Click Add new MCP server (may be a plus sign or “Add”).
4. Fill in:

• Name: ASO Companion
• Type: command (stdio)
• Command: npx -y @modelcontextprotocol/server-http —url http://localhost:42111

5. Leave the secret field empty (for localhost).
6. Click Save.
7. Make sure the server appears in the list and is enabled.
8. Done! Now Cursor can use MCP.

1. Open Antigravity and go to Settings (gear icon or menu).
2. Find the section for External MCP Servers or similar.
3. Click Add or New Server.
4. Enter:

• URL: http://localhost:42111
• Secret: (optional, copy from ASO.dev if needed)

5. Click Save or OK.
6. Make sure the server is listed and enabled.
7. Restart Antigravity if needed.
8. Done! Antigravity is now connected to MCP.

1. Go to Settings → Features → MCP.
2. Click Add new MCP server.
3. Fill in:

• Name: ASO Companion
• Type: command (stdio)
• Command: npx -y @modelcontextprotocol/server-http —url http://localhost:42111

4. Secret is not required for local connection.
5. Save - the server will be available for AI in Cursor.

1. Open Antigravity settings.
2. Find the section for external MCP servers.
3. Add a new server:

• URL: http://localhost:42111
• (optional) Secret: ASODEV_SECRET_KEY

4. Save and restart the assistant if needed.

• Make sure MCP is running (via ASO.dev settings or the button on Editor/Bulk Editor/Cross-Locales).
• All connection parameters can be copied with one click on the Editor/Bulk Editor/Cross-Locales pages.
• For most modern editors, just specify the launch command and URL; the secret is not required for localhost.

If you need instructions for another environment, let us know!

In modern editors (e.g., Cursor, Windsurf):

• Type: command (stdio)
• Command: npx -y @modelcontextprotocol/server-http --url http://localhost:42111

3. If connecting locally, the secret is not required.

If your AI tool requires manual setup:

{
  "mcpServers": {
    "aso-dev": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-http",
        "--url",
        "http://localhost:42111"
      ],
      "env": {
        "ASODEV_SECRET_KEY": "your-secret-key"
      }
    }
  }
}

Secret key is optional for localhost. All parameters can be copied from the AI Companion launch window.

• Cursor: Settings → Features → MCP
• VSCode (Cline/Roo Code): Extension sidebar → MCP Servers → Configure MCP Servers
• Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)

If your AI assistant does not support MCP directly, use HTTP requests:

Port: 42111 (can be changed in settings) Secret: ASODEV_SECRET_KEY (optional for localhost)

Check status:

curl http://localhost:42111/status
# or with secret:
curl -H "X-Client-Secret: YOUR_SECRET" http://localhost:42111/status

Get editor data:

curl -X POST -H "Content-Type: application/json" \
     -d '{"action": "get_editor_data"}' http://localhost:42111/apple/metadata/editor/get
# or with secret:
curl -X POST -H "X-Client-Secret: YOUR_SECRET" -H "Content-Type: application/json" \
     -d '{"action": "get_editor_data"}' http://localhost:42111/apple/metadata/editor/get

Bulk fill:

curl -X POST -H "Content-Type: application/json" \
     -d '{"localizations": {"en-US": {"title": "New Title"}}}' http://localhost:42111/apple/metadata/editor/bulk_fill
# or with secret:
curl -X POST -H "X-Client-Secret: YOUR_SECRET" -H "Content-Type: application/json" \
     -d '{"localizations": {"en-US": {"title": "New Title"}}}' http://localhost:42111/apple/metadata/editor/bulk_fill

OpenAPI spec: http://localhost:42111/openapi.json

• Port: 42111 (default, can be changed in settings)
• ASODEV_SECRET_KEY: optional secret, copied in AI Companion settings
• JSON config: copied with one click on Editor/BulkEditor/Cross-Locales pages

• MCP server works only with the current ASO.dev project
• Secret key is unique to your installation
• AI cannot publish changes directly - only suggests, final save is always manual
• For remote access, use tunnels (ngrok, Cloudflare Tunnel)

Where do I get the config?
On Editor/Bulk Editor/Cross-Locales pages, click the AI Companion launch button - a window with ready-to-use JSON config will appear.

Is the secret key required?
For local connections - no, but for scripts and API requests it is recommended.

How do I change the port?
In Global Settings → AI Companion → Port.

What if I can’t connect?
Check that the service is running, the port is free, and (if needed) the secret is correct.

The service runs locally, your data never leaves your computer and is only available to the AI assistant you choose.

MCP now supports not only Apple App Store, but also Google Play:

• Get Google Play metadata: /google/metadata/editor/get-data (POST)
• Bulk fill Google Play: /google/metadata/editor/bulk-fill (POST)

Examples:

# Get Google Play data
curl -X POST -H "Content-Type: application/json" \
  -d '{"action": "get_google_editor_data"}' http://localhost:42111/google/metadata/editor/get-data

# Bulk fill Google Play
curl -X POST -H "Content-Type: application/json" \
  -d '{"localizations": {"en-US": {"title": "New Title"}}}' http://localhost:42111/google/metadata/editor/bulk-fill

All methods now accept parameters:

• pageId — page identifier (optional)
• locales — list of locales (e.g., ["en-US", "ru-RU"])
• fields — list of fields to fetch or fill
• data — object with data for bulk fill

New JSON-RPC methods:

• get_google_editor_data — get Google Play metadata
• bulk_fill_google — bulk fill for Google Play

Example JSON-RPC call:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_google_editor_data",
    "arguments": {
      "locales": ["en-US", "ru-RU"],
      "fields": ["title", "description"]
    }
  }
}

The OpenAPI description now includes all new endpoints for Apple and Google. You can import it for client code generation.

• “Get Google Play metadata via MCP”
• “Bulk update descriptions for all locales in Google Play via MCP bulk_fill_google”
• “POST to /google/metadata/editor/get-data and return the result”

Check MCP status:

curl http://localhost:42111/status
# or with secret:
curl -H "X-Client-Secret: YOUR_SECRET" http://localhost:42111/status

Get editor data:

curl -X POST -H "Content-Type: application/json" \
  -d '{"action": "get_editor_data"}' http://localhost:42111/apple/metadata/editor/get
# or with secret:
curl -X POST -H "X-Client-Secret: YOUR_SECRET" -H "Content-Type: application/json" \
  -d '{"action": "get_editor_data"}' http://localhost:42111/apple/metadata/editor/get

Bulk fill metadata:

curl -X POST -H "Content-Type: application/json" \
  -d '{"localizations": {"en-US": {"title": "New Title"}}}' http://localhost:42111/apple/metadata/editor/bulk_fill
# or with secret:
curl -X POST -H "X-Client-Secret: YOUR_SECRET" -H "Content-Type: application/json" \
  -d '{"localizations": {"en-US": {"title": "New Title"}}}' http://localhost:42111/apple/metadata/editor/bulk_fill

OpenAPI spec: http://localhost:42111/openapi.json

You can ask your AI assistant to perform MCP actions with prompts like:

• “Get current app metadata via MCP”
• “Bulk fill all localizations with a new title using MCP bulk_fill”
• “Make an HTTP POST to /apple/metadata/editor/get and return the result”
• “Check MCP server status and show the response”
• “Send a curl request to MCP for bulk metadata fill”

AI agents that support external APIs can perform these actions automatically if you specify the endpoint and parameters.