arize-graphql-analytics
/arize-graphql-analytics
Query and analyze data from the Arize platform using GraphQL, or help build/validate GraphQL queries and mutations. Use when users want to explore spaces, models, monitors, datasets, any Arize platform data, OR when they need help writing, formatting, or debugging GraphQL queries/mutations for the Arize API.
- Author
- duncankmckinnon ↗
- Repository
- arize_toolkit ↗
- Licence
- MIT
- Last repository change
- 26.05.2026
Assessment and security
- Files in this package
- 3
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 4
No signals detected. Repository changed on 26.05.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Query and analyze data from the Arize platform using GraphQL, or help build/validate GraphQL queries and mutations. Use when users want to explore spaces, models, monitors, datasets, any Arize platform data, OR when they need help writing, formatting, or debugging GraphQL queries/mutations for the Arize API.
Original author description
Query and analyze data from the Arize platform using GraphQL, or help build/validate GraphQL queries and mutations. Use when users want to explore spaces, models, monitors, datasets, any Arize platform data, OR when they need help writing, formatting, or debugging GraphQL queries/mutations for the Arize API.
How it works
- Workflow
- Step 1: Check API Key
- Step 2: Fetch Full Schema (REQUIRED FIRST STEP)
- Step 3: Build Query or Mutation
- Step 4: Execute
- Step 5: Summarize Results
- Quick Reference: Common Patterns
- Query Building Mode
- Troubleshooting
- References
SKILL.md preview
---
name: arize-graphql-analytics
description: Query and analyze data from the Arize platform using GraphQL, or help build/validate GraphQL queries and mutations. Use when users want to explore spaces, models, monitors, datasets, any Arize platform data, OR when they need help writing, formatting, or debugging GraphQL queries/mutations for the Arize API.
---
# Arize GraphQL Analytics
Query and analyze data from the Arize ML observability platform using GraphQL via curl.
---
## Workflow
```
1. Check API Key → 2. Fetch Full Schema → 3. Build Query/Mutation → 4. Execute → 5. Summarize
```
**CRITICAL**: Always fetch the full schema FIRST before building any queries. This ensures accuracy.
---
## Step 1: Check API Key
```bash
echo "${ARIZE_API_KEY:-NOT_SET}"
```
### If NOT_SET
Ask the user for their API key:
> "To query the Arize GraphQL API, I need your API key. You can find it in Arize: Settings → API Keys."
Then set it:
```bash
export ARIZE_API_KEY="user-provided-key"
```
Verify:
```bash
curl -s -X POST "${ARIZE_GRAPHQL_ENDPOINT:-https://app.arize.com/graphql}" \
-H "Content-Type: application/json" \
-H "x-api-key: ${ARIZE_API_KEY}" \
-d '{"query": "{ __typename }"}'
```
Expected: `{"data":{"__typename":"Query"}}`
---
## Step 2: Fetch Full Schema (REQUIRED FIRST STEP)
Use this comprehensive introspection query to get the complete schema. This query uses fragments to capture all type information including nested types up to 10 levels deep.
```bash
curl -s -X POST "${ARIZE_GRAPHQL_ENDPOINT:-https://app.arize.com/graphql}" \
-H "Content-Type: application/json" \
-H "x-api-key: ${ARIZE_API_KEY}" \
-d @- <<'EOF'
{
"query": "query IntrospectionQuery { __schema { queryType { name } mutationType { name } subscriptionType { name } types { ...FullType } directives { name description locations args { ...InputValue } } } } fragment FullType on __Type { kind name description fields(includeDeprecated: true) { name description args { ...InputValue } type { ...TypeRef } isDeprecated deprecationReason } inputFields { ...InputValue } interfaces { ...TypeRef } enumValues(includeDeprecated: true) { name description isDeprecated deprecationReason } possibleTypes { ...TypeRef } } fragment InputValue on __InputValue { name description type { ...TypeRef } defaultValue } fragment TypeRef on __Type { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } } } } } } } }"
}
EOF
```
### Understanding the Schema Response
The introspection returns:
- **queryType**: Root query type (usually "Query")
- **mutationType**: Root mutation type (usually "Mutation")
- **types**: All types in the schema with their fields, arguments, and relationships
- **directives**: Available directives
### Key Type Kinds
| Kind | Description | Example |
|------|-------------|---------|
| `SCALAR` | Primitive types | `String`, `Int`, `ID`, `Boolean`, `Float` |
| `OBJECT` | Complex types with fields | `Space`, `Model`, `Monitor` |
| `INPUT_OBJECT` | Input types for mutations | `CreateMonitorInput` |
| `ENUM` | Enumeration types | `ModelType`, `MonitorStatus` |
| `LIST` | Array wrapper | `[Model]` |
| `NON_NULL` | Required wrapper | `String!` |
| `INTERFACE` | Shared field contract | `Node` |
| `UNION` | One of multiple types | `SearchResult` |
### Unwrapping Types
When `kind` is `NON_NULL` or `LIST`, the actual type is in `ofType`. Keep unwrapping until you reach a named type:
```
NON_NULL → LIST → NON_NULL → OBJECT(Model)
means: [Model!]!
```
---
## Step 3: Build Query or Mutation
Using the schema, construct the appropriate operation.
### For Queries
1. Find the query field in the schema's queryType
1. Check its return type and arguments
1. Follow the Relay connection pattern for lists
1. Use inline fragments for interface/union types
### For Mutations
1. Find the mutation in mutationType
1. Get the input argument's type name
1. Look up that INPUT_OBJECT in types
1. Build mutation with all required inputFields
See [references/PATTERNS.md](references/PATTERNS.md) for detailed patterns.
---
## Step 4: Execute
### Simple Query
```bash
curl -s -X POST "${ARIZE_GRAPHQL_ENDPOINT:-https://app.arize.com/graphql}" \
-H "Content-Type: application/json" \
-H "x-api-key: ${ARIZE_API_KEY}" \
-d '{"query": "{ spaces { edges { node { id name } } } }"}'
```
### With Variables (for Mutations)
```bash
curl -s -X POST "${ARIZE_GRAPHQL_ENDPOINT:-https://app.arize.com/graphql}" \
-H "Content-Type: application/json" \
-H "x-api-key: ${ARIZE_API_KEY}" \
-d @- <<'EOF'
{
"query": "mutation CreateSpace($input: CreateSpaceInput!) { createSpace(input: $input) { space { id name } } }",
"variables": {
"input": {
"name": "My Space",
"organizationId": "org-id-here"
}
}
}
EOF
```
---
## Step 5: Summarize Results
Parse the JSON response and provide clear insights to the user.
---
## Quick Reference: Common Patterns
### Relay Connections (Lists)
All lists use edges/node pattern:
```graphql
{
spaces {
edges {
node { id name }
cursor
}
pageInfo { hasNextPage endCursor }
}
}
```
### Node Lookup (by ID)
```graphql
{
node(id: "BASE64_ID") {
... on Space { name }
... on Model { name modelType }
}
}
```
### Pagination
```graphql
{ spaces(first: 10, after: "cursor") { edges { node { id } } } }
```
### Mutations
```graphql
mutation Op($input: InputType!) {
mutationName(input: $input) {
entity { id }
errors { field message }
}
}
```
---
## Query Building Mode
When helping users write queries (without executing):
1. **Fetch schema first**
1. **Identify relevant types** from schema
1. **Build query** following patterns
1. **Provide multiple formats**:
- Pretty (readable)
- Compact (for curl)
- Full curl command
---
## Troubleshooting
| Error | Solution |
|-------|----------|
| `401 Unauthorized` | Invalid/expired API key |
| `Field doesn't exist` | Check schema for correct field name |
| `Cannot query field on type` | Use inline fragment for interfaces |
| Parse errors | Check JSON escaping in curl |
---
## References
- [references/PATTERNS.md](references/PATTERNS.md) - Detailed GraphQL patterns
- [references/EXAMPLES.md](references/EXAMPLES.md) - Ready-to-use examples
Files in this package (3)
- SKILL.md 6 KB
- references/EXAMPLES.md 8 KB
- references/PATTERNS.md 7 KB
Versions
The database has no other skills named arize-graphql-analytics.
Database snapshot: 13.11.2026 · package version 812bea330575 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100new-query-workflow
Complete workflow for adding new GraphQL queries or mutations to the Arize Toolkit, including models, types, tests, client methods, and documentation. Use when (1) adding a new GraphQL query or mutation to arize_toolkit, (2) implementing new API functionality that requires… - 100arize-toolkit-cli
Manage Arize platform resources using the arize_toolkit CLI. Use when users want to list, create, update, or delete Arize resources (models, monitors, prompts, evaluators, custom metrics, dashboards, spaces, organizations, users, or data imports) via the command line, configure… - 100arize-dataset
Creates, manages, and queries Arize datasets and examples. Covers dataset CRUD, appending examples, exporting data, and file-based dataset creation using the ax CLI. Use when the user needs test data, evaluation examples, or mentions create dataset, list datasets, export… - 100arize-dataset
Creates, manages, and queries Arize datasets and examples. Covers dataset CRUD, appending examples, exporting data, and file-based dataset creation using the ax CLI. Use when the user needs test data, evaluation examples, or mentions create dataset, list datasets, export… - 100graphql-schema
GraphQL queries, mutations, and code generation patterns. Use when creating GraphQL operations, working with Apollo Client, or generating types. - 100graphql-schema
GraphQL queries, mutations, and code generation patterns. Use when creating GraphQL operations, working with Apollo Client, or generating types.