# How to Configure Different LLM Providers (OpenAI, Anthropic, NVIDIA) in SkillSpector

> Effortlessly configure SkillSpector with OpenAI, Anthropic, or NVIDIA LLM providers by setting the SKILLSPECTOR_PROVIDER environment variable and API key. Switch backends easily without code changes.

- Repository: [NVIDIA Corporation/SkillSpector](https://github.com/NVIDIA/SkillSpector)
- Tags: how-to-guide
- Published: 2026-06-16

---

**Set the `SKILLSPECTOR_PROVIDER` environment variable to `openai`, `anthropic`, or `nv_build`, then provide the corresponding API key (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `NVIDIA_INFERENCE_KEY`) to switch LLM backends without modifying code.**

SkillSpector abstracts LLM access behind a provider plugin system that standardizes credential resolution and model metadata. To configure different LLM providers like OpenAI, Anthropic, or NVIDIA in SkillSpector, you manipulate environment variables that drive the selection logic in [`src/skillspector/providers/__init__.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/__init__.py). This architecture allows the static analysis engine to route inference requests to any supported backend while enforcing token budgets defined in per-provider registries.

## Provider Selection Architecture

SkillSpector selects the active provider at runtime based on the **`SKILLSPECTOR_PROVIDER`** environment variable. The selection logic lives in [`src/skillspector/providers/__init__.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/__init__.py) inside the `_select_active_provider()` function, which instantiates the appropriate provider class based on the variable's value.

```python

# src/skillspector/providers/__init__.py

def _select_active_provider() -> ModelMetadataProvider:
    name = os.environ.get("SKILLSPECTOR_PROVIDER", "").strip().lower()
    if name == "openai":
        from .openai import OpenAIProvider
        return OpenAIProvider()
    if name == "anthropic":
        from .anthropic import AnthropicProvider
        return AnthropicProvider()
    if name == "nv_build":
        return NvBuildProvider()
    # fallback to nv_build when the optional nv_inference package is absent

    if name in ("nv_inference", ""):
        try:
            from .nv_inference import NvInferenceProvider
            return NvInferenceProvider()
        except ImportError:
            return NvBuildProvider()
    raise ValueError(...)

```

If **`SKILLSPECTOR_PROVIDER`** is unset or empty, SkillSpector defaults to the **NVIDIA build-time provider** (`nv_build`). The system also attempts to load the `nv_inference` provider if available, falling back to `nv_build` when the optional package is missing.

### Core Provider Interfaces

Every provider implements two standardized interfaces:

- **`CredentialsProvider`** (via `resolve_credentials`): Returns a tuple `(api_key, base_url)` or `None` if required environment variables are missing.
- **`ModelMetadataProvider`** (via `get_context_length`, `get_max_output_tokens`, `resolve_model`): Looks up model-specific limits from a bundled [`model_registry.yaml`](https://github.com/NVIDIA/SkillSpector/blob/main/model_registry.yaml) and supplies per-slot default model names.

## Configuring OpenAI

To route requests to OpenAI, set the provider identifier and API credentials. The **`OpenAIProvider`** class in [`src/skillspector/providers/openai/provider.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/openai/provider.py) resolves credentials from standard OpenAI environment variables.

```python

# src/skillspector/providers/openai/provider.py

class OpenAIProvider:
    DEFAULT_MODEL = "gpt-5.4"
    SLOT_DEFAULTS: dict[str, str] = {}

    def resolve_credentials(self) -> tuple[str, str | None] | None:
        api_key = os.environ.get("OPENAI_API_KEY", "").strip()
        if not api_key:
            return None
        base_url = os.environ.get("OPENAI_BASE_URL", "").strip() or None
        return api_key, base_url

```

**Required configuration:**

1. Set `SKILLSPECTOR_PROVIDER=openai`
2. Export `OPENAI_API_KEY` with your API key
3. Optionally set `OPENAI_BASE_URL` to override the default `https://api.openai.com/v1`

```bash
export SKILLSPECTOR_PROVIDER=openai
export OPENAI_API_KEY=sk-your-openai-key
export OPENAI_BASE_URL=https://api.openai.com/v1  # Optional

skillspector scan path/to/skill

```

## Configuring Anthropic

The **Anthropic provider** requires the `ANTHROPIC_API_KEY` environment variable and defaults to the Claude model family. Unlike OpenAI, this provider defines slot-specific defaults, routing the `meta_analyzer` slot to a different model than the default.

| Configuration | Value |
|---------------|-------|
| Default Model | `claude-opus-4-6` |
| Meta Analyzer Slot | `claude-sonnet-4-6` |
| Base URL | `https://api.anthropic.com/v1/` |

**Required configuration:**

```bash
export SKILLSPECTOR_PROVIDER=anthropic
export ANTHROPIC_API_KEY=sk-your-anthropic-key

skillspector analyze path/to/skill

```

## Configuring NVIDIA

SkillSpector defaults to the **NVIDIA build provider** (`nv_build`) when no provider is specified. This provider targets the NVIDIA inference endpoint and requires the `NVIDIA_INFERENCE_KEY` environment variable.

| Configuration | Value |
|---------------|-------|
| Default Model | `deepseek-ai/deepseek-v4-flash` |
| Meta Analyzer Slot | `deepseek-ai/deepseek-v4-pro` |
| Base URL | `https://integrate.api.nvidia.com/v1` |

**Required configuration:**

```bash
export NVIDIA_INFERENCE_KEY=sk-your-nvidia-key

# SKILLSPECTOR_PROVIDER defaults to nv_build, so it can be omitted

skillspector run path/to/skill

```

If you have the optional `nv_inference` package installed, you can explicitly set `SKILLSPECTOR_PROVIDER=nv_inference` to use that implementation instead of the build provider.

## Runtime Credential Resolution

After selection, the active provider supplies credentials to the LLM utility layer. The [`src/skillspector/llm_utils.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/llm_utils.py) module delegates credential resolution to the provider system before falling back to raw environment variables.

```python

# src/skillspector/llm_utils.py

def _resolve_llm_credentials() -> tuple[str, str | None]:
    creds = resolve_provider_credentials()   # ← from providers/__init__.py

    if creds is not None:
        return creds
    # fall back to raw OpenAI env vars

    resolved_key = os.environ.get("OPENAI_API_KEY", "").strip()
    ...

```

The resolved `(api_key, base_url)` tuple is passed to `langchain_openai.ChatOpenAI`, which SkillSpector uses for all LLM-based analyses regardless of the underlying provider.

## Advanced Model Configuration

### Overriding Default Models

Set **`SKILLSPECTOR_MODEL`** to override the provider's default model for the current session. This variable accepts either a model name that matches the default slot or a slot-specific identifier.

```bash

# Use a specific OpenAI model

export SKILLSPECTOR_PROVIDER=openai
export SKILLSPECTOR_MODEL=gpt-5.4-turbo

# Use a specific Anthropic model for meta-analysis

export SKILLSPECTOR_PROVIDER=anthropic
export SKILLSPECTOR_MODEL=claude-sonnet-4-6

```

### Custom Model Registries

Each provider references a [`model_registry.yaml`](https://github.com/NVIDIA/SkillSpector/blob/main/model_registry.yaml) file that stores **`context_length`** and **`max_output_tokens`** for supported models. To use custom model definitions or enterprise-specific token limits, point to your own registry:

```bash
export SKILLSPECTOR_MODEL_REGISTRY=/path/to/custom/models.yaml

```

The registry utilities in [`src/skillspector/providers/registry.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/registry.py) load and cache this metadata, ensuring token budgets are enforced regardless of which provider is active.

## Summary

- **Provider selection** is controlled by the `SKILLSPECTOR_PROVIDER` environment variable (`openai`, `anthropic`, `nv_build`, or `nv_inference`), with `nv_build` as the default.
- **Credential resolution** happens through provider-specific implementations of `resolve_credentials()` that read environment variables like `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `NVIDIA_INFERENCE_KEY`.
- **Model metadata** (context length and output limits) is loaded from per-provider [`model_registry.yaml`](https://github.com/NVIDIA/SkillSpector/blob/main/model_registry.yaml) files via the `ModelMetadataProvider` interface.
- **Runtime integration** occurs in [`src/skillspector/llm_utils.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/llm_utils.py), which passes resolved credentials to the LangChain client.
- **Customization** is possible via `SKILLSPECTOR_MODEL` for model overrides and `SKILLSPECTOR_MODEL_REGISTRY` for custom token budgets.

## Frequently Asked Questions

### What is the default LLM provider in SkillSpector?

When `SKILLSPECTOR_PROVIDER` is unset, SkillSpector defaults to the **NVIDIA build provider** (`nv_build`). The selection logic in [`src/skillspector/providers/__init__.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/__init__.py) attempts to import the optional `NvInferenceProvider` first, then falls back to `NvBuildProvider` if the package is unavailable.

### Can I use a custom OpenAI-compatible endpoint with SkillSpector?

Yes. When using the OpenAI provider, set the **`OPENAI_BASE_URL`** environment variable to your custom endpoint URL. The `OpenAIProvider.resolve_credentials()` method checks for this variable and passes it to the LangChain client, allowing you to use OpenAI-compatible APIs from other vendors or self-hosted inference servers.

### How do I configure different models for different analysis slots?

SkillSpector supports slot-specific model defaults through the provider's `SLOT_DEFAULTS` dictionary (e.g., `meta_analyzer` uses `claude-sonnet-4-6` in the Anthropic provider). To override these at runtime, set **`SKILLSPECTOR_MODEL`** to the desired model name. The provider's `resolve_model()` method selects the appropriate model based on the active slot and environment configuration.

### Why does SkillSpector require different environment variables for each provider?

Each provider implements the **`CredentialsProvider`** interface with its own `resolve_credentials()` method that checks for vendor-specific secrets. This design isolates authentication concerns: OpenAI checks `OPENAI_API_KEY`, Anthropic checks `ANTHROPIC_API_KEY`, and NVIDIA checks `NVIDIA_INFERENCE_KEY`. This prevents credential leakage between providers and allows you to keep multiple provider credentials in your environment simultaneously without conflict.