Memory SDK

Agent memory — episodic, semantic, procedural, entity, trust-weighted, temporal types with hash-chain provenance

Operations

Method	Description
`lucidAddEpisodicMemory`	Store episodic memory
`lucidAddSemanticMemory`	Store semantic memory (extracted fact)
`lucidAddProceduralMemory`	Store procedural memory (learned rule)
`lucidAddEntityMemory`	Store entity memory (knowledge graph node)
`lucidAddTrustWeightedMemory`	Store trust-weighted memory (cross-agent trust)
`lucidAddTemporalMemory`	Store temporal memory (time-bounded fact)
`lucidRecallMemory`	Recall relevant memories via two-stage retrieval
`lucidCompactMemory`	Trigger memory compaction
`lucidMemoryHealth`	Memory store health and diagnostics
`lucidStartMemorySession`	Start a new conversation session
`lucidListMemorySessions`	List sessions for an agent
`lucidVerifyMemoryChain`	Verify memory hash chain integrity
`lucidGetMemoryEntry`	Read a single memory entry
`lucidListMemoryEntries`	List memory entries with filters
`lucidCloseMemorySession`	Close a memory session
`lucidGetMemorySessionContext`	Get session context
`lucidGetMemoryProvenanceChain`	Get provenance chain
`lucidGetMemoryEntryProvenance`	Single entry provenance
`lucidGetMemoryStats`	Memory diagnostics

Generated Reference

Overview

Agent memory — episodic, semantic, procedural, entity, trust-weighted, temporal types with hash-chain provenance

Available Operations

lucidAddEpisodicMemory - Store episodic memory
lucidAddSemanticMemory - Store semantic memory (extracted fact)
lucidAddProceduralMemory - Store procedural memory (learned rule)
lucidAddEntityMemory - Store entity memory (knowledge graph node)
lucidAddTrustWeightedMemory - Store trust-weighted memory (cross-agent trust)
lucidAddTemporalMemory - Store temporal memory (time-bounded fact)
lucidRecallMemory - Recall relevant memories via two-stage retrieval
lucidCompactMemory - Trigger memory compaction
lucidMemoryHealth - Memory store health and diagnostics
lucidStartMemorySession - Start a new conversation session
lucidListMemorySessions - List sessions for an agent
lucidVerifyMemoryChain - Verify memory hash chain integrity
lucidGetMemoryEntry - Read a single memory entry
lucidListMemoryEntries - List memory entries with filters
lucidCloseMemorySession - Close a memory session
lucidGetMemorySessionContext - Get session context
lucidGetMemoryProvenanceChain - Get provenance chain
lucidGetMemoryEntryProvenance - Single entry provenance
lucidGetMemoryStats - Memory diagnostics

lucidAddEpisodicMemory

