Node.js SDK

npm install tensoras

# or with yarn / pnpm
yarn add tensoras
pnpm add tensoras

import Tensoras from "tensoras";
 
const client = new Tensoras({ apiKey: "tns_your_key_here" });
 
const response = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [
    { role: "user", content: "Explain RAG in one sentence." },
  ],
});
 
console.log(response.choices[0].message.content);

export TENSORAS_API_KEY="tns_your_key_here"

import Tensoras from "tensoras";
 
const client = new Tensoras(); // reads TENSORAS_API_KEY from env

const client = new Tensoras({
  apiKey: "tns_...",
  baseURL: "http://localhost:8000/v1",
});

const response = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "What is the capital of France?" },
  ],
  temperature: 0.7,
  max_tokens: 256,
});
 
console.log(response.choices[0].message.content);

const stream = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [
    { role: "user", content: "Write a short poem about APIs." },
  ],
  stream: true,
});
 
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}
 
console.log();

const response = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [
    { role: "system", content: "Return JSON with keys: name, genre, year." },
    { role: "user", content: "Tell me about Inception." },
  ],
  response_format: { type: "json_object" },
});
 
const data = JSON.parse(response.choices[0].message.content!);

import type { ResponseFormatJsonSchema } from "tensoras";
 
const responseFormat: ResponseFormatJsonSchema = {
  type: "json_schema",
  json_schema: {
    name: "movie",
    strict: true,
    schema: {
      type: "object",
      properties: {
        name: { type: "string" },
        year: { type: "integer" },
        genre: { type: "string" },
      },
      required: ["name", "year", "genre"],
      additionalProperties: false,
    },
  },
};
 
const response = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [
    { role: "system", content: "Extract movie data." },
    { role: "user", content: "Tell me about Inception." },
  ],
  response_format: responseFormat,
});
 
const data = JSON.parse(response.choices[0].message.content!);
console.log(data.name);  // "Inception"
console.log(data.year);  // 2010

const response = await client.embeddings.create({
  model: "gte-large-en-v1.5",
  input: "The quick brown fox jumps over the lazy dog.",
});
 
const embedding = response.data[0].embedding;
console.log(`Dimensions: ${embedding.length}`);

const response = await client.rerank.create({
  model: "bge-reranker-v2-m3",
  query: "What is deep learning?",
  documents: [
    "Deep learning is a subset of machine learning.",
    "The weather today is sunny.",
    "Neural networks are the foundation of deep learning.",
  ],
});
 
for (const result of response.results) {
  console.log(`Index: ${result.index}, Score: ${result.relevance_score.toFixed(4)}`);
}

// Create a Knowledge Base
const kb = await client.knowledgeBases.create({
  name: "support-docs",
  description: "Customer support documentation",
});
 
console.log(kb.id); // e.g. "kb_a1b2c3d4"
 
// Add a data source
const dataSource = await client.knowledgeBases.dataSources.create(kb.id, {
  type: "file_upload",
  file: fs.createReadStream("handbook.pdf"),
});
 
// Query with RAG
const response = await client.chat.completions.create({
  model: "llama-3.3-70b",
  messages: [
    { role: "user", content: "How do I reset my password?" },
  ],
  knowledge_bases: [kb.id],
});
 
console.log(response.choices[0].message.content);
 
for (const citation of response.citations) {
  console.log(`  Source: ${citation.source}, Score: ${citation.score.toFixed(3)}`);
}

const knowledgeBases = await client.knowledgeBases.list();
 
for (const kb of knowledgeBases.data) {
  console.log(`${kb.id}: ${kb.name}`);
}

import Tensoras from "tensoras";
import type {
  ChatCompletion,
  ChatCompletionChunk,
  ChatCompletionMessage,
  ChatCompletionCreateParams,
  EmbeddingResponse,
  EmbeddingCreateParams,
  RerankResponse,
  Model,
  KnowledgeBase,
} from "tensoras";
 
const client = new Tensoras();
 
const params: ChatCompletionCreateParams = {
  model: "llama-3.3-70b",
  messages: [{ role: "user", content: "Hello" }],
};
 
const response: ChatCompletion = await client.chat.completions.create(params);
const message: ChatCompletionMessage = response.choices[0].message;

import Tensoras, {
  TensorasAPIError,
  AuthenticationError,
  RateLimitError,
} from "tensoras";
 
const client = new Tensoras();
 
try {
  const response = await client.chat.completions.create({
    model: "llama-3.3-70b",
    messages: [{ role: "user", content: "Hello" }],
  });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error("Invalid or missing API key.");
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limited. Retry after ${error.retryAfter}s.`);
  } else if (error instanceof TensorasAPIError) {
    console.error(`API error ${error.status}: ${error.message}`);
  } else {
    throw error;
  }
}

const client = new Tensoras({
  maxRetries: 5,      // default: 3
  timeout: 60_000,    // request timeout in ms, default: 120_000
});