SDK Reference

npm install @hippocortex/sdk
# or
yarn add @hippocortex/sdk
# or
pnpm add @hippocortex/sdk

pip install hippocortex
# or
poetry add hippocortex

import { Hippocortex } from '@hippocortex/sdk';

const hx = new Hippocortex({
  apiKey: 'hx_live_abc123...',
  baseUrl: 'https://api.hippocortex.dev/v1', // optional
  timeoutMs: 30000,                           // optional
});

from hippocortex import Hippocortex

hx = Hippocortex(
    api_key="hx_live_abc123...",
    base_url="https://api.hippocortex.dev/v1",  # optional
    timeout=30.0,                                # optional, seconds
)

import { Hippocortex, HippocortexError } from '@hippocortex/sdk';

try {
  await hx.capture(event);
} catch (err) {
  if (err instanceof HippocortexError) {
    console.error(`API error: ${err.code} (HTTP ${err.statusCode})`);
    console.error(err.message);

    if (err.code === 'rate_limited') {
      // Back off and retry
    }
    if (err.code === 'validation_error') {
      console.error('Details:', err.details);
    }
  }
}

import { autoMemory } from '@hippocortex/sdk/adapters';

const memory = autoMemory({
  apiKey: process.env.HIPPOCORTEX_API_KEY!,
  injectMemory: true,     // auto-synthesize context on user messages
  captureMessages: true,  // capture message events
  captureTools: true,     // capture tool call/result events
  sessionId: 'custom-id', // optional custom session ID
  timeoutMs: 10000,       // adapter uses a lower timeout (10s default)
});

// Check if the adapter has a valid API key
if (memory.enabled) {
  console.log(`Session: ${memory.sessionId}`);
}

// Process user message: captures + returns context
const context = await memory.onMessage('Deploy to staging', 'user');

// Process assistant response: captures it
await memory.onResponse('Deploying to staging now...');

// Capture tool interactions
await memory.onToolCall('kubectl', { command: 'apply -f deploy.yaml' });
await memory.onToolResult('kubectl', 'deployment.apps/payments created');

// Inject context into a messages array (prepends system message)
const enrichedMessages = await memory.injectIntoMessages(messages, query);

from hippocortex.adapters import LangGraphMemory

memory = LangGraphMemory(api_key="hx_live_...")

# Use as a LangGraph tool or callback
# See adapter documentation for framework-specific integration

from hippocortex import Hippocortex, CaptureEvent

async with Hippocortex(api_key="hx_live_...") as hx:
    # Capture an event
    result = await hx.capture(CaptureEvent(
        type="message",
        session_id="sess-1",
        payload={"role": "user", "content": "Hello"},
    ))

    # Trigger learning
    learn_result = await hx.learn()

    # Synthesize context
    ctx = await hx.synthesize("deployment procedures")

    # List artifacts
    artifacts = await hx.list_artifacts(type="task_schema")

    # Get metrics
    metrics = await hx.get_metrics(period="24h")

from hippocortex import SyncHippocortex, CaptureEvent

with SyncHippocortex(api_key="hx_live_...") as hx:
    result = hx.capture(CaptureEvent(
        type="message",
        session_id="sess-1",
        payload={"role": "user", "content": "Hello"},
    ))
    ctx = hx.synthesize("deployment procedures")