Retrieval & RAG

Production models for RAG pipelines

Built for the synthesis step your retrieval feeds into, and priced forrunning on every query. Same SDK, one line of configuration.

Start with $25 in free credit. No card required.

Get your API key
Drop‑in for
Anthropic SDK
OpenAI SDK
Git Hub Copliot
Claude Code CLI
LangGraph
Vercel AI SDK
LlamaIndex
VS Code
Lite LLM
Anthropic SDK
OpenAI SDK
Git Hub Copliot
Claude Code CLI
LangGraph
Vercel AI SDK
LlamaIndex
VS Code
Lite LLM
Our Models

Our top‑tier models across everystage of your RAG pipeline

Clarke matches retrieval and chat without frontier pricing. Route harder synthesis to Hal, and extraction to Tycho.

Coding
Agents
Tool Calling

Hal 1.0

Maximum Capability

Comparable to Anthropic
Opus 5.5 or OpenAI GPT-6 Astra

Retrieval
RAG
Chat

Clarke 1.0

Balanced Performance

Comparable to Anthropic
Sonnet 5.5 or OpenAI GPT-6 Sol

Classification
Extraction

Tycho 1.0

High-Efficiency Scale

Comparable to Anthropic Haiku
5.5 or OpenAI GPT-6 Luna

Designed for the work you already run these models for.

Tycho 1.0

Ingest & chunk

Structure and label documents before indexing

Keep As-is

Embed & index

Split, vectorise and store.

Keep As-is

Retrieve

Match the query to the nearest chunks

Clarke 1.0

Generate

Read the chunks, write the answer

Model Comparison

Scored against frontier models on real product tasks

Radium Hal 1.0
50
77
 / 
80
 correct
Anthropic Opus 5.5
50
75
 / 
80
 correct
Tasks in category
Runs per task
Scored by
80
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
15
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
17
 / 
20
 correct
Anthropic Opus 5.5
50
20
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
15
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
20
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema

Independent Radium benchmark, not endorsed by Anthropic. Claude and Opus are Anthropic PBC trademarks, used for identification only. Results are a single run, provided “as is,” and not a guarantee of future performance. See the full benchmark report

The number that matters

Control the cost per completed task

Every new account gets $25 in credit. No card required.

Get your API key
Dense cluster of white dots scattered against a dark background, resembling stars or particles.
RAG specs

Built for long-context retrieval and structured answers

The numbers that matter when your chunks are measured in thousands of tokens.

Context window

128k

Stuffs 50+ retrieved chunks without truncation. System prompt + retrieved context + user query all in one call.

TTFT at 32k

<120ms

Time-to-first-token for a typical RAG call: system prompt + 30 retrieved chunks + user query. Not a warm-cache best case.

Max output tokens

4k

Room for a full answer with inline citations and a summary paragraph. Streaming delivers tokens as they are generated.

What changes

Two lines of configuration

Point your client at Radium and name a model. The SDK, the loop, the tools, and the evals carry on as they are.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.radium.cloud/v1",
)

response = client.chat.completions.create(
    model="hal-1.0",
    messages=[
        {"role": "user", "content": "Hello, Radium!"}
    ],
)

print(response.choices[0].message.content)
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.radium.cloud/v1",
});

const response: OpenAI.Chat.ChatCompletion =
  await client.chat.completions.create({
    model: "hal-1.0",
    messages: [{ role: "user", content: "Hello, Radium!" }],
  });

console.log(response.choices[0].message.content);
curl https://api.radium.cloud/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "hal-1.0",
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'
package main

import (
	"context"
	"fmt"

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	cfg := openai.DefaultConfig("YOUR_API_KEY")
	cfg.BaseURL = "https://api.radium.cloud/v1"
	client := openai.NewClientWithConfig(cfg)

	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: "hal-1.0",
			Messages: []openai.ChatCompletionMessage{
				{Role: openai.ChatMessageRoleUser, Content: "Hello, Radium!"},
			},
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.Choices[0].Message.Content)
}
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey("YOUR_API_KEY")
    .baseUrl("https://api.radium.cloud/v1")
    .build();

