Graxon JavaScript SDK

Graxon: First Open-Source Agentic Hybrid RAG to eliminate hallucinations through a persistent Knowledge Graph layer.

Graxon combines dense vector search, sparse retrieval, and a structured Knowledge Graph to deliver accurate, traceable, and context-aware answers — at scale, across multiple organizations, projects, and documents.

The Graxon JavaScript SDK provides an asynchronous, developer-friendly interface for managing organizations, model providers, models, credentials, projects, project configurations, webhooks, and documents.

The SDK is designed to work with modern JavaScript and TypeScript applications and is fully compatible with Bun.

API & Docs

API References -> https://www.graxonrag.com/docs/api-reference

Install

Bun

bun add graxon

npm

npm install graxon

yarn

yarn add graxon

pnpm

pnpm add graxon

Examples

For comprehensive scripts, end-to-end use cases, and advanced configurations, check out the official examples repository:

👉 Graxon JavaScript Examples (GitHub)

Usage

The Graxon JavaScript SDK provides asynchronous APIs for interacting with the Graxon platform.

All SDK operations return Promises and should be used with async/await.

1. Initialization

Most Graxon clients use the same configuration:

import { Orgs } from "graxon";

const baseUrl = "http://localhost:8888";
const apiKey = "graxon-api-key";
const timeout = 120000;

const orgs = new Orgs.OrganizationClient({
  baseUrl,
  apiKey,
  timeout,
});

Configuration

Parameter	Description
`baseUrl`	Graxon API base URL
`apiKey`	Graxon API key (None for local server)
`timeout`	Request timeout in milliseconds

For production deployments, replace the local API URL and example API key with your actual Graxon API configuration.

2. Organizations

Organizations are the top-level entities in Graxon. Projects, models, credentials, and other resources can be associated with an organization.

import { Orgs } from "graxon";

async function main() {
  const orgs = new Orgs.OrganizationClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await orgs.create({
    name: "Acme Corp",
    description: "A test organization",
  });

  console.log("Created:", createResponse);

  const getResponse = await orgs.get(createResponse.id);
  console.log("Organization:", getResponse);

  const listResponse = await orgs.list();
  console.log("Organizations:", listResponse);

  const deleteResponse = await orgs.delete(createResponse.id);
  console.log("Deleted:", deleteResponse);
}

main();

Available operations

create()
get()
list()
delete()

3. Model Credentials

Model credentials store provider authentication information that can be associated with models.

import { ModelCredentials, ModelProvider } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const modelCredentials = new ModelCredentials.ModelCredentialClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await modelCredentials.create(orgId, {
    org_id: orgId,
    name: "Deepseek API Key",
    description: "Deepseek API Key",
    provider: ModelProvider.DEEPSEEK,
    api_key: "deepseek_api_key",
  });

  console.log("Created:", createResponse);

  const getResponse = await modelCredentials.get(orgId, createResponse.id);

  console.log("Credential:", getResponse);

  const listResponse = await modelCredentials.listByProvider(
    orgId,
    ModelProvider.DEEPSEEK,
  );

  console.log("Credentials:", listResponse);

  const deleteResponse = await modelCredentials.delete(
    orgId,
    createResponse.id,
  );

  console.log("Deleted:", deleteResponse);
}

main();

Available operations

create()
get()
listByProvider()
delete()

Security: Never commit real API keys or credentials to source control. Use environment variables or a secure secrets manager in production.

4. Exploring Available Providers

The ModelProviders client allows you to discover the model providers supported by Graxon.

import { ModelProviders } from "graxon";

async function main() {
  const modelProviders = new ModelProviders.ModelProviderClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const allModels = await modelProviders.allModels();
  console.log("All models:", allModels);

  const audioModels = await modelProviders.audioModels();
  console.log("Audio models:", audioModels);

  const embeddingModels = await modelProviders.embeddingModels();

  console.log("Embedding models:", embeddingModels);

  const llmModels = await modelProviders.llmModels();
  console.log("LLM models:", llmModels);

  const ocrModels = await modelProviders.ocrModels();
  console.log("OCR models:", ocrModels);

  const rerankerModels = await modelProviders.rerankerModels();

  console.log("Reranker models:", rerankerModels);

  const sparseModels = await modelProviders.sparseModels();

  console.log("Sparse models:", sparseModels);

  const videoModels = await modelProviders.videoModels();

  console.log("Video models:", videoModels);
}

