# How to Configure LLM Providers for SkillSpector: A Complete Guide

> Configure LLM providers for SkillSpector with this comprehensive guide. Learn how to leverage environment variables or force specific providers for seamless integration.

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

---

**SkillSpector uses a pluggable provider framework that automatically selects the first available provider based on environment variables, or you can force a specific provider by setting `SKILLSPECTOR_PROVIDER` to one of five supported options.**

Managing multiple LLM backends in NVIDIA's SkillSpector requires understanding its provider interface system. The repository implements a flexible configuration mechanism that supports OpenAI, Anthropic, and NVIDIA APIs while allowing custom model registries and per-slot provider assignments.

## Understanding the LLM Provider Architecture

SkillSpector's provider system is built around three core interfaces defined in [`src/skillspector/providers/base.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/base.py). Each concrete provider implements these protocols to standardize credential management, metadata retrieval, and model instantiation.

The composite `LLMProvider` protocol unifies three specific interfaces:

- **ModelMetadataProvider**: Supplies token-budget information including `context_length` and `max_output_tokens`
- **CredentialsProvider**: Returns API keys and optional base URLs for client initialization
- **ChatModelProvider**: Constructs LangChain `BaseChatModel` instances for specific model names

All provider implementations (`OpenAIProvider`, `AnthropicProvider`, `AnthropicProxyProvider`, `NvBuildProvider`, and `NvInferenceProvider`) inherit from this protocol structure, ensuring consistent behavior across different LLM backends.

## Provider Selection Logic

SkillSpector selects providers through a cascading credential detection system in [`src/skillspector/llm_utils.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/llm_utils.py). The `get_llm_provider()` function evaluates environment variables in a hard-coded priority order.

### Automatic Provider Detection

When `SKILLSPECTOR_PROVIDER` is unset, SkillSpector scans for credentials in this sequence:

1. **OpenAI** (`OpenAIProvider`) - Requires `OPENAI_API_KEY`
2. **Anthropic** (`AnthropicProvider`) - Requires `ANTHROPIC_API_KEY`
3. **Anthropic Proxy** (`AnthropicProxyProvider`) - Uses `ANTHROPIC_API_KEY` with `ANTHROPIC_BASE_URL` for Vertex-style endpoints
4. **NVIDIA Build** (`NvBuildProvider`) - Requires `NV_BUILD_API_KEY` and `NV_BUILD_BASE_URL`
5. **NVIDIA Inference** (`NvInferenceProvider`) - Falls back to NVIDIA Build credentials

The first provider with valid credentials becomes the default.

### Explicit Provider Configuration

Override automatic selection by setting the environment variable:

```bash
export SKILLSPECTOR_PROVIDER=anthropic

```

Valid values are: `openai`, `anthropic`, `anthropic_proxy`, `nv_build`, or `nv_inference`.

## Configuring Provider Credentials

Each provider requires specific environment variables for authentication and endpoint configuration.

**OpenAI**

```bash
export OPENAI_API_KEY=sk-openai-xxxx

```

**Anthropic**

```bash
export ANTHROPIC_API_KEY=sk-anthropic-xxxx

```

**Anthropic Proxy**

```bash
export ANTHROPIC_API_KEY=sk-anthropic-xxxx
export ANTHROPIC_BASE_URL=https://your-proxy.example.com/v1

```

**NVIDIA Build**

```bash
export NV_BUILD_API_KEY=sk-nv-build-xxxx
export NV_BUILD_BASE_URL=https://api.nvidia.com/v1

```

**NVIDIA Inference**

Uses the same variables as NVIDIA Build, functioning as a fallback when Build credentials are present but `SKILLSPECTOR_PROVIDER` is not explicitly set to `nv_inference`.

## Model Selection and Overrides

Each provider defines a `DEFAULT_MODEL` constant (e.g., `OpenAIProvider.DEFAULT_MODEL`). SkillSpector resolves the final model name through a three-tier hierarchy implemented in each provider's `resolve_model()` method.

### Environment-Based Model Overrides

Set these variables to customize model selection:

- **`SKILLSPECTOR_MODEL`**: Global override affecting all analysis slots
- **`SKILLSPECTOR_SLOT_<slot_name>`**: Slot-specific override (e.g., `SKILLSPECTOR_SLOT_meta_analyzer`)
- **Provider `SLOT_DEFAULTS`**: Dictionary mapping slots to models within the provider class

### Custom Model Registry

Point to a custom YAML file containing model metadata:

```bash
export SKILLSPECTOR_MODEL_REGISTRY=/path/to/custom_models.yaml

```

The registry loader in [`src/skillspector/providers/registry.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/registry.py) reads this file to supply token-budget data to providers.

