# Which LLM Providers Are Supported by SkillSpector? OpenAI, Anthropic, and NVIDIA Build

> SkillSpector integrates with major LLM providers including OpenAI, Anthropic, and NVIDIA Build. Discover seamless credential resolution and uniform model access. Explore supported LLMs now.

- Repository: [NVIDIA Corporation/SkillSpector](https://github.com/NVIDIA/SkillSpector)
- Tags: getting-started
- Published: 2026-06-14

---

**SkillSpector supports three built-in LLM providers—OpenAI, Anthropic, and NVIDIA Build—each implementing a common interface defined in [`src/skillspector/providers/base.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/base.py) to enable uniform credential resolution and model registry access for the LLM Analyzer node.**

NVIDIA SkillSpector is an open-source framework for automated skill analysis that integrates with multiple LLM backends through a pluggable provider architecture. Understanding which LLM providers are supported by SkillSpector helps developers configure the LLM Analyzer node for evaluating code against specific criteria. The framework currently ships with production-ready implementations for OpenAI, Anthropic, and NVIDIA Build services.

## Built-In SkillSpector LLM Providers

### OpenAI Provider

The **OpenAI Provider** is implemented in [`src/skillspector/providers/openai/provider.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/openai/provider.py) via the `OpenAIProvider` class. This provider connects to the OpenAI API using credentials from the `OPENAI_API_KEY` environment variable and defaults to the `gpt-5.4` model when `SKILLSPECTOR_MODEL` is unspecified.

### Anthropic Provider

The **Anthropic Provider** resides in [`src/skillspector/providers/anthropic/provider.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/anthropic/provider.py) as the `AnthropicProvider` class. It queries the Anthropic API using `ANTHROPIC_API_KEY` and defaults to `claude-3-sonnet-20240229` for analysis tasks.

### NVIDIA Build Provider

The **NVIDIA Build Provider** is defined in [`src/skillspector/providers/nv_build/provider.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/nv_build/provider.py) through the `NVBuildProvider` class. This provider interfaces with NVIDIA's Build (NV-ML) service, reading credentials from `NV_BUILD_API_KEY` to enable on-premise or cloud-hosted NVIDIA model inference.

## How SkillSpector Discovers and Manages Providers

All providers implement the abstract base class defined in [`src/skillspector/providers/base.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/base.py), ensuring consistent methods for `resolve_credentials()`, `resolve_model()`, `get_context_length()`, and `get_max_output_tokens()`. The `ProviderRegistry` in [`src/skillspector/providers/__init__.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/__init__.py) automatically discovers and registers these three providers at runtime, making them available to the LLM Analyzer node without manual configuration.

## Credential Resolution and Model Registry

Each provider follows a standardized credential resolution pattern. They read environment variables—`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `NV_BUILD_API_KEY`—and return `None` if credentials are missing, causing the LLM Analyzer to skip that backend. For model metadata, each provider ships a [`model_registry.yaml`](https://github.com/NVIDIA/SkillSpector/blob/main/model_registry.yaml) file mapping model identifiers to context lengths and output token limits. The helper functions in [`src/skillspector/providers/registry.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/registry.py) cache this data for fast lookup during analysis runs.

If the user does not specify a model via the `SKILLSPECTOR_MODEL` environment variable, the provider falls back to hard-coded defaults specific to each service.

## Code Examples: Using SkillSpector LLM Providers

The following examples demonstrate how to instantiate each provider and query their configuration:

### OpenAI Provider Example

```python
from skillspector.providers.openai.provider import OpenAIProvider

openai = OpenAIProvider()

# Resolve API key and optional custom endpoint

creds = openai.resolve_credentials()
if creds:
    api_key, base_url = creds
    print("OpenAI key:", api_key[:4] + "…" )
    print("Base URL:", base_url or "default (api.openai.com)")

# Get model information

model = openai.resolve_model()
ctx_len = openai.get_context_length(model)
max_out = openai.get_max_output_tokens(model)

print(f"Using model {model}: context={ctx_len}, max_output={max_out}")

```

### Anthropic Provider Example

```python
from skillspector.providers.anthropic.provider import AnthropicProvider

anthropic = AnthropicProvider()

creds = anthropic.resolve_credentials()
if creds:
    api_key, base_url = creds
    print("Anthropic key:", api_key[:4] + "…")
    print("Base URL:", base_url or "default (api.anthropic.com)")

model = anthropic.resolve_model()
ctx_len = anthropic.get_context_length(model)
max_out = anthropic.get_max_output_tokens(model)

print(f"Anthropic model {model}: context={ctx_len}, max_output={max_out}")

```

### NVIDIA Build Provider Example

```python
from skillspector.providers.nv_build.provider import NVBuildProvider

nv = NVBuildProvider()

creds = nv.resolve_credentials()
if creds:
    api_key, base_url = creds
    print("NV Build key:", api_key[:4] + "…")
    print("Endpoint:", base_url)

model = nv.resolve_model()
ctx_len = nv.get_context_length(model)
max_out = nv.get_max_output_tokens(model)

print(f"NV Build model {model}: context={ctx_len}, max_output={max_out}")

```

All three snippets follow the same pattern: instantiate the provider, pull credentials from the environment, and query the model registry for token limits.

## Summary

- **SkillSpector supports three LLM providers**: OpenAI, Anthropic, and NVIDIA Build, each implemented in `src/skillspector/providers/<name>/provider.py`.
- **Automatic discovery**: The `ProviderRegistry` in [`src/skillspector/providers/__init__.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/__init__.py) registers providers automatically for the LLM Analyzer node.
- **Unified interface**: All providers inherit from the base class in [`src/skillspector/providers/base.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/base.py) and implement `resolve_credentials()`, `resolve_model()`, and registry lookup methods.
- **Environment-based configuration**: API keys are read from `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, and `NV_BUILD_API_KEY` respectively.

## Frequently Asked Questions

### How do I configure API keys for SkillSpector LLM providers?

SkillSpector reads API credentials from environment variables specific to each backend: set `OPENAI_API_KEY` for OpenAI, `ANTHROPIC_API_KEY` for Anthropic, and `NV_BUILD_API_KEY` for NVIDIA Build. If a required variable is missing, the provider returns `None` and the LLM Analyzer skips that backend.

### What are the default models for each SkillSpector LLM provider?

When `SKILLSPECTOR_MODEL` is not specified, OpenAI defaults to `gpt-5.4`, Anthropic defaults to `claude-3-sonnet-20240229`, and NVIDIA Build uses its internal default as defined in the provider's [`model_registry.yaml`](https://github.com/NVIDIA/SkillSpector/blob/main/model_registry.yaml) file.

### How does SkillSpector discover available LLM providers?

The framework automatically discovers providers through the `ProviderRegistry` class defined in [`src/skillspector/providers/__init__.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/__init__.py), which imports and registers `OpenAIProvider`, `AnthropicProvider`, and `NVBuildProvider` at runtime.

### Can I use custom base URLs or endpoints with SkillSpector providers?

Yes, the `resolve_credentials()` method returns an optional `base_url` parameter alongside the API key, allowing you to override the default endpoint for OpenAI, Anthropic, or NVIDIA Build services through the credentials tuple.