Skip to content
Skills Library
Data & analytics · Tool integration

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.

Licence
MIT
Last repository change
26.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
4
Deprecation

No signals detected. Repository changed on 26.05.2026, without references to retired models or APIs.

Licence

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

  1. Workflow
  2. Step 1: Check API Key
  3. Step 2: Fetch Full Schema (REQUIRED FIRST STEP)
  4. Step 3: Build Query or Mutation
  5. Step 4: Execute
  6. Step 5: Summarize Results
  7. Quick Reference: Common Patterns
  8. Query Building Mode
  9. Troubleshooting
  10. References
Original SKILL.md headings · 234 lines, 901 words
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.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.