Models and providers

from criogenai import Agent, Anthropic, AnthropicCompatible, Gemini, Groq, Ollama, OpenAI, OpenAICompatible, Qwen, Retry

Agent("openai:gpt-5-mini")  # key from OPENAI_API_KEY
Agent(Anthropic("claude-sonnet-5-5"))  # ANTHROPIC_API_KEY
Agent(Gemini("gemini-2.5-flash"))  # GEMINI_API_KEY
Agent(OpenAI("gpt-5-mini", api_key="sk-…"))  # or pass the key yourself

# Open models on fast hosts, by name: deepseek, mistral, xai, groq, cerebras,
# together, fireworks, qwen, moonshot, zai.
Agent("deepseek:deepseek-chat")  # DEEPSEEK_API_KEY
Agent(Groq("llama-3.3-70b-versatile"))  # GROQ_API_KEY
Agent(Qwen("qwen-plus", base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"))  # China endpoint
Agent(AnthropicCompatible("glm-5.2", base_url="https://api.z.ai/api/anthropic", api_key="…"))

# Self-hosted: nothing leaves your network.
Agent(Ollama("llama3.2"))
Agent(OpenAICompatible("qwen3", base_url="http://gpu-box:8000/v1"))  # vLLM, LM Studio, a gateway

# Rate limits, overload and outages go to the next model.
Agent("openai:gpt-5-mini", fallbacks=[Ollama("llama3.2")], model_retry=Retry(max_attempts=4))

import { Agent, anthropic, anthropicCompatible, gemini, groq, ollama, openai, openaiCompatible, qwen } from "criogenai";

new Agent({ model: "openai:gpt-5-mini" }); // key from OPENAI_API_KEY
new Agent({ model: anthropic("claude-sonnet-5-5") }); // ANTHROPIC_API_KEY
new Agent({ model: gemini("gemini-2.5-flash") }); // GEMINI_API_KEY
new Agent({ model: openai("gpt-5-mini", { apiKey: "sk-…" }) }); // or pass the key yourself

// Open models on fast hosts, by name: deepseek, mistral, xai, groq, cerebras,
// together, fireworks, qwen, moonshot, zai.
new Agent({ model: "deepseek:deepseek-chat" }); // DEEPSEEK_API_KEY
new Agent({ model: groq("llama-3.3-70b-versatile") }); // GROQ_API_KEY
new Agent({ model: qwen("qwen-plus", { baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1" }) }); // China endpoint
new Agent({ model: anthropicCompatible("glm-5.2", { baseUrl: "https://api.z.ai/api/anthropic", apiKey: "…" }) });

// Self-hosted: nothing leaves your network.
new Agent({ model: ollama("llama3.2") });
new Agent({ model: openaiCompatible("qwen3", { baseUrl: "http://gpu-box:8000/v1" }) }); // vLLM, LM Studio, a gateway

// Rate limits, overload and outages go to the next model.
new Agent({ model: "openai:gpt-5-mini", fallbacks: [ollama("llama3.2")], modelRetry: { maxAttempts: 4 } });

use criogenai_agent::Agent;
use criogenai_providers::{Endpoint, ProviderModel};

let openai = ProviderModel::new(Endpoint::openai(key), "gpt-5-mini")?;
let claude = ProviderModel::new(
    Endpoint::anthropic(std::env::var("ANTHROPIC_API_KEY")?),
    "claude-sonnet-5-5",
)?;
let gemini = ProviderModel::new(
    Endpoint::gemini(std::env::var("GEMINI_API_KEY")?),
    "gemini-2.5-flash",
)?;
// Self-hosted: nothing leaves your network.
let local = ProviderModel::new(Endpoint::ollama(), "llama3.2")?;
let vllm = ProviderModel::new(Endpoint::vllm("http://gpu-box:8000/v1", None), "qwen3")?;

// Rate limits, overload and outages go to the next model.
let agent = Agent::builder(openai).fallback(local).build()?;

from criogenai import Agent, load_env, env

load_env()                      # reads ./.env; never replaces a variable already set
print(env.status())             # {"openai": True, "anthropic": True, ...}: yes or no, never a key

fast = Agent("openai:gpt-5-mini")
careful = Agent("anthropic:claude-sonnet-5-5")

import { Agent, loadEnv, envStatus } from "criogenai";

loadEnv();                      // reads ./.env; never replaces a variable already set
console.log(envStatus());       // { openai: true, anthropic: true, ... }: yes or no, never a key

const fast = new Agent({ model: "openai:gpt-5-mini" });
const careful = new Agent({ model: "anthropic:claude-sonnet-5-5" });

from criogenai import Agent, Kaggle

agent = Agent("kaggle:google/gemini-3.6-flash")      # or Kaggle("...", api_token=...)

import { Agent, kaggle } from "criogenai";

const agent = new Agent({ model: "kaggle:google/gemini-3.6-flash" }); // or kaggle("...", { apiToken })

use criogenai_providers::KaggleModel;

let model = KaggleModel::from_env("google/gemini-3.6-flash")?;

from criogenai import Embedder, Gateway, Ollama

gw = Gateway(fallbacks=[Ollama("llama3.2")])  # retries and fallbacks as for an agent
reply = await gw.chat("openai:gpt-5-mini", "Summarize: …", instructions="Two sentences.")
print(reply.text, reply.model)  # reply.model: the model that answered

async for chunk in gw.stream("openai:gpt-5-mini", "Write a haiku"):
    print(chunk.text, end="")

triage = {"type": "object", "properties": {"urgent": {"type": "boolean"}}, "required": ["urgent"]}
reply = await gw.chat("openai:gpt-5-mini", "Patient reports chest pain.", output=triage)
reply.output  # {"urgent": True}, checked against the schema

vectors = await gw.embed(Embedder.openai(), ["first note", "second note"])

import { Embedder, Gateway } from "criogenai";

const gw = new Gateway({ fallbacks: [ollama("llama3.2")] }); // retries and fallbacks as for an agent
const reply = await gw.chat("openai:gpt-5-mini", "Summarize: …", { instructions: "Two sentences." });
console.log(reply.text, reply.model); // reply.model: the model that answered

for await (const chunk of gw.stream("openai:gpt-5-mini", "Write a haiku")) process.stdout.write(chunk.text);

const triage = { type: "object", properties: { urgent: { type: "boolean" } }, required: ["urgent"] };
const answer = await gw.chat<{ urgent: boolean }>("openai:gpt-5-mini", "Patient reports chest pain.", { output: triage });
answer.output?.urgent; // checked against the schema

const vectors = await gw.embed(Embedder.openai(), ["first note", "second note"]);

use std::sync::Arc;

use criogenai_agent::ResilientModel;
use criogenai_core::RetryPolicy;
use criogenai_providers::{Endpoint, Message, Model, ModelRequest, ProviderModel};

let openai = ProviderModel::new(Endpoint::openai(key), "gpt-5-mini")?;
let local = ProviderModel::new(Endpoint::ollama(), "llama3.2")?;
// Retries and fallbacks as for an agent.
let model = ResilientModel::new(Arc::new(openai))
    .fallback(Arc::new(local))
    .retry(RetryPolicy::new().max_attempts(4));
let request = ModelRequest::new(vec![
    Message::system("Two sentences."),
    Message::user("Summarize: …"),
]);
let response = model.invoke(&request).await?;
println!("{}", response.message.text());