Chat

Powerful AI chat with text correction, streaming, and function calling

Overview

60db’s LM (Large Language Model) API provides intelligent chat completions with advanced text correction capabilities, streaming responses, and function calling support. Our Small Language Model (SLM) is optimized for fast, efficient responses.

Features

OpenAI Compatible

Drop-in compatible with OpenAI’s chat completion format

Text Correction

Smart text correction with dictionary and style options

Real-time Streaming

Server-Sent Events for instant response streaming

Function Calling

Built-in tool/function calling support

Basic Usage

JavaScript

import { SixtyDBClient } from '60db';

const client = new SixtyDBClient('your-api-key');

const response = await client.chat.completions.create({
  model: 'qcall/slm-3b-int4',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'How can I improve my English?' }
  ],
  stream: true
});

for await (const chunk of response) {
  console.log(chunk.choices[0]?.delta?.content);
}

Python

from sixtydb import SixtyDBClient

client = SixtyDBClient('your-api-key')

response = client.chat.completion(
    model='qcall/slm-3b-int4',
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'How can I improve my English?'}
    ],
    stream=True
)

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

cURL

curl --location 'https://api.60db.ai/v1/chat/completions' \
--header 'Content-Type: application/json' \
--data '{
  "model": "qcall/slm-3b-int4",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello! How are you?"}
  ],
  "stream": true
}'

Streaming Responses

Real-time streaming with Server-Sent Events:

const response = await fetch("https://api.60db.ai/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "qcall/slm-3b-int4",
    messages: [{ role: "user", content: "Tell me a story" }],
    stream: true,
  }),
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const chunk = decoder.decode(value);
  const lines = chunk.split("\n");

  for (const line of lines) {
    if (line.startsWith("data: ")) {
      const data = JSON.parse(line.slice(6));
      if (data.choices?.[0]?.delta?.content) {
        console.log(data.choices[0].delta.content);
      }
    }
  }
}

Function Calling (Tools)

Define tools the model can use:

const response = await client.chat.completions.create({
  model: "qcall/slm-3b-int4",
  messages: [
    { role: "user", content: "What is the weather in San Francisco?" },
  ],
  tool: [
    {
      name: "get_weather",
      description: "Get the current weather for a location",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA",
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"],
          },
        },
        required: ["location"],
      },
    },
  ],
});

Streaming Response (SSE)

data: {"chat_id": "550e8400-e29b-41d4-a716-446655440000", "type": "chat_id"}

data: {"id": "chatcmpl-123", "choices": [{"delta": {"content": "I'm"}}]}

data: {"id": "chatcmpl-123", "choices": [{"delta": {"content": " doing"}}]}

data: {"id": "chatcmpl-123", "choices": [{"delta": {"content": " well!"}}]}

data: {"type": "done", "response_time_ms": 1250}

data: [DONE]

Application Contexts

Supported contexts for text correction:

Context	Description
email	Professional email communication
chat	Casual chat/messaging
document	Formal documents/reports
message	Short messages/notifications
social	Social media posts

const response = await client.chat.completions.create({
  text: "hey can u send me the report pls",
  appContext: "email",
  style: { tone: "professional", autoCapitalize: true },
});

// Output: "Hey, can you send me the report, please?"

Best Practices

Prompt Engineering

• Be specific in your system prompt
• Provide examples for few-shot learning
• Use appropriate tone for your use case
• Test different prompts for optimal results

Streaming

• Use streaming for better UX - Handle connection errors gracefully - Buffer chunks for smooth display - Implement timeout handling

Cost Optimization

• Cache common responses - Use shorter prompts when possible - Enable chat history for context - Monitor token usage

Text Correction

• Use dictionary for domain-specific terms
• Set appropriate app context
• Test style options for your use case
• Combine multiple style options

Use Cases

Customer Support Chatbot

async function handleCustomerMessage(message) {
  const response = await client.chat.completions.create({
    model: "qcall/slm-3b-int4",
    messages: [
      {
        role: "system",
        content:
          "You are a helpful customer support assistant. Be friendly and professional.",
      },
      { role: "user", content: message },
    ],
    stream: true,
    save_chat: true,
    chat_id: customerId,
  });

  return response;
}

Text Correction Service

async function correctText(text, context = "email") {
  const response = await client.chat.completions.create({
    text: text,
    appContext: context,
    dictionary: commonTypos,
    style: {
      tone: "professional",
      autoCapitalize: true,
      autoPunctuate: true,
    },
  });

  return response.choices[0].message.content;
}

AI Assistant with Tools

async function aiAssistant(userQuery) {
  const response = await client.chat.completions.create({
    messages: [{ role: "user", content: userQuery }],
    tool: [getWeatherTool, searchDatabaseTool, sendEmailTool],
  });

  // Handle tool calls and return results
  return response;
}

Pricing

Charges are based on token usage:

Metric	Cost
Per Token	~$0.00002

Token usage is tracked and billed to your workspace. Monitor usage via the Analytics API.

API Reference

For detailed API documentation, see:

Chat

Complete API reference with all parameters and examples