> ## Documentation Index
> Fetch the complete documentation index at: https://radarhq.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Any model

> Run self-managed AI investigations on any model behind an OpenAI-compatible API: OpenAI, Azure OpenAI, open models on Amazon Bedrock, Gemini, a company gateway, or vLLM and Ollama in your cluster.

Self-managed Radar lets you choose which model runs [AI investigations](https://radarhq.io/docs/features/diagnose.md). Claude models run on the Claude Agent SDK, configured through the Anthropic, Amazon Bedrock, or Google Vertex providers. Any other model - GPT on OpenAI or Azure, open models on Amazon Bedrock (Kimi, DeepSeek, gpt-oss, Qwen), Gemini, a company AI gateway, or a model server you run yourself (vLLM, Ollama) - runs on the Vercel AI SDK, configured through `hub.agent.provider: openai-compatible`. You pick one endpoint and one model for the whole hub.

When investigations are enabled, the chart defaults to the Anthropic provider with `claude-sonnet-4-6`; a self-managed deployment can point at another supported model instead. The OpenAI-compatible path is for self-managed control planes only and needs Radar Hub 1.15.0 or later. The values for every provider are in [AI investigations](https://radarhq.io/docs/cloud/self-hosted/ai-agent.md#provider-values); this page covers how to point the hub at each OpenAI-compatible endpoint and how running another model differs from Claude.

## Choosing a model

Pick a model your organization already allows and pays for, in a region and under data terms you accept. For investigations it also needs to be good at **tool calling** and to carry **enough context** to hold a growing conversation: a turn drives the model through many tool calls and resends the whole conversation on every step. The [endpoint examples](#endpoint-examples) below name models we have run successfully; run a few representative investigations before you adopt one.

Claude models and other models share the same tools, prompts, and evidence linking, but they run on different engines (the Claude Agent SDK and the Vercel AI SDK), and the behavior differs in a few ways worth knowing:

* **Notification lines.** An alert analysis ends with a one-line cause and fix that the hub sends to Slack, email, and phones. Non-Claude models often leave these out. The analysis itself still posts.
* **Evidence links.** Some models cite Radar's "not found" reply as their proof (for example, the Secret that doesn't exist). Radar links only reads that returned data, so that evidence shows without a link even when the answer is right.
* **No spend figure.** Claude reports what each investigation cost; other models don't. A self-managed control plane doesn't meter or limit investigations either way: the model account is yours, and its spend shows in your provider's billing.

The provider you set picks the engine; there is no separate choice. For how an investigation runs and what reaches the model, see [AI investigations](https://radarhq.io/docs/cloud/self-hosted/ai-agent.md#how-it-runs).

## Endpoint examples

The base URL is the API root **including its version path**. The hub adds `/chat/completions` or `/responses` itself.

| Endpoint | `baseUrl` | `model` | Key and `authHeader` | Notes |
| - | - | - | - | - |
| OpenAI | `https://api.openai.com/v1` | `gpt-5.5` | OpenAI API key, `bearer` | GPT-5.x needs `api: responses`: on chat it refuses the `max_tokens` field the hub sends. GPT-4.1 works on `chat`. GPT-4o needs `maxOutputTokens: 16384`. |
| Azure OpenAI | `https://<resource>.openai.azure.com/openai/v1` | your deployment name | Azure key, `api-key` | The v1 API needs no `api-version`. |
| Amazon Bedrock | `https://bedrock-mantle.<region>.api.aws/v1` | `moonshotai.kimi-k2.5`, `deepseek.v3.2`, `openai.gpt-oss-120b` | Bedrock API key, `bearer` | gpt-oss also works on `responses`. The model must be enabled for the account. |
| Google Gemini | `https://generativelanguage.googleapis.com/v1beta/openai` | `gemini-flash-latest` | Gemini API key, `bearer` | Chat only. |
| Company gateway (LiteLLM proxy and similar) | the gateway's OpenAI route, for example `https://ai-gw.internal/v1` | the gateway's model name | the gateway key, `bearer` | The hub sends only the key header: gateways that route on extra headers or query parameters won't work. |
| vLLM | `http://vllm.models.svc:8000/v1` | the served model name | none, or the `--api-key` you set | Start vLLM with tool calling enabled (`--enable-auto-tool-choice` and a `--tool-call-parser` for the model). Needs the egress rule below. |
| Ollama | `http://ollama.models.svc:11434/v1` | for example `qwen3:32b` | none | Raise the context length (`OLLAMA_CONTEXT_LENGTH=65536`); the default is too small for investigations. Needs the egress rule below. |

For Claude through a company gateway, keep `provider: anthropic` and set `hub.agent.anthropic.baseUrl` instead, so Claude stays on the Claude engine.

### Example values

```yaml theme={null}
hub:
  agent:
    enabled: true
    provider: openai-compatible
    openaiCompatible:
      baseUrl: https://bedrock-mantle.us-east-1.api.aws/v1
      model: moonshotai.kimi-k2.5
      api: chat              # or responses
      authHeader: bearer     # or api-key (Azure)
      reasoningEffort: ""    # low | medium | high, for models that reason
      maxOutputTokens: null  # lower it for models that allow fewer than 32,000 output tokens
```

Pass the key with `--set-file hub.agent.credentials.apiKey=./model.key`, or put it in [your own Secret](https://radarhq.io/docs/cloud/self-hosted/ai-agent.md#using-your-own-secret) under `HUB_AGENT_OPENAI_COMPAT_API_KEY`. Leave it empty for a model server that takes no key.

### Chat Completions or Responses

Use `chat` unless you have a reason not to: every compatible server speaks it.

Use `responses` for OpenAI reasoning models (GPT-5.x, o-series, gpt-oss) on endpoints that serve OpenAI's Responses API. Nothing is stored at the provider: each step resends the conversation, with the model's reasoning in the encrypted form OpenAI returns. A model that doesn't reason may reject that request on `responses`, so use `chat` for those.

Set `reasoningEffort` only for models that reason. On `responses` it also tells the client to treat the model as a reasoning model, which matters for model ids it doesn't recognize, such as `openai.gpt-oss-120b` or an Azure deployment name.

### Reply length

Each model reply may be up to 32,000 tokens long. A model with a lower output limit (GPT-4o allows 16,384; many vLLM deployments allow less) refuses every request with a "max tokens" error. Set `maxOutputTokens` to the model's limit.

## Network egress

Investigation pods may reach only DNS, port 443, the hub, and Postgres. An endpoint on port 443 needs nothing extra. One on another port (vLLM on 8000, Ollama on 11434, a gateway on 4000) needs an egress rule, for example:

```yaml theme={null}
hub:
  agent:
    sandbox:
      networkPolicy:
        extraEgress:
          - to:
              - namespaceSelector:
                  matchLabels:
                    kubernetes.io/metadata.name: models
            ports:
              - { protocol: TCP, port: 11434 }
```

Plain `http` is accepted for in-cluster servers, since they commonly have no TLS. The key, if any, then crosses the cluster network unencrypted.

## Not supported

* Images, files, and audio in investigations.
* The provider's own tools: web search, file search, code interpreter, remote MCP servers, computer use.
* Provider-stored state: stored conversations, prompts, earlier responses, background jobs.
* More than one model per hub, or a model per organization.
* Endpoints that need custom request headers or query parameters, or a key in the URL.
* Shortening a long conversation. The whole conversation is sent on every step, so a model with a small context window can fail on a long investigation or a later follow-up.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.