Build, train, and deploy AI models with confidence

Sign Up

Create an account at anrak.ai/auth/signup. Every new account receives free credits to get started. No credit card required.

Dashboard Overview

After signing in, your dashboard shows an overview of your organization:

• Datasets — Training data you've uploaded or generated
• Training Jobs — Fine-tuning runs with real-time progress
• Models — Your trained models, ready to deploy or download
• Deploy — Production API endpoints with key management
• Inference Playground — Test any model interactively
• Evaluations — Benchmark your models against standard tests

Credits

ANRAK uses a credit-based system. Credits are consumed for dataset generation, training compute, and inference requests. Your remaining balance is always visible on the dashboard. See the Pricing page for details.

Upload a Dataset

Upload your own training data in JSONL, CSV, or Parquet format. For supervised fine-tuning, use the standard chat format with a messages array:

{"messages": [
  {"role": "system", "content": "You are a helpful medical receptionist."},
  {"role": "user", "content": "What are your visiting hours?"},
  {"role": "assistant", "content": "Our visiting hours are 9 AM to 8 PM daily."}
]}

For preference training (DPO), include chosen and rejected response pairs. Maximum file size is 100 MB.

AI Generation

Let a frontier model generate your training data. Provide a topic and instructions describing what you want, then choose:

• Task Type — Instruction Following, Multi-turn Chat, Chain of Thought, or Code Generation
• Teacher Model — GPT-5, Claude Opus 4.5, Claude Sonnet 4.5, o3, and others
• Sample Count — How many examples to generate (100 to 100,000)

Neurosymbolic Generation

The most precise way to generate training data. Neurosymbolic generation combines AI generation with rule-based verification — every sample is checked against your rules before inclusion.

You define three things:

Samples that fail verification are automatically regenerated with feedback. The platform also supports diversity settings — rotating through different scenarios, customer personas, conversation depths, and temperature levels to ensure variety.

For even higher quality, attach verification models (cops) to your generation run. See the Verification Models section below.

CSV to Q&A

Upload a CSV file and the platform converts each row into conversational question-and-answer pairs. This is ideal for turning structured data (product catalogs, FAQs, knowledge bases) into training data.

Configure the number of Q&A pairs per row and provide optional system context to guide the conversion style.

Data Augmentation

Expand an existing dataset by applying transformations. Select a source dataset and choose from six augmentation types:

Set a multiplier (e.g., 2x) to control how many new samples are generated per original example.

Training Types

Choosing Base Models

Select a base model to fine-tune. Supported families:

Hyperparameters

Key settings you can configure for each training run:

• Epochs — Number of full passes through the dataset (1-10)
• Batch Size — Samples per training step (1-32)
• Learning Rate — Step size for weight updates (typical: 2e-5)
• LoRA Rank — Dimensionality of the adapter (higher = more capacity, more compute)
• Loss Function — Cross Entropy (default), PPO, CISPO, DRO, or Importance Sampling

The platform provides sensible defaults. Adjust only if you have specific requirements.

Monitoring Training

Track your training job in real time:

• Live loss curve and step progress
• Training logs with warnings and errors
• Automatic checkpoints saved during training
• Inline evaluation benchmarks (IFEval, MMLU, GSM8K, HellaSwag, ARC)
• Training duration and cost tracking

Deploy a Model

Navigate to the Deploypage and click "Deploy Model." Select your trained model from the dropdown. The platform provisions a serverless GPU endpoint that scales automatically.

API Keys

Create API keys for each deployment. Keys are shown only once at creation — store them securely. You can create multiple keys per deployment and revoke them individually.

Inference Endpoint

Send requests to your deployed model using standard HTTP:

curl -X POST "https://api.anrak.ai/api/v1/deployments/inference" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "Your prompt here..."}
    ],
    "max_tokens": 1024,
    "temperature": 0.7
  }'

import requests

response = requests.post(
    "https://api.anrak.ai/api/v1/deployments/inference",
    headers={
        "X-API-Key": "YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "messages": [
            {"role": "user", "content": "Your prompt here..."}
        ],
        "max_tokens": 1024,
        "temperature": 0.7
    }
)

print(response.json()["content"])

The response follows the OpenAI chat completions format. You can also use the /v1/chat/completions endpoint with the OpenAI Python SDK by setting base_url="https://api.anrak.ai".

What Are Cops?

