Apollo GraphQL Agent Skills

A collection of skills for AI coding agents working with Apollo GraphQL tools and technologies.

Apollo Skills follow the Agent Skills format and are available on skills.sh.

Installation

Install skills using the Skills CLI:

npx skills add apollographql/skills

The CLI guides you through an interactive installation:

Select skills - Choose which skills to install
Select agents - Pick target agents (Claude Code, Codex, Cursor, Gemini CLI, Goose, OpenCode)
Installation scope - Project (committed with your code) or Global
Installation method - Symlink (recommended) or Copy

◇  Found 11 skills
│
◆  Select skills to install
│  ◼ apollo-client
│  ◼ apollo-connectors
│  ◼ apollo-server
│  ○ ...
└

Claude Code Plugin

You can also install skills as a Claude Code plugin:

First, add the marketplace:

/plugin marketplace add apollographql/skills

Then, install the plugin:

/plugin install apollo-skills@apollo-marketplace

Once installed, skills are available as namespaced slash commands:

Slash Command	Description
`/apollo-skills:apollo-client`	Apollo Client 4.x for React — queries, mutations, caching, local state
`/apollo-skills:apollo-connectors`	Apollo Connectors — integrate REST APIs into GraphQL
`/apollo-skills:apollo-kotlin`	Apollo Kotlin — GraphQL client for Android and Kotlin
`/apollo-skills:apollo-mcp-server`	Apollo MCP Server — connect AI agents with GraphQL APIs
`/apollo-skills:apollo-server`	Apollo Server 4.x — schemas, resolvers, auth, plugins
`/apollo-skills:graphql-operations`	GraphQL operations — queries, mutations, fragments
`/apollo-skills:graphql-schema`	GraphQL schema design — types, naming, pagination, errors
`/apollo-skills:rover`	Rover CLI — schema management and local supergraph development
`/apollo-skills:rust-best-practices`	Rust best practices — idiomatic Rust following Apollo conventions
`/apollo-skills:skill-creator`	Skill creator — guide for creating new Apollo skills

Available Skills

apollo-connectors

Write Apollo Connectors schemas to integrate REST APIs into GraphQL.

Install:

npx skills add apollographql/skills@apollo-connectors

Use when:

Connecting REST APIs to a GraphQL supergraph
Writing @source and @connect directives
Implementing entity resolvers with batching
Validating connector schemas with rover

Categories covered:

Selection mapping grammar
HTTP methods and headers
Variable interpolation ($args, $this, $config)
Entity patterns and @key directives
Batch requests with @listSize

Examples:

"Connect my REST API to my GraphQL schema"
"Write a connector for this OpenAPI spec"
"Add entity resolvers with batching for my users endpoint"

References:
SKILL.md ·
Grammar ·
Methods ·
Variables ·
Entities ·
Validation ·
Troubleshooting

apollo-federation

Author Apollo Federation subgraph schemas with entities, sharing, and cross-subgraph field resolution.

Install:

npx skills add apollographql/skills --skill apollo-federation

Use when:

Creating new subgraph schemas for a federated supergraph
Defining or modifying entities with @key
Sharing types/fields across subgraphs with @shareable
Working with federation directives (@external, @requires, @provides, @override)
Troubleshooting composition errors

Categories covered:

Entity definition and @key patterns (compound, multiple, differing)
Reference resolvers and computed fields
Value types with @shareable
Field migration with @override (including progressive rollout)
Entity interfaces with @interfaceObject
Common composition errors and fixes

Examples:

"Create a federated subgraph for my products service"
"Add a computed field that requires data from another subgraph"
"Migrate this field from one subgraph to another"

References:
SKILL.md ·
Directives ·
Schema Patterns ·
Composition

apollo-mcp-server

Configure and use Apollo MCP Server to connect AI agents with GraphQL APIs.

Install:

npx skills add apollographql/skills@apollo-mcp-server

Use when:

Setting up Apollo MCP Server for Claude or other AI agents
Defining MCP tools from GraphQL operations
Using introspection tools (introspect, search, validate, execute)
Troubleshooting MCP server connectivity issues

Categories covered:

Server configuration (endpoints, schemas, headers)
Built-in tools and compact notation
Operation sources (files, collections, persisted queries)
Authentication and security
Health checks and debugging

Examples:

