Pick your stack. Copy. Ship.

# pip install anthropic
import anthropic

client = anthropic.Anthropic(
    api_key="sk-anvat-...",            # your Anvat key
    base_url="https://api.anvat.app",  # the one change
)

res = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Explain MoE routing in one paragraph."}],
)
print(res.content[0].text)

import anthropic

client = anthropic.Anthropic(
    api_key="sk-anvat-...",
    base_url="https://api.anvat.app",
)

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a haiku about Postgres."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

# pip install openai
from openai import OpenAI

client = OpenAI(
    api_key="sk-anvat-...",
    base_url="https://api.anvat.app/v1",
)

res = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Two sentences on Rust traits."}],
)
print(res.choices[0].message.content)

from openai import OpenAI

client = OpenAI(
    api_key="sk-anvat-...",
    base_url="https://api.anvat.app/v1",
)

stream = client.chat.completions.create(
    model="claude-haiku-4-5",   # any Anvat-catalog model works here
    messages=[{"role": "user", "content": "Quick brainstorm of cache eviction strategies?"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content or ""
    print(delta, end="", flush=True)

// npm i ai @ai-sdk/openai
import { createOpenAI } from "@ai-sdk/openai";
import { streamText } from "ai";

const anvat = createOpenAI({
  baseURL: "https://api.anvat.app/v1",
  apiKey: process.env.ANVAT_API_KEY!,
});

const { textStream } = await streamText({
  model: anvat("claude-sonnet-4-6"),
  prompt: "Outline a 3-step database migration plan.",
});

for await (const part of textStream) {
  process.stdout.write(part);
}

// npm i @anthropic-ai/sdk
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.ANVAT_API_KEY!,
  baseURL: "https://api.anvat.app",
});

const res = await client.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  tools: [
    {
      name: "get_weather",
      description: "Get current weather for a city.",
      input_schema: {
        type: "object",
        properties: { city: { type: "string" } },
        required: ["city"],
      },
    },
  ],
  messages: [{ role: "user", content: "What's the weather in Hanoi?" }],
});

console.log(res.content);

// npm i langchain @langchain/openai
import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "deepseek-v4-pro",
  apiKey: process.env.ANVAT_API_KEY,
  configuration: { baseURL: "https://api.anvat.app/v1" },
});

const res = await llm.invoke("Classify this ticket: 'My credit card was declined twice.'");
console.log(res.content);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

type message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}
type req struct {
	Model     string    `json:"model"`
	MaxTokens int       `json:"max_tokens"`
	Messages  []message `json:"messages"`
}

func main() {
	body, _ := json.Marshal(req{
		Model:     "claude-sonnet-4-6",
		MaxTokens: 512,
		Messages:  []message{{Role: "user", Content: "Hi"}},
	})
	r, _ := http.NewRequest("POST",
		"https://api.anvat.app/v1/messages", bytes.NewReader(body))
	r.Header.Set("x-api-key", "sk-anvat-...")
	r.Header.Set("anthropic-version", "2023-06-01")
	r.Header.Set("content-type", "application/json")

	resp, _ := http.DefaultClient.Do(r)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

// cargo add reqwest serde_json tokio --features tokio/full
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let body = json!({
        "model": "claude-haiku-4-5",
        "max_tokens": 256,
        "messages": [{ "role": "user", "content": "Hello?" }]
    });
    let res = client
        .post("https://api.anvat.app/v1/messages")
        .header("x-api-key", "sk-anvat-...")
        .header("anthropic-version", "2023-06-01")
        .json(&body)
        .send()
        .await?
        .text()
        .await?;
    println!("{res}");
    Ok(())
}

curl https://api.anvat.app/v1/messages \
  -H "x-api-key: sk-anvat-..." \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "hi"}]
  }'

curl https://api.anvat.app/v1/chat/completions \
  -H "Authorization: Bearer sk-anvat-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5",
    "messages": [{"role": "user", "content": "hi"}]
  }'

curl -N https://api.anvat.app/v1/messages \
  -H "x-api-key: sk-anvat-..." \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "max_tokens": 1024,
    "stream": true,
    "messages": [{"role": "user", "content": "Stream a short poem."}]
  }'

# pip install litellm
from litellm import completion

res = completion(
    model="openai/gemini-3-5-pro",
    messages=[{"role": "user", "content": "hi"}],
    api_base="https://api.anvat.app/v1",
    api_key="sk-anvat-...",
)
print(res["choices"][0]["message"]["content"])