ChatCompletion completion = client.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("hal-1.0")
        .addUserMessage("Hello, Radium!")
        .build());

System.out.println(
    completion.choices().get(0).message().content().orElseThrow());
using OpenAI;
using OpenAI.Chat;

var client = new OpenAIClient(
    new ApiKeyCredential("YOUR_API_KEY"),
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.radium.cloud/v1"),
    });

var chatClient = client.GetChatClient("hal-1.0");
var response = await chatClient.CompleteChatAsync(
    new UserChatMessage("Hello, Radium!"));

Console.WriteLine(response.Value.Content[0].Text);
import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.radium.cloud",
)

message = client.messages.create(
    model="hal-1.0",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Radium!"}
    ],
)

print(message.content[0].text)
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.radium.cloud",
});

const message: Anthropic.Message = await client.messages.create({
  model: "hal-1.0",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Radium!" }],
});

console.log(message.content[0].text);
curl https://api.radium.cloud/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "hal-1.0",
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'

What changes

The base URL in your client

The model string

The invoice

What stays the same

The agent loop

The Anthropic or OpenAI SDK

Tool and function calls

Parallel tool calls

Streaming, including tool deltas

Structured output

Retry and error handling

Evals, tracing and observability

Cost

What the difference looks like monthly

Same tasks, different rate, two bills to compare.

Monthly spend on frontier RAG generation traffic
Share moved
Estimated monthly savings
$0
0% lower
than current bill

Hal 1.0 against Claude Opus 5.5 list pricing, using real per-task token averages from the production benchmark. See the working

Pricing Breakdown

Six cost layers sit inside a frontier token. Two sit inside ours

The same arithmetic holds whether the call comes from an agent loop or a retrieval chain.

Frontier Token
Radium Token

The switch is one line, and so is the way back

Get your API key
Cost
Does Radium replace our vector database?

No. Retrieval, your index and your reranker stay exactly where they are. Radium sits downstream of retrieval and answers the query once the context is assembled.

What about embeddings? Do those move too?

Not on day one. Embeddings keep running through whatever provider generates them today. Only the generation call, the model that reads the retrieved chunks and writes the answer, points at Radium.

Will answer quality change if we swap the generation model?

That's the right question, which is why we publish model comparisons instead of asking you to trust a claim. Clarke is scored against the frontier tier it replaces on the same production tasks. Run your own retrieval eval against both endpoints before you decide.

Do citations and structured output still work?

Yes. Tool calling, structured outputs and JSON schema behave the same way, because the API is compatible rather than similar. If your chain asks the model to return sources alongside an answer, that shape doesn't change.

How does it handle large retrieved context windows?

Context window and maximum output are published in the model reference. A call that stuffs ten or twenty retrieved chunks into the prompt is a normal request, not an edge case.

Does prompt caching help, since our system prompt repeats every query?

It should help more here than almost anywhere else. A RAG system prompt and its instructions repeat on every call; only the retrieved chunks change. Prompt caching is supported and priced separately from the rest of the input.

Which model should the generation step use?

Clarke for most retrieval and chat traffic. Route to Hal when a query needs multi-hop reasoning across several retrieved documents, and to Tycho for the classification and extraction steps upstream in ingestion.

What are the concurrency limits when an agent fans out?

Published, and above what most agent traffic needs. Agents burst rather than trickle, so if your ceiling is the problem we raise it rather than throttle you, because we own the capacity.

How do we test this without touching production traffic?

Point a staging chain at the endpoint and run the queries you already run. Compare cost per answered query on both endpoints before anything user-facing changes.

Can we switch back?

Remove one environment variable. Nothing upstream of the generation call, your retriever, your index, or your chunking, ever pointed anywhere else.