main();

Available provider queries

allModels()
audioModels()
embeddingModels()
llmModels()
ocrModels()
rerankerModels()
sparseModels()
videoModels()

5. Managing Models

Graxon supports multiple model categories for different stages of the RAG and ingestion pipeline.

Supported model categories include:

LLM
Embedding
OCR
Audio
Video
Reranker
Sparse

Most model clients support:

create()
createMultiple()
get()
list()
listByProvider()
delete()

The exact operations depend on the model type.

5.1. LLM Models

Use LlmModels.LLMModelClient to manage Large Language Models.

import { LlmModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const llmModels = new LlmModels.LLMModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await llmModels.create(orgId, {
    org_id: orgId,
    name: "OpenAI Test Model",
    model_name: "text-davinci-003",
    model_id: "text-davinci-003",
    provider: LlmModels.LLMModelProvider.OPENAI,
    description: "OpenAI Test Model",
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await llmModels.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "DeepSeek Test Model",
      model_name: "DeepSeek Chat",
      model_id: "deepseek-chat",
      provider: LlmModels.LLMModelProvider.DEEPSEEK,
      description: "DeepSeek Test Model",
    },
    {
      org_id: orgId,
      name: "Gemini Test Model",
      model_name: "Gemini 2.5 Pro",
      model_id: "gemini-2.5-pro",
      provider: LlmModels.LLMModelProvider.GEMINI,
      description: "Gemini Test Model",
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const getResponse = await llmModels.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const listResponse = await llmModels.listByProvider(
    orgId,
    LlmModels.LLMModelProvider.OPENAI,
  );

  console.log("Models:", listResponse);

  const deleteResponse = await llmModels.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

5.2. Embedding Models

Embedding models convert text into vector representations used for semantic retrieval.

import { EmbeddingModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const embeddingModels = new EmbeddingModels.EmbeddingModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await embeddingModels.create(orgId, {
    org_id: orgId,
    name: "OpenAI Test Model",
    model_name: "text-embedding-ada-002",
    model_id: "text-embedding-ada-002",
    provider: EmbeddingModels.EmbeddingModelProvider.OPENAI,
    dimension: 1536,
    description: "OpenAI Test Model",
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await embeddingModels.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "Gemini Test Model",
      model_name: "text-embedding-001",
      model_id: "text-embedding-001",
      provider: EmbeddingModels.EmbeddingModelProvider.GEMINI,
      dimension: 1536,
      description: "Gemini Test Model",
    },
    {
      org_id: orgId,
      name: "Voyage Test Model",
      model_name: "Voyage Embedding",
      model_id: "voyage-4-large",
      provider: EmbeddingModels.EmbeddingModelProvider.VOYAGE,
      dimension: 1536,
      description: "Voyage Test Model",
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const getResponse = await embeddingModels.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const listResponse = await embeddingModels.listByProvider(
    orgId,
    EmbeddingModels.EmbeddingModelProvider.GEMINI,
  );

  console.log("Models:", listResponse);

  const deleteResponse = await embeddingModels.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

5.3. OCR Models

OCR models are used to extract text and structured information from documents and images.

import { OcrModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const ocrModels = new OcrModels.OCRModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await ocrModels.create(orgId, {
    org_id: orgId,
    name: "Datalab Test Model",
    provider: OcrModels.OCRModelProvider.DATALAB,
    model_name: "Datalab OCR",
    model_id: "datalab-ocr",
    description: "Datalab OCR Test Model",
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await ocrModels.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "Mistral OCR Test Model",
      provider: OcrModels.OCRModelProvider.MISTRAL,
      model_name: "Mistral OCR",
      model_id: "mistral-ocr-latest",
      description: "Mistral OCR Test Model",
    },
    {
      org_id: orgId,
      name: "LlamaParse Test Model",
      provider: OcrModels.OCRModelProvider.LLAMAPARSE,
      model_name: "LlamaParse",
      model_id: "llamaparse",
      description: "LlamaParse OCR Test Model",
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const getResponse = await ocrModels.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const listResponse = await ocrModels.listByProvider(
    orgId,
    OcrModels.OCRModelProvider.DATALAB,
  );

  console.log("Models:", listResponse);

  const deleteResponse = await ocrModels.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

5.4. Audio Models

Audio models can be configured for audio ingestion and processing.

import { AudioModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const audioModel = new AudioModels.AudioModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await audioModel.create(orgId, {
    org_id: orgId,
    name: "Deepgram Test Model",
    model_name: "en-US_BroadbandModel",
    model_id: "en-US_BroadbandModel",
    provider: AudioModels.AudioModelProvider.DEEPGRAM,
    description: "Deepgram Test Model",
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await audioModel.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "ElevenLabs Test Model",
      model_name: "ElevenLabs Test Model",
      model_id: "en-ELEVENLABS",
      provider: AudioModels.AudioModelProvider.ELEVENLABS,
      description: "ElevenLabs Test Model",
    },
    {
      org_id: orgId,
      name: "AssemblyAI Test Model",
      model_name: "AssemblyAI Test Model",
      model_id: "en-ASSEMBLYAI",
      provider: AudioModels.AudioModelProvider.ASSEMBLYAI,
      description: "AssemblyAI Test Model",
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const getResponse = await audioModel.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const listResponse = await audioModel.listByProvider(
    orgId,
    AudioModels.AudioModelProvider.DEEPGRAM,
  );

  console.log("Models:", listResponse);

  const deleteResponse = await audioModel.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

5.5. Video Models

Video models can be configured for video ingestion and processing.

import { VideoModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const videoModels = new VideoModels.VideoModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await videoModels.create(orgId, {
    org_id: orgId,
    name: "TwelveLabs Test Model",
    provider: VideoModels.VideoModelProvider.TWELVELABS,
    model_name: "TwelveLabs Video Model",
    model_id: "twelvelabs-video",
    description: "TwelveLabs Video Test Model",
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await videoModels.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "Gemini Video Test Model",
      provider: VideoModels.VideoModelProvider.GEMINI,
      model_name: "Gemini Video",
      model_id: "gemini-video",
      description: "Gemini Video Test Model",
    },
    {
      org_id: orgId,
      name: "TwelveLabs Test Model 2",
      provider: VideoModels.VideoModelProvider.TWELVELABS,
      model_name: "TwelveLabs Video Model 2",
      model_id: "twelvelabs-video-2",
      description: "TwelveLabs Video Test Model 2",
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const listResponse = await videoModels.listByProvider(
    orgId,
    VideoModels.VideoModelProvider.TWELVELABS,
  );

  console.log("Models:", listResponse);

  const getResponse = await videoModels.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const deleteResponse = await videoModels.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

5.6. Reranker Models

Reranker models improve retrieval quality by re-ranking candidate documents based on query relevance.

import { RerankerModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const rerankerModels = new RerankerModels.RerankerModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await rerankerModels.create(orgId, {
    org_id: orgId,
    name: "Jina Reranker Test Model",
    provider_type: RerankerModels.RerankerModelProviderType.CLOUD,
    provider: RerankerModels.RerankerModelProvider.JINA,
    model_name: "Jina Reranker v2",
    model_id: "jina-reranker-v2",
    description: "Jina Reranker Test Model",
    size_in_gb: 0.0,
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await rerankerModels.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "Cohere Reranker Test Model",
      provider_type: RerankerModels.RerankerModelProviderType.CLOUD,
      provider: RerankerModels.RerankerModelProvider.COHERE,
      model_name: "Cohere Rerank",
      model_id: "rerank-v3.5",
      description: "Cohere Reranker Test Model",
      size_in_gb: 0.0,
    },
    {
      org_id: orgId,
      name: "Xenova Reranker Test Model",
      provider_type: RerankerModels.RerankerModelProviderType.LOCAL,
      provider: RerankerModels.RerankerModelProvider.XENOVA,
      model_name: "Xenova Reranker",
      model_id: "Xenova/ms-marco-MiniLM-L-6-v2",
      description: "Xenova Local Reranker Test Model",
      size_in_gb: 0.1,
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const getResponse = await rerankerModels.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const listResponse = await rerankerModels.list(orgId);

  console.log("Models:", listResponse);

  const deleteResponse = await rerankerModels.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

5.7. Sparse Models

Sparse models provide sparse retrieval capabilities for hybrid search.

import { SparseModels } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const sparseModels = new SparseModels.SparseModelClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await sparseModels.create(orgId, {
    org_id: orgId,
    name: "Pinecone Sparse Test Model",
    provider_type: SparseModels.SparseModelProviderType.CLOUD,
    provider: SparseModels.SparseModelProvider.PINECONE,
    model_name: "Pinecone Sparse English",
    model_id: "pinecone-sparse-english-v0",
    description: "Pinecone Sparse Text Test Model",
    size_in_gb: 0.0,
  });

  console.log("Created:", createResponse);

  const multipleCreateResponse = await sparseModels.createMultiple(orgId, [
    {
      org_id: orgId,
      name: "Qdrant Sparse Test Model",
      provider_type: SparseModels.SparseModelProviderType.CLOUD,
      provider: SparseModels.SparseModelProvider.QDRANT,
      model_name: "Qdrant Sparse",
      model_id: "qdrant-sparse",
      description: "Qdrant Sparse Text Test Model",
      size_in_gb: 0.0,
    },
    {
      org_id: orgId,
      name: "Prithvida Sparse Test Model",
      provider_type: SparseModels.SparseModelProviderType.LOCAL,
      provider: SparseModels.SparseModelProvider.PRITHVIDA,
      model_name: "Prithvida Sparse",
      model_id: "prithvida-sparse",
      description: "Prithvida Local Sparse Text Test Model",
      size_in_gb: 0.5,
    },
  ]);

  console.log("Created multiple:", multipleCreateResponse);

  const listResponse = await sparseModels.list(orgId);

  console.log("Models:", listResponse);

  const getResponse = await sparseModels.get(orgId, createResponse.id);

  console.log("Model:", getResponse);

  const deleteResponse = await sparseModels.delete(orgId, createResponse.id);

  console.log("Deleted:", deleteResponse);
}

main();

6. Managing Projects & Configurations

Projects represent individual Graxon workloads inside an organization.

A project can be configured with:

Knowledge Graph retrieval
Sparse embeddings
Reranking
LLM tag extraction
LLM models
Embedding models
Sparse models
Reranker models
OCR models
Audio models
Video models
Model credentials

6.1. Creating and Managing Projects

import { Projects, ProjectConfigs } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const projects = new Projects.ProjectClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const config: ProjectConfigs.ProjectConfigCreateParams = {
    graph_db_enable: true,
    sparse_embedding_enable: true,
    reranker_enable: true,
    llm_tag_extraction_enable: true,

    llm_model_id: "88443744-69ec-4edc-b871-bd1ff2660727",

    llm_model_credential_id: "ce7287fe-259a-4d60-8285-570cbdb23bf1",

    embedding_model_id: "deb8c174-d69a-48dc-9bb3-f47b9158cb5b",

    embedding_model_credential_id: "58663c55-48e6-4325-8f20-e550e13aa15b",

    sparse_text_model_id: "793bd3e9-bbd9-44ee-b32c-b978197a46d6",

    reranker_model_id: "9457b729-8ca1-4846-9f67-3c38cd3f9fa4",

    reranker_model_credential_id: "48442ab7-8dbf-4566-9671-36ecb5132433",

    ocr_model_id: "b8cd56e6-64fe-4ebb-a213-3757b6bab4df",

    ocr_model_credential_id: "83e6e278-d481-488a-a617-487b35129dd8",

    audio_model_id: "255feead-f73e-4e98-aba6-55771c76ca48",

    audio_model_credential_id: "1d43a606-5757-4427-97d6-30e7ab171293",

    video_model_id: "198cf249-d517-4ebb-adbf-8095eeb1b736",

    video_model_credential_id: "37110741-a709-4790-996e-c83d58c4936a",
  };

  const request: Projects.ProjectCreateParams = {
    org_id: orgId,
    name: "My Project",
    description: "My Project",
    config,
  };

  const createResponse = await projects.create(orgId, request);

  console.log("Created:", createResponse);

  const getResponse = await projects.get(orgId, createResponse.id);

  console.log("Project:", getResponse);

  const listResponse = await projects.list(orgId);

  console.log("Projects:", listResponse);
}

main();

Project operations

create()
get()
list()
delete()

6.2. Updating Project Configurations

Project configurations can be retrieved and updated independently.

import { ProjectConfigs } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const projectId = "4e242473-55eb-4882-b9a7-0c1f61b4e216";

  const configId = "de49eef3-8fb0-4c21-a3f0-8fd1ed98ac34";

  const projectConfigs = new ProjectConfigs.ProjectConfigClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const getResponse = await projectConfigs.get(orgId, projectId, configId);

  console.log("Configuration:", getResponse);

  const updateResponse = await projectConfigs.update(
    orgId,
    projectId,
    configId,
    {
      llm_model_id: "7ed7a88a-f59c-4f3a-a00e-072b41c62fe4",

      llm_model_credential_id: "58663c55-48e6-4325-8f20-e550e13aa15b",

      // Additional configuration fields...
    },
  );

  console.log("Updated:", updateResponse);
}

main();

Only the fields included in the update request are modified.

7. Webhooks

Webhooks allow Graxon to send project events to an external HTTP endpoint.

import { Webhooks } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const projectId = "4e242473-55eb-4882-b9a7-0c1f61b4e216";

  const webhooks = new Webhooks.WebhookClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const createResponse = await webhooks.create(orgId, projectId, {
    org_id: orgId,
    project_id: projectId,
    name: "Document Processing Webhook",
    url: "http://localhost:8080/webhooks/graxon",
    token: "xxxxxxxxxxxxxxxxxxx",
  });

  console.log("Created:", createResponse);

  const getResponse = await webhooks.get(orgId, projectId, createResponse.id);

  console.log("Webhook:", getResponse);

  const listResponse = await webhooks.list(orgId, projectId);

  console.log("Webhooks:", listResponse);
}

main();

Webhook operations

create()
get()
list()
delete()

8. Managing Documents

The Documents client allows you to upload, retrieve, list, process, generate signed URLs, and delete documents.

Supported document types depend on the configured Graxon ingestion pipeline.

Example:

import { Documents } from "graxon";

async function main() {
  const orgId = "acmecorp";

  const projectId = "4e242473-55eb-4882-b9a7-0c1f61b4e216";

  const documents = new Documents.DocumentClient({
    baseUrl: "http://localhost:8888",
    apiKey: "graxon-api-key",
    timeout: 120000,
  });

  const filePath = "./test_data/youtube_podcast_video.mp4";

  const uploadResponse = await documents.upload(orgId, projectId, filePath);

  console.log("Uploaded:", uploadResponse);

  const getResponse = await documents.get(
    orgId,
    projectId,
    uploadResponse.document_id,
  );

  console.log("Document:", getResponse);

  const listResponse = await documents.list(orgId, projectId);

  console.log("Documents:", listResponse);

  const signedUrl = await documents.getSignedUrl(
    orgId,
    projectId,
    getResponse.bucket,
    getResponse.key,
  );

  console.log("Signed URL:", signedUrl);

  const deleteResponse = await documents.delete(
    orgId,
    projectId,
    uploadResponse.document_id,
  );

  console.log("Deleted:", deleteResponse);
}

main();

Document operations

upload()
get()
list()
process()
getSignedUrl()
delete()

Processing a document

const processResponse = await documents.process(
  orgId,
  projectId,
  uploadResponse.document_id,
);

console.log("Processed:", processResponse);

Error Handling

All SDK operations are asynchronous and may reject with an error when the API request fails.

Use standard JavaScript try/catch handling:

import { Orgs } from "graxon";

async function main() {
  try {
    const orgs = new Orgs.OrganizationClient({
      baseUrl: "http://localhost:8888",
      apiKey: "graxon-api-key",
      timeout: 120000,
    });

    const response = await orgs.list();

    console.log(response);
  } catch (error) {
    console.error("Graxon API error:", error);
  }
}

main();

For production applications, it is recommended to handle:

Authentication errors
Validation errors
Resource-not-found errors
Request timeouts
Network errors
Server/API errors

TypeScript Support

The Graxon JavaScript SDK is designed with TypeScript support and exposes typed request parameters, responses, enums, and client classes.

For example:

import { ProjectConfigs } from "graxon";

const config: ProjectConfigs.ProjectConfigCreateParams = {
  graph_db_enable: true,
  sparse_embedding_enable: true,
  reranker_enable: true,
  llm_tag_extraction_enable: true,

  llm_model_id: "llm-model-id",
  embedding_model_id: "embedding-model-id",
  sparse_text_model_id: "sparse-model-id",
  reranker_model_id: "reranker-model-id",
};

Provider enums are also available directly from the SDK:

import {
  LlmModels,
  EmbeddingModels,
  OcrModels,
  AudioModels,
  VideoModels,
  RerankerModels,
  SparseModels,
} from "graxon";

const llmProvider = LlmModels.LLMModelProvider.OPENAI;

const embeddingProvider = EmbeddingModels.EmbeddingModelProvider.OPENAI;

const ocrProvider = OcrModels.OCRModelProvider.MISTRAL;

const audioProvider = AudioModels.AudioModelProvider.DEEPGRAM;

const videoProvider = VideoModels.VideoModelProvider.GEMINI;

const rerankerProvider = RerankerModels.RerankerModelProvider.JINA;

const sparseProvider = SparseModels.SparseModelProvider.PINECONE;

Client Overview

The following clients are currently available in the Graxon JavaScript SDK:

Client	Purpose
`OrganizationClient`	Manage organizations
`ModelCredentialClient`	Manage model credentials
`ModelProviderClient`	Explore available model providers
`LLMModelClient`	Manage LLM models
`EmbeddingModelClient`	Manage embedding models
`OCRModelClient`	Manage OCR models
`AudioModelClient`	Manage audio models
`VideoModelClient`	Manage video models
`RerankerModelClient`	Manage reranker models
`SparseModelClient`	Manage sparse models
`ProjectClient`	Manage projects
`ProjectConfigClient`	Manage project configurations
`WebhookClient`	Manage webhooks
`DocumentClient`	Upload and manage documents

For more information, documentation, and API references, visit:

https://www.graxonrag.com/docs/api-reference

Community & Resources

Documentation: https://www.graxonrag.com/docs/api-reference
JavaScript SDK: https://www.npmjs.com/package/graxon
GitHub: https://github.com/Graxon-rag
Examples: https://github.com/Graxon-rag/js-examples

If you find Graxon useful, consider giving the project a ⭐ on GitHub and contributing to the open-source ecosystem.

Name		Name	Last commit message	Last commit date
Latest commit History 19 Commits
src		src
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
bun.lock		bun.lock
package.json		package.json
tsconfig.json		tsconfig.json
tsup.config.ts		tsup.config.ts

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

Graxon JavaScript SDK

Table of Contents

API & Docs

Install

Bun

npm

yarn

pnpm

Examples

Usage

1. Initialization

Configuration

2. Organizations

Available operations

3. Model Credentials

Available operations

4. Exploring Available Providers

Available provider queries

5. Managing Models

5.1. LLM Models

5.2. Embedding Models

5.3. OCR Models

5.4. Audio Models

5.5. Video Models

5.6. Reranker Models

5.7. Sparse Models

6. Managing Projects & Configurations

6.1. Creating and Managing Projects

Project operations

6.2. Updating Project Configurations

7. Webhooks

Webhook operations

8. Managing Documents

Document operations

Processing a document

Error Handling

TypeScript Support

Client Overview

Community & Resources

About

Topics

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages