Knowledge Base Management

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({ apiKey: "your-api-key" });
// Access this API via: client.conversationalAi

/**
 * Add content to knowledge base
 * @param request - File or URL with optional metadata
 * @param requestOptions - Optional request configuration
 * @returns Knowledge base document info
 * @throws UnprocessableEntityError if request fails
 */
client.conversationalAi.addToKnowledgeBase(
  request: BodyAddToKnowledgeBaseV1ConvaiKnowledgeBasePost,
  requestOptions?: RequestOptions
): HttpResponsePromise<AddKnowledgeBaseResponseModel>;

interface BodyAddToKnowledgeBaseV1ConvaiKnowledgeBasePost {
  /** File to upload (PDF, TXT, DOCX, etc.) */
  file?: File | Blob;
  /** URL to ingest (alternative to file) */
  url?: string;
  /** Document name */
  name?: string;
  /** Document description */
  description?: string;
}

interface AddKnowledgeBaseResponseModel {
  /** Document ID */
  documentation_id: string;
  /** Document name */
  name: string;
  /** Processing status */
  status: string;
}

/**
 * Get RAG index overview
 */
client.conversationalAi.ragIndexOverview(
  requestOptions?: RequestOptions
): HttpResponsePromise<RagIndexOverviewResponseModel>;

/**
 * Get RAG indexes for a specific document
 */
client.conversationalAi.getDocumentRagIndexes(
  documentation_id: string,
  requestOptions?: RequestOptions
): HttpResponsePromise<RagDocumentIndexesResponseModel>;

/**
 * Delete a RAG index for a document
 */
client.conversationalAi.deleteDocumentRagIndex(
  documentation_id: string,
  rag_index_id: string,
  requestOptions?: RequestOptions
): HttpResponsePromise<RagDocumentIndexResponseModel>;

/**
 * List knowledge base documents with filtering
 */
client.conversationalAi.knowledgeBase.list(
  request?: KnowledgeBaseListRequest,
  requestOptions?: RequestOptions
): HttpResponsePromise<GetKnowledgeBaseListResponseModel>;

/**
 * Get or create RAG indexes for documents in batch
 */
client.conversationalAi.knowledgeBase.getOrCreateRagIndexes(
  request: BodyComputeRagIndexesInBatchV1ConvaiKnowledgeBaseRagIndexPost,
  requestOptions?: RequestOptions
): HttpResponsePromise<Record<string, KnowledgeBaseGetOrCreateRagIndexesResponseValue>>;

/**
 * Create document from URL
 */
client.conversationalAi.knowledgeBase.documents.createFromUrl(
  request: BodyCreateUrlDocumentV1ConvaiKnowledgeBaseUrlPost,
  requestOptions?: RequestOptions
): HttpResponsePromise<AddKnowledgeBaseResponseModel>;

/**
 * Create document from uploaded file
 */
client.conversationalAi.knowledgeBase.documents.createFromFile(
  request: BodyCreateFileDocumentV1ConvaiKnowledgeBaseFilePost,
  requestOptions?: RequestOptions
): HttpResponsePromise<AddKnowledgeBaseResponseModel>;

/**
 * Create document from text content
 */
client.conversationalAi.knowledgeBase.documents.createFromText(
  request: BodyCreateTextDocumentV1ConvaiKnowledgeBaseTextPost,
  requestOptions?: RequestOptions
): HttpResponsePromise<AddKnowledgeBaseResponseModel>;

/**
 * Get document details
 */
client.conversationalAi.knowledgeBase.documents.get(
  documentation_id: string,
  request?: DocumentsGetRequest,
  requestOptions?: RequestOptions
): HttpResponsePromise<DocumentsGetResponse>;

/**
 * Update document name
 */
client.conversationalAi.knowledgeBase.documents.update(
  documentation_id: string,
  request: BodyUpdateDocumentV1ConvaiKnowledgeBaseDocumentationIdPatch,
  requestOptions?: RequestOptions
): HttpResponsePromise<DocumentsUpdateResponse>;

/**
 * Delete a document
 */
client.conversationalAi.knowledgeBase.documents.delete(
  documentation_id: string,
  request?: DocumentsDeleteRequest,
  requestOptions?: RequestOptions
): HttpResponsePromise<unknown>;

/**
 * Get agents depending on this document
 */
client.conversationalAi.knowledgeBase.documents.getAgents(
  documentation_id: string,
  request?: DocumentsGetAgentsRequest,
  requestOptions?: RequestOptions
): HttpResponsePromise<GetKnowledgeBaseDependentAgentsResponseModel>;

/**
 * Get the full content of a document
 */
client.conversationalAi.knowledgeBase.documents.getContent(
  documentation_id: string,
  requestOptions?: RequestOptions
): HttpResponsePromise<void>;

/**
 * Get document summaries by IDs
 */
client.conversationalAi.knowledgeBase.documents.summaries.get(
  request?: SummariesGetRequest,
  requestOptions?: RequestOptions
): HttpResponsePromise<Record<string, SummariesGetResponseValue>>;

/**
 * Get document chunk details for RAG
 */
client.conversationalAi.knowledgeBase.documents.chunk.get(
  documentation_id: string,
  chunk_id: string,
  requestOptions?: RequestOptions
): HttpResponsePromise<KnowledgeBaseDocumentChunkResponseModel>;

/**
 * Compute RAG index for document
 * In case the document is not RAG indexed, it triggers rag indexing task,
 * otherwise it just returns the current status.
 */
client.conversationalAi.knowledgeBase.document.computeRagIndex(
  documentation_id: string,
  request: RagIndexRequestModel,
  requestOptions?: RequestOptions
): HttpResponsePromise<RagDocumentIndexResponseModel>;

interface KnowledgeBaseListRequest {
  /** Number of items per page */
  pageSize?: number;
  /** Search query string */
  search?: string;
  /** Show only documents owned by the user */
  showOnlyOwnedDocuments?: boolean;
  /** Filter by document types */
  types?: KnowledgeBaseDocumentType[];
  /** Parent folder ID to filter by */
  parentFolderId?: string;
  /** Ancestor folder ID to filter by */
  ancestorFolderId?: string;
  /** Show folders first in results */
  foldersFirst?: boolean;
  /** Sort direction: "asc" or "desc" */
  sortDirection?: SortDirection;
  /** Field to sort by */
  sortBy?: KnowledgeBaseSortBy;
  /** Pagination cursor */
  cursor?: string;
}

interface BodyComputeRagIndexesInBatchV1ConvaiKnowledgeBaseRagIndexPost {
  /** Array of documents to process */
  items: Array<{
    /** Document ID */
    documentId: string;
    /** Create index if missing */
    createIfMissing: boolean;
    /** RAG model to use */
    model: string;
  }>;
}

interface BodyCreateUrlDocumentV1ConvaiKnowledgeBaseUrlPost {
  /** URL to scrape */
  url: string;
  /** Optional document name */
  name?: string;
  /** Optional description */
  description?: string;
}

interface BodyCreateFileDocumentV1ConvaiKnowledgeBaseFilePost {
  /** File to upload */
  file: File | Blob;
  /** Optional document name */
  name?: string;
  /** Parent folder ID */
  parentFolderId?: string;
}

interface BodyCreateTextDocumentV1ConvaiKnowledgeBaseTextPost {
  /** Text content */
  text: string;
  /** Optional document name */
  name?: string;
  /** Optional description */
  description?: string;
}

interface DocumentsGetRequest {
  /** Optional agent ID for context */
  agentId?: string;
}

interface DocumentsDeleteRequest {
  /** Force delete even if used by agents */
  force?: boolean;
}

interface BodyUpdateDocumentV1ConvaiKnowledgeBaseDocumentationIdPatch {
  /** New document name */
  name: string;
}

interface DocumentsGetAgentsRequest {
  /** Type of dependency: "direct" or "inherited" */
  dependentType?: KnowledgeBaseDependentType;
  /** Number of items per page */
  pageSize?: number;
  /** Pagination cursor */
  cursor?: string;
}

interface SummariesGetRequest {
  /** Array of document IDs to get summaries for */
  documentIds?: string[];
}

interface RagIndexRequestModel {
  /** RAG model to use */
  model: string;
}

import { readFile } from "fs/promises";
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

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

// Upload document
const pdfFile = await readFile("faq.pdf");
const doc = await client.conversationalAi.addToKnowledgeBase({
  file: new File([pdfFile], "faq.pdf"),
  name: "FAQ Document",
  description: "Frequently asked questions and answers",
});

// Or add from URL
const webDoc = await client.conversationalAi.addToKnowledgeBase({
  url: "https://example.com/help-center",
  name: "Help Center",
});