Credits & Pricing

credits = (tokens / 1000) × model_multiplier

tokens ≈ characters / 4

// JavaScript
import { TrainlyClient } from "@trainly/react";

const trainly = new TrainlyClient({
  apiKey: "tk_your_api_key",
  chatId: "chat_abc123",
});

// Check remaining credits
const credits = await trainly.getCredits();
console.log(`Remaining: ${credits.remaining}/${credits.total}`);
console.log(`Used: ${credits.used}`);

# Python
from trainly import TrainlyClient

trainly = TrainlyClient(
    api_key="tk_your_api_key",
    chat_id="chat_abc123"
)

# Check remaining credits
credits = trainly.get_credits()
print(f"Remaining: {credits.remaining}/{credits.total}")
print(f"Used: {credits.used}")

// Track credit usage per request
interface UsageTracker {
  requests: number;
  totalCredits: number;
  averageCreditsPerRequest: number;
}

const usage: UsageTracker = {
  requests: 0,
  totalCredits: 0,
  averageCreditsPerRequest: 0,
};

async function trackedQuery(question: string) {
  const response = await trainly.query({ question });

  // Calculate credits used (estimate)
  const tokensUsed = response.usage.total_tokens;
  const creditsUsed = (tokensUsed / 1000) * 1; // Assuming gpt-4o-mini

  usage.requests += 1;
  usage.totalCredits += creditsUsed;
  usage.averageCreditsPerRequest = usage.totalCredits / usage.requests;

  console.log(`Credits used: ${creditsUsed.toFixed(3)}`);
  console.log(
    `Total usage: ${usage.totalCredits.toFixed(2)} credits over ${usage.requests} requests`,
  );

  return response;
}

class BudgetMonitor:
    """Monitor credit usage and alert when approaching limits"""

    def __init__(self, trainly_client: TrainlyClient, budget_limit: float):
        self.trainly = trainly_client
        self.budget_limit = budget_limit
        self.usage_log = []

    def check_budget(self) -> dict:
        """Check if within budget"""
        credits = self.trainly.get_credits()
        used = credits.used
        remaining = credits.remaining

        usage_percentage = (used / credits.total) * 100

        status = {
            "within_budget": used < self.budget_limit,
            "used": used,
            "remaining": remaining,
            "budget_limit": self.budget_limit,
            "usage_percentage": usage_percentage,
            "warning": usage_percentage > 80
        }

        if status["warning"]:
            self.send_alert(status)

        return status

    def send_alert(self, status: dict):
        """Send alert when approaching budget limit"""
        print(f"⚠️  WARNING: Credit usage at {status['usage_percentage']:.1f}%")
        print(f"Used: {status['used']:.2f} / Budget: {status['budget_limit']:.2f}")

        # In production, send email/Slack notification

    async def query_with_budget_check(self, question: str, **kwargs):
        """Query with automatic budget checking"""
        budget_status = self.check_budget()

        if not budget_status["within_budget"]:
            raise Exception(f"Budget exceeded: {budget_status['used']:.2f} credits used")

        response = await self.trainly.query(question=question, **kwargs)

        # Log usage
        self.usage_log.append({
            "question": question,
            "tokens": response.usage.total_tokens,
            "timestamp": datetime.now()
        })

        return response

# Usage
monitor = BudgetMonitor(trainly, budget_limit=1000.0)

try:
    response = await monitor.query_with_budget_check(
        "What is the methodology?"
    )
except Exception as e:
    print(f"Query blocked: {e}")

// cost-calculator.ts
interface ModelPricing {
  name: string;
  multiplier: number;
}

const MODEL_MULTIPLIERS: Record<string, number> = {
  'gpt-4o-mini': 1,
  'gpt-3.5-turbo': 0.7,
  'gpt-4': 18,
  'gpt-4-turbo': 12,
  'gpt-4o': 15,
  'claude-3-haiku': 1,
  'claude-3-sonnet': 8,
  'claude-3.5-sonnet': 10,
  'claude-3-opus': 20,
};

