Quickstart

Get Memory Router running in three steps. The only changes to your application are the base URL, a boundary_id query parameter, and — in BYOK mode — one header.

Memory Router is in private preview. If the Memory Router card is not yet visible under Integrations in your console, contact support@memorylake.ai to request access.

Step 1: Get a key and a Boundary

Sign in to the console and create a MemoryLake API key (starts with sk-).
Open Integrations → Memory Router API and create a Boundary — the memory scope that binds your conversations to a workspace, project, and actors. Copy its id.

Keep your MemoryLake key in an environment variable such as MEMORYLAKE_API_KEY. See Authentication for details on managing keys. Requests without a boundary_id still work, but run as plain passthrough with memory disabled.

Step 2: Pick a mode and swap the base URL

Both modes use the same endpoints — what differs is which keys you send:

Mode	Keys
MemoryLake-hosted	MemoryLake key only, in the native auth header
BYOK (bring your own key)	Your provider key in the native auth header + MemoryLake key in the `x-memorylake-api-key` header

Protocol	Endpoint
OpenAI · Chat Completions	`POST https://app.memorylake.ai/openai/v1/chat/completions`
OpenAI · Responses	`POST https://app.memorylake.ai/openai/v1/responses`
OpenAI · Embeddings	`POST https://app.memorylake.ai/openai/v1/embeddings`
Anthropic · Messages	`POST https://app.memorylake.ai/anthropic/v1/messages`

See Deployment Modes for a full comparison.

MemoryLake-hosted — one key

No provider account required. GPT, Claude, and Qwen model families are built in; pick any model by its native name.

import OpenAI from "openai";

// Hosted: no provider account. MemoryLake runs the models,
// so a single MemoryLake key is all you need.
const client = new OpenAI({
  baseURL: "https://app.memorylake.ai/openai/v1",
  apiKey: process.env.MEMORYLAKE_API_KEY,
});

const resp = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Hello!" }],
}, { query: { boundary_id: process.env.MEMORYLAKE_BOUNDARY_ID } });

from openai import OpenAI
import os

# Hosted: no provider account. MemoryLake runs the models,
# so a single MemoryLake key is all you need.
client = OpenAI(
    base_url="https://app.memorylake.ai/openai/v1",
    api_key=os.environ["MEMORYLAKE_API_KEY"],
)

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_query={"boundary_id": os.environ["MEMORYLAKE_BOUNDARY_ID"]},
)

curl "https://app.memorylake.ai/openai/v1/chat/completions?boundary_id=$MEMORYLAKE_BOUNDARY_ID" \
  -H "Authorization: Bearer $MEMORYLAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

BYOK — your provider key

Keep your provider account. Your provider key goes in the provider’s native auth header (Authorization: Bearer for OpenAI, x-api-key for Anthropic); the MemoryLake key rides in the x-memorylake-api-key header.

import OpenAI from "openai";

// BYOK: you send your own provider key. It is encrypted in transit,
// forwarded to the provider, and never stored.
const client = new OpenAI({
  baseURL: "https://app.memorylake.ai/openai/v1",
  apiKey: process.env.OPENAI_API_KEY,        // your provider key
  defaultHeaders: {
    "x-memorylake-api-key": process.env.MEMORYLAKE_API_KEY,
  },
});

const resp = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Hello!" }],
}, { query: { boundary_id: process.env.MEMORYLAKE_BOUNDARY_ID } });

from openai import OpenAI
import os

# BYOK: you send your own provider key. It is encrypted in transit,
# forwarded to the provider, and never stored.
client = OpenAI(
    base_url="https://app.memorylake.ai/openai/v1",
    api_key=os.environ["OPENAI_API_KEY"],        # your provider key
    default_headers={
        "x-memorylake-api-key": os.environ["MEMORYLAKE_API_KEY"],
    },
)

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_query={"boundary_id": os.environ["MEMORYLAKE_BOUNDARY_ID"]},
)

curl "https://app.memorylake.ai/openai/v1/chat/completions?boundary_id=$MEMORYLAKE_BOUNDARY_ID" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "x-memorylake-api-key: $MEMORYLAKE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Anthropic SDK

With the Anthropic SDK, set the base URL to https://app.memorylake.ai/anthropic — the SDK appends /v1/messages itself.

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://app.memorylake.ai/anthropic",
  apiKey: process.env.MEMORYLAKE_API_KEY,   // or your Anthropic key + x-memorylake-api-key header for BYOK
});

const resp = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello!" }],
}, { query: { boundary_id: process.env.MEMORYLAKE_BOUNDARY_ID } });

import anthropic
import os

client = anthropic.Anthropic(
    base_url="https://app.memorylake.ai/anthropic",
    api_key=os.environ["MEMORYLAKE_API_KEY"],
)

resp = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
    extra_query={"boundary_id": os.environ["MEMORYLAKE_BOUNDARY_ID"]},
)

curl "https://app.memorylake.ai/anthropic/v1/messages?boundary_id=$MEMORYLAKE_BOUNDARY_ID" \
  -H "x-api-key: $MEMORYLAKE_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

The console’s Integrations → Memory Router API page generates these snippets for you, pre-filled with your Boundary id, across cURL / Python / Node.js and both modes.

Step 3: Call as normal

Send requests exactly as you do today. With a boundary_id attached, relevant memories are recalled into the prompt automatically, and new memories are extracted and stored asynchronously — the response is never delayed.

TypeScript

const completion = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Remind me what we decided last time." }],
}, { query: { boundary_id: process.env.MEMORYLAKE_BOUNDARY_ID } });

console.log(completion.choices[0].message.content);

Check the X-Trace-ID response header and the console Logs page to confirm the call went through the Router — see Observability.

Newer OpenAI reasoning models (gpt-5 family, o1/o3/o4) expect max_completion_tokens instead of max_tokens on Chat Completions. Keep your parameters in the provider’s official format — the Router passes them through unchanged.

Getting started

Scenarios

Memory Router

Model Router

MemoryLake

Team collaboration

Step 1: Get a key and a Boundary

Step 2: Pick a mode and swap the base URL

MemoryLake-hosted — one key

BYOK — your provider key

Anthropic SDK

Step 3: Call as normal

Next Steps

Deployment Modes

Observability

​Step 1: Get a key and a Boundary

​Step 2: Pick a mode and swap the base URL

​MemoryLake-hosted — one key

​BYOK — your provider key

​Anthropic SDK

​Step 3: Call as normal

​Next Steps

Deployment Modes

Observability

Step 1: Get a key and a Boundary

Step 2: Pick a mode and swap the base URL

MemoryLake-hosted — one key

BYOK — your provider key

Anthropic SDK

Step 3: Call as normal

Next Steps