JavaScript SDK

npm install @engramma/sdk

import { Engramma } from '@engramma/sdk';

const client = new Engramma({
  apiKey: process.env.ENGRAMMA_API_KEY
});

const result = await client.text.store(
  'The deployment window is Tuesday 2-4pm UTC',
  { category: 'ops', priority: 'high' }
);
console.log(result.pattern_id);    // 'pat_7f3a2b...'
console.log(result.embedding_dim); // 384
console.log(result.patterns_used); // 42
console.log(result.patterns_limit); // 10000

const results = await client.text.batchStore([
  { text: 'Alice joined the team on Jan 5' },
  { text: 'Project deadline is March 15', metadata: { dept: 'engineering' } },
  { text: 'Budget approved for Q2', metadata: { dept: 'finance' } }
]);
console.log(results);

const response = await client.text.retrieve('When can we deploy?', 5);
console.log(`Latency: ${response.latency_ms}ms`);
for (const r of response.results) {
  console.log(`${r.text} (similarity: ${r.similarity}, id: ${r.pattern_id})`);
  console.log('Metadata:', r.metadata);
}

const response = await client.text.recall('What happened before the outage?', 10);
for (const r of response.results) {
  console.log(`${r.text} (similarity: ${r.similarity})`);
}

const explanation = await client.text.explain('When can we deploy?', 'en');
console.log(explanation.explanation);
console.log(explanation.method);     // e.g. 'cosine_similarity'
console.log(explanation.confidence); // 0.92

const result = await client.text.forget(
  'deployment window',
  'ops',
  0.85
);
console.log(result);

const stats = await client.text.stats();
console.log(`Total patterns: ${stats.total_patterns}`);
console.log(`Embedding dim: ${stats.embedding_dim}`);
console.log(`Storage: ${stats.storage_bytes} bytes`);

const embedding = await client.text.embed('deployment window');
console.log(`Dimensions: ${embedding.length}`); // 384

const result = await client.consolidation.sleep('full');
console.log(result);

// Light consolidation (faster, less aggressive)
const light = await client.consolidation.sleep('light');

const status = await client.consolidation.status();
console.log(status);

const regime = await client.regime.current();
console.log(regime);

const result = await client.causal.strength(
  'Deployment failed',
  'Alert triggered'
);
console.log(result);

const neighbors = await client.causal.neighbors(
  'Server CPU spike',
  'forward',   // 'forward' | 'backward' | 'both'
  0.5          // minimum causal strength
);
for (const n of neighbors) {
  console.log(n);
}

import type {
  StoreResult,
  RetrieveResponse,
  RetrieveResult,
  ExplainResult,
  TextStats,
  EngrammaConfig
} from '@engramma/sdk';

// StoreResult
interface StoreResult {
  success: boolean;
  pattern_id: string;
  embedding_dim: number;
  patterns_used: number;
  patterns_limit: number;
}

// RetrieveResponse
interface RetrieveResponse {
  results: RetrieveResult[];
  latency_ms: number;
}

interface RetrieveResult {
  text: string;
  metadata: Record<string, unknown>;
  similarity: number;
  pattern_id: string;
}

// ExplainResult
interface ExplainResult {
  explanation: string;
  method: string;
  confidence: number;
}

// TextStats
interface TextStats {
  total_patterns: number;
  embedding_dim: number;
  storage_bytes: number;
}

// Generic metadata support
interface MyMeta { category: string; priority: string }
const response = await client.text.retrieve('test', 5);
const first = response.results[0];
console.log(first.similarity); // number

import {
  EngrammaError,        // Base error class
  AuthenticationError,  // 401
  PermissionError,      // 403
  NotFoundError,        // 404
  ValidationError,      // 422
  RateLimitError,       // 429
  ServerError           // 5xx
} from '@engramma/sdk';

try {
  const response = await client.text.retrieve('test');
} catch (error) {
  if (error instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${error.retryAfter}s`);
  } else if (error instanceof AuthenticationError) {
    console.log('Invalid API key');
  } else if (error instanceof ValidationError) {
    console.log(`Validation failed: ${error.message}`);
  } else if (error instanceof EngrammaError) {
    console.log(`Error ${error.statusCode}: ${error.message}`);
  }
}

const client = new Engramma({
  apiKey: process.env.ENGRAMMA_API_KEY
});

// Request interceptor
client.interceptors.request.use((config) => {
  console.log(`[${config.method}] ${config.url}`);
  config.headers['X-Request-Id'] = crypto.randomUUID();
  return config;
});

// Response interceptor
client.interceptors.response.use(
  (response) => {
    console.log(`Response: ${response.status} in ${response.duration}ms`);
    return response;
  },
  (error) => {
    console.error(`Failed: ${error.message}`);
    throw error;
  }
);

const client = new Engramma({
  apiKey: 'nx_live_...',
  maxRetries: 5,           // default: 3
  retryBackoff: 2.0,       // backoff multiplier
  retryMaxWait: 30000      // max wait between retries (ms)
});