function estimateCredits(
  questionLength: number,
  expectedAnswerLength: number,
  model: string = 'gpt-4o-mini'
): number {
  // Estimate tokens (characters / 4)
  const questionTokens = Math.ceil(questionLength / 4);
  const answerTokens = Math.ceil(expectedAnswerLength / 4);
  const totalTokens = questionTokens + answerTokens;

  // Get model multiplier
  const multiplier = MODEL_MULTIPLIERS[model] || 1;

  // Calculate credits
  return (totalTokens / 1000) * multiplier;
}

function estimateMonthlyCost(
  queriesPerDay: number,
  avgQuestionLength: number,
  avgAnswerLength: number,
  model: string = 'gpt-4o-mini'
): number {
  const creditsPerQuery = estimateCredits(
    avgQuestionLength,
    avgAnswerLength,
    model
  );

  const monthlyQueries = queriesPerDay * 30;
  const monthlyCredits = monthlyQueries * creditsPerQuery;

  return monthlyCredits;
}

// Example usage
const monthlyCost = estimateMonthlyCost(
  queriesPerDay: 1000,
  avgQuestionLength: 100,
  avgAnswerLength: 500,
  model: 'gpt-4o-mini'
);

console.log(`Estimated monthly credits: ${monthlyCost.toFixed(2)}`);

# cost_comparison.py
from dataclasses import dataclass
from typing import Dict

@dataclass
class CostEstimate:
    model: str
    credits_per_query: float
    queries_per_month: int
    total_monthly_credits: float

    def __str__(self):
        return f"{self.model}: {self.total_monthly_credits:.2f} credits/month"

MODEL_MULTIPLIERS = {
    'gpt-4o-mini': 1,
    'gpt-3.5-turbo': 0.7,
    'gpt-4': 18,
    'gpt-4-turbo': 12,
    'gpt-4o': 15,
    'claude-3-haiku': 1,
    'claude-3-sonnet': 8,
    'claude-3.5-sonnet': 10,
    'claude-3-opus': 20,
}

def compare_models(
    question_chars: int,
    answer_chars: int,
    queries_per_month: int
) -> Dict[str, CostEstimate]:
    """Compare costs across different models"""

    # Estimate tokens
    question_tokens = question_chars // 4
    answer_tokens = answer_chars // 4
    total_tokens = question_tokens + answer_tokens

    estimates = {}

    for model, multiplier in MODEL_MULTIPLIERS.items():
        credits_per_query = (total_tokens / 1000) * multiplier
        total_monthly = credits_per_query * queries_per_month

        estimates[model] = CostEstimate(
            model=model,
            credits_per_query=credits_per_query,
            queries_per_month=queries_per_month,
            total_monthly_credits=total_monthly
        )

    return estimates

# Example usage
if __name__ == "__main__":
    estimates = compare_models(
        question_chars=100,
        answer_chars=500,
        queries_per_month=10000
    )

    print("Cost Comparison:")
    print("-" * 50)

    # Sort by cost
    sorted_estimates = sorted(
        estimates.values(),
        key=lambda x: x.total_monthly_credits
    )

    for estimate in sorted_estimates:
        print(f"{estimate.model:20} {estimate.total_monthly_credits:>10.2f} credits/month")

    # Show savings
    baseline = estimates['gpt-4o-mini'].total_monthly_credits
    most_expensive = estimates['claude-3-opus'].total_monthly_credits

    print("\nSavings Analysis:")
    print(f"Using gpt-4o-mini vs claude-3-opus: {most_expensive - baseline:.2f} credits/month saved")
    print(f"That's {((most_expensive - baseline) / most_expensive * 100):.1f}% savings!")

// Your app with 1,000 monthly active users
// Each user makes 10 queries per month
// Average response: 500 tokens
// Model: gpt-4o-mini (1x multiplier)

const monthlyCalculation = {
  users: 1000,
  queriesPerUser: 10,
  totalQueries: 1000 * 10, // 10,000 queries
  tokensPerQuery: 500,
  totalTokens: 10_000 * 500, // 5,000,000 tokens
  credits: (5_000_000 / 1000) * 1, // 5,000 credits
  model: "gpt-4o-mini",
};

