> For the complete documentation index, see [llms.txt](https://docs.amply.tools/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.amply.tools/getting-started/ai-assisted-integration.md).

# AI-assisted integration

There are two ways to get Amply into your app. You can wire it **by hand** — add the SDK, forward your events, set the attributes you target on (that's the [Developer Guide](/developer-guide/installation.md)). Or you can let an **AI coding assistant do it for you** — this page.

Connect Amply to your assistant and it does the work: it reads your app and sets the SDK up, and it turns a plain-language request into a real campaign. You review and approve; the assistant does the legwork.

This doesn't replace the dashboard or the SDK — it's a faster door to both. Developers can still integrate by hand and PMs can still build campaigns in the dashboard. The AI-assisted path is for teams who'd rather describe the outcome and review the result than do every step themselves.

## Set it up

Two pieces, set up once. You need an MCP-capable AI assistant (Claude Code, the Codex CLI, or any client that supports MCP). Connecting installs nothing; the skill in step 2 installs either from inside Claude Code, or with the `skills` CLI, which needs [Node](https://nodejs.org).

**1. The Amply MCP** — connects your assistant to your Amply account. Amply hosts it, so you point your assistant at a URL:

```bash
claude mcp add --transport http amply https://api.amply.tools/mcp
```

Then run `/mcp` in Claude Code and authenticate. A browser window opens, you sign in to Amply, and you approve what the assistant may do — reading your projects, creating draft campaigns, and so on. Amply keeps those permissions separate, so creating a draft can never be the thing that makes it live, but approving is one decision rather than a checklist. You never hand over your password, and you can revoke the connection at any time under **Profile settings → Connected apps**.

Any client that supports a remote MCP server over HTTP takes the same URL. See [MCP tools](/reference/mcp-tools.md) for the full permission list and every tool.

{% hint style="info" %}
If you used Amply's old local MCP — the `@amplytools/amply-mcp` npm package — it is retired and no longer works. Remove it, connect with the command above, and delete `~/.amply/credentials.json`.
{% endhint %}

**2. The integration skill (`amply-integration`)** — an open-source playbook that tells the assistant *how* to add Amply well: detect the platform and package manager, audit the analytics the app already has, wire the SDK through a single thin layer, set up the custom properties you'll target on, and verify the build itself.

Install it whichever way suits your assistant:

{% tabs %}
{% tab title="Any assistant (skills CLI)" %}
Works with Claude Code, the Codex CLI, and any other host the [`skills` CLI](https://skills.sh) supports:

```bash
npx skills add amply-tools/sdk-skill
```

Add `-g` to install for your user instead of the current project. Target a specific assistant with `-a` (e.g. `-a claude-code` or `-a codex`); run `npx skills --help` for the full list of supported assistants.
{% endtab %}

{% tab title="Claude Code (plugin)" %}
Claude Code can install the skill as a plugin from Amply's plugin catalog. Run both commands once, inside Claude Code:

```
/plugin marketplace add amply-tools/claude-plugins
/plugin install amply-integration@amply
```

The first command **adds Amply's plugin catalog** — it installs nothing on its own. The second command **installs the skill** from that catalog. (`amply` is the catalog name; `amply-integration` is the skill.)
{% endtab %}
{% endtabs %}

Either path installs the same skill — pick one. Source: [github.com/amply-tools/sdk-skill](https://github.com/amply-tools/sdk-skill)

The MCP is the *connection* to your account; the skill is the *know-how* for a clean integration. With both in place you describe the outcome and review the result.

## Integration, the AI way

Integrating an analytics-style SDK is usually a checklist a developer works through by hand: install it, find the events the app already fires, forward the ones that matter, and set the user attributes you'll target on. It's mechanical, easy to get subtly wrong, and slow to repeat across apps.

> When a developer connects the Amply MCP to their AI coding assistant and asks it to add Amply, the assistant audits the app's existing analytics, installs and initializes the SDK, forwards the events Amply needs for targeting, and sets up custom properties — as a reviewable change in the codebase, not a black box. The developer reads the diff and merges.

The result: the same integration a developer would do, produced in one pass and handed back for review — so the judgment stays with you and the typing doesn't.

If you granted it the permission to register apps, the assistant does the whole thing: it creates the project, registers the application, takes its `appId` and API key, and writes them into your app's configuration — you never copy a value out of the admin. Without that permission it asks you for those three values instead and carries on from there. Either way the code, the events and the properties are its work.

## Running campaigns by describing them

Campaign work normally means a person in the dashboard translating an idea into targeting, a trigger, and an action. MCP lets you state the idea and get the campaign.

> When a PM asks the assistant to "show a rewarded-ad gate before export, for free users, once per session," the MCP turns that into a campaign in Amply — audience, trigger, and action wired — for you to review and activate. Checking how an existing campaign is set up works the same way: ask, and it reads it back to you.

Common shapes are a single request away — a deeplink when a user's status changes (for example, trial → expired), a prompt after a positive moment, or a paywall on the Nth session. The assistant fills in your audience and trigger and leaves the campaign in Draft for you to review.

Two limits worth knowing before you start. The assistant **cannot edit a campaign** — if a draft comes out wrong it will offer you a new one, and you finish or fix it in the dashboard. And on create it can target by country, application, app version and OS version; audiences built on custom properties, install date or event history are authored in the dashboard.

You stay in control of what goes live: the assistant proposes, you approve in the dashboard. It compresses the path from idea to live campaign; it doesn't take the decision away from you.

## When to reach for it

* **Integrating, or adding Amply to another app** — let the assistant do the SDK pass and hand you a diff.
* **Spinning up a campaign quickly** — describe it instead of clicking through the form, then review and activate.
* **You'd still use the dashboard** for a careful look before activating, and for anything you'd rather see laid out visually.

## Related

* [Quickstart](/getting-started/quickstart.md) — the by-hand path from zero to a working integration
* [User Guide](/user-guide/overview.md) — building and managing campaigns in the dashboard
* [Developer Guide](/developer-guide/installation.md) — integrating the SDK by hand
* [amply-integration skill](https://github.com/amply-tools/sdk-skill) — the open-source playbook the assistant follows