npm install xalen-sdk

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

const response = await client.chat.completions.create({
  model: "vedika-standard",
  messages: [{ role: "user", content: "Hello, world!" }],
});

console.log(response.choices[0].message.content);

curl https://api.xalen.io/v1/chat/completions \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "vedika-standard",
    "messages": [{"role": "user", "content": "Hello, world!"}]
  }'

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

const response = await client.chat.completions.create({
  model: "vedika-pro",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "What is my birth chart?" },
  ],
  temperature: 0.7,
  max_tokens: 1024,
});

console.log(response.choices[0].message.content);

curl https://api.xalen.io/v1/chat/completions \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "vedika-pro",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "What is my birth chart?"}
    ],
    "temperature": 0.7,
    "max_tokens": 1024
  }'

import Xalen from "xalen-sdk";
const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

const models = await client.models.list();
models.data.forEach(m => console.log(m.id, m.owned_by));

curl https://api.xalen.io/v1/models \
  -H "Authorization: Bearer xln_live_YOUR_KEY"

import Xalen from "xalen-sdk";
const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

const response = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: "Vedic astrology birth chart analysis",
});

console.log(response.data[0].embedding.length); // 1536

curl https://api.xalen.io/v1/embeddings \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "text-embedding-3-small", "input": "Vedic astrology birth chart analysis"}'

curl https://api.xalen.io/v1/images/generations \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A serene Hindu temple at sunrise, watercolor style", "size": "1024x1024"}'

curl https://api.xalen.io/v1/audio/speech \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "tts-1", "voice": "nova", "input": "Welcome to your daily horoscope reading."}' \
  --output output.mp3

curl https://api.xalen.io/v1/audio/transcriptions \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -F [email protected] \
  -F model=whisper-1 \
  -F language=hi

curl https://api.xalen.io/v1/voice/binary \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -F [email protected] \
  -F language=hi \
  -F voice=nova \
  --output answer.mp3

curl "https://api.xalen.io/v1/astrology/kundali?date=1990-01-15&time=14:30&lat=18.5204&lon=73.8567" \
  -H "Authorization: Bearer xln_live_YOUR_KEY"

curl https://api.xalen.io/v1/agents/run \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "kundali-reader",
    "input": "What career paths suit my chart?",
    "context": {"birth_date": "1990-01-15", "birth_time": "14:30", "birth_place": "Pune, India"}
  }'

curl https://api.xalen.io/v1/billing/balance \
  -H "Authorization: Bearer xln_live_YOUR_KEY"

curl https://api.xalen.io/v1/billing/deposit \
  -H "Authorization: Bearer xln_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount": 5000}'

import Xalen from "xalen-sdk";
import fs from "fs";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

// 1. Upload training data
const trainingFile = await client.files.create({
  file: fs.createReadStream("training_data.jsonl"),
  purpose: "fine-tune",
});

// 2. Create fine-tuning job
const job = await client.fineTuning.jobs.create({
  model: "llama-3.3-70b",
  training_file: trainingFile.id,
  hyperparameters: {
    epochs: 3,
    learning_rate: 1e-5,
    batch_size: 4,
  },
  suffix: "astro-expert",
});

console.log(`Job created: ${job.id}, status: ${job.status}`);

// 3. Poll for completion
let status = job.status;
while (!["succeeded", "failed", "cancelled"].includes(status)) {
  await new Promise((r) => setTimeout(r, 30000));
  const updated = await client.fineTuning.jobs.retrieve(job.id);
  status = updated.status;
  console.log(`Status: ${status}`);
}

// 4. Use the fine-tuned model
if (status === "succeeded") {
  const updated = await client.fineTuning.jobs.retrieve(job.id);
  const response = await client.chat.completions.create({
    model: updated.fine_tuned_model,
    messages: [{ role: "user", content: "Analyze my chart" }],
  });
  console.log(response.choices[0].message.content);
}

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

// Create a dedicated endpoint
const endpoint = await client.endpoints.create({
  model: "llama-3.3-70b",
  hardware: "h100-80gb",
  min_replicas: 1,
  max_replicas: 4,
});

console.log(`Endpoint: ${endpoint.id}, status: ${endpoint.status}`);

// Use the dedicated endpoint for inference
const response = await client.chat.completions.create({
  model: endpoint.model,
  messages: [{ role: "user", content: "Hello!" }],
}, {
  headers: { "X-Endpoint-Id": endpoint.id },
});

console.log(response.choices[0].message.content);

// List all endpoints
const endpoints = await client.endpoints.list();
for (const ep of endpoints.data) {
  console.log(`${ep.id}: ${ep.model} on ${ep.hardware} (${ep.status})`);
}

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