console.log(`Monthly cost: ${monthlyCalculation.credits} credits`);

// If using GPT-4o instead:
const expensiveModel = {
  ...monthlyCalculation,
  credits: (5_000_000 / 1000) * 15, // 75,000 credits!
  model: "gpt-4o",
};

console.log(
  `With GPT-4o: ${expensiveModel.credits} credits (15x more expensive!)`,
);

import { TrainlyClient, InsufficientCreditsError } from "@trainly/react";

const trainly = new TrainlyClient({
  apiKey: "tk_your_api_key",
  chatId: "chat_abc123",
});

try {
  const response = await trainly.query({
    question: "What is the conclusion?",
    model: "gpt-4o",
  });

  console.log(response.answer);
} catch (error) {
  if (error instanceof InsufficientCreditsError) {
    console.error(`Insufficient credits!`);
    console.error(`Required: ${error.required} credits`);
    console.error(`Available: ${error.available} credits`);
    console.error(`Shortfall: ${error.required - error.available} credits`);

    // Notify user to upgrade
    notifyUser({
      type: "credit_limit",
      message: "Please purchase more credits to continue",
      upgradeUrl: "https://trainlyai.com/billing",
    });
  }
}

from trainly import TrainlyClient, InsufficientCreditsError

trainly = TrainlyClient(
    api_key="tk_your_api_key",
    chat_id="chat_abc123"
)

try:
    response = trainly.query(
        question="What is the conclusion?",
        model="gpt-4o"
    )
    print(response.answer)

except InsufficientCreditsError as e:
    print(f"Insufficient credits!")
    print(f"Required: {e.required} credits")
    print(f"Available: {e.available} credits")
    print(f"Shortfall: {e.required - e.available} credits")

    # Notify user
    notify_user(
        type="credit_limit",
        message="Please purchase more credits to continue",
        upgrade_url="https://trainlyai.com/billing"
    )

// analytics.ts
import { TrainlyClient } from "@trainly/react";

interface UsageMetrics {
  date: string;
  queries: number;
  credits: number;
  avgCreditsPerQuery: number;
  models: Record<string, number>;
}

class UsageAnalytics {
  private trainly: TrainlyClient;
  private metrics: Map<string, UsageMetrics>;

  constructor(trainly: TrainlyClient) {
    this.trainly = trainly;
    this.metrics = new Map();
  }

  trackQuery(model: string, tokens: number) {
    const today = new Date().toISOString().split("T")[0];
    const multiplier = MODEL_MULTIPLIERS[model] || 1;
    const credits = (tokens / 1000) * multiplier;

    let metrics = this.metrics.get(today);
    if (!metrics) {
      metrics = {
        date: today,
        queries: 0,
        credits: 0,
        avgCreditsPerQuery: 0,
        models: {},
      };
      this.metrics.set(today, metrics);
    }

    metrics.queries += 1;
    metrics.credits += credits;
    metrics.avgCreditsPerQuery = metrics.credits / metrics.queries;
    metrics.models[model] = (metrics.models[model] || 0) + credits;
  }

  getDailyReport(date?: string): UsageMetrics | null {
    const key = date || new Date().toISOString().split("T")[0];
    return this.metrics.get(key) || null;
  }

  getMonthlyReport(): UsageMetrics[] {
    return Array.from(this.metrics.values()).filter((m) => {
      const metricDate = new Date(m.date);
      const thirtyDaysAgo = new Date();
      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
      return metricDate >= thirtyDaysAgo;
    });
  }

  getTotalCredits(): number {
    return Array.from(this.metrics.values()).reduce(
      (sum, m) => sum + m.credits,
      0,
    );
  }
}

// Usage
const analytics = new UsageAnalytics(trainly);

// After each query
const response = await trainly.query({ question: "What is AI?" });
analytics.trackQuery("gpt-4o-mini", response.usage.total_tokens);

// Generate reports
const dailyReport = analytics.getDailyReport();
console.log("Today:", dailyReport);

const monthlyReport = analytics.getMonthlyReport();
console.log("This month:", analytics.getTotalCredits(), "credits");