## Using Multiple Providers Simultaneously

SkillSpector's node graph supports different providers for different analysis slots. Instantiate providers directly rather than relying on `get_llm_provider()`:

```python
from skillspector.providers.openai import OpenAIProvider
from skillspector.providers.anthropic import AnthropicProvider

openai = OpenAIProvider()
anthropic = AnthropicProvider()

static_chat = openai.create_chat_model(
    model=openai.resolve_model(),
    max_tokens=512,
)

semantic_chat = anthropic.create_chat_model(
    model=anthropic.resolve_model(),
    max_tokens=1024,
)

```

## Complete Configuration Example

Configure SkillSpector to use Anthropic with custom model settings:

```python
import os
from skillspector.llm_utils import get_llm_provider, get_metadata_provider

# Force specific provider

os.environ["SKILLSPECTOR_PROVIDER"] = "anthropic"
os.environ["ANTHROPIC_API_KEY"] = "sk-anthropic-xxxx"

# Optional: custom endpoint

os.environ["ANTHROPIC_BASE_URL"] = "https://my-proxy.example.com/v1"

# Model overrides

os.environ["SKILLSPECTOR_MODEL"] = "claude-sonnet-4-6"
os.environ["SKILLSPECTOR_MODEL_REGISTRY"] = "/path/to/custom_models.yaml"

# Retrieve configured provider

provider = get_llm_provider()
metadata = get_metadata_provider()

# Create LangChain model

chat = provider.create_chat_model(
    model=provider.resolve_model(),
    max_tokens=1024,
    timeout=60,
)

```

## Summary

- SkillSpector implements a **pluggable provider framework** in [`src/skillspector/providers/base.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/base.py) with three core interfaces for metadata, credentials, and chat model creation
- **Automatic selection** scans for credentials in order: OpenAI, Anthropic, Anthropic Proxy, NVIDIA Build, then NVIDIA Inference
- Use **`SKILLSPECTOR_PROVIDER`** environment variable to force a specific provider (`openai`, `anthropic`, `anthropic_proxy`, `nv_build`, or `nv_inference`)
- Configure credentials through provider-specific environment variables (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `NV_BUILD_API_KEY`, etc.)
- Override models globally with **`SKILLSPECTOR_MODEL`** or per-slot with **`SKILLSPECTOR_SLOT_<name>`**
- Instantiate provider classes directly to use **multiple providers** in a single SkillSpector run

## Frequently Asked Questions

### How does SkillSpector choose which LLM provider to use?

SkillSpector checks for environment variables in a fixed priority order defined in [`src/skillspector/llm_utils.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/llm_utils.py). It selects the first provider that finds valid credentials: OpenAI first, then Anthropic, Anthropic Proxy, NVIDIA Build, and finally NVIDIA Inference. You can override this by setting `SKILLSPECTOR_PROVIDER` to your preferred provider name.

### Can I use different LLM providers for different analysis tasks?

Yes. While `get_llm_provider()` returns a single default provider, you can instantiate provider classes directly (e.g., `OpenAIProvider()`, `AnthropicProvider()`) and pass different instances to different nodes in your analysis graph. Each provider maintains its own credential configuration.

### What is the difference between NVIDIA Build and NVIDIA Inference providers?

Both use the same credential variables (`NV_BUILD_API_KEY` and `NV_BUILD_BASE_URL`), but `NvInferenceProvider` serves as a fallback option when you want to explicitly switch to inference-specific endpoints. Set `SKILLSPECTOR_PROVIDER=nv_inference` to use this variant instead of the default NVIDIA Build provider.

### How do I configure a custom model not in the default registry?

Set the `SKILLSPECTOR_MODEL_REGISTRY` environment variable to a YAML file path containing your custom model metadata. The registry loader in [`src/skillspector/providers/registry.py`](https://github.com/NVIDIA/SkillSpector/blob/main/src/skillspector/providers/registry.py) will parse this file to provide token-budget information and model specifications to your configured provider.