Providers

altimate supports 35+ LLM providers. Configure them in the provider section of your config file.

Provider Configuration

Each provider has a key in the provider object:

{
  "provider": {
    "<provider-name>": {
      "apiKey": "{env:API_KEY}",
      "baseURL": "https://custom.endpoint.com/v1",
      "headers": {
        "X-Custom-Header": "value"
      }
    }
  }
}

Tip

Use {env:...} substitution for API keys so you never commit secrets to version control.

Altimate LLM Gateway

Managed LLM access with dynamic routing across Sonnet 4.6, Opus 4.6, GPT-5.4, GPT-5.3, and more. No API keys to manage — 10M tokens free to get started.

{
  "provider": {
    "altimate": {}
  },
  "model": "altimate/auto"
}

For pricing, security, and data handling details, see the Altimate LLM Gateway guide.

Automatic model selection

When Altimate credentials are configured and no model is explicitly chosen, the Altimate LLM Gateway is selected automatically. You can override this by setting model in your config or by restricting the provider section to specific providers only.

Anthropic

{
  "provider": {
    "anthropic": {
      "apiKey": "{env:ANTHROPIC_API_KEY}"
    }
  },
  "model": "anthropic/claude-sonnet-4-6"
}

Available models: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5-20251001

OpenAI

{
  "provider": {
    "openai": {
      "apiKey": "{env:OPENAI_API_KEY}"
    }
  },
  "model": "openai/gpt-4o"
}

Amazon Bedrock

{
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1"
      }
    }
  },
  "model": "amazon-bedrock/anthropic.claude-sonnet-4-6-v1"
}

Uses the standard AWS credential chain: environment variables (AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY), named profiles (AWS_PROFILE), SSO sessions, IAM roles, and container credentials.

Note

If you have AWS SSO, IAM roles, or environment credentials (AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY) configured, Bedrock will use your default credential chain automatically.

Custom Endpoints (API Gateways)

If your organization routes Bedrock traffic through a custom API gateway or proxy, set the baseURL in the provider options:

{
  "provider": {
    "amazon-bedrock": {
      "options": {
        "baseURL": "https://your-gateway.example.com/v1",
        "region": "us-east-1"
      }
    }
  },
  "model": "amazon-bedrock/anthropic.claude-sonnet-4-6-v1"
}

For a complete walkthrough — including bearer token authentication, cross-region model IDs, and troubleshooting — see the Amazon Bedrock Custom Endpoints guide.

Azure OpenAI

{
  "provider": {
    "azure": {
      "apiKey": "{env:AZURE_OPENAI_API_KEY}",
      "baseURL": "https://your-resource.openai.azure.com/openai/deployments/your-deployment"
    }
  },
  "model": "azure/gpt-4o"
}

Google (Gemini)

{
  "provider": {
    "google": {
      "apiKey": "{env:GOOGLE_API_KEY}"
    }
  },
  "model": "google/gemini-2.5-pro"
}

Google Vertex AI

{
  "provider": {
    "google-vertex": {
      "project": "my-gcp-project",
      "location": "us-central1"
    }
  },
  "model": "google-vertex/gemini-2.5-pro"
}

Uses Google Cloud Application Default Credentials. Authenticate with:

gcloud auth application-default login

The project and location fields can also be set via environment variables:

Field	Environment Variables (checked in order)
`project`	`GOOGLE_CLOUD_PROJECT`, `GCP_PROJECT`, `GCLOUD_PROJECT`
`location`	`GOOGLE_VERTEX_LOCATION`, `GOOGLE_CLOUD_LOCATION`, `VERTEX_LOCATION`

If location is not set, it defaults to us-central1.

Tip

You can also access Anthropic models through Vertex AI using the google-vertex provider (e.g., google-vertex/claude-sonnet-4-6).

Ollama (Local)

{
  "provider": {
    "ollama": {
      "baseURL": "http://localhost:11434"
    }
  },
  "model": "ollama/llama3.1"
}

No API key needed. Runs entirely on your local machine.

Info

Make sure Ollama is running before starting altimate. Install it from ollama.com and pull your desired model with ollama pull llama3.1.

LM Studio (Local)

Run local models through LM Studio's OpenAI-compatible server:

{
  "provider": {
    "lmstudio": {
      "name": "LM Studio",
      "npm": "@ai-sdk/openai-compatible",
      "env": ["LMSTUDIO_API_KEY"],
      "options": {
        "apiKey": "lm-studio",
        "baseURL": "http://localhost:1234/v1"
      },
      "models": {
        "qwen2.5-7b-instruct": {
          "name": "Qwen 2.5 7B Instruct",
          "tool_call": true,
          "limit": { "context": 131072, "output": 8192 }
        }
      }
    }
  },
  "model": "lmstudio/qwen2.5-7b-instruct"
}

Setup:

Open LM Studio → Developer tab → Start Server (default port: 1234)
Load a model in LM Studio
Find your model ID: curl http://localhost:1234/v1/models
Add the model ID to the models section in your config
Use it: altimate-code run -m lmstudio/<model-id>

Tip

The model key in your config must match the model ID returned by LM Studio's /v1/models endpoint. If you change models in LM Studio, update the config to match.

Note

If you changed LM Studio's default port, update the baseURL accordingly. No real API key is needed — the "lm-studio" placeholder satisfies the SDK requirement.