// Create a batch of requests
const requests = Array.from({ length: 100 }, (_, i) => ({
  messages: [{ role: "user", content: `Summarize article ${i}` }],
}));

const batch = await client.batch.create({
  model: "deepseek-v3",
  requests,
  metadata: { project: "content-pipeline" },
});

console.log(`Batch ${batch.id} created, status: ${batch.status}`);

// Poll for completion
let status = batch.status;
while (!["completed", "failed"].includes(status)) {
  await new Promise((r) => setTimeout(r, 10000));
  const updated = await client.batch.retrieve(batch.id);
  status = updated.status;
  console.log(`Progress: ${updated.completed_requests}/${updated.total_requests}`);
}

// Process results
if (status === "completed") {
  const completed = await client.batch.retrieve(batch.id);
  for (const result of completed.results) {
    console.log(result.choices[0].message.content.slice(0, 100));
  }
}

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

// Compare two model outputs head-to-head
const evaluation = await client.evaluations.create({
  type: "comparison",
  judge_model: "llama-3.3-70b",
  criteria: "Which response is more accurate and detailed?",
  test_cases: [
    {
      input: [{ role: "user", content: "What is Ketu in astrology?" }],
      output: [
        "Ketu is the south node of the Moon in Vedic astrology...",
        "Ketu represents past karma and spiritual liberation..."
      ],
    },
  ],
});

// Retrieve results
const results = await client.evaluations.retrieve(evaluation.id);
for (const r of results.results) {
  console.log(`Winner: Output ${r.winner}, Reasoning: ${r.reasoning}`);
}

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

// Provision an 8xH100 cluster
const cluster = await client.clusters.create({
  gpu_type: "h100-sxm",
  gpu_count: 8,
  region: "us-east",
  scheduler: "kubernetes",
  max_runtime_hours: 24,
});

console.log(`Cluster ${cluster.id}: ${cluster.status}`);
console.log(`SSH: ${cluster.ssh_host}`);
console.log(`K8s config: ${cluster.kubeconfig_url}`);

// Monitor GPU utilization
const status = await client.clusters.retrieve(cluster.id);
for (const node of status.nodes) {
  console.log(
    `Node ${node.id}: GPU util ${node.gpu_utilization}%, ` +
    `memory ${node.gpu_memory_used_gb}/${node.gpu_memory_total_gb} GB`
  );
}

// Tear down when done
await client.clusters.delete(cluster.id);

import Xalen from "xalen-sdk";

const client = new Xalen({ apiKey: "xln_live_YOUR_KEY" });

// Long system prompt that stays the same across requests
const systemPrompt = `You are a Vedic astrology expert trained on classical texts
including BPHS, Phaladeepika, and Brihat Jataka. Provide detailed analysis
based on planetary positions, houses, aspects, and dasha periods.
Always cite the relevant classical reference for each interpretation.
...(2000+ tokens of instructions)...`;

// First request: creates cache
const r1 = await client.chat.completions.create({
  model: "claude-sonnet-4.6",
  messages: [
    { role: "system", content: systemPrompt },
    { role: "user", content: "Analyze Saturn in the 10th house." },
  ],
});
console.log(`Cache created: ${r1.usage.cache_creation_tokens} tokens`);

// Second request: hits cache (90% cheaper on cached prefix)
const r2 = await client.chat.completions.create({
  model: "claude-sonnet-4.6",
  messages: [
    { role: "system", content: systemPrompt },
    { role: "user", content: "What does Jupiter in the 5th house mean?" },
  ],
});
console.log(`Cache read: ${r2.usage.cache_read_tokens} tokens (90% discount)`);

// Flutter SDK — pub.dev: xalen ^0.1.0
import 'package:xalen/xalen.dart';

final client = XALEN(apiKey: 'xln_live_YOUR_KEY');

final response = await client.chatCompletion(
  model: 'vedika-standard',
  messages: [ChatMessage(role: 'user', content: 'Hello')],
);
print(response.choices.first.message.content);

import Xalen from 'xalen-sdk';

const client = new Xalen({ apiKey: 'your-key' });

async function queryWithRetry(prompt, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.chat.completions.create({
        model: 'vedika-pro-ultra',
        messages: [{ role: 'user', content: prompt }]
      });
    } catch (err) {
      if (err.status === 429 || err.status >= 500) {
        const wait = Math.min(Math.pow(2, attempt) * 1000, 60000);
        await new Promise(r => setTimeout(r, wait));
        continue;
      }
      throw err;
    }
  }
  throw new Error('Max retries exceeded');
}