"Set up Apollo MCP Server for my GraphQL endpoint"
"Configure MCP tools from my GraphQL operations"
"Debug MCP server connection issues"

References:
SKILL.md ·
Tools ·
Configuration ·
Troubleshooting

apollo-router

Configure and run Apollo Router for federated GraphQL supergraphs.

Install:

npx skills add apollographql/skills@apollo-router

Use when:

Setting up Apollo Router to run a supergraph
Configuring routing, headers, or CORS
Implementing custom plugins (Rhai scripts or coprocessors)
Configuring telemetry and observability
Troubleshooting Router performance or connectivity issues

Categories covered:

Installation and quick start
Router configuration (YAML)
Header propagation and manipulation
CORS and authentication
Rhai scripts and coprocessors
Telemetry (tracing, metrics, logging)

Examples:

"Set up Apollo Router for my supergraph"
"Configure CORS for my Router"
"Add header propagation for authentication"

References:
SKILL.md ·
Configuration ·
Headers ·
Plugins ·
Telemetry ·
Troubleshooting

apollo-server

Build GraphQL servers with Apollo Server 4.x, including schemas, resolvers, authentication, and plugins.

Install:

npx skills add apollographql/skills@apollo-server

Use when:

Setting up a new Apollo Server project
Writing resolvers or defining GraphQL schemas
Implementing authentication or authorization
Creating plugins or custom data sources
Troubleshooting Apollo Server errors or performance issues

Categories covered:

Quick start setup (standalone and Express)
Schema definition and type system
Resolver patterns and best practices
Context and authentication
Plugins and lifecycle hooks
Data sources and DataLoader
Error handling and formatting

Examples:

"Create an Apollo Server with user authentication"
"Write resolvers for my GraphQL schema"
"Add a custom plugin to log all queries"

References:
SKILL.md ·
Resolvers ·
Context & Auth ·
Plugins ·
Data Sources ·
Error Handling ·
Troubleshooting

apollo-client

Build React applications with Apollo Client 4.x for GraphQL data management, caching, and local state.

Install:

npx skills add apollographql/skills@apollo-client

Use when:

Setting up Apollo Client in a React project
Writing GraphQL queries or mutations with hooks
Configuring caching or cache policies
Managing local state with reactive variables
Troubleshooting Apollo Client errors or performance issues

Categories covered:

Quick start setup (install, client, provider, query)
useQuery and useLazyQuery hooks
useMutation with optimistic UI
InMemoryCache and type policies
Reactive variables and local state
Error handling and error links
Performance optimization

Examples:

"Set up Apollo Client in my React app"
"Implement optimistic UI for my mutation"
"Configure cache policies for my queries"

References:
SKILL.md ·
Queries ·
Mutations ·
Caching ·
State Management ·
Error Handling ·
Troubleshooting

apollo-kotlin

Build applications with Apollo Kotlin, the GraphQL client library for Android and Kotlin.

Install:

npx skills add apollographql/skills@apollo-kotlin

Use when:

Setting up Apollo Kotlin in a Gradle project for Android, Kotlin/JVM, or KMP
Configuring schema download and codegen for GraphQL services
Configuring an ApolloClient with auth, interceptors, and caching
Writing queries, mutations, or subscriptions

Categories covered:

Gradle plugin setup and service configuration
Schema management and code generation
ApolloClient configuration
Coroutines and Flow usage patterns
Normalized cache and cache policies

Examples:

"Set up Apollo Kotlin in my Android app"
"Configure code generation for multiple GraphQL services"
"Add normalized caching for offline support"

References:
SKILL.md ·
Setup ·
Operations ·
Caching ·

rover

Manage GraphQL schemas and run local supergraph development with Apollo Rover CLI.

Install:

npx skills add apollographql/skills@rover

Use when:

Publishing or fetching subgraph schemas to/from GraphOS
Composing supergraph schemas locally
Running local supergraph development with rover dev
Validating schemas with check and lint commands

Categories covered:

Subgraph commands (fetch, publish, check, lint)
Graph commands (monograph management)
Supergraph composition
Local development with rover dev
Authentication and configuration

Examples:

"Publish my subgraph schema to GraphOS"
"Run rover dev to test my supergraph locally"
"Check my schema changes before deploying"