OpenRouter

{
  "provider": {
    "openrouter": {
      "apiKey": "{env:OPENROUTER_API_KEY}"
    }
  },
  "model": "openrouter/anthropic/claude-sonnet-4-6"
}

Access 150+ models through a single API key.

Copilot

{
  "provider": {
    "copilot": {}
  },
  "model": "copilot/gpt-4o"
}

Uses your GitHub Copilot subscription. Authenticate with altimate auth.

Codespaces & GitHub Actions

In GitHub Codespaces and GitHub Actions, the machine-scoped GITHUB_TOKEN lacks models:read permission and cannot be used for GitHub Copilot or GitHub Models inference. altimate automatically skips these providers in machine environments. To use them, authenticate explicitly with altimate auth or set a personal access token with models:read scope as a Codespace secret.

Snowflake Cortex

{
  "provider": {
    "snowflake-cortex": {}
  },
  "model": "snowflake-cortex/claude-sonnet-4-6"
}

Authenticate with altimate auth snowflake-cortex using a Programmatic Access Token (PAT). Enter credentials as account-identifier::pat-token.

Create a PAT in Snowsight: Admin > Security > Programmatic Access Tokens.

Billing flows through your Snowflake credits — no per-token costs.

Available models:

Model	Tool Calling
`claude-sonnet-4-6`, `claude-opus-4-6`, `claude-sonnet-4-5`, `claude-opus-4-5`, `claude-haiku-4-5`, `claude-4-sonnet`, `claude-3-7-sonnet`, `claude-3-5-sonnet`	Yes
`openai-gpt-4.1`, `openai-gpt-5`, `openai-gpt-5-mini`, `openai-gpt-5-nano`, `openai-gpt-5-chat`	Yes
`llama4-maverick`, `snowflake-llama-3.3-70b`, `llama3.1-70b`, `llama3.1-405b`, `llama3.1-8b`	No
`mistral-large`, `mistral-large2`, `mistral-7b`	No
`deepseek-r1`	No

Note

Model availability depends on your Snowflake region. Enable cross-region inference with ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'ANY_REGION' for full model access.

Databricks AI Gateway

Connect to Databricks serving endpoints (Foundation Model APIs) via your workspace PAT. Use Databricks-hosted Llama, Claude, GPT, Gemini, DBRX, or Mixtral for agent reasoning — billing flows through your Databricks account.

{
  "provider": {
    "databricks": {}
  },
  "model": "databricks/databricks-claude-sonnet-4-6"
}

Authenticate with altimate auth databricks and enter credentials as workspace-host::pat-token:

myworkspace.cloud.databricks.com::dapi1234567890abcdef

Or set environment variables:

export DATABRICKS_HOST=myworkspace.cloud.databricks.com
export DATABRICKS_TOKEN=dapi1234567890abcdef

Create a PAT in Databricks: Settings → Developer → Access Tokens → Generate New Token.

Supported workspace domains: *.cloud.databricks.com (AWS), *.azuredatabricks.net (Azure), *.gcp.databricks.com (GCP).

Available models:

Provider	Models
Meta Llama	`databricks-meta-llama-3-1-405b-instruct`, `databricks-meta-llama-3-1-70b-instruct`, `databricks-meta-llama-3-1-8b-instruct`
Anthropic via Databricks	`databricks-claude-sonnet-4-6`, `databricks-claude-opus-4-6`
OpenAI via Databricks	`databricks-gpt-5-4`, `databricks-gpt-5-mini`
Google via Databricks	`databricks-gemini-3-1-pro`
Databricks native	`databricks-dbrx-instruct`
Mistral (tool calls unsupported)	`databricks-mixtral-8x7b-instruct`

Note

Databricks bills directly for these models — altimate-code reports $0 cost for Databricks-routed requests since pricing depends on your Databricks contract.

Custom / OpenAI-Compatible

Any OpenAI-compatible endpoint can be used as a provider:

{
  "provider": {
    "my-provider": {
      "api": "openai",
      "baseURL": "https://my-llm-proxy.example.com/v1",
      "apiKey": "{env:MY_API_KEY}"
    }
  },
  "model": "my-provider/my-model"
}

Tip

This works with any service that exposes an OpenAI-compatible chat completions API, including vLLM, LiteLLM, and self-hosted inference servers.

Model Selection

Set your default model and a smaller model for lightweight tasks:

{
  "model": "anthropic/claude-sonnet-4-6",
  "small_model": "anthropic/claude-haiku-4-5-20251001"
}

The small_model is used for lightweight tasks like summarization and context compaction.

Provider Options Reference

Field	Type	Description
`apiKey`	`string`	API key (supports `{env:...}` and `{file:...}`)
`baseURL`	`string`	Custom API endpoint URL
`api`	`string`	API type (e.g., `"openai"` for compatible endpoints)
`headers`	`object`	Custom HTTP headers to include with requests
`options.region`	`string`	AWS region (Amazon Bedrock only, default: `us-east-1`)
`options.profile`	`string`	AWS named profile (Amazon Bedrock only)
`options.baseURL`	`string`	Custom endpoint URL for Bedrock gateway/proxy (Amazon Bedrock only)
`project`	`string`	GCP project ID (Google Vertex AI only)
`location`	`string`	GCP region (Google Vertex AI only, default: `us-central1`)