# What can I query? (compact overview)
rover graph fetch | rover schema describe -

# Find a field by concept/keyword (returns the path from a root operation)
rover graph fetch | rover schema search - " "

# Zoom into one type or field
rover graph fetch | rover schema describe - --coord --depth 1

 @ 

export APOLLO_GRAPH_REF=my-graph@production

# From schema file
rover subgraph publish my-graph@production \
 --name products \
 --schema ./schema.graphql \
 --routing-url https://products.example.com/graphql

# From running server (introspection)
rover subgraph publish my-graph@production \
 --name products \
 --schema Create `supergraph.yaml`:

 Compose:

### Fetch Composed Supergraph

 
 This returns the **supergraph SDL** (federation directives + `join__`/`link__` internals) — use it for composition/router work. To **explore what you can query** or write an operation, use `rover graph fetch` (the API schema) instead — see Explore a Graph's Schema .

## Local Development with `rover dev`

Start a local Router with automatic schema composition:

### With MCP Integration

## Schema Exploration (for Agents)

`rover schema describe` and `rover schema search` let an agent explore a schema **without loading the full SDL into context** — that is the entire point of these commands.

 
 ⚠️ **Never read the raw SDL into context.** Running `rover graph fetch <ref>` (or `rover graph introspect <url>`) on its own prints the entire schema — hundreds to tens of thousands of lines — straight into your context, which defeats the purpose of these commands. **Always pipe fetch output into `rover schema describe`/`search`**: the SDL flows through stdin and only the compact overview/results reach you. (Fetching to a file is fine when the user actually wants the SDL.)

 These commands also take SDL on **stdin or a file, NOT a graph ref** — you can't pass `graph@variant` to them. Fetch first, then pipe:

 
 To explore a graph in GraphOS, fetch its schema and pipe it in. **Use `rover graph fetch` (the API schema) for "what can I query?" exploration** — it omits federation internals. Reach for `rover supergraph fetch` only when you need composition details (`join__`/`link__` types, subgraph structure):

 **Coordinate forms:** `--coord` accepts a type (`User`), a field (`User.posts`), a field argument (`Type.field(arg:)`), or a directive (`@deprecated`) — omit it for the overview.

 **`search` vs `describe`:** reach for `rover schema search` first when matching a concept or keyword and you don't yet know the field name — it finds **nested** fields and shows the path from a root operation. The `describe` overview lists only root fields, so `search` is how you locate fields buried deeper. Use `describe` for the overview or once you know the type/field coordinate.

 This enables a closed-loop workflow — search → describe → write a query — with no MCP server setup. See [Schema Exploration](https://github.com/apollographql/skills/blob/main/skills/rover/references/schema.md) for the full command reference, ranking rules, and the save-once pattern for large schemas.

 **Running the generated operation:** Rover does **not** execute queries — it only manages and inspects schemas. To actually run a generated query you need the graph's endpoint:

 

- **Single-subgraph graph:** `rover subgraph list <graph@variant>` prints the **Routing Url** — send the query there with `curl`. 

- **Multi-subgraph / federated:** the client endpoint is the **router** URL (find it in GraphOS Studio; for a GraphOS cloud router, `rover cloud config fetch <graph@variant>`), not the per-subgraph routing URLs. 

- Don't try to discover the endpoint via the GraphOS Platform API — Rover keeps the API key in its profile/keychain, not `$APOLLO_KEY`, so ad-hoc API calls will come back unauthenticated.

## Reference Files

Detailed documentation for specific topics:

 

- [Subgraphs](https://github.com/apollographql/skills/blob/main/skills/rover/references/subgraphs.md) - fetch, publish, check, lint, introspect, delete 

- [Graphs](https://github.com/apollographql/skills/blob/main/skills/rover/references/graphs.md) - monograph commands (non-federated) 

- [Supergraphs](https://github.com/apollographql/skills/blob/main/skills/rover/references/supergraphs.md) - compose, fetch, config format 

- [Dev](https://github.com/apollographql/skills/blob/main/skills/rover/references/dev.md) - rover dev for local development 

- [Schema Exploration](https://github.com/apollographql/skills/blob/main/skills/rover/references/schema.md) - describe, search, agent schema discovery workflows 

- [Configuration](https://github.com/apollographql/skills/blob/main/skills/rover/references/configuration.md) - install, auth, env vars, profiles

## Common Patterns

### CI/CD Pipeline

### Schema Linting

### Output Formats

## Ground Rules

- ALWAYS authenticate before using GraphOS commands (`rover config auth` or `APOLLO_KEY`) 

- ALWAYS use the correct graph reference format: `graph@variant` 

- PREFER `rover subgraph check` before `rover subgraph publish` in CI/CD 

- USE `rover dev` for local supergraph development instead of running Router manually 

- NEVER commit `APOLLO_KEY` to version control; use environment variables 

- USE `--format json` when parsing output programmatically 

- SPECIFY `federation_version` explicitly in supergraph.yaml for reproducibility 

- USE `rover subgraph introspect` to extract schemas from running services 

- USE `rover schema search` / `rover schema describe` (piped from a `fetch`) to explore large schemas instead of loading the full SDL into context 

- NEVER fetch a full schema into context just to explore it — pipe `rover graph fetch`/`introspect` into `rover schema describe`/`search` (a bare `fetch` is only for when the user wants the SDL file itself)