BizXEngine API

The memory and intelligence layer for AI agents. Store context, search semantically, and reason over your data — all from a single API.

What is BizXEngine?

BizXEngine is a hosted memory infrastructure API. Rather than managing your own vector databases, embedding pipelines, and retrieval logic, you make a few HTTP calls and get back semantically-ranked, importance-weighted memories tailored to your agent's context.

Unlike raw RAG pipelines, BizXEngine memories carry metadata — importance scores, temporal decay, categories, and access frequency — so retrieval quality improves over time, not degrades.

Five intelligence primitives

Base URL

All API requests must use HTTPS. HTTP is not supported. Requests to the wrong scheme will receive a redirect, not a 200 response.

Request & response format

All request bodies must be JSON (Content-Type: application/json). All responses are JSON. Dates are ISO 8601 UTC strings. Amounts and IDs are strings unless noted.

Quick Start

From zero to your first memory stored and retrieved in under 5 minutes.

Step 1 — Get your API key

Create an account at app.bizxengine.com. Navigate to Settings → API Keys and create a new key. Keys are prefixed with bxe_.

Step 2 — Store your first memory

curl -X POST https://api.bizxengine.com/v1/memory/write \
  -H "Authorization: Bearer bxe_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Client XYZ prefers async comms and morning meetings",
    "workspace_id": "ws_abc123",
    "importance": 8
  }'

import bizxengine

client = bizxengine.Client(api_key="bxe_YOUR_KEY")

memory = client.memory.write(
    workspace_id="ws_abc123",
    text="Client XYZ prefers async comms and morning meetings",
    importance=8
)

print(memory.id)  # mem_7xKzP3...

import { BizXEngine } from "@bizxengine/sdk";

const client = new BizXEngine({ apiKey: "bxe_YOUR_KEY" });

const memory = await client.memory.write({
  workspaceId: "ws_abc123",
  text: "Client XYZ prefers async comms and morning meetings",
  importance: 8,
});

console.log(memory.id);

Step 3 — Search your memories

curl -X POST https://api.bizxengine.com/v1/memory/search \
  -H "Authorization: Bearer bxe_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "workspace_id": "ws_abc123",
    "query": "communication preferences",
    "top_k": 5
  }'

The response returns ranked memories with relevance scores:

{
  "memories": [
    {
      "id": "mem_7xKzP3",
      "text": "Client XYZ prefers async comms and morning meetings",
      "score": 0.94,
      "importance": 8,
      "created_at": "2025-03-14T09:41:00Z"
    }
  ],
  "request_id": "req_Kx8mN..."
}

Authentication

BizXEngine uses bearer token authentication. Every request must include a valid API key in the Authorization header.

Authorization header

Authorization: Bearer bxe_YOUR_API_KEY

API key types

Authentication errors

Workspaces

A Workspace is your Business Memory Brain — an isolated namespace for a single AI agent or product. Your plan limits apply per workspace.

What is a workspace?

Every memory you write belongs to a workspace. Workspaces are fully isolated — memories in ws_sales are never returned in queries against ws_support. You can create as many workspaces as you need under a single BizXEngine account.

Creating a workspace

Workspaces are created in the dashboard at app.bizxengine.com. Each workspace gets a unique ID prefixed with ws_. Pass this ID in every API call.

Workspace object

memory.write

Store a new memory entry in a workspace. The engine automatically embeds the text, assigns importance, and classifies temporal context.

Request parameters

Response

{
  "id": "mem_7xKzP3qR",
  "workspace_id": "ws_abc123",
  "text": "Client XYZ prefers async comms and morning meetings",
  "importance": 8,
  "tags": [],
  "temporal_type": "persistent",
  "created_at": "2025-03-14T09:41:00Z",
  "request_id": "req_Kx8mN7..."
}

Deduplication

Before storing, the engine checks for semantic duplicates. If a memory with cosine similarity ≥ 0.97 already exists, the existing record is returned with status: "duplicate" and a duplicate_of field pointing to the original ID.

memory.search

Retrieve semantically relevant memories from a workspace, ranked by a multi-factor scoring model.

Request parameters

Scoring model

The composite score S is computed as a weighted sum:

S = 0.55 × similarity
  + 0.20 × recency
  + 0.15 × importance
  + 0.10 × frequency
  × decay_multiplier

The decay_multiplier reduces scores for old low-importance memories and zeroes out expired temporal ones. High-importance memories (≥9) decay very slowly over 1,000 days.

reason

Run an LLM-powered reasoning pass over retrieved memories. Supports streaming via Server-Sent Events.

Request parameters

Streaming

When stream: true, the response is an SSE stream. Each event is a JSON delta:

event: delta
data: {"token":"Based"}

data: {"token":" on"}

data: {"token":" the"}

event: done
data: {"usage":{"prompt_tokens":312,"completion_tokens":87}}

Errors & Status Codes

BizXEngine uses standard HTTP status codes. Every error response includes a machine-readable code and a human-readable message.

Error format

{
  "error": {
    "code": "memory_not_found",
    "message": "No memory with ID mem_xyz in workspace ws_abc123.",
    "request_id": "req_Kx8mN7..."
  }
}

Status codes

Rate Limits

Rate limits are enforced per workspace, per minute. Monthly operation limits are enforced per billing cycle.

Limits by plan

Rate limit headers

Every response includes headers so you can track your current usage:

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 57
X-RateLimit-Reset: 1741954860
X-Monthly-Writes-Remaining: 24821

Changelog

All notable changes to the BizXEngine API, SDKs, and platform.

memory.get

Retrieve a single memory by ID.

Returns the full memory object including text, importance, temporal metadata, and access statistics.

memory.delete

Permanently delete a memory from a workspace.

memory.list

Paginate through all memories in a workspace, sorted by creation date.

Supports limit (max 100) and cursor pagination. Returns a next_cursor field if more results exist.

context.inject

Returns a ready-to-inject context string from the top-k memories, with deduplication and token budgeting applied.

Pass the result directly as the system or context field in your LLM call. BizXEngine handles ranking, window management, and deduplication — you just pass a token budget.

Memory Decay

BizXEngine automatically deprioritizes stale memories. The decay model ensures long-running agents don't drown in outdated context.

Decay model

Decay is applied as a multiplier (0.05–1.0) on the composite retrieval score. The multiplier depends on memory type, importance, and age.

Python SDK

The official Python client for BizXEngine. Supports Python 3.9+.

Installation

pip install bizxengine

Initializing the client

import bizxengine

# Reads BXE_API_KEY from environment if not provided
client = bizxengine.Client(api_key="bxe_YOUR_KEY")

# Write a memory
m = client.memory.write(workspace_id="ws_abc", text="...")

# Search
results = client.memory.search(workspace_id="ws_abc", query="meeting prefs")

TypeScript SDK

The official TypeScript / JavaScript client. Works in Node.js 18+ and modern browsers.

Installation

npm install @bizxengine/sdk

Initializing

import { BizXEngine } from "@bizxengine/sdk";

const client = new BizXEngine({ apiKey: "bxe_YOUR_KEY" });

const memory = await client.memory.write({
  workspaceId: "ws_abc",
  text: "...",
});

Webhooks BETA

Receive real-time HTTP callbacks when events occur in your workspace — memory written, deleted, or when you approach plan limits.

Events