Examples

Real integration patterns for Memcone. Same primitives, multiple languages:remember,recall,context.

Chatbot with user memory

The core pattern. Load compressed memory before the model responds, then store the new event after the interaction.

example.ts

const mem = (path: string, body: object) =>
  fetch(`https://api.memcone.com/v1/${path}`, {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  }).then((r) => r.json())

export async function POST(req: Request) {
  const { userId, message } = await req.json()
  const { result: memory } = await mem("context", { scopeId: userId, task: "reply to user" })

  const reply = await openai.responses.create({
    model: "gpt-4.1",
    input: [
      { role: "system", content: `About this user: ${memory}` },
      { role: "user", content: message },
    ],
  })

  void mem("remember", { scopeId: userId, event: message })
  return Response.json(reply)
}

const mem = (path: string, body: object) =>
  fetch(`https://api.memcone.com/v1/${path}`, {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  }).then((r) => r.json())

export async function POST(req: Request) {
  const { userId, message } = await req.json()
  const { result: memory } = await mem("context", { scopeId: userId, task: "reply to user" })

  const reply = await openai.responses.create({
    model: "gpt-4.1",
    input: [
      { role: "system", content: `About this user: ${memory}` },
      { role: "user", content: message },
    ],
  })

  void mem("remember", { scopeId: userId, event: message })
  return Response.json(reply)
}

example.py

import os
import requests

def mem(path: str, body: dict):
    return requests.post(
        f"https://api.memcone.com/v1/{path}",
        headers={
            "Authorization": f"Bearer {os.environ['MEMCONE_API_KEY']}",
            "Content-Type": "application/json",
        },
        json=body,
        timeout=30,
    ).json()

def reply(user_id: str, message: str):
    memory = mem("context", {
        "scopeId": user_id,
        "task": "reply to user",
    })["result"]

    reply = openai.responses.create(
        model="gpt-4.1",
        input=[
            {"role": "system", "content": f"About this user: {memory}"},
            {"role": "user", "content": message},
        ],
    )

    mem("remember", {"scopeId": user_id, "event": message})
    return reply

import os
import requests

def mem(path: str, body: dict):
    return requests.post(
        f"https://api.memcone.com/v1/{path}",
        headers={
            "Authorization": f"Bearer {os.environ['MEMCONE_API_KEY']}",
            "Content-Type": "application/json",
        },
        json=body,
        timeout=30,
    ).json()

def reply(user_id: str, message: str):
    memory = mem("context", {
        "scopeId": user_id,
        "task": "reply to user",
    })["result"]

    reply = openai.responses.create(
        model="gpt-4.1",
        input=[
            {"role": "system", "content": f"About this user: {memory}"},
            {"role": "user", "content": message},
        ],
    )

    mem("remember", {"scopeId": user_id, "event": message})
    return reply

terminal

export MEMCONE_API_KEY="mem_live_xxx"

# before the model responds
curl -sS -X POST https://api.memcone.com/v1/context \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"user_123","task":"reply to user"}'

# after the interaction
curl -sS -X POST https://api.memcone.com/v1/remember \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"user_123","event":"user message here"}'

export MEMCONE_API_KEY="mem_live_xxx"

# before the model responds
curl -sS -X POST https://api.memcone.com/v1/context \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"user_123","task":"reply to user"}'

# after the interaction
curl -sS -X POST https://api.memcone.com/v1/remember \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"user_123","event":"user message here"}'

Support agent with returning user context

Support flows benefit from the same pattern, but you usually scope memory per support user or ticket thread.

example.ts

async function handleSupportTicket(userId: string, message: string) {
  const { result: userContext } = await fetch("https://api.memcone.com/v1/context", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      scopeId: `support:${userId}`,
      task: "respond to support request",
    }),
  }).then((r) => r.json())

  const reply = await anthropic.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 1024,
    system: userContext
      ? `You are a support agent. Context about this user: ${userContext}`
      : "You are a support agent.",
    messages: [{ role: "user", content: message }],
  })

  void fetch("https://api.memcone.com/v1/remember", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      scopeId: `support:${userId}`,
      event: { ticket: message, timestamp: new Date().toISOString() },
    }),
  })

  return reply.content[0].text
}

async function handleSupportTicket(userId: string, message: string) {
  const { result: userContext } = await fetch("https://api.memcone.com/v1/context", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      scopeId: `support:${userId}`,
      task: "respond to support request",
    }),
  }).then((r) => r.json())

  const reply = await anthropic.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 1024,
    system: userContext
      ? `You are a support agent. Context about this user: ${userContext}`
      : "You are a support agent.",
    messages: [{ role: "user", content: message }],
  })

  void fetch("https://api.memcone.com/v1/remember", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      scopeId: `support:${userId}`,
      event: { ticket: message, timestamp: new Date().toISOString() },
    }),
  })

  return reply.content[0].text
}

example.py

from datetime import datetime
import os
import requests

