GraphOS MCP Server
io.github.apollographql/graphos-mcp-serverapollographqlstreamable-httpv1.17.0Scanned
Search Apollo docs, specs, and best practices
48 tools: 14 can delete or cancel things, 6 change things and 28 only read.
- Reads private data · 5
- Reads text others write · 45
- Can send data out · 7
- 2 findings
Tools listed without sign-in. Remote posture
With Anlyon
14 tools here can delete or cancel things. Govern them.
- Anlyon lists the tools and adopts none.
- Each tool you adopt gets approvals and receipts.
- Your agent never holds the key.
A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.
What the GraphOS MCP Server can do
The GraphOS MCP Server is published by the GitHub account apollographql. It has 48 tools. It can delete or cancel things (14 tools: PublishGraphSchema, PublishReadme, DeleteSubgraph, UntagGraphArtifact and 10 more) and create or change data (6 tools: CreateProposal, RunSubgraphCheck, AddProposalComment, CreateApiKey and 2 more). 28 tools only read.
5 tools read private data (GetLintResults, ApolloDocsRead, GetApiKeys and 2 more); 45 tools bring in text other people can write (PublishGraphSchema, GetSupergraphSchema, PublishReadme and 42 more); 7 tools can send data out of your system (PublishGraphSchema, PublishReadme, AddProposalComment and 4 more). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.
The fixed checks matched 2 findings (credentials-mention). Each one comes with the text it matched.
Its remote endpoint lists its tools without sign-in, and its tools changed 2 times since Anlyon Radar first saw them.
Last scanned Nov 16, 2026, version 1.17.0.
Tools
Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.
48 tools
Deletes or cancels 14Claude Code: deny
DeleteApiKeyDelete an API key from an organization, the same write that `rover api-key delete` performs.Reads text others writeNo findings
Why it is in this group
- The name "DeleteApiKey" says "delete": a word for removing or ending something.
- The description says "cannot be undone".
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Delete an API key from an organization, the same write that `rover api-key delete` performs. This cannot be undone, and every client that uses the key stops authenticating. Returns the deleted key's ID. Provide the organization ID and the key ID, which GetApiKeys returns.
Annotations the server declares
- title: Delete an organization API key
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
DeleteGraphDelete a graph, the same write that `rover graph delete` performs.Reads text others writeNo findings
Why it is in this group
- The name "DeleteGraph" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Delete a graph, the same write that `rover graph delete` performs. This is a soft delete: the data is not removed permanently and Apollo support can restore the graph. Every variant of the graph stops serving, so confirm the graph ID with the user before you call this. Returns null on success. Provide the graph ID.
Annotations the server declares
- title: Delete a graph
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
DeleteSubgraphRemove a subgraph from a variant and start composition, the same write that `rover subgraph delete` performs.Reads text others writeNo findings
Why it is in this group
- The name "DeleteSubgraph" says "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Remove a subgraph from a variant and start composition, the same write that `rover subgraph delete` performs. Returns the composition errors that the removal causes. This deletes the subgraph from the variant and can break the running router. Set dryRun to true first: the response then reports the composition result that the removal would produce, including updatedGateway, and deletes nothing. Provide the graph ID, the variant name, and the subgraph name.
Annotations the server declares
- title: Delete a subgraph
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
PublishContractCreate or update a contract variant and start a launch for it, the same write that `rover contract publish` performs.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "PublishContract" says "publish": a word for a change that another call does not undo.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "PublishContract" says "publish": it sends or publishes something to other people.
Description, as the server wrote it Create or update a contract variant and start a launch for it, the same write that `rover contract publish` performs. A contract variant is a filtered view of another variant's schema, built by including and excluding schema elements by tag. The filter configuration replaces the previous one in full, so send the complete include and exclude lists rather than only the tags you want to change. The same applies to hideUnreachableTypes, which has no default: when you update a contract, pass the value it has now. GetContractConfig states that value in its description. Returns the contract variant and a link to the launch, or the error messages that stopped it. Provide the graph ID, the contract variant name, the source variant, the include and exclude tag lists, and whether to hide unreachable types.
Annotations the server declares
- title: Publish a contract
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
PublishGraphSchemaPublish a schema to a graph variant, the same write that `rover graph publish` performs.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "PublishGraphSchema" says "publish": a word for a change that another call does not undo.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "PublishGraphSchema" says "publish": it sends or publishes something to other people.
Description, as the server wrote it Publish a schema to a graph variant, the same write that `rover graph publish` performs. Use this for a monograph; use PublishSubgraph for one subgraph of a federated graph. Returns a result code, whether the publish succeeded, a human-readable message, and the hash of the published schema. This changes the schema registry and can change what clients see. Run RunSchemaCheck first to see the effect on client operations. Provide the graph ID, the variant name, and the schema as SDL. Optionally provide the git branch and commit to label the publication.
Annotations the server declares
- title: Publish a graph schema
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
PublishPersistedQueriesPublish operations to a persisted query list, the same write that `rover persisted-queries publish` performs.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "PublishPersistedQueries" says "publish": a word for a change that another call does not undo.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "PublishPersistedQueries" says "publish": it sends or publishes something to other people.
Description, as the server wrote it Publish operations to a persisted query list, the same write that `rover persisted-queries publish` performs. A persisted query list is the set of operations a router accepts when it is configured to reject anything else. Operations you do not mention stay in the list unchanged: pass operations to add or replace entries, and remove to drop them. Returns the new revision and the total operation count, or reports that nothing changed. Use GetPersistedQueryListStatus to find the list ID and its current revision. Provide the graph ID and the persisted query list ID.
Annotations the server declares
- title: Publish persisted queries
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
PublishProposalRevisionSave a new revision of a schema proposal by publishing changed subgraph schemas to its proposal variant, the same action as Save revision in GraphOS Studio.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "PublishProposalRevision" says "publish": a word for a change that another call does not undo.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "PublishProposalRevision" says "publish": it sends or publishes something to other people.
Description, as the server wrote it Save a new revision of a schema proposal by publishing changed subgraph schemas to its proposal variant, the same action as Save revision in GraphOS Studio. GraphOS composes the proposal variant, records the diff against the source variant, and runs schema checks on it. The source variant does not change. Send only the subgraphs that change, each with its full SDL. previousLaunchId must be the proposal variant's latest launch ID from GetProposal. If someone saved a revision since, the call fails, so read the proposal again before you retry. GraphOS saves the revision even when the schema does not compose, so this call succeeding does not mean the change is valid. Call GetProposal after the check finishes: latestRevision.checkWorkflow.status and latestRevision.launch.status show the result, and GetCheckResults takes the check ID for the details. Returns the proposal's new latest revision, or an error with a message. Provide the graph ID, the proposal variant name, previousLaunchId, a unique revision label, a summary of the change, and the subgraphs.
Annotations the server declares
- title: Save a schema proposal revision
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
PublishReadmeReplace the README of a graph variant, the same write that `rover readme publish` performs.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "PublishReadme" says "publish": a word for a change that another call does not undo.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "PublishReadme" says "publish": it sends or publishes something to other people.
Description, as the server wrote it Replace the README of a graph variant, the same write that `rover readme publish` performs. The README is the Markdown document shown on the variant's page in GraphOS Studio. The new text replaces the whole README, so read the current one with GetReadme first if you intend to keep any of it. Provide the graph ID, the variant name, and the full README text.
Annotations the server declares
- title: Publish a variant README
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
PublishSubgraphPublish a subgraph schema to a variant and start composition, the same write that `rover subgraph publish` performs.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "PublishSubgraph" says "publish": a word for a change that another call does not undo.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "PublishSubgraph" says "publish": it sends or publishes something to other people.
Description, as the server wrote it Publish a subgraph schema to a variant and start composition, the same write that `rover subgraph publish` performs. Returns whether the subgraph was created or updated, any composition errors, and the launch that started. This changes the schema registry and can change what the router serves. Run RunSubgraphCheck first to see the effect on client operations. Provide the graph ID, the variant name, the subgraph name, and the schema as SDL. Provide the routing URL when you add a subgraph or move its endpoint. Optionally provide a revision label and the git branch and commit.
Annotations the server declares
- title: Publish a subgraph schema
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
RenameApiKeyRename an API key in an organization, the same write that `rover api-key rename` performs.Reads text others writeNo findings
Why it is in this group
- The name "RenameApiKey" says "rename": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Rename an API key in an organization, the same write that `rover api-key rename` performs. The key value and its access do not change. Returns the key's ID and new name. Provide the organization ID, the key ID, which GetApiKeys returns, and the new name.
Annotations the server declares
- title: Rename an organization API key
- readOnlyHint: false
- destructiveHint: true
- idempotentHint: true
- openWorldHint: true
ReviewProposalApprove or reject a revision of a schema proposal, with an optional comment, the same action as Review in GraphOS Studio.Reads text others writeNo findings
Why it is in this group
- The description's first verb is "approve": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Approve or reject a revision of a schema proposal, with an optional comment, the same action as Review in GraphOS Studio. Only a requested reviewer can review, and calling this again replaces the caller's earlier review. Returns the proposal's status and its reviews, or an error with a message. Provide the graph ID, the proposal variant name and latestRevision.id from GetProposal, and the decision (APPROVED or NOT_APPROVED).
Annotations the server declares
- title: Review a schema proposal
- readOnlyHint: false
- destructiveHint: true
- idempotentHint: true
- openWorldHint: true
TagGraphArtifactAssign a tag to a graph artifact, the same write that `rover graph-artifact tag` performs.Reads text others writeNo findings
Why it is in this group
- The description's first verb is "assign": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Assign a tag to a graph artifact, the same write that `rover graph-artifact tag` performs. If the tag does not exist, it is created. If it exists, it moves to this artifact, and any router that fetches by that tag receives the new artifact. Returns the artifact's ID and digest, or an error with a message. Provide the graph ID, the tag name, and the artifact digest.
Annotations the server declares
- title: Tag a graph artifact
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
UntagGraphArtifactDelete a graph artifact tag from a graph, the same write that `rover graph-artifact untag` performs.Reads text others writeNo findings
Why it is in this group
- The description's first verb is "delete": a word for removing or ending something.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Delete a graph artifact tag from a graph, the same write that `rover graph-artifact untag` performs. The tag and its full history are removed, and any router that fetches by that tag can no longer resolve it. The artifact itself stays. Tags that Apollo manages, such as a variant's latest tag, cannot be deleted. Returns the deleted tag name, or an error with a message. Provide the graph ID and the tag name.
Annotations the server declares
- title: Remove a graph artifact tag
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
UpdateProposalStatusChange the status of a schema proposal, the same action as the status menu in GraphOS Studio.Reads text others writeNo findings
Why it is in this group
- The name "UpdateProposalStatus" says "update": a word for a change.
- The server marks it destructive (destructiveHint: true).
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Change the status of a schema proposal, the same action as the status menu in GraphOS Studio. DRAFT is for work in progress, OPEN asks reviewers to review, and CLOSED abandons the proposal. GraphOS accepts APPROVED only when the proposal has as many approvals as the graph requires, and it never accepts IMPLEMENTED from this tool. Both return a ValidationError that names the rule. Returns the proposal's ID and new status. Provide the graph ID, the proposal variant name from GetProposal, and the new status.
Annotations the server declares
- title: Update a schema proposal status
- readOnlyHint: false
- destructiveHint: true
- openWorldHint: true
Changes things 6Claude Code: ask
AddProposalCommentAdd a comment to a schema proposal, the same action as commenting in GraphOS Studio.Reads text others writeCan send data outNo findings
Why it is in this group
- The name "AddProposalComment" says "add": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- outboundThe name "AddProposalComment" says "add" and "comment": it writes something other people read.
Description, as the server wrote it Add a comment to a schema proposal, the same action as commenting in GraphOS Studio. With no other options, the comment is a general comment on the proposal. To comment on one change, pass the schema coordinate (for example Query.products) and the subgraph name as schemaScope. To reply, pass the parent comment's ID. Returns the new comment's ID and message, or an error with a message. Provide the graph ID, the proposal variant name and latestRevision.id from GetProposal, and the message.
Annotations the server declares
- title: Comment on a schema proposal
- readOnlyHint: false
- destructiveHint: false
- openWorldHint: true
CreateApiKeyCreate an API key for an organization.Reads text others write1 finding
Why it is in this group
- The name "CreateApiKey" says "create": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description mentions "credential".
What this check looks forMatched text
description: "...new key's value in token. It is a live credential, so give it to the user to store in a s..."
Description, as the server wrote it Create an API key for an organization. The response contains the new key's value in token. It is a live credential, so give it to the user to store in a secret manager, and do not repeat it, log it, or pass it to another tool. Which key types you can create depends on how you authenticate. With the GraphOS sign-in (OAuth), you can create OPERATOR, SCIM, and GATEWAY keys. SUBGRAPH and VARIANT keys need a personal API key in the x-api-key header. With an operator key in x-api-key, you can create only GATEWAY keys, and a graph key can create none. No credential can create ROUTER keys. OPERATOR, SCIM, and GATEWAY keys also require the Org Admin role. GATEWAY keys are used by Apollo Gateway instances. Choose the narrowest type that does the job, and confirm the type and its resources with the user before you call this tool. Provide the organization ID, the key name, and the type. For a SUBGRAPH key, list each graphId, variantName, and subgraphName in resources.subgraphs. For a VARIANT key, list each graphId and variantName in resources.variants.
Annotations the server declares
- title: Create an organization API key
- readOnlyHint: false
- destructiveHint: false
- openWorldHint: true
CreateProposalCreate a schema proposal against a source variant, the same action as Create proposal in GraphOS Studio.Reads text others writeNo findings
Why it is in this group
- The name "CreateProposal" says "create": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Create a schema proposal against a source variant, the same action as Create proposal in GraphOS Studio. GraphOS creates a proposal variant that starts as a copy of the source variant's schema, and the proposal starts in DRAFT. Returns the proposal variant's name and the new proposal's ID and status, or an error with a message. To add schema changes, call PublishProposalRevision next. Provide the graph ID, the title, and the source variant name. Optionally provide a description.
Annotations the server declares
- title: Create a schema proposal
- readOnlyHint: false
- destructiveHint: false
- openWorldHint: true
LintSchemaLint a GraphQL schema document against the graph's lint rules and return each diagnostic's coordinate, severity level, message, rule, and source location, plus the error, warning, …Reads text others writeNo findings
Why it is in this group
- Nothing in its name or description says what it does, so it is counted as a write.
- The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Lint a GraphQL schema document against the graph's lint rules and return each diagnostic's coordinate, severity level, message, rule, and source location, plus the error, warning, total, and ignored counts. This is the same check that `rover graph lint` and `rover subgraph lint` run. Nothing is published and no state changes. Provide the graph ID and the schema as SDL. The rules that run are the ones enabled in the graph's linter configuration, so a missing diagnostic can mean the rule is turned off. Optionally provide baseSdl to report only the diagnostics that the new schema introduces against that base; empty diagnostics then mean the new schema introduces no violations of the enabled rules, and ignored diagnostics are counted in ignoredCount, not listed.
Annotations the server declares
- title: Lint a schema
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
RunSchemaCheckStart a schema check of a proposed schema against a variant, the same check that `rover graph check` starts.Reads text others writeNo findings
Why it is in this group
- The name "RunSchemaCheck" says "run": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Start a schema check of a proposed schema against a variant, the same check that `rover graph check` starts. Use this for a monograph or for a whole supergraph schema; use RunSubgraphCheck for one subgraph. The check runs in the background, so this returns a workflow ID and a Studio URL, not a result. Pass the returned workflowID to GetCheckResults to read the outcome. Provide the graph ID, the variant name, and the proposed schema as SDL. Optionally provide the git branch and commit to label the run in Studio.
Annotations the server declares
- title: Run a schema check
- readOnlyHint: false
- destructiveHint: false
- openWorldHint: true
RunSubgraphCheckStart a schema check of one proposed subgraph schema against a variant, the same check that `rover subgraph check` starts.Reads text others writeNo findings
Why it is in this group
- The name "RunSubgraphCheck" says "run": a word for a change.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Start a schema check of one proposed subgraph schema against a variant, the same check that `rover subgraph check` starts. The check runs in the background, so this returns a workflow ID and a Studio URL, not a result. Nothing is published, but the check run is recorded and shows in Studio. Pass the returned workflowID to GetCheckResults as checkId to read the outcome. Provide the graph ID, the variant name, the subgraph name, and the proposed subgraph schema as SDL. Optionally provide the git branch and commit to label the run in Studio.
Annotations the server declares
- title: Run a subgraph schema check
- readOnlyHint: false
- destructiveHint: false
- openWorldHint: true
Only reads 28Show 28 read-only tools
ApolloConnectorsSpecReturns the Apollo Connectors specification for guidance on creating or modifying GraphQL schemas that use @connect or @source.No findings
Why it is in this group
- The description's first verb is "return": a word for reading.
Description, as the server wrote it Returns the Apollo Connectors specification for guidance on creating or modifying GraphQL schemas that use @connect or @source.
Annotations the server declares
- title: Read the Apollo Connectors specification
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
ApolloDocsReadReads an Apollo documentation page by slug in chunks.Reads private dataNo findings
Why it is in this group
- The name "ApolloDocsRead" says "read": a word for reading.
What it can reach
- private-dataThe name "ApolloDocsRead" says "read" and "doc": it reads documents.
Description, as the server wrote it Reads an Apollo documentation page by slug in chunks. Use slugs returned by ApolloDocsSearch.
Annotations the server declares
- title: Read Apollo documentation
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
ApolloDocsSearchSearches official Apollo documentation for GraphQL, GraphOS, Apollo Router, Apollo Client, MCP Server, schema design, deployment, and Connectors.Reads private dataNo findings
Why it is in this group
- The name "ApolloDocsSearch" says "search": a word for reading.
What it can reach
- private-dataThe name "ApolloDocsSearch" says "search" and "doc": it reads documents.
Description, as the server wrote it Searches official Apollo documentation for GraphQL, GraphOS, Apollo Router, Apollo Client, MCP Server, schema design, deployment, and Connectors. Returns URLs, slugs, and excerpts.
Annotations the server declares
- title: Search Apollo documentation
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: false
GetApiKeysList the API keys and client-credential pairs of an organization.Reads private dataReads text others write1 finding
Why it is in this group
- The name "GetApiKeys" says "get": a word for reading.
What it can reach
- private-dataThe description's first sentence says "list" and "credential": it reads secrets.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Findings
- Info
The description mentions "credential".
What this check looks forMatched text
description: "List the API keys and client-credential pairs of an organization. For each key:..."
Description, as the server wrote it List the API keys and client-credential pairs of an organization. For each key: its ID, name, type, creation, expiry, last use, revocation time, and the resources it can access. For each client-credential pair (an OAuth client that authenticates with the client credentials grant): its client ID, name, creation time, creator, grant types, scopes, and the resources it can access. Key values and client secrets are never returned. Pass a key's ID to RenameApiKey or DeleteApiKey. Those tools do not work on pairs, so manage pairs in GraphOS Studio or with `rover api-key`. Provide the organization ID, which GetMyIdentity returns. Optionally filter keys by status (ACTIVE by default, or ALL, EXPIRED, REVOKED) and type (OPERATOR, SUBGRAPH, VARIANT, GATEWAY, SCIM). The filters do not apply to pairs. The two lists page separately: page keys with first and after, and pairs with pairsFirst and pairsAfter.
Annotations the server declares
- title: List organization API keys
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetCheckResultsRead the outcome of one schema check run: the overall status, and for each task in the run the composition errors, lint diagnostics, schema changes with the client operations they …Reads text others writeNo findings
Why it is in this group
- The name "GetCheckResults" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read the outcome of one schema check run: the overall status, and for each task in the run the composition errors, lint diagnostics, schema changes with the client operations they affect, downstream variant results, and custom check violations. Get a check ID from GetSchemaChecks, from latestRevision.checkWorkflow.id in GetProposal (null if no check was triggered), or from the workflowID that RunSubgraphCheck returns. Provide the graph ID and the check ID. Read baseVariant before you compare the changes with another diff. For a proposal's check, baseVariant can name the proposal variant, but the changes are measured against the source variant as of the proposal's creation or its last upstream pull, so they cover every revision of the proposal and leave out later upstream changes. implementingServiceName may not match the subgraph whose changes are listed, so read the changes themselves. numberOfCheckedOperations of 0 means no client operations were tested, not that none are affected. An empty list of affected operations covers only operations seen in the graph's usage data, so it does not prove that a change is safe. The affected operations are paged with affectedOperationsLimit and affectedOperationsOffset; the change list is capped by the server, and areChangesTruncated reports when that happened.
Annotations the server declares
- title: Get schema check results
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetClientMetricsTraffic broken down by client for a graph over a time window, as compact CSV.Reads text others writeNo findings
Why it is in this group
- The name "GetClientMetrics" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Traffic broken down by client for a graph over a time window, as compact CSV. Columns: start timestamp, end exclusive timestamp, client name, client version, operation name, request count, request latency p50 ms, request latency p99 ms, request with error count. Answers which clients call a graph, which client versions are still on the wire, and which client drives errors or latency. Clients that do not report `apollographql-client-name`/`-version` come back with empty name and version columns. Ranked by `orderBy` descending: default REQUEST_COUNT (busiest); REQUEST_WITH_ERROR_COUNT for most error-prone, REQUEST_LATENCY_P99_MS for slowest. `variantName` and `operationName` scope to one or more variants or operations by exact name (omit for all). Rows are one per client + version + operation, so a busy graph has far more groups than the other metrics tools: scope by `operationName` or raise `limit` when a breakdown looks truncated. Keep the default `resolution` of ENTIRE_RANGE for totals and top-N, which gives one row per group ranked over the whole window. DAY/HOUR/MINUTE give one row per group per bucket ranked within each bucket, so a window total then needs a per-group sum plus a `limit` big enough to cover every bucket; too small a `limit` silently undercounts. Only HOUR and MINUTE accept a `to` of now, so use them for bursts in the last 24 hours. Avoid MONTH: it labels buckets by calendar month, not by the requested window.
Annotations the server declares
- title: Get client metrics
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetContractConfigRead the filter configuration of a contract variant: the tags it includes, the tags it excludes, the source variant it is built from, and a human-readable description of the config…Reads text others writeNo findings
Why it is in this group
- The name "GetContractConfig" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read the filter configuration of a contract variant: the tags it includes, the tags it excludes, the source variant it is built from, and a human-readable description of the configuration. This is the same read that `rover contract describe` performs. A contract variant is a filtered view of another variant's schema, built by including and excluding schema elements by tag. The filter configuration does not include whether unreachable types are hidden. The description states it, so read it there before you update a contract with PublishContract. A variant that is not a contract returns null for the filter configuration. Provide the graph ID and the contract variant name.
Annotations the server declares
- title: Get a contract configuration
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetGraphArtifactFetch a graph artifact by its digest, the same lookup that `rover graph-artifact fetch --digest` performs.Reads text others writeNo findings
Why it is in this group
- The name "GetGraphArtifact" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Fetch a graph artifact by its digest, the same lookup that `rover graph-artifact fetch --digest` performs. A graph artifact is the build output, such as the composed supergraph schema, that GraphOS Router fetches from Apollo's OCI registry. Returns the artifact's ID, digest, status (GRAPH_ARTIFACT_COMPLETED, GRAPH_ARTIFACT_PENDING, or GRAPH_ARTIFACT_FAILED), build errors, timestamps, variant, the launch that produced it, its registry URI, and the tags assigned to it. To find a digest from a tag name, use GetGraphArtifactTags. Provide the graph ID and the digest.
Annotations the server declares
- title: Get a graph artifact
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetGraphArtifactTagsList the graph artifact tags on a graph and the artifact each tag points to: the artifact's ID, digest, status, creation time, and variant.Reads text others writeNo findings
Why it is in this group
- The name "GetGraphArtifactTags" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List the graph artifact tags on a graph and the artifact each tag points to: the artifact's ID, digest, status, creation time, and variant. GraphOS Router can fetch an artifact by tag name instead of by digest. It is similar to `rover graph-artifact list-tags`, which filters by artifact digest instead of variant. Use it to find a tag or a digest before you call GetGraphArtifact, TagGraphArtifact, or UntagGraphArtifact. Provide the graph ID. Optionally filter by variant name, and page with first (at most 20) and after.
Annotations the server declares
- title: List graph artifact tags
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetGraphSchemaRead the schema (SDL) that is currently published to a graph variant, with its hash and publication time.Reads text others writeNo findings
Why it is in this group
- The name "GetGraphSchema" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read the schema (SDL) that is currently published to a graph variant, with its hash and publication time. This is the same read that `rover graph fetch` performs. The response holds the whole document and is not truncated. A large federated graph measured over 800,000 characters, roughly 200,000 tokens, which exceeds the context window of most models. Prefer GetSubgraphSchema, which reads one subgraph at a time, and use this tool only when you need the whole API schema. Provide the graph ID and the variant name.
Annotations the server declares
- title: Get a graph schema
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetLatestLaunchInspect the most recent launch for a graph variant: status, completion time, subgraph changes, composition errors, and a schema diff summary vs the previous launch (additions/remov…Reads text others writeNo findings
Why it is in this group
- The name "GetLatestLaunch" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Inspect the most recent launch for a graph variant: status, completion time, subgraph changes, composition errors, and a schema diff summary vs the previous launch (additions/removals/edits/deprecations plus affected operations). Use to assess schema composition health and the impact of recent schema changes. Also returns the latest approved launch for comparison. Provide the graph ID and variant name.
Annotations the server declares
- title: Get latest launch
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetLaunchInspect a single launch by ID for full detail: status, timestamps, which subgraphs changed, composition errors, and the schema diff summary.Reads text others writeNo findings
Why it is in this group
- The name "GetLaunch" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Inspect a single launch by ID for full detail: status, timestamps, which subgraphs changed, composition errors, and the schema diff summary. Use to drill into a specific launch — e.g. a failed or superseded one found via GetLaunchHistory (pass its id here). Provide the graph ID, variant name, and launch ID.
Annotations the server declares
- title: Get a specific launch
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetLaunchHistoryRetrieve recent launches for a graph variant (most recent first) to detect deployment instability such as repeated failures or frequent superseded launches.Reads text others writeNo findings
Why it is in this group
- The name "GetLaunchHistory" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Retrieve recent launches for a graph variant (most recent first) to detect deployment instability such as repeated failures or frequent superseded launches. Each entry includes the launch id, status, and timestamps, so you can identify a specific launch and drill into it with GetLaunch. Use to assess deployment stability. Provide the graph ID, variant name, and optionally a limit (default 20 most recent launches, max 100 per page) and an offset to page further back.
Annotations the server declares
- title: Get launch history
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetLintResultsRetrieve schema lint violations from a graph's most recent schema checks: for each check, the subgraph and variant it ran against and when it completed, and each diagnostic's coord…Reads private dataReads text others writeNo findings
Why it is in this group
- The name "GetLintResults" says "get": a word for reading.
What it can reach
- private-dataThe description's first sentence says "retrieve" and "message": it reads messages.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "retrieve" and "message": it reads messages, which other people can write.
Description, as the server wrote it Retrieve schema lint violations from a graph's most recent schema checks: for each check, the subgraph and variant it ran against and when it completed, and each diagnostic's coordinate, severity level, message, rule, and source location, plus error/warning/total/ignored counts. These are past check results, not a lint of the current schema; use LintSchema to lint a schema now. Provide the graph ID. Without filters the results span every variant and subgraph on the graph, so pass variants and subgraphs to narrow them, and check implementingServiceName, baseVariant, and completedAt on each result. Optionally set a limit (default 5 most recent schema checks).
Annotations the server declares
- title: Get schema lint results
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetMyIdentityResolve the caller's identity from their API key or OAuth token.Reads text others writeNo findings
Why it is in this group
- The name "GetMyIdentity" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Resolve the caller's identity from their API key or OAuth token. Call this FIRST when the user asks about "my graph" but has not provided a graph ID. For a graph/service key, `me` resolves to a Graph: use `id` as the graphId and `variants[].name` as the variant for the graph-scoped health-check tools, so the user does not have to supply either. For a user (personal key or OAuth), `me` resolves to a User instead: there's no single graph, so each org membership's `graphs[].id` / `graphs[].variants[].name` lists the graphId/variant options the graph-scoped tools need, across every org the user belongs to. Also handles service-account keys.
Annotations the server declares
- title: Get my GraphOS identity
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetOfflineLicenseFetch the offline Enterprise license for the organization that owns a graph, the same data that `rover license fetch` returns.Reads text others writeNo findings
Why it is in this group
- The name "GetOfflineLicense" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Fetch the offline Enterprise license for the organization that owns a graph, the same data that `rover license fetch` returns. The license is a signed JWT that lets GraphOS Router enable Enterprise features while it runs disconnected from GraphOS. Returns null when the organization does not have offline licenses enabled, which requires a request to Apollo. Provide the graph ID.
Annotations the server declares
- title: Get the offline Enterprise license
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetOperationMetricsTop operations by usage/health for a graph over a time window, as compact CSV.Reads text others writeNo findings
Why it is in this group
- The name "GetOperationMetrics" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Top operations by usage/health for a graph over a time window, as compact CSV. Columns: start timestamp, end exclusive timestamp, operation name, request count, request latency p50 ms, request latency p99 ms, request with error count. Ranked by `orderBy` descending: default REQUEST_COUNT (busiest); REQUEST_WITH_ERROR_COUNT for most error-prone, REQUEST_LATENCY_P99_MS for slowest. `variantName` scopes to one or more variants (omit for all). `clients` scopes to one or more clients; omit `clientVersion` to match every version of that client, and use GetClientMetrics to discover the names a graph sees. Keep the default `resolution` of ENTIRE_RANGE for totals and top-N, which gives one row per operation ranked over the whole window. DAY/HOUR/MINUTE give one row per operation per bucket ranked within each bucket, so a window total then needs a per-operation sum plus a `limit` big enough to cover every bucket; too small a `limit` silently undercounts. Only HOUR and MINUTE accept a `to` of now, so use them for bursts in the last 24 hours. Avoid MONTH: it labels buckets by calendar month, not by the requested window.
Annotations the server declares
- title: Get operation metrics
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetPersistedQueryListStatusCheck whether a graph variant has a Persisted Query List (PQL), and return its ID, its name, and its current build (revision and operation count).Reads text others writeNo findings
Why it is in this group
- The name "GetPersistedQueryListStatus" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Check whether a graph variant has a Persisted Query List (PQL), and return its ID, its name, and its current build (revision and operation count). Pass the ID to PublishPersistedQueries. Use to assess PQL configuration — a production variant with no PQL is a security gap. Provide the graph ID and variant name.
Annotations the server declares
- title: Get persisted query list status
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetProposalRead one schema proposal by its ID: title, description, status, author, the source variant, and the proposal variant with the ID of its latest launch.Reads text others writeNo findings
Why it is in this group
- The name "GetProposal" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read one schema proposal by its ID: title, description, status, author, the source variant, and the proposal variant with the ID of its latest launch. Also returns the latest revision (its ID, summary, schema check, and launch), every review with its decision and comment, and whether the source variant changed since the proposal was created. hasUpstreamChanges does not say which subgraphs changed upstream. The proposal variant starts as a copy of every subgraph on the source variant and is not updated automatically; it picks up upstream changes only when the author pulls them in. So a diff of the two variants also shows changes published to the source since the proposal was created or last pulled upstream, reversed as if the proposal made them. hasUpstreamChanges is always false for proposals created before Nov 15, 2024. To see what the proposal itself changes, read its latest check with latestRevision.checkWorkflow.id and GetCheckResults: the check's changes cover every revision of the proposal and leave out upstream changes. If you diff the variants, compare each source subgraph's updatedAt with when the proposal was created or last pulled upstream, and do not treat a subgraph that is on only one side as added or removed by the proposal. GetVariantDetails lists the subgraph names on each variant. The write tools for a proposal take the graph ID and the proposal variant name from this response. ReviewProposal and AddProposalComment take latestRevision.id, and PublishProposalRevision takes backingVariant.latestLaunch.id as previousLaunchId. Provide the proposal ID, which GetProposals returns.
Annotations the server declares
- title: Get a schema proposal
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetProposalsList the schema proposals on a graph: each proposal's ID, title, status (DRAFT, OPEN, APPROVED, IMPLEMENTED, CLOSED), timestamps, author, the source variant it proposes changes to,…Reads text others writeNo findings
Why it is in this group
- The name "GetProposals" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List the schema proposals on a graph: each proposal's ID, title, status (DRAFT, OPEN, APPROVED, IMPLEMENTED, CLOSED), timestamps, author, the source variant it proposes changes to, and the proposal variant that holds its changes, plus the total count for the filter. A schema proposal is a reviewable set of schema changes that GraphOS stores on its own variant. Pass a proposal's id to GetProposal for its revisions and reviews. Provide the graph ID. Optionally filter by status, source variant names, or subgraph names, and page with limit and offset.
Annotations the server declares
- title: List schema proposals
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetReadmeRead the README of a graph variant, with the time it was last updated and who updated it.Reads text others writeNo findings
Why it is in this group
- The name "GetReadme" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read the README of a graph variant, with the time it was last updated and who updated it. This is the same read that `rover readme fetch` performs. The README is the Markdown document shown on the variant's page in GraphOS Studio. Provide the graph ID and the variant name.
Annotations the server declares
- title: Get a variant README
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetSchemaChecksList past schema checks for a graph: each check's ID, status, timestamps, the subgraph it checked, the variant it ran against, the commit, and the status of each task in the check,…Reads private dataReads text others writeNo findings
Why it is in this group
- The name "GetSchemaChecks" says "get": a word for reading.
What it can reach
- private-dataThe description's first sentence says "list" and "commit": it reads repositories.
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it List past schema checks for a graph: each check's ID, status, timestamps, the subgraph it checked, the variant it ran against, the commit, and the status of each task in the check, plus the total count for the filter. Use this to find a check, then pass its ID to GetCheckResults for failure details. Provide the graph ID. Optionally filter by status (PASSED, FAILED, PENDING), subgraph names, branches, variants, authors, or check IDs, and page with limit and offset.
Annotations the server declares
- title: List schema checks
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetSubgraphMetricsTop subgraphs/connectors by traffic/health for a graph over a time window, as compact CSV.Reads text others writeNo findings
Why it is in this group
- The name "GetSubgraphMetrics" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Top subgraphs/connectors by traffic/health for a graph over a time window, as compact CSV. Columns: start timestamp, end exclusive timestamp, fetch service name, fetch count, fetch latency p50 ms, fetch latency p99 ms, fetch with errors count. Ranked by `orderBy` descending: default FETCH_COUNT (busiest); FETCH_WITH_ERRORS_COUNT for most error-prone, FETCH_LATENCY_P99_MS for slowest. `variantName` scopes to one or more variants (omit for all). `subgraphName` scopes to one or more subgraphs by exact name (omit for all); pattern/substring matching is not supported. `clients` scopes to the fetches driven by one or more clients; omit `clientVersion` to match every version of that client, and use GetClientMetrics to discover the names a graph sees. Keep the default `resolution` of ENTIRE_RANGE for totals and top-N, which gives one row per subgraph ranked over the whole window. DAY/HOUR/MINUTE give one row per subgraph per bucket ranked within each bucket, so a window total then needs a per-subgraph sum plus a `limit` big enough to cover every bucket; too small a `limit` silently undercounts. Only HOUR and MINUTE accept a `to` of now, so use them for bursts in the last 24 hours. Avoid MONTH: it labels buckets by calendar month, not by the requested window.
Annotations the server declares
- title: Get subgraph metrics
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetSubgraphSchemaRead one subgraph's published schema (SDL) from a variant, with its routing URL, revision, and last update time.Reads text others writeNo findings
Why it is in this group
- The name "GetSubgraphSchema" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "read" and "url": it reads web pages, which anyone can write.
Description, as the server wrote it Read one subgraph's published schema (SDL) from a variant, with its routing URL, revision, and last update time. This is the same read that `rover subgraph fetch` performs. Read one subgraph at a time: a whole supergraph document is much larger and can pass the token limit of the model. Provide the graph ID, the variant name, and the subgraph name. Use GetVariantDetails first if you do not know the subgraph names. The revision is free text, such as a commit hash or "proposal-creation", and it can differ between two variants whose SDL is identical, so compare the SDL to tell whether a subgraph changed.
Annotations the server declares
- title: Get a subgraph schema
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetSupergraphSchemaRead the composed supergraph schema (SDL) for a graph variant, with the composition ID and any composition errors.Reads text others writeNo findings
Why it is in this group
- The name "GetSupergraphSchema" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Read the composed supergraph schema (SDL) for a graph variant, with the composition ID and any composition errors. This is the same read that `rover supergraph fetch` performs. A supergraph schema is the single schema that composition builds from every subgraph, and it carries federation directives that the API schema does not. The response holds the whole document and is not truncated, and a supergraph schema is larger than the API schema it produces. Expect the same order of size: a large federated graph exceeds 800,000 characters, roughly 200,000 tokens. A variant that is not federated has no composition result, and the tool returns null for it rather than an empty document. Provide the graph ID and the variant name.
Annotations the server declares
- title: Get a supergraph schema
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetTopOperationsIdentify the most-used operations on a graph variant for a time range, with request counts, types, and signatures.Reads text others writeNo findings
Why it is in this group
- The name "GetTopOperations" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Identify the most-used operations on a graph variant for a time range, with request counts, types, and signatures. Use to find high-traffic operations, detect unused operations, and prioritize findings by traffic impact. Provide graph ID, variant, and a from/to time range (ISO 8601 timestamps; `to` must be at least 6 hours before now), plus an optional limit (default 50). This report is rate limited.
Annotations the server declares
- title: Get top operations
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
GetVariantDetailsRetrieve metadata for a graph variant: its identifier, federation version, the URL of its GraphQL endpoint, and its subgraph inventory (names only).Reads text others writeNo findings
Why it is in this group
- The name "GetVariantDetails" says "get": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
- untrusted-inputThe description's first sentence says "retrieve" and "url": it reads web pages, which anyone can write.
Description, as the server wrote it Retrieve metadata for a graph variant: its identifier, federation version, the URL of its GraphQL endpoint, and its subgraph inventory (names only). Use this to assess a variant's composition setup, such as subgraph inventory and federation version compliance. Provide the graph ID and variant name (e.g., "production").
Annotations the server declares
- title: Get graph variant details
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
ValidateOperationsValidate client GraphQL operations against a variant's published schema and return each problem's type (FAILURE, WARNING, INVALID), code, description, and the name of the operation…Reads text others writeNo findings
Why it is in this group
- The name "ValidateOperations" says "validate": a word for reading.
What it can reach
- untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
Description, as the server wrote it Validate client GraphQL operations against a variant's published schema and return each problem's type (FAILURE, WARNING, INVALID), code, description, and the name of the operation it came from. This is the same check that `rover client check` runs. Nothing is published and no state changes. Provide the graph ID and the operations, each one a body and an optional name. Optionally name the variant to validate against; the default is "current".
Annotations the server declares
- title: Validate client operations
- readOnlyHint: true
- destructiveHint: false
- idempotentHint: true
- openWorldHint: true
This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.
Exfil surface
Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.
1575 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 5 private-data tools breaks every one.
- Reads private data5
- Reads files, mail, messages, databases, secrets, calendars or repositories.
- Reads text others write45
- Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
- Can send data out7
- Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
{
"permissions": {
"deny": [
"mcp__graphos__ApolloDocsRead",
"mcp__graphos__ApolloDocsSearch",
"mcp__graphos__GetApiKeys",
"mcp__graphos__GetLintResults",
"mcp__graphos__GetSchemaChecks"
]
}
}Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.
Remote posture
What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.
Looked at Nov 20, 2026, 19:02 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.
- Reachable
- yes
- HTTP status of an anonymous initialize
- 200
- tools/list served without credentials
- yes
- Tools that change things, listed without credentials
- 23
- Protocol version
- 2025-06-18
- WWW-Authenticate on 401
- not observed
- resource_metadata in WWW-Authenticate
- not observed
- RFC 9728 protected resource metadata
- https://mcp.apollographql.com/.well-known/oauth-protected-resource
- Authorization servers
- https://auth.apollographql.com/oauth2
- Legacy HTTP+SSE transport
- no
- Dynamic client registration
- yes
- Client ID metadata documents
- no
- HighThe whole server
The endpoint served tools/list without credentials, and the list has 23 tools that change things (17 destructive, 6 write). Whether a call also works without credentials was not tested: tools are never called.
What this check looks forMatched text
https://mcp.apollographql.com: tools/list returned 53 tools to an anonymous client, including DeleteApiKey (destructive), DeleteGraph (destructive), DeleteSubgraph (destructive), PublishContract (destructive), PublishGraphSchema (destructive) and 18 more
Posture changes
- Nov 20, 2026
- Tools that change things, listed without credentials: 20 to 23
- Oct 29, 2026
- Tools that change things, listed without credentials: 10 to 20
Findings
Matches of fixed checks, with the text they matched.
- InfoGetApiKeys
The description mentions "credential".
What this check looks forMatched text
description: "List the API keys and client-credential pairs of an organization. For each key:..."
- InfoCreateApiKey
The description mentions "credential".
What this check looks forMatched text
description: "...new key's value in token. It is a live credential, so give it to the user to store in a s..."
History
Changes to its tool definitions and to its remote endpoint, newest first.
PostureRemote posture changed. Tools that change things, listed without credentials: 20 -> 23.View diff
- Tools that change things, listed without credentials: 20 to 23
Tools6 changed.~6 changedView diff
- Changed:GetCheckResultsOnly readsdescription
- Changed:GetLintResultsOnly readsdescriptioninputSchema
- Changed:GetProposalOnly readsdescription
- Changed:GetSubgraphSchemaOnly readsdescription
- Changed:LintSchemaChanges thingsdescription
- Changed:RunSubgraphCheckChanges thingsdescription
Tools16 added, 31 changed.+16 added~31 changedView diff
- Added:AddProposalCommentChanges things
- Added:CreateApiKeyChanges things
- Added:CreateProposalChanges things
- Added:DeleteApiKeyDeletes or cancels
- Added:GetApiKeysOnly reads
- Added:GetGraphArtifactOnly reads
- Added:GetGraphArtifactTagsOnly reads
- Added:GetOfflineLicenseOnly reads
- Added:GetProposalOnly reads
- Added:GetProposalsOnly reads
- Added:PublishProposalRevisionDeletes or cancels
- Added:RenameApiKeyDeletes or cancels
- Added:ReviewProposalDeletes or cancels
- Added:TagGraphArtifactDeletes or cancels
- Added:UntagGraphArtifactDeletes or cancels
- Added:UpdateProposalStatusDeletes or cancels
- Changed:ApolloDocsReadOnly readsdescription
- Changed:ApolloDocsSearchOnly readsdescription
- Changed:DeleteGraphDeletes or cancelsdescription
- Changed:DeleteSubgraphDeletes or cancelsdescription
- Changed:GetCheckResultsOnly readsdescription
- Changed:GetClientMetricsOnly readsdescriptioninputSchema
- Changed:GetContractConfigOnly readsdescription
- Changed:GetGraphSchemaOnly readsdescription
- Changed:GetLatestLaunchOnly readsdescription
- Changed:GetLaunchOnly readsdescription
- Changed:GetLaunchHistoryOnly readsdescription
- Changed:GetLintResultsOnly readsdescription
- Changed:GetMyIdentityOnly readsdescription
- Changed:GetOperationMetricsOnly readsdescriptioninputSchema
- Changed:GetPersistedQueryListStatusOnly readsdescription
- Changed:GetReadmeOnly readsdescription
- Changed:GetSchemaChecksOnly readsdescription
- Changed:GetSubgraphMetricsOnly readsdescriptioninputSchema
- Changed:GetSubgraphSchemaOnly readsdescription
- Changed:GetSupergraphSchemaOnly readsdescription
- Changed:GetTopOperationsOnly readsdescription
- Changed:GetVariantDetailsOnly readsdescription
- Changed:LintSchemaChanges thingsdescription
- Changed:PublishContractDeletes or cancelsdescription
- Changed:PublishGraphSchemaDeletes or cancelsdescription
- Changed:PublishPersistedQueriesDeletes or cancelsdescription
- Changed:PublishReadmeDeletes or cancelsdescription
- Changed:PublishSubgraphDeletes or cancelsdescription
- Changed:RunSchemaCheckChanges thingsdescription
- Changed:RunSubgraphCheckChanges thingsdescription
- Changed:ValidateOperationsOnly readsdescription
PostureRemote posture changed. Tools that change things, listed without credentials: 10 -> 20.View diff
- Tools that change things, listed without credentials: 10 to 20
Install
Pinned to version 1.17.0. Values in angle brackets are yours to fill in.
claude mcp add --transport http graphos https://mcp.apollographql.comclaude mcp add --transport http graphos https://mcp.apollographql.comRun in a terminal.
Claude Code permissions
Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.
{
"permissions": {
"allow": [
"mcp__graphos__GetSupergraphSchema",
"mcp__graphos__GetOfflineLicense",
"mcp__graphos__GetGraphSchema",
"mcp__graphos__GetSubgraphSchema",
"mcp__graphos__GetClientMetrics",
"mcp__graphos__GetLintResults",
"mcp__graphos__GetOperationMetrics",
"mcp__graphos__ApolloDocsRead",
"mcp__graphos__GetVariantDetails",
"mcp__graphos__GetContractConfig",
"mcp__graphos__GetApiKeys",
"mcp__graphos__GetReadme",
"mcp__graphos__GetProposals",
"mcp__graphos__GetGraphArtifact",
"mcp__graphos__GetGraphArtifactTags",
"mcp__graphos__GetLatestLaunch",
"mcp__graphos__GetCheckResults",
"mcp__graphos__GetPersistedQueryListStatus",
"mcp__graphos__GetLaunchHistory",
"mcp__graphos__GetProposal",
"mcp__graphos__GetSchemaChecks",
"mcp__graphos__GetTopOperations",
"mcp__graphos__GetSubgraphMetrics",
"mcp__graphos__GetMyIdentity",
"mcp__graphos__ValidateOperations",
"mcp__graphos__ApolloDocsSearch",
"mcp__graphos__ApolloConnectorsSpec",
"mcp__graphos__GetLaunch"
],
"ask": [
"mcp__graphos__CreateProposal",
"mcp__graphos__RunSubgraphCheck",
"mcp__graphos__AddProposalComment",
"mcp__graphos__CreateApiKey",
"mcp__graphos__RunSchemaCheck",
"mcp__graphos__LintSchema"
],
"deny": [
"mcp__graphos__PublishGraphSchema",
"mcp__graphos__PublishReadme",
"mcp__graphos__DeleteSubgraph",
"mcp__graphos__UntagGraphArtifact",
"mcp__graphos__ReviewProposal",
"mcp__graphos__UpdateProposalStatus",
"mcp__graphos__PublishPersistedQueries",
"mcp__graphos__TagGraphArtifact",
"mcp__graphos__PublishContract",
"mcp__graphos__PublishSubgraph",
"mcp__graphos__DeleteApiKey",
"mcp__graphos__DeleteGraph",
"mcp__graphos__RenameApiKey",
"mcp__graphos__PublishProposalRevision"
]
}
}Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as graphos. Review it before you use it.
Capability tags behind 47 rules
- mcp__graphos__PublishGraphSchema untrusted-input, outbound
- mcp__graphos__GetSupergraphSchema untrusted-input
- mcp__graphos__PublishReadme untrusted-input, outbound
- mcp__graphos__GetOfflineLicense untrusted-input
- mcp__graphos__CreateProposal untrusted-input
- mcp__graphos__GetGraphSchema untrusted-input
- mcp__graphos__DeleteSubgraph untrusted-input
- mcp__graphos__GetSubgraphSchema untrusted-input
- mcp__graphos__GetClientMetrics untrusted-input
- mcp__graphos__GetLintResults private-data, untrusted-input
- mcp__graphos__RunSubgraphCheck untrusted-input
- mcp__graphos__GetOperationMetrics untrusted-input
- mcp__graphos__ApolloDocsRead private-data
- mcp__graphos__GetVariantDetails untrusted-input
- mcp__graphos__GetContractConfig untrusted-input
- mcp__graphos__GetApiKeys private-data, untrusted-input
- mcp__graphos__GetReadme untrusted-input
- mcp__graphos__AddProposalComment untrusted-input, outbound
- mcp__graphos__GetProposals untrusted-input
- mcp__graphos__CreateApiKey untrusted-input
- mcp__graphos__UntagGraphArtifact untrusted-input
- mcp__graphos__ReviewProposal untrusted-input
- mcp__graphos__GetGraphArtifact untrusted-input
- mcp__graphos__GetGraphArtifactTags untrusted-input
- mcp__graphos__GetLatestLaunch untrusted-input
- mcp__graphos__UpdateProposalStatus untrusted-input
- mcp__graphos__GetCheckResults untrusted-input
- mcp__graphos__PublishPersistedQueries untrusted-input, outbound
- mcp__graphos__RunSchemaCheck untrusted-input
- mcp__graphos__TagGraphArtifact untrusted-input
- mcp__graphos__PublishContract untrusted-input, outbound
- mcp__graphos__LintSchema untrusted-input
- mcp__graphos__GetPersistedQueryListStatus untrusted-input
- mcp__graphos__PublishSubgraph untrusted-input, outbound
- mcp__graphos__GetLaunchHistory untrusted-input
- mcp__graphos__GetProposal untrusted-input
- mcp__graphos__GetSchemaChecks private-data, untrusted-input
- mcp__graphos__GetTopOperations untrusted-input
- mcp__graphos__DeleteApiKey untrusted-input
- mcp__graphos__DeleteGraph untrusted-input
- mcp__graphos__GetSubgraphMetrics untrusted-input
- mcp__graphos__RenameApiKey untrusted-input
- mcp__graphos__GetMyIdentity untrusted-input
- mcp__graphos__PublishProposalRevision untrusted-input, outbound
- mcp__graphos__ValidateOperations untrusted-input
- mcp__graphos__ApolloDocsSearch private-data
- mcp__graphos__GetLaunch untrusted-input
Pin
Keep the decision: fail CI when the tools change, follow every change, or show a badge.
Pin in CI
Fail a build when the tools you reviewed are not the tools the server serves today.
curl -s "https://radar.anlyon.com/api/v1/servers/io.github.apollographql/graphos-mcp-server/verify?hash=330d1c418f007bee02cbecebd7810405ccf9713def243cf58f1da2cdb10e0af1" | jq -e '.changed == false'Pinned hash 330d1c418f00, from Nov 16, 2026, 22:17 UTC.
Watch
Get told when its tools change: a new tool, a new description, a new class.
https://radar.anlyon.com/servers/io.github.apollographql/graphos-mcp-server/changes.xmlAn Atom feed. Works in any feed reader or Slack's RSS app.
Badge
[](https://radar.anlyon.com/servers/io.github.apollographql/graphos-mcp-server)Source: MCP Registry. Synced Oct 21, 2026, 18:23 UTC.
GraphOS MCP Server: questions and answers
Answered from the scan above, not from the publisher's description.
Is the GraphOS MCP Server safe?
- No scan can promise that. What its definitions show: 48 tools, 20 of which can change, send or delete something, and 2 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.
Can the GraphOS MCP Server delete data?
- Yes. 14 tools can delete, cancel or revoke something: PublishGraphSchema, PublishReadme, DeleteSubgraph, UntagGraphArtifact, ReviewProposal, UpdateProposalStatus and 8 more.
Can the GraphOS MCP Server do things that cannot be undone?
- No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.
What tools does the GraphOS MCP Server have?
- 48 tools: 14 destructive, 6 write, 28 read. PublishGraphSchema, PublishReadme, DeleteSubgraph, UntagGraphArtifact, ReviewProposal, UpdateProposalStatus, PublishPersistedQueries, TagGraphArtifact and 40 more.
Does the GraphOS MCP Server need sign-in or OAuth?
- Its remote endpoint listed its tools to an anonymous client, without sign-in.
Does the GraphOS MCP Server send data to outside services?
- 7 tools can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): PublishGraphSchema, PublishReadme, AddProposalComment, PublishPersistedQueries, PublishContract, PublishSubgraph and 1 more.
Has the GraphOS MCP Server changed its tools?
- Yes, 2 times since Anlyon Radar started tracking it, most recently on Nov 16, 2026. Every change is on this page and in its Atom feed.