Store a conversation turn as episodic memory. Requires session_id, role, and content.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidAddEpisodicMemory({
    xAgentPassportId: "<id>",
    body: {
      sessionId: "<id>",
      role: "tool",
      content: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidAddEpisodicMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidAddEpisodicMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidAddEpisodicMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      sessionId: "<id>",
      role: "tool",
      content: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidAddEpisodicMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidAddEpisodicMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryWriteResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidAddSemanticMemory

Store semantic memory (extracted fact)

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidAddSemanticMemory({
    xAgentPassportId: "<id>",
    body: {
      fact: "<value>",
      confidence: 4432.89,
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidAddSemanticMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidAddSemanticMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidAddSemanticMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      fact: "<value>",
      confidence: 4432.89,
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidAddSemanticMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidAddSemanticMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryWriteResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidAddProceduralMemory

Store procedural memory (learned rule)

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidAddProceduralMemory({
    xAgentPassportId: "<id>",
    body: {
      rule: "<value>",
      trigger: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidAddProceduralMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidAddProceduralMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidAddProceduralMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      rule: "<value>",
      trigger: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidAddProceduralMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidAddProceduralMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryWriteResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidAddEntityMemory

Store entity memory (knowledge graph node)

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidAddEntityMemory({
    xAgentPassportId: "<id>",
    body: {
      entityName: "<value>",
      entityType: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidAddEntityMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidAddEntityMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidAddEntityMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      entityName: "<value>",
      entityType: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidAddEntityMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidAddEntityMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryWriteResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidAddTrustWeightedMemory

Store trust-weighted memory (cross-agent trust)

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidAddTrustWeightedMemory({
    xAgentPassportId: "<id>",
    body: {
      sourceAgentPassportId: "<id>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidAddTrustWeightedMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidAddTrustWeightedMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidAddTrustWeightedMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      sourceAgentPassportId: "<id>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidAddTrustWeightedMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidAddTrustWeightedMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryWriteResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidAddTemporalMemory

Store temporal memory (time-bounded fact)

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidAddTemporalMemory({
    xAgentPassportId: "<id>",
    body: {
      content: "<value>",
      validFrom: 352529,
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidAddTemporalMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidAddTemporalMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidAddTemporalMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      content: "<value>",
      validFrom: 352529,
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidAddTemporalMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidAddTemporalMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryWriteResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidRecallMemory

Two-stage recall: vector similarity search (if embeddings available) followed by metadata-aware reranking. Scoring: 0.55similarity + 0.20recency + 0.15type_bonus + 0.10quality.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidRecallMemory({
    xAgentPassportId: "<id>",
    body: {
      query: "<value>",
    },
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidRecallMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidRecallMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidRecallMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {
      query: "<value>",
    },
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidRecallMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidRecallMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<models.MemoryRecallResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidCompactMemory

Tiered compaction: warm (archive old episodics), cold (hard-prune archived past retention). Self-healing: auto-compacts before rejecting writes when limits are exceeded.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidCompactMemory({
    xAgentPassportId: "<id>",
    body: {},
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidCompactMemory } from "raijin-labs-lucid-ai/funcs/memoryLucidCompactMemory.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidCompactMemory(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
    body: {},
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidCompactMemory failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidCompactMemoryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidCompactMemoryResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidMemoryHealth

Returns store type, entry/vector counts, embedding pipeline status, and store capabilities.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidMemoryHealth({
    xAgentPassportId: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidMemoryHealth } from "raijin-labs-lucid-ai/funcs/memoryLucidMemoryHealth.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidMemoryHealth(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidMemoryHealth failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidMemoryHealthRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidMemoryHealthResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidStartMemorySession

Start a new conversation session

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidStartMemorySession({
    xAgentPassportId: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidStartMemorySession } from "raijin-labs-lucid-ai/funcs/memoryLucidStartMemorySession.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidStartMemorySession(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidStartMemorySession failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidStartMemorySessionRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidStartMemorySessionResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidListMemorySessions

List sessions for an agent

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidListMemorySessions({
    xAgentPassportId: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidListMemorySessions } from "raijin-labs-lucid-ai/funcs/memoryLucidListMemorySessions.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidListMemorySessions(raijinLabsLucidAi, {
    xAgentPassportId: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidListMemorySessions failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidListMemorySessionsRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidListMemorySessionsResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidVerifyMemoryChain

Verify memory hash chain integrity

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidVerifyMemoryChain({
    agentPassportId: "<id>",
    namespace: "<value>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidVerifyMemoryChain } from "raijin-labs-lucid-ai/funcs/memoryLucidVerifyMemoryChain.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidVerifyMemoryChain(raijinLabsLucidAi, {
    agentPassportId: "<id>",
    namespace: "<value>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidVerifyMemoryChain failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidVerifyMemoryChainRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidVerifyMemoryChainResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidGetMemoryEntry

Retrieve a single memory entry by its unique identifier.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidGetMemoryEntry({
    id: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidGetMemoryEntry } from "raijin-labs-lucid-ai/funcs/memoryLucidGetMemoryEntry.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidGetMemoryEntry(raijinLabsLucidAi, {
    id: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidGetMemoryEntry failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidGetMemoryEntryRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidGetMemoryEntryResponse>

Errors

Error Type	Status Code	Content Type
errors.ErrorResponse	404	application/json
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidListMemoryEntries

List memory entries for an agent, optionally filtered by type and namespace. Supports pagination via page and per_page query parameters.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidListMemoryEntries({});

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidListMemoryEntries } from "raijin-labs-lucid-ai/funcs/memoryLucidListMemoryEntries.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidListMemoryEntries(raijinLabsLucidAi, {});
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidListMemoryEntries failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidListMemoryEntriesRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidListMemoryEntriesResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidCloseMemorySession

Close an active memory session, preventing further writes.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidCloseMemorySession({
    id: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidCloseMemorySession } from "raijin-labs-lucid-ai/funcs/memoryLucidCloseMemorySession.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidCloseMemorySession(raijinLabsLucidAi, {
    id: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidCloseMemorySession failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidCloseMemorySessionRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidCloseMemorySessionResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidGetMemorySessionContext

Retrieve the full context for a memory session, including recent turns, extracted facts, and relevant procedural rules.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidGetMemorySessionContext({
    id: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidGetMemorySessionContext } from "raijin-labs-lucid-ai/funcs/memoryLucidGetMemorySessionContext.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidGetMemorySessionContext(raijinLabsLucidAi, {
    id: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidGetMemorySessionContext failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidGetMemorySessionContextRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidGetMemorySessionContextResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidGetMemoryProvenanceChain

Return the full hash-chain provenance for a given agent and namespace, ordered from oldest to newest.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidGetMemoryProvenanceChain({
    agentId: "<id>",
    namespace: "<value>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidGetMemoryProvenanceChain } from "raijin-labs-lucid-ai/funcs/memoryLucidGetMemoryProvenanceChain.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidGetMemoryProvenanceChain(raijinLabsLucidAi, {
    agentId: "<id>",
    namespace: "<value>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidGetMemoryProvenanceChain failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidGetMemoryProvenanceChainRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidGetMemoryProvenanceChainResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidGetMemoryEntryProvenance

Retrieve the provenance record for a single memory entry.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidGetMemoryEntryProvenance({
    id: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidGetMemoryEntryProvenance } from "raijin-labs-lucid-ai/funcs/memoryLucidGetMemoryEntryProvenance.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidGetMemoryEntryProvenance(raijinLabsLucidAi, {
    id: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidGetMemoryEntryProvenance failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidGetMemoryEntryProvenanceRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidGetMemoryEntryProvenanceResponse>

Errors

Error Type	Status Code	Content Type
errors.ErrorResponse	404	application/json
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

lucidGetMemoryStats

Return memory statistics and diagnostics for a specific agent, including entry counts by type, storage usage, and hash chain integrity status.

Example Usage

import { RaijinLabsLucidAi } from "raijin-labs-lucid-ai";

const raijinLabsLucidAi = new RaijinLabsLucidAi();

async function run() {
  const result = await raijinLabsLucidAi.memory.lucidGetMemoryStats({
    agentId: "<id>",
  });

  console.log(result);
}

run();

Standalone function

The standalone function version of this method:

import { RaijinLabsLucidAiCore } from "raijin-labs-lucid-ai/core.js";
import { memoryLucidGetMemoryStats } from "raijin-labs-lucid-ai/funcs/memoryLucidGetMemoryStats.js";

// Use `RaijinLabsLucidAiCore` for best tree-shaking performance.
// You can create one instance of it to use across an application.
const raijinLabsLucidAi = new RaijinLabsLucidAiCore();

async function run() {
  const res = await memoryLucidGetMemoryStats(raijinLabsLucidAi, {
    agentId: "<id>",
  });
  if (res.ok) {
    const { value: result } = res;
    console.log(result);
  } else {
    console.log("memoryLucidGetMemoryStats failed:", res.error);
  }
}

run();

Parameters

Parameter	Type	Required	Description
`request`	operations.LucidGetMemoryStatsRequest	:heavy_check_mark:	The request object to use for the request.
`options`	RequestOptions	:heavy_minus_sign:	Used to set various options for making HTTP requests.
`options.fetchOptions`	RequestInit	:heavy_minus_sign:	Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed.
`options.retries`	RetryConfig	:heavy_minus_sign:	Enables retrying HTTP requests under certain failure conditions.

Response

Promise<operations.LucidGetMemoryStatsResponse>

Errors

Error Type	Status Code	Content Type
errors.RaijinLabsLucidAiDefaultError	4XX, 5XX	/

Match SDK

Mirror SDK

​Memory SDK

​Operations

​Generated Reference

​Overview

​Available Operations

​lucidAddEpisodicMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidAddSemanticMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidAddProceduralMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidAddEntityMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidAddTrustWeightedMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidAddTemporalMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidRecallMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidCompactMemory

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidMemoryHealth

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidStartMemorySession

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidListMemorySessions

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidVerifyMemoryChain

​Example Usage

​Standalone function

​Parameters

​Response

​Errors

​lucidGetMemoryEntry

​Example Usage

​Standalone function

Memory SDK

Operations

Generated Reference

Overview

Available Operations

lucidAddEpisodicMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidAddSemanticMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidAddProceduralMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidAddEntityMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidAddTrustWeightedMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidAddTemporalMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidRecallMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidCompactMemory

Example Usage

Standalone function

Parameters

Response

Errors

lucidMemoryHealth

Example Usage

Standalone function

Parameters

Response

Errors

lucidStartMemorySession

Example Usage

Standalone function

Parameters

Response

Errors

lucidListMemorySessions

Example Usage

Standalone function

Parameters

Response

Errors

lucidVerifyMemoryChain

Example Usage

Standalone function

Parameters

Response

Errors

lucidGetMemoryEntry

Example Usage

Standalone function