TypeScript

npm install @denserai/retriever-sdk

import { DenserRetriever } from "@denserai/retriever-sdk";

const client = new DenserRetriever({
  apiKey: "your-api-key"
});

async function quickExample() {
  // Create a knowledge base
  const kb = await client.createKnowledgeBase("My First KB");
  const kbId = kb.data.id;

  // Import text content
  await client.importTextContentAndPoll(
    kbId,
    "Getting Started",
    "Denser Retriever enables semantic search across your documents."
  );

  // Search
  const results = await client.query("semantic search");

  console.log(results.data);

  // Cleanup
  await client.deleteKnowledgeBase(kbId);
}

import { DenserRetriever } from "@denserai/retriever-sdk";

const client = new DenserRetriever({
  apiKey: "YOUR_API_KEY",           // Required: Your API key
  timeout: 30000                    // Optional: Request timeout in ms (default: 10000)
});

const kb = await client.createKnowledgeBase(
  "Technical Documentation",
  "Product docs and API references"
);
const kbId = kb.data.id;

{
  success: boolean;
  data: {
    id: string;
    name: string;
    description: string | null;
    createdAt: string;
    updatedAt: string;
  }
}

const kbs = await client.listKnowledgeBases();
kbs.data.forEach(kb => {
  console.log(`${kb.name} (ID: ${kb.id})`);
});

await client.updateKnowledgeBase(kbId, {
  name: "Updated Name",
  description: "Updated description"
});

await client.deleteKnowledgeBase(kbId);

const presign = await client.presignUploadUrl(kbId, "document.pdf", 1024000);
const fileId = presign.data.fileId;
const uploadUrl = presign.data.uploadUrl;
const expiresAt = presign.data.expiresAt;

const doc = await client.importFile(fileId);
console.log(`Document ID: ${doc.data.id}, Status: ${doc.data.status}`);

const doc = await client.importFileAndPoll(fileId, {
  intervalMs: 2000,
  timeoutMs: 600000
});
// Returns when status is "processed" or throws on "failed"/"timeout"

const doc = await client.importTextContent(
  kbId,
  "API Documentation",
  "Complete API reference and usage examples..."
);

const doc = await client.importTextContentAndPoll(
  kbId,
  "Release Notes",
  "Version 2.0 includes...",
  { intervalMs: 1000, timeoutMs: 300000 }
);

const docs = await client.listDocuments(kbId);
docs.data.forEach(doc => {
  console.log(`${doc.title} - ${doc.status} (${doc.size} bytes)`);
});

{
  success: boolean;
  data: Array<{
    id: string;
    title: string;
    type: string;
    size: number;
    status: "pending" | "processing" | "processed" | "failed" | "timeout";
    createdAt: string;
  }>
}

const status = await client.getDocumentStatus(docId);
console.log(`Status: ${status.data.status}`);

await client.deleteDocument(docId);

// Search across all knowledge bases
const results = await client.query("machine learning algorithms");

// Search within specific knowledge bases
const results = await client.query("deployment guide", {
  knowledgeBaseIds: [kbId1, kbId2],
  limit: 20
});

// Process results
results.data.forEach(item => {
  console.log(`Score: ${item.score.toFixed(3)}`);
  console.log(`Title: ${item.title}`);
  console.log(`Content: ${item.content}`);
  console.log(`Document: ${item.document_id}`);
  console.log(`KB: ${item.knowledge_base_id}`);
  console.log(`Metadata: ${item.metadata}`);
  console.log("---");
});

{
  success: boolean;
  data: Array<{
    id: string;
    score: number;
    document_id: string;
    knowledge_base_id: string;
    title: string;
    type: string;
    content: string;
    metadata?: {
      source?: string | null;
      annotations?: string;
    }
  }>
}

const usage = await client.getUsage();
console.log(`Knowledge Bases: ${usage.data.knowledgeBaseCount}`);
console.log(`Storage Used: ${usage.data.storageUsed} bytes`);

{
  success: boolean;
  data: {
    knowledgeBaseCount: number;
    storageUsed: number;  // bytes
  }
}

const balance = await client.getBalance();
console.log(`Balance: ${balance.data.balance} credits`);

{
  success: boolean;
  data: {
    balance: number;
  }
}

class APIError extends Error {
  code: string;           // Machine-readable error code
  message: string;        // Human-readable error message
  httpStatus: number;     // HTTP status code
  data?: object;          // Additional error context
}

import { DenserRetriever, APIError } from "@denserai/retriever-sdk";

const client = new DenserRetriever({ apiKey: "your-api-key" });

try {
  const results = await client.query("search term", {
    knowledgeBaseIds: ["invalid-kb-id"],
    limit: 5
  });
  console.log(results.data);
} catch (error) {
  if (error instanceof APIError) {
    console.error(`[${error.code}] ${error.message}`);
    console.error(`HTTP Status: ${error.httpStatus}`);
    
    // Handle specific error codes
    if (error.code === "INSUFFICIENT_CREDITS") {
      console.error("Please top up your account to continue.");
    } else if (error.code === "NOT_FOUND") {
      console.error("The requested resource does not exist.");
    } else if (error.code === "STORAGE_LIMIT_EXCEEDED") {
      console.error("Storage quota exceeded:", error.data);
    } else if (error.code === "KNOWLEDGE_BASE_LIMIT_EXCEEDED") {
      console.error("Maximum knowledge bases reached.");
    } else {
      console.error("An error occurred:", error.message);
    }
  } else {
    console.error("Unexpected error:", error);
  }
}