What LLM Providers Does NVIDIA SkillSpector Support? A Complete Guide

NVIDIA SkillSpector supports three built-in LLM providers: OpenAI, Anthropic, and NVIDIA Build, each implementing a common interface in src/skillspector/providers/base.py for uniform credential resolution and model management.

SkillSpector is an open-source framework that ships with native integrations for major large language model APIs. Understanding which LLM providers SkillSpector supports is essential for configuring the LLM Analyzer node to evaluate and inspect AI-generated skills.

---

The Three Built-in LLM Providers in SkillSpector

The repository provides three first-party provider implementations located under src/skillspector/providers/. Each provider inherits from the abstract base class defined in src/skillspector/providers/base.py and registers itself automatically through the ProviderRegistry in src/skillspector/providers/__init__.py.

OpenAI Provider

The OpenAIProvider class in src/skillspector/providers/openai/provider.py enables integration with the OpenAI API. It reads the OPENAI_API_KEY environment variable and defaults to the gpt-5.4 model when SKILLSPECTOR_MODEL is unspecified. The provider resolves credentials via resolve_credentials() and queries model limits through get_context_length() and get_max_output_tokens().

Anthropic Provider

The AnthropicProvider class in src/skillspector/providers/anthropic/provider.py connects to Anthropic's Claude API. It expects the ANTHROPIC_API_KEY environment variable and falls back to claude-3-sonnet-20240229 as the default model. Like its OpenAI counterpart, it implements the full provider contract for credential and registry operations.

NVIDIA Build Provider

The NVBuildProvider class in src/skillspector/providers/nv_build/provider.py interfaces with the NVIDIA Build (NV-ML) service. It requires the NV_BUILD_API_KEY environment variable and provides access to NVIDIA-hosted models. This provider is particularly useful for organizations running workloads on NVIDIA infrastructure.

---

How SkillSpector LLM Providers Work

All three providers follow a standardized architecture defined in the base implementation:

• Credential resolution – Each provider reads environment-specific variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, NV_BUILD_API_KEY). If the variable is missing, resolve_credentials() returns None, causing the LLM Analyzer node to skip that backend.
• Model-registry lookup – Located in src/skillspector/providers/registry.py, the registry loader caches model_registry.yaml files that map model identifiers to context length and max output tokens metadata.
• Default model selection – When the user omits the SKILLSPECTOR_MODEL environment variable, providers fall back to hard-coded defaults specific to their respective APIs.

---

Using SkillSpector LLM Providers in Code

The following examples demonstrate how to instantiate each provider and query their capabilities directly.

OpenAI Provider Example

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

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

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 implementations follow the same pattern: instantiate the provider, retrieve credentials from the environment, and query the model registry for token limits.

---

Summary

SkillSpector provides a unified interface for three major LLM backends:

• OpenAI via OpenAIProvider in src/skillspector/providers/openai/provider.py, using OPENAI_API_KEY
• Anthropic via AnthropicProvider in src/skillspector/providers/anthropic/provider.py, using ANTHROPIC_API_KEY
• NVIDIA Build via NVBuildProvider in src/skillspector/providers/nv_build/provider.py, using NV_BUILD_API_KEY

Each provider implements resolve_credentials(), resolve_model(), and registry lookup methods defined in the base class, enabling the LLM Analyzer node to switch between backends without code changes.

---

Frequently Asked Questions

How does SkillSpector handle missing API keys?

If the required environment variable (such as OPENAI_API_KEY or ANTHROPIC_API_KEY) is not set, the provider's resolve_credentials() method returns None. The LLM Analyzer node detects this and automatically skips that backend, allowing the framework to continue with other available providers.

Can I use a custom base URL or endpoint with these providers?

Yes. Each provider's resolve_credentials() method returns a tuple containing both the API key and an optional base URL. If you specify a custom endpoint in your environment configuration, the provider passes it to the underlying client; otherwise, it defaults to the standard API endpoint for that service.

Where does SkillSpector store model configuration data?

Model metadata—including context lengths and maximum output tokens—is stored in model_registry.yaml files within each provider's directory. The helper functions in src/skillspector/providers/registry.py load and cache this data at runtime for fast lookup by get_context_length() and get_max_output_tokens().

Is it possible to add custom LLM providers to SkillSpector?

Yes. You can create a new provider by subclassing the abstract base class in src/skillspector/providers/base.py and implementing the required methods: resolve_credentials(), resolve_model(), get_context_length(), and get_max_output_tokens(). Register your provider in src/skillspector/providers/__init__.py to make it discoverable by the ProviderRegistry.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}