def handle_support_ticket(user_id: str, message: str):
    headers = {
        "Authorization": f"Bearer {os.environ['MEMCONE_API_KEY']}",
        "Content-Type": "application/json",
    }

    user_context = requests.post(
        "https://api.memcone.com/v1/context",
        headers=headers,
        json={
            "scopeId": f"support:{user_id}",
            "task": "respond to support request",
        },
        timeout=30,
    ).json()["result"]

    reply = anthropic.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        system=f"You are a support agent. Context about this user: {user_context}" if user_context else "You are a support agent.",
        messages=[{"role": "user", "content": message}],
    )

    requests.post(
        "https://api.memcone.com/v1/remember",
        headers=headers,
        json={
            "scopeId": f"support:{user_id}",
            "event": {"ticket": message, "timestamp": datetime.utcnow().isoformat()},
        },
        timeout=2,
    )

    return reply.content[0].text

from datetime import datetime
import os
import requests

def handle_support_ticket(user_id: str, message: str):
    headers = {
        "Authorization": f"Bearer {os.environ['MEMCONE_API_KEY']}",
        "Content-Type": "application/json",
    }

    user_context = requests.post(
        "https://api.memcone.com/v1/context",
        headers=headers,
        json={
            "scopeId": f"support:{user_id}",
            "task": "respond to support request",
        },
        timeout=30,
    ).json()["result"]

    reply = anthropic.messages.create(
        model="claude-opus-4-5",
        max_tokens=1024,
        system=f"You are a support agent. Context about this user: {user_context}" if user_context else "You are a support agent.",
        messages=[{"role": "user", "content": message}],
    )

    requests.post(
        "https://api.memcone.com/v1/remember",
        headers=headers,
        json={
            "scopeId": f"support:{user_id}",
            "event": {"ticket": message, "timestamp": datetime.utcnow().isoformat()},
        },
        timeout=2,
    )

    return reply.content[0].text

terminal

export MEMCONE_API_KEY="mem_live_xxx"

curl -sS -X POST https://api.memcone.com/v1/context \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"support:user_123","task":"respond to support request"}'

curl -sS -X POST https://api.memcone.com/v1/remember \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"support:user_123","event":"User reported a billing issue."}'

export MEMCONE_API_KEY="mem_live_xxx"

curl -sS -X POST https://api.memcone.com/v1/context \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"support:user_123","task":"respond to support request"}'

curl -sS -X POST https://api.memcone.com/v1/remember \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"support:user_123","event":"User reported a billing issue."}'

Project memory for coding agents

Use project scopes when you want architectural decisions, stack choices, and past implementation context to persist across sessions.

example.ts

async function getCodingContext(projectId: string, task: string) {
  const { result } = await fetch("https://api.memcone.com/v1/context", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ scopeId: `project:${projectId}`, task }),
  }).then((r) => r.json())

  return result
}

async function rememberDecision(projectId: string, decision: string) {
  await fetch("https://api.memcone.com/v1/remember", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ scopeId: `project:${projectId}`, event: decision }),
  })
}

async function getCodingContext(projectId: string, task: string) {
  const { result } = await fetch("https://api.memcone.com/v1/context", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ scopeId: `project:${projectId}`, task }),
  }).then((r) => r.json())

  return result
}

async function rememberDecision(projectId: string, decision: string) {
  await fetch("https://api.memcone.com/v1/remember", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + process.env.MEMCONE_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ scopeId: `project:${projectId}`, event: decision }),
  })
}

example.py

import os
import requests

HEADERS = {
    "Authorization": f"Bearer {os.environ['MEMCONE_API_KEY']}",
    "Content-Type": "application/json",
}

def get_coding_context(project_id: str, task: str):
    return requests.post(
        "https://api.memcone.com/v1/context",
        headers=HEADERS,
        json={"scopeId": f"project:{project_id}", "task": task},
        timeout=30,
    ).json()["result"]

def remember_decision(project_id: str, decision: str):
    requests.post(
        "https://api.memcone.com/v1/remember",
        headers=HEADERS,
        json={"scopeId": f"project:{project_id}", "event": decision},
        timeout=10,
    )

import os
import requests

HEADERS = {
    "Authorization": f"Bearer {os.environ['MEMCONE_API_KEY']}",
    "Content-Type": "application/json",
}

def get_coding_context(project_id: str, task: str):
    return requests.post(
        "https://api.memcone.com/v1/context",
        headers=HEADERS,
        json={"scopeId": f"project:{project_id}", "task": task},
        timeout=30,
    ).json()["result"]

def remember_decision(project_id: str, decision: str):
    requests.post(
        "https://api.memcone.com/v1/remember",
        headers=HEADERS,
        json={"scopeId": f"project:{project_id}", "event": decision},
        timeout=10,
    )

terminal

export MEMCONE_API_KEY="mem_live_xxx"

curl -sS -X POST https://api.memcone.com/v1/context \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"project:proj_abc","task":"implement authentication"}'

curl -sS -X POST https://api.memcone.com/v1/remember \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"project:proj_abc","event":"Decided to use Redis for session storage."}'

export MEMCONE_API_KEY="mem_live_xxx"

curl -sS -X POST https://api.memcone.com/v1/context \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"project:proj_abc","task":"implement authentication"}'

curl -sS -X POST https://api.memcone.com/v1/remember \
  -H "Authorization: Bearer $MEMCONE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"scopeId":"project:proj_abc","event":"Decided to use Redis for session storage."}'

Related guides

PreviousDebug mode

Next Memcone CLI