# Integration Create

> Creates a new ADK integration documentation page (a Markdown file under docs/integrations/) for a third-party tool, plugin, observability platform, data store, MCP server, or connector. Gathers details, picks the right category template, and drafts a page that follows adk-docs conventions. Triggers on "integration-create", "create integration page", "new integration", "add an integration", "write an integration page".

- Skill: `google/integration-create` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add google/integration-create`
- Raw SKILL.md: https://api.skillmd.com/api/skills/google/integration-create/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: Google (https://skillmd.com/u/google)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/google/integration-create

---


# ADK Integration Page Creator (integration-create)

This skill creates a new integration page for the
[adk-docs](https://github.com/google/adk-docs) repository. Integration pages
live under `docs/integrations/` and are auto-discovered into a card catalog. The
output of this skill is a strong starting point, not a finished page: when done,
run the `integration-review` skill on it and test with `mkdocs serve`.

The real template is the set of **existing shipping pages**. Before drafting,
open the exemplar(s) for the chosen category and match their structure and
conventions:

- MCP tools: `docs/integrations/github.md`, `docs/integrations/notion.md`
- Observability: `docs/integrations/phoenix.md`, `docs/integrations/arize-ax.md`
- Plugins: `docs/integrations/daytona.md`, `docs/integrations/goodmem.md`

To find more similar pages, scan `catalog_tags` in one pass (`grep catalog_tags
docs/integrations/*.md`) and read the ones sharing the category's tag (e.g.
`mcp`, `observability`) or product domain in full. Match live pages and repo
conventions rather than inferring everything from the templates below.

See `CONTRIBUTING.md` (the "Integrations" section) for the human-facing
contract. For the full rulebook applied during review, see the
`integration-review` skill.

## Step 1: Gather inputs

Ask the user for whatever is not already provided:

- **Product / integration name** (drives `catalog_title` and the H1).
- **Category**, which selects the template:
    - **MCP tool** (an MCP server the agent connects to)
    - **Observability** (tracing / metrics / evaluation exporter)
    - **Plugin** (an installable package exposing tools or callbacks)
- **Language support**: Python only, or Python + TypeScript.
- **Package name** (PyPI / npm) and install command.
- **Connection style** for MCP: local (stdio) and/or remote (HTTP).
- **Tools or methods** the integration exposes (for the table).
- **Links**: product docs, GitHub repo, PyPI/npm, where to get an API key.
- **Icon**: confirm an asset will be added at
  `docs/integrations/assets/<slug>.png`.

## Step 2: Choose the filename

- Use a short, lowercase, hyphenated slug based on the product or technology
  name.
- Avoid `adk-` or other prefixes that would float the card to the top of the
  alphabetically sorted catalog.
- Create the file at `docs/integrations/<slug>.md`.

## Step 3: Draft the page

Use the frontmatter and the category skeleton below. Fill each section by
reading the exemplar page(s) for the same category and adapting their prose and
code.

Do **not** add a `mkdocs.yml` nav entry; pages are auto-discovered by
`render_catalog('integrations/*.md')`. Add a redirect only if this page replaces
an existing URL, and never chain redirects.

## Step 4: Hand off

Tell the user this is a draft, then:

- Remind them to add the icon asset at `docs/integrations/assets/<slug>.png`
  (square, reasonably sized) and any screenshots.
- Recommend running the `integration-review` skill on the new page.
- Recommend `mkdocs serve` to confirm the card renders and the icon loads.

## Frontmatter (all categories)

```yaml
---
catalog_title: <Display Name>
catalog_description: <short verb-led phrase>
catalog_icon: /integrations/assets/<slug>.png
catalog_tags: ["<tag>", "<tag>"]
---
```

- `catalog_description`: short and verb-led, roughly 45 to 75 characters (about
  6 to 11 words); keep it under ~80 so it does not wrap awkwardly on a card. Do
  not repeat the product name (the title shows it). No verbose lists, no
  overclaims.
- `catalog_tags`: use only tags that already exist in the catalog; never invent
  one. Enumerate the valid tags in one pass with
  `grep catalog_tags docs/integrations/*.md`. Tags combine. Any page that uses
  MCP must include `mcp`.
- `catalog_icon`: `/integrations/assets/<slug>.png` (or `.svg` or `.jpg`). No
  `/adk-docs/` prefix.

## H1 and language support tag (all categories)

```markdown
# <Product> <type> for ADK
```

`<type>` is `MCP tool`, `observability`, or `plugin` per category. Immediately
after the H1, add the language support div (spans must be on a single line; drop
the TypeScript span if Python-only):

```html
<div class="language-support-tag">
  <span class="lst-supported">Supported in ADK</span><span class="lst-python">Python</span><span class="lst-typescript">TypeScript</span>
</div>
```

## Skeleton: MCP tool

````markdown
## Use cases

- **<Use case>**: <what the user accomplishes>
- **<Use case>**: <...>

## Prerequisites

- <account, API key, or token, with a link to where to get it>

## Use with agent

=== "Python"

    === "Remote MCP Server"

        ```python
        from google.adk.agents import Agent
        from google.adk.tools.mcp_tool import McpToolset
        from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

        root_agent = Agent(
            model="gemini-flash-latest",
            name="<slug>_agent",
            instruction="Help users get information from <Product>",
            tools=[
                McpToolset(
                    connection_params=StreamableHTTPConnectionParams(
                        url="<server url>",
                        headers={"Authorization": "Bearer YOUR_TOKEN"},
                    ),
                )
            ],
        )
        ```

=== "TypeScript"

    === "Remote MCP Server"

        ```typescript
        import { LlmAgent, MCPToolset } from "@google/adk";

        const rootAgent = new LlmAgent({
            model: "gemini-flash-latest",
            name: "<slug>_agent",
            instruction: "Help users get information from <Product>",
            tools: [
                new MCPToolset({
                    type: "StreamableHTTPConnectionParams",
                    url: "<server url>",
                }),
            ],
        });

        export { rootAgent };
        ```

## Available tools

Tool | Description
---- | -----------
`<tool>` | <what it does>

## Additional resources

- [<Product> Documentation](<url>)
- [<Product> Repository](<url>)
````

Include both `Local MCP Server` (stdio) and `Remote MCP Server` sub-tabs when
the server supports both. Add a `## Configuration` section for optional headers
or environment variables.

## Skeleton: Observability

````markdown
<one-paragraph intro of what the platform provides for ADK>

## Overview

- **<Capability>**: <...>
- **<Capability>**: <...>

## Installation

```bash
pip install <package>
```

## Setup

<API keys, environment variables, and instrumentor initialization>

## Observe

<a complete, runnable ADK agent example that is traced end-to-end>

## Support and Resources

- [<Platform> Documentation](<url>)
- [<Platform> Repository](<url>)
````

A single copy-pasteable end-to-end code block is acceptable and often better
than splitting Setup and Observe.

## Skeleton: Plugin

````markdown
## Use cases

- **<Use case>**: <...>

## Prerequisites

- <account / API key with link>

## Installation

```bash
pip install <package>
```

## Use with agent

```python
from <package> import <Plugin>
from google.adk.agents import Agent

root_agent = Agent(
    model="gemini-flash-latest",
    name="<slug>_agent",
    instruction="<what the agent does>",
    tools=<plugin>.get_tools(),
)
```

## Available tools

Tool | Description
---- | -----------
`<tool>` | <what it does>

## Additional resources

- [<Product> Documentation](<url>)
- [<Product> on PyPI](<url>)
- [<Product> on GitHub](<url>)
````

Add a `## Configuration` section for environment variables when relevant.

## Style rules to bake in

- Model strings should be `gemini-flash-latest`, `gemini-pro-latest`, or other
  valid `*-latest` aliases in sample code rather than specific versioned model
  strings, which increase the maintenance burden when new model versions are
  released.
- Imports: `from google.adk.agents import Agent`; MCP uses
  `from google.adk.tools.mcp_tool import McpToolset`. Agent variable is
  `root_agent` (Python) / `rootAgent` (TypeScript, with `export { rootAgent };`).
- No em dashes or verbose AI-generated content: Use a colon in `**term**:
  definition` bullets; split prose into sentences otherwise.
- When referring to ADK, use "ADK", never "Google ADK" or "The ADK".
- Do not start a sentence with an inline-code word.
- Internal ADK-docs links are site-relative (e.g. `/sessions/memory/`); external
  links must resolve. Do not invent links.
- Verify all code samples against actual APIs and library code. The canonical
  source repositories are listed in `docs/community/contributing-guide.md`.
- Confirm that the package exists on PyPI/npm, before presenting the draft.