Examples

Code Examples

Copy-paste examples for common use cases.

Basic Chat Completion

Simple question-answer with automatic model selection

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KOMILION_API_KEY,
  baseURL: "https://www.komilion.com/api",
});

async function chat(message: string) {
  const response = await client.chat.completions.create({
    model: "neo-mode/balanced",
    messages: [{ role: "user", content: message }],
  });
  
  return response.choices[0].message.content;
}

// Usage
const answer = await chat("What is the capital of France?");
console.log(answer);  // "Paris"
console.log("Used model:", response.model);  // e.g., "gpt-4o-mini"

Streaming Response

Stream tokens as they're generated

async function streamChat(message: string) {
  const stream = await client.chat.completions.create({
    model: "neo-mode/balanced",
    messages: [{ role: "user", content: message }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content || "";
    process.stdout.write(content);  // Print without newline
  }
  console.log();  // Final newline
}

// Usage
await streamChat("Write a haiku about coding");

Multi-turn Conversation

Maintain context across multiple exchanges

interface Message {
  role: "system" | "user" | "assistant";
  content: string;
}

class ChatSession {
  private messages: Message[] = [];

  constructor(systemPrompt?: string) {
    if (systemPrompt) {
      this.messages.push({ role: "system", content: systemPrompt });
    }
  }

  async send(message: string): Promise<string> {
    this.messages.push({ role: "user", content: message });

    const response = await client.chat.completions.create({
      model: "neo-mode/balanced",
      messages: this.messages,
    });

    const reply = response.choices[0].message.content!;
    this.messages.push({ role: "assistant", content: reply });
    
    return reply;
  }
}

// Usage
const session = new ChatSession("You are a helpful coding assistant.");
await session.send("How do I read a file in Node.js?");
await session.send("Now how do I write to it?");  // Remembers context

Code Generation with Execution

Generate and run code in a secure sandbox

const response = await fetch("https://www.komilion.com/api/chat", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KOMILION_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    messages: [{
      role: "user",
      content: "Calculate the first 20 prime numbers using Python"
    }],
    policy: "balanced",
    enableToolCalling: true,
    tools: ["python_execute"]
  })
});

const result = await response.json();
console.log(result.response);  // "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...]"
console.log(result.toolsUsed);  // ["python_execute"]

Real-time Voice Conversation

Bidirectional voice with WebSocket

import WebSocket from "ws";

// Step 1: Get WebSocket config
const configRes = await fetch("https://www.komilion.com/api/voice/realtime", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KOMILION_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    policy: "balanced",  // "frugal" | "balanced" | "premium"
    voice: "alloy"
  })
});
const config = await configRes.json();

// Step 2: Connect to WebSocket
const ws = new WebSocket(config.websocket.url);

ws.on("open", () => {
  console.log("Connected!");
  
  // Configure session
  ws.send(JSON.stringify({
    type: "session.update",
    session: config.sessionConfig
  }));
});

ws.on("message", (data) => {
  const msg = JSON.parse(data.toString());
  
  if (msg.type === "response.audio.delta") {
    // Play audio: msg.delta (base64 encoded PCM16)
  }
  if (msg.type === "response.text.delta") {
    process.stdout.write(msg.delta);  // Show transcript
  }
});

// Step 3: Send audio
function sendAudio(pcm16Base64: string) {
  ws.send(JSON.stringify({
    type: "input_audio_buffer.append",
    audio: pcm16Base64
  }));
}

Image Generation

Generate images from text prompts

const response = await fetch("https://www.komilion.com/api/chat", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KOMILION_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    messages: [{
      role: "user",
      content: "Generate an image of a futuristic city at sunset"
    }],
    policy: "balanced",
    enableToolCalling: true,
    tools: ["image_generate"]
  })
});

const result = await response.json();
console.log(result.result.image_url);  // URL to generated image

Web Search Integration

Search the web and get AI-summarized results

const response = await fetch("https://www.komilion.com/api/chat", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KOMILION_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    messages: [{
      role: "user",
      content: "What are the latest developments in quantum computing? Search the web."
    }],
    policy: "balanced",
    enableToolCalling: true,
    tools: ["web_search"]
  })
});

const result = await response.json();
console.log(result.response);  // AI-summarized answer with citations

💰 Check Balance

Monitor your account balance

async function checkBalance() {
  const res = await fetch("https://www.komilion.com/api/wallet/balance", {
    headers: {
      "Authorization": `Bearer ${process.env.KOMILION_API_KEY}`
    }
  });
  const balance = await res.json();
  
  console.log(`Available: $${balance.total_available.toFixed(2)}`);
  console.log(`  Wallet: $${balance.wallet_balance.toFixed(2)}`);
  console.log(`  Trial:  $${balance.trial_credits.toFixed(2)}`);
  
  if (balance.is_low_balance) {
    console.warn("⚠️ Low balance! Consider topping up.");
  }
}

await checkBalance();
// Available: $52.97
//   Wallet: $50.00
//   Trial:  $2.97

API Reference

All endpoints and parameters

Playground

Test interactively