References:
SKILL.md ·
Subgraphs ·
Graphs ·
Supergraphs ·
Dev ·
Configuration

graphql-schema

Design GraphQL schemas following industry best practices for type design, naming, pagination, errors, and security.

Install:

npx skills add apollographql/skills@graphql-schema

Use when:

Designing a new GraphQL schema or API
Reviewing existing schema for improvements
Deciding on type structures or nullability
Implementing pagination or error patterns
Ensuring security in schema design

Categories covered:

Type design patterns (interfaces, unions, custom scalars)
Naming conventions for types, fields, and arguments
Cursor-based pagination (Connection pattern)
Error modeling and result types
Security best practices (depth limiting, complexity, authorization)

Examples:

"Design a GraphQL schema for my e-commerce API"
"Review my schema for best practices"
"Add cursor-based pagination to my queries"

References:
SKILL.md ·
Types ·
Naming ·
Pagination ·
Errors ·
Security

graphql-operations

Write GraphQL operations (queries, mutations, fragments) following best practices for client-side development.

Install:

npx skills add apollographql/skills@graphql-operations

Use when:

Writing GraphQL queries or mutations
Organizing operations with fragments
Optimizing data fetching patterns
Setting up type generation or linting
Reviewing operations for efficiency

Categories covered:

Query patterns and optimization
Mutation patterns and error handling
Fragment organization and colocation
Variable usage and types
Tooling (GraphQL Code Generator, ESLint, IDE extensions)

Examples:

"Write a query with pagination"
"Organize my operations with fragments"
"Set up GraphQL Code Generator for type safety"

References:
SKILL.md ·
Queries ·
Mutations ·
Fragments ·
Variables ·
Tooling

rust-best-practices

Write idiomatic Rust code following Apollo GraphQL's best practices handbook.

Install:

npx skills add apollographql/skills@rust-best-practices

Use when:

Writing new Rust code or functions
Reviewing or refactoring existing Rust code
Deciding between borrowing vs cloning or ownership patterns
Implementing error handling with Result types
Optimizing Rust code for performance
Writing tests or documentation for Rust projects

Categories covered:

Coding style and idioms (borrowing, Option/Result, iterators)
Clippy and linting discipline
Performance optimization and profiling
Error handling with thiserror and anyhow
Testing strategies and snapshot testing
Generics, static and dynamic dispatch
Type state pattern for compile-time safety
Documentation best practices
Pointer types and thread safety

Examples:

"Review this Rust code for best practices"
"Help me decide between cloning and borrowing here"
"Add proper error handling to this function"

References:
SKILL.md ·
Style ·
Errors ·
Performance ·
Testing ·
Advanced

skill-creator

Guide for creating effective skills for Apollo GraphQL and GraphQL development.

Install:

npx skills add apollographql/skills@skill-creator

Use when:

Creating a new skill for this repository
Updating an existing skill's structure or content
Learning skill best practices and patterns
Writing SKILL.md files or reference documentation

Categories covered:

SKILL.md format and frontmatter fields
Directory structure and reference files
Description writing for agent activation triggers
Progressive disclosure and context optimization
Apollo Voice writing style guidelines
Validation checklist for new skills

Examples:

"Create a new skill for Apollo Federation"
"Help me write a SKILL.md for my custom skill"
"Review my skill structure for best practices"

References:
SKILL.md ·
Apollo Skills

Usage

Skills activate automatically once installed. The agent uses them when relevant tasks are detected.

You can also explicitly invoke a skill depending on your tool:

Tool	Automatic	Explicit Invocation
Claude Code	Yes	Slash command (e.g., `/graphql-schema` or `/apollo-skills:graphql-schema` via plugin)
GitHub Copilot	Yes	`/agent` for custom agents, `@github` for GitHub skills
Cursor	Yes	Rules matched by file patterns (no direct invocation)
Windsurf	Yes	Slash command for workflows (e.g., `/workflow-name`)

Skill Structure

Each skill contains:

SKILL.md - Instructions for the agent (required)
references/ - Supporting documentation (optional)

Resources

Disclaimer

The code in this repository is experimental and for reference purposes only. Community feedback is welcome but this project is not officially supported in the same way that repositories in the official Apollo GraphQL GitHub organization are. If you need help you can file an issue on this repository, contact Apollo to talk to an expert, or create a ticket directly in Apollo Studio.