Which LLM Providers Does SkillSpector Support? A Complete Guide to OpenAI, Anthropic, and NVIDIA Build

SkillSpector supports three built-in LLM providers: OpenAI, Anthropic, and NVIDIA Build, implemented through the OpenAIProvider, AnthropicProvider, and NVBuildProvider classes that share a common interface defined in src/skillspector/providers/base.py.

SkillSpector, NVIDIA's open-source skill analysis framework, ships with native integration for three major LLM providers. Understanding which LLM providers SkillSpector supports is essential for configuring the LLM Analyzer node to process skills data using your preferred AI backend. All three providers are auto-discovered through the ProviderRegistry in src/skillspector/providers/__init__.py.

The Three Built-In LLM Providers in SkillSpector

SkillSpector includes three provider implementations located in the src/skillspector/providers/ directory. Each provider inherits from the abstract base class defined in src/skillspector/providers/base.py, ensuring consistent credential resolution, model selection, and metadata retrieval across all backends.

OpenAI Provider (OpenAIProvider)

The OpenAI provider resides in src/skillspector/providers/openai/provider.py. It reads the OPENAI_API_KEY environment variable and defaults to the gpt-5.4 model when SKILLSPECTOR_MODEL is unspecified. This provider connects to the standard OpenAI API endpoint or a custom base URL if configured.

Anthropic Provider (AnthropicProvider)

The Anthropic provider is implemented in src/skillspector/providers/anthropic/provider.py. It requires the ANTHROPIC_API_KEY environment variable and defaults to claude-3-sonnet-20240229. The class follows the same interface pattern as the OpenAI provider, enabling seamless switching between LLM backends.

NVIDIA Build Provider (NVBuildProvider)

The NVIDIA Build provider lives in src/skillspector/providers/nv_build/provider.py. It authenticates using NV_BUILD_API_KEY and connects to NVIDIA's Build (NV-ML) service. This provider is particularly useful for organizations leveraging NVIDIA's infrastructure for skill analysis workloads.

How SkillSpector Providers Work Under the Hood

The provider architecture relies on three core mechanisms that enable the LLM Analyzer node to interact with different backends uniformly.

Credential Resolution: Each provider implements resolve_credentials() to check for environment-specific API keys. If the required variable is missing—such as OPENAI_API_KEY, ANTHROPIC_API_KEY, or NV_BUILD_API_KEY—the provider returns None, causing the LLM Analyzer node to skip that backend.

Model Registry Lookup: Provider-specific model_registry.yaml files map model identifiers to their context lengths and maximum output tokens. The helper functions in src/skillspector/providers/registry.py cache this data for fast lookup during runtime.

Default Model Selection: When users do not specify a model via the SKILLSPECTOR_MODEL environment variable, providers fall back to hard-coded defaults: gpt-5.4 for OpenAI, claude-3-sonnet-20240229 for Anthropic, and appropriate NVIDIA Build equivalents.

Practical Implementation Examples

You can instantiate any provider directly to query credentials, resolve models, and retrieve token limits.

Using the OpenAI Provider

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}")

Using the Anthropic Provider

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}")

Using the NVIDIA Build Provider

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 examples follow the identical pattern: instantiate the provider, resolve credentials from the environment, and query the model registry for limits.

Summary

SkillSpector provides a unified interface for three major LLM providers:

• OpenAI: Implemented in src/skillspector/providers/openai/provider.py, uses OPENAI_API_KEY, defaults to gpt-5.4
• Anthropic: Implemented in src/skillspector/providers/anthropic/provider.py, uses ANTHROPIC_API_KEY, defaults to claude-3-sonnet-20240229
• NVIDIA Build: Implemented in src/skillspector/providers/nv_build/provider.py, uses NV_BUILD_API_KEY

All providers auto-discover via src/skillspector/providers/__init__.py and share the base interface from src/skillspector/providers/base.py.

Frequently Asked Questions

Which environment variables do I need to configure for each provider?

You must set OPENAI_API_KEY for the OpenAI provider, ANTHROPIC_API_KEY for the Anthropic provider, and NV_BUILD_API_KEY for the NVIDIA Build provider. Each provider checks these variables through its resolve_credentials() method, returning None if the credentials are missing.

Can I add custom LLM providers to SkillSpector?

Yes, you can extend the abstract base class in src/skillspector/providers/base.py to implement new providers. The ProviderRegistry in src/skillspector/providers/__init__.py automatically discovers any provider following the base interface, though you must also create a corresponding model_registry.yaml file for context limit metadata.

How does SkillSpector handle missing API credentials?

When a provider's resolve_credentials() method returns None—indicating the required environment variable is missing—the LLM Analyzer node automatically skips that backend. This graceful degradation allows the framework to continue operating with available providers only.

Where are the model context limits defined?

Context lengths and maximum output tokens are defined in each provider's model_registry.yaml file. The src/skillspector/providers/registry.py module loads and caches these YAML files, providing fast lookup for methods like get_context_length() and get_max_output_tokens().

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