A cop is a small fine-tuned model (typically 500M to 7B parameters) trained for a single verification task. Think of it as a quality control inspector that checks every response your primary model generates.

Why small models? Because they're:

• Fast — 50-150ms per check, running in parallel
• Reliable — Trained on one narrow task, they're consistent where large models aren't
• Semantic — Unlike regex rules, cops understand meaning: "9 AM to 8 PM" and "9:00 AM to 8:00 PM" are the same fact
• Independent — They can't be tricked by the primary model because they're separate systems

Training a Cop

Creating a cop follows the same training flow as any other model, with three additional steps:

{"messages": [
  {"role": "system", "content": "You check if responses are grounded in the provided context. Output JSON."},
  {"role": "user", "content": "Context: Visiting hours are 9 AM to 8 PM.\nResponse: Our visiting hours are from nine to eight."},
  {"role": "assistant", "content": "{\"pass\": true, \"reason\": \"Hours match the context\"}"}
]}
{"messages": [
  {"role": "system", "content": "You check if responses are grounded in the provided context. Output JSON."},
  {"role": "user", "content": "Context: Visiting hours are 9 AM to 8 PM.\nResponse: We offer free valet parking."},
  {"role": "assistant", "content": "{\"pass\": false, \"reason\": \"Parking info not in context\"}"}
]}

Attaching Cops

Once you have a trained cop, attach it to any primary model:

1. Go to your primary model's detail page
2. Open the COPS tab
3. Click Attach Cop
4. Select the cop model from the dropdown
5. Choose when it runs (generation, inference, or both)
6. Set the severity level (critical, error, or warning)

You can attach multiple cops to the same model. They run in parallel, so adding more cops doesn't significantly increase latency. Each cop can be toggled on/off individually.

Cop Types

ANRAK supports seven cop types, each specialized for a different verification task:

Generation vs. Inference

Cops can run at two points in the lifecycle:

Severity Levels

Each cop attachment has a severity that controls what happens when it flags an issue:

GGUF Export

GGUF is the standard format for running models locally. ANRAK automatically converts your fine-tuned model and offers three quantization levels:

Go to your model's Run Locally tab to export and download.

Ollama Setup

Three steps to run your model locally:

# 1. Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 2. Create the model from your downloaded GGUF
ollama create my-model -f Modelfile

# 3. Run it
ollama run my-model

Once running, Ollama exposes an OpenAI-compatible API at http://localhost:11434/v1/chat/completions — any OpenAI client library works out of the box.

Overview

With MCP, you can ask your AI assistant to "create a dataset," "start a training job," or "deploy my model" — and it calls the ANRAK API on your behalf. No switching between the dashboard and your editor.

Setup

Generate a platform API key from Settings > API Keys in the ANRAK dashboard. Then add the MCP server to your AI client:

{
  "mcpServers": {
    "anrak-ai": {
      "url": "https://anrak.ai/mcp",
      "headers": {
        "Authorization": "Bearer anrak_pk_YOUR_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "anrak-ai": {
      "serverUrl": "https://anrak.ai/mcp",
      "headers": {
        "Authorization": "Bearer anrak_pk_YOUR_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "anrak-ai": {
      "command": "npx",
      "args": ["-y", "@anrak/mcp-server"],
      "env": {
        "ANRAK_API_KEY": "anrak_pk_YOUR_API_KEY"
      }
    }
  }
}

Available Tools

The MCP server provides 50+ tools organized into categories:

Authentication

Two authentication methods:

Endpoints

Base URL: https://api.anrak.ai

Code Examples

Start a Training Job

import requests

response = requests.post(
    "https://api.anrak.ai/api/v1/training",
    headers={
        "Authorization": "Bearer anrak_pk_YOUR_KEY",
        "Content-Type": "application/json"
    },
    json={
        "name": "my-customer-service-model",
        "base_model": "meta-llama/Llama-3.2-3B",
        "dataset_id": "YOUR_DATASET_ID",
        "training_type": "sft",
        "config": {
            "epochs": 3,
            "learning_rate": "2e-5",
            "batch_size": 8
        }
    }
)

print(response.json())

Chat with a Deployed Model

from openai import OpenAI

client = OpenAI(
    base_url="https://api.anrak.ai",
    api_key="anrak_pk_YOUR_KEY"
)

response = client.chat.completions.create(
    model="my-customer-service-model",
    messages=[
        {"role": "user", "content": "When are your visiting hours?"}
    ]
)

print(response.choices[0].message.content)