세 개의 모델, 하나의 계보.

WOS 모델은 사람이 지식을 지녀 온 방식에서 이름을 땁니다 - Tablet, Scroll, Codex. 돌판, 두루마리, 제본된 책. 뒤로 갈수록 엔진이 에이전트를 위해 해내는 일이 늘어납니다.

Tablet 1의 전체 벤치마크 리포트는 벤치마크 페이지에 있습니다.

우리에게 $2, LLM에선 그 몇 배를 아낍니다.

WOS는 매 프롬프트에 전체 히스토리를 욱여넣는 대신, 쿼리당 ~1,200개의 관련 토큰만 LLM에 전달합니다. 그 격차는 막대하고, 히스토리가 커질수록 더 벌어집니다.

절감이 나오는 곳

• WOS 없이는 매 프롬프트에 전체 히스토리를 넣습니다 - 100K 토큰 × $2.50/1M = $0.25, 매 쿼리마다 (GPT-4o 입력 단가 기준, Opus급 모델은 약 2배).
• WOS는 한 번만 적재($2/1M)하고, 이후 각 쿼리는 작은 검색($3/1M × 1,200)과 ~1,200 토큰에 대한 LLM 호출뿐입니다.
• LLM이 읽는 토큰이 적을수록 비용이 줄고, WOS는 기억이 커져도 그 수치를 일정하게 유지합니다.

모든 언어, 같은 정확도.

검색은 순수 의미 기반입니다 - 임베딩만 쓰고 키워드나 BM25 매칭은 전혀 없습니다. 그래서 사용자가 日本語, 中文, Español, English 무엇으로 적어도 검색 품질이 동일합니다.

BM25 같은 어휘 매칭은 특정 언어의 형태 - 형태소, 띄어쓰기, 문자 체계 - 에 맞춰 동작합니다. 여러 언어를 섞어 쓰는 저장소에서는 그만큼 언어별로 검색 품질이 달라진다는 뜻입니다. WOS는 어휘 매칭을 아예 사용하지 않아, 모든 언어가 같은 경로를 지납니다.

한 저장소에 세 언어를 동시에

저장소마다 언어를 정할 필요가 없습니다 - 자유롭게 섞으세요. 아래는 한 사용자의 기억에 일본어·영어·스페인어가 동시에 들어있고, 어떤 언어로 묻든 맞는 기억을 찾아오는 모습입니다. 라이브 API에서 실제로 주고받은 내용입니다:

# one user, three languages stored together
mem.add("彼女はコーヒーより紅茶が好き", user_id="alice")                      # Japanese
mem.add("she works at a design studio in Brooklyn", user_id="alice")       # English
mem.add("A ella le encanta hacer senderismo los sábados", user_id="alice")  # Spanish

"¿Qué bebe ella?"               -> 彼女はコーヒーより紅茶が好き
"what does she do on weekends?" -> A ella le encanta hacer senderismo los sábados
"彼女の仕事は?"                  -> she works at a design studio in Brooklyn

번역 단계도, 언어 감지도, 언어별 설정도 없습니다. 기억과 질문은 언어가 아니라 의미로 배치됩니다 - 맥락과 의미만 같으면 언어가 달라도 찾아냅니다.

키워드를 일부러 금지한 이유

BM25 같은 어휘 점수는 특정 언어를 더 강화하는 성질이 있어, 한 저장소에 여러 언어를 담는 사용에서는 방해가 됩니다. 그래서 엔진에서 완전히 제거했고 코드 리뷰에서 규칙으로 강제합니다: 어휘 점수가 경로에 끼면 언어별로 검색 품질이 달라지기 때문입니다.

당신의 기억 위엔 모델이 돌지 않습니다.

저장은 말한 그대로 두고, 엔진은 임베딩으로 검색합니다 - 저렴하고 빠르고 결정론적입니다. 당신의 저장된 기억 위에선 어떤 모델도 돌지 않습니다. Tablet은 모델을 전혀 쓰지 않고, Scroll·Codex는 더 나은 결과를 위해 엔진 둘레에 모델을 더하지만, 그 모델은 당신의 질문만 볼 뿐 저장한 것은 보지 않습니다.

• 결정론적 엔진. 엔진은 같은 쿼리에 같은 기억을 반환합니다 - 그래서 벤치마크 편차가 리더 모델에서만 발생합니다.
• 대규모에서도 저렴. 저장·검색에 생성 비용이 없어, 기억이 커져도 비용이 모델 사용량이 아니라 저장량을 따라갑니다.

당신의 말, 그대로

쓰기 시점에 언어 모델로 텍스트에서 "사실"을 추출해 다시 쓰는 설계도 흔합니다. 그 설계는 세 가지를 맞바꿉니다: 매 쓰기마다의 생성 비용, 추가 지연, 그리고 원문 대신 모델의 의역이 저장된다는 점. WOS는 반대쪽을 선택했습니다 - 말한 그대로 저장하고, 해석은 읽기 시점에 당신의 LLM이 원문을 들고 하게 합니다.

측정되고 재현 가능한 90.7%.

LongMemEval-S에서 90.7%, 5회 독립 실행 평균(σ 0.5%, 체리피킹 없음), 벤치마크 표준 채점자인 GPT-4o로 채점.

같은 벤치마크라도 채점 프로토콜에 따라 수치가 크게 달라집니다 - 채점자, 프롬프트, 검색 레이어에 무엇을 허용하는지에 따라서요. 우리는 벤치마크가 공표한 표준 제3자 GPT-4o 채점자를 그대로 쓰고, 시험에 맞춰 아무것도 바꾸지 않으며, 채점 코드와 리더 프롬프트를 공개해 누구나 90.7%를 그대로 재현할 수 있게 합니다.

측정 프로토콜 한눈에

정직하게 유지하는 것: 제3자 채점자, 변경 없이 공개한 리더 프롬프트, 순수 의미 기반 검색, 그리고 최고 회차가 아니라 전 회차 보고. 검색 엔진은 결정론적이라 다시 돌려도 같은 기억이 나옵니다.

더 어려운 벤치로 올라갑니다

우리는 아직 정복하지 못한 가장 어려운 표준 벤치마크 위에서 겨룹니다 - 적힌 점수는 모든 WOS 모델이 세운 최고 기록이고, 더 나은 모델이 나올 때마다 새로 쓰입니다. 94%를 넘기는 순간, 더 어려운 벤치마크로 졸업합니다.

모델당 토큰 단가 둘,
요청당 $0.0001.

100만 토큰 단가에 요청당 $0.0001을 더해, 쓴 만큼만. 구독도, 저장료도, 기억 개수 제한도 없습니다. 에이전트가 쓰고 읽을 때만 내고 - 기억하고 있는 것에는 내지 않습니다.

• 요청당 $0.0001. 모든 API 호출에 붙는 정액 요금으로, 토큰 사용량에 더해집니다.
• 저장은 무료입니다. 적재할 때 한 번 내면 보관은 공짜입니다. 개수 제한도, 보관 기간 제한도 없습니다.
• 보관만 합니다. 학습하지 않고, 사용하지 않고, 보지 않습니다. 에이전트의 기억은 당신의 것 - 저희는 회수할 수 있게 정리만 합니다.
• Tablet이 이렇게 싼 이유: 엔진이 모델을 돌리지 않아 원가가 임베딩과 디스크지 GPU가 아니기 때문입니다. Scroll·Codex는 모델을 더하며, 그 비용이 더 높은 가격에 담겨 있습니다.

사용량 티어별 한도 보기 →

세 번의 호출: 저장, 회수, 답변.

하나의 API. recall() 호출이 단기·장기 기억과 주변 컨텍스트를 한 번의 왕복으로 돌려줘, 프롬프트에 바로 넣을 수 있습니다.

from wontopos import Client
mem = Client(api_key="wos-...")
mem.add("she prefers tea over coffee", user_id="alice")
# one call: short + long + context
ctx = mem.recall("what does alice drink?", user_id="alice")

5분 안에 첫 recall.

키 하나, 설치 한 줄, 호출 세 번이면 에이전트에 기억이 생깁니다. 이 페이지의 모든 코드는 실제로 실행해 검증했고, 응답도 실물 그대로입니다.

pip install wontopos        # Python
npm install wontopos        # TypeScript / JavaScript
cargo add wontopos          # Rust
# curl - nothing to install, just set WOS_API_KEY

from wontopos import Client

mem = Client(api_key="wos-live-...", user_id="alice")  # set the store once
mem.create_store()              # create it (stores are explicit)
mem.add("she prefers tea over coffee")  # no user_id needed

# one call → short-term + long-term + context
ctx = mem.recall("what does alice drink?")

import { Client } from "wontopos";

const mem = new Client({ apiKey: "wos-live-...", userId: "alice" });  // set the store once
await mem.createStore();            // create it (stores are explicit)
await mem.add("she prefers tea over coffee");  // no userId needed

// one call → short-term + long-term + context
const ctx = await mem.recall("what does alice drink?");

use wontopos::Client;

let mem = Client::new("wos-live-...").with_user("alice");  // set the store once
mem.create_store(None).await?;            // create it (stores are explicit)
mem.add("she prefers tea over coffee", None, json!({})).await?;

// one call → short-term + long-term + context
let ctx = mem.recall("what does alice drink?", None).await?;

# create the store once - stores are explicit
curl -X POST https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice"}'

# store - embedded on the way in, no LLM call
curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"she prefers tea over coffee"}'

# one call → short-term + long-term + context
curl -X POST https://api.wontopos.com/api/v1/memory/recall \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does alice drink?"}'

{"user_id": "alice", "status": "created"}

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

recall()은 네 블록을 돌려줍니다 - short_term(최근 대화), long_term(관련 기억), context(가장 관련된 기억의 주변), 그리고 LLM에게 쓰는 법을 알려주는 instruction. 이 덩어리를 그대로 프롬프트에 넣으면 됩니다.

언어별 메서드 전부 보기 →

저장소 - 만들고, 보고, 지우기.

저장소는 저장·회수의 단위인 user_id - 최종 사용자·에이전트·주제마다 격리된 기억 공간 하나입니다. 저장소는 명시적이라 저장·회수 전에 먼저 만들어야 하고, 아니면 404가 돌아옵니다. 모든 계정엔 default 저장소가 기본으로 있어 만들지 않고도 바로 시작할 수 있습니다.

mem.create_store("alice")        # create (idempotent)
mem.list_stores()              # [{"user_id","created_at"}, ...]
mem.delete_store("alice")        # delete the store + all its memories

await mem.createStore("alice");
await mem.listStores();          // [{ user_id, created_at }, ...]
await mem.deleteStore("alice");     // store + all its memories

mem.create_store("alice").await?;
let stores = mem.list_stores().await?;
mem.delete_store("alice").await?;

# create
curl -X POST https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" -d '{"user_id":"alice"}'
# list
curl https://api.wontopos.com/api/v1/memory/collections -H "X-API-Key: $WOS_API_KEY"
# delete (store + all its memories)
curl -X DELETE https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" -d '{"user_id":"alice"}'

{ "user_id": "alice", "status": "created" }   // "exists" if it already did

{ "collections": [
  { "user_id": "default", "created_at": "2026-06-26T02:23:14Z" },
  { "user_id": "alice",   "created_at": "2026-06-26T02:24:01Z" }
], "count": 2 }

{ "error": { "type": "not_found_error",
  "message": "Store 'ghost' does not exist. Create it first with
              POST /api/v1/memory/collection {\"user_id\":\"ghost\"}, then store or recall." } }

Python - 모든 메서드, 세 그룹.

쓰고, 읽고, 지우고. 아래 모든 예제는 2026-06-10 라이브 API에서 실제로 실행했고, 응답은 실물 그대로입니다.

pip install wontopos

from wontopos import Client

mem = Client(api_key="wos-live-...")  # or read from an env var

모델 선택

mem = Client(api_key="wos-live-...", model="tablet-1")  # default engine
mem.recall("...", user_id="alice")                  # tablet-1
mem.recall("...", user_id="alice", model="tablet-1")  # or pick a model per call

mem.list_models()

[{"id": "tablet-1", "name": "Tablet 1", "available": true, "memory": "shared"}]

위 카탈로그는 항상 지금 쓸 수 있는 모델만 보여줘요 - 다른 id를 넣으면 명확한 에러가 돌아와요. 새 모델은 출시되면 자동으로 거기 나타나요.

쓰기

mem.add("she prefers tea over coffee", user_id="alice")

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

mem.add_turn("alice", "hi", "hello!")

{"status": "ok"}

mem.add_bulk("Alice moved to Brooklyn in March. She works at a design studio downtown.", user_id="alice")

{"elapsed_secs": 0.154154944, "status": "ok", "stored": 1, "total_chunks": 1}

mem.update("alice", old_memory_id="576700aa-...", new_content="she switched to coffee this year")

{"new_memory_id": "07e94433-b7cc-4e49-8d8f-f37fc1a392b7",
 "old_memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "superseded"}

읽기

r = mem.search("what does she drink?", user_id="alice", limit=1)

{"memories": [{
   "id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624",
   "content": "she prefers tea over coffee",
   "category": "general",
   "time_bucket": "2026-06",
   "importance": 0.3,
   "similarity": 0.6316057443618774,
   "is_superseded": false,
   "superseded_by": null,
   "created_at": "2026-06-10T04:20:39.688276876Z"
 }], "search_ms": 315, "total_found": 1}

ctx = mem.recall("what does she drink?", user_id="alice")

{"short_term":  {"count": 2, "turns": [{"role": "user", "content": "hi", ...}]},
 "long_term":   {"count": 4, "memories": [{"content": "she prefers tea over coffee",
                                           "similarity": 0.63, ...}]},
 "context":     {"count": 4, "around_top_memory": [
                  "[match] she prefers tea over coffee",
                  "[after] Alice moved to Brooklyn in March. ..."]},
 "instruction": "Use short_term for recent context, long_term for relevant
                 past memories, context for surrounding conversation of the
                 most relevant memory."}

turns = mem.history("alice")

{"count": 2, "turns": [
   {"role": "user",      "content": "hi",     "timestamp": "2026-06-10T04:20:40.989011337Z"},
   {"role": "assistant", "content": "hello!", "timestamp": "2026-06-10T04:20:40.989013416Z"}
 ], "user_id": "alice"}

mem.stats("alice")

{"short_term_turns": 2, "total_memories": 4, "user_id": "alice"}

삭제

mem.delete("alice", memory_id="576700aa-...")

{"memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "deleted"}

mem.delete_all("alice")

{"memories_deleted": 4, "status": "deleted", "user_id": "alice"}

TypeScript - 모든 메서드, 세 그룹.

쓰고, 읽고, 지우고. 아래 모든 예제는 2026-06-10 라이브 API에서 실제로 실행했고, 응답은 실물 그대로입니다.

npm install wontopos

import { Client } from "wontopos";

const mem = new Client({ apiKey: "wos-live-..." });

모델 선택

const mem = new Client({ apiKey: "wos-live-...", model: "tablet-1" });  // default
mem.recall("...", "alice");                          // tablet-1
mem.withModel("tablet-1").recall("...", "alice");  // or pick a model per call

await mem.listModels();

[{"id": "tablet-1", "name": "Tablet 1", "available": true, "memory": "shared"}]

위 카탈로그는 항상 지금 쓸 수 있는 모델만 보여줘요 - 다른 id를 넣으면 명확한 에러가 돌아와요. 새 모델은 출시되면 자동으로 거기 나타나요.

쓰기

await mem.add("she prefers tea over coffee", "alice");

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

await mem.addTurn("alice", "hi", "hello!");

{"status": "ok"}

await mem.addBulk("Alice moved to Brooklyn in March. She works at a design studio downtown.", "alice");

{"elapsed_secs": 0.154154944, "status": "ok", "stored": 1, "total_chunks": 1}

await mem.update("alice", "576700aa-...", "she switched to coffee this year");

{"new_memory_id": "07e94433-b7cc-4e49-8d8f-f37fc1a392b7",
 "old_memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "superseded"}

읽기

const r = await mem.search("what does she drink?", "alice", 1);

{"memories": [{
   "id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624",
   "content": "she prefers tea over coffee",
   "category": "general",
   "time_bucket": "2026-06",
   "importance": 0.3,
   "similarity": 0.6316057443618774,
   "is_superseded": false,
   "superseded_by": null,
   "created_at": "2026-06-10T04:20:39.688276876Z"
 }], "search_ms": 315, "total_found": 1}

const ctx = await mem.recall("what does she drink?", "alice");

{"short_term":  {"count": 2, "turns": [{"role": "user", "content": "hi", ...}]},
 "long_term":   {"count": 4, "memories": [{"content": "she prefers tea over coffee",
                                           "similarity": 0.63, ...}]},
 "context":     {"count": 4, "around_top_memory": [
                  "[match] she prefers tea over coffee",
                  "[after] Alice moved to Brooklyn in March. ..."]},
 "instruction": "Use short_term for recent context, long_term for relevant
                 past memories, context for surrounding conversation of the
                 most relevant memory."}

const turns = await mem.history("alice");

{"count": 2, "turns": [
   {"role": "user",      "content": "hi",     "timestamp": "2026-06-10T04:20:40.989011337Z"},
   {"role": "assistant", "content": "hello!", "timestamp": "2026-06-10T04:20:40.989013416Z"}
 ], "user_id": "alice"}

await mem.stats("alice");

{"short_term_turns": 2, "total_memories": 4, "user_id": "alice"}

삭제

await mem.delete("alice", "576700aa-...");

{"memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "deleted"}

await mem.deleteAll("alice");

{"memories_deleted": 4, "status": "deleted", "user_id": "alice"}

Rust - 모든 메서드, 세 그룹.

쓰고, 읽고, 지우고. 아래 모든 예제는 2026-06-10 라이브 API에서 실제로 실행했고, 응답은 실물 그대로입니다.

cargo add wontopos

use wontopos::Client;

let mem = Client::new("wos-live-...");

모델 선택

let mem = Client::new("wos-live-...").with_model("tablet-1");  // default
mem.recall("...", "alice").await?;                       // tablet-1
mem.with_model("tablet-1").recall("...", "alice").await?;  // or pick a model per call

mem.list_models().await?;

[{"id": "tablet-1", "name": "Tablet 1", "available": true, "memory": "shared"}]

위 카탈로그는 항상 지금 쓸 수 있는 모델만 보여줘요 - 다른 id를 넣으면 명확한 에러가 돌아와요. 새 모델은 출시되면 자동으로 거기 나타나요.

쓰기

mem.add("she prefers tea over coffee", "alice", json!({})).await?;

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

mem.add_turn("alice", "hi", "hello!").await?;

{"status": "ok"}

mem.add_bulk("Alice moved to Brooklyn in March...", "alice", "general").await?;

{"elapsed_secs": 0.154154944, "status": "ok", "stored": 1, "total_chunks": 1}

mem.update("alice", "576700aa-...", "she switched to coffee this year").await?;

{"new_memory_id": "07e94433-b7cc-4e49-8d8f-f37fc1a392b7",
 "old_memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "superseded"}

읽기

let r = mem.search("what does she drink?", "alice", 1).await?;

{"memories": [{
   "id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624",
   "content": "she prefers tea over coffee",
   "category": "general",
   "time_bucket": "2026-06",
   "importance": 0.3,
   "similarity": 0.6316057443618774,
   "is_superseded": false,
   "superseded_by": null,
   "created_at": "2026-06-10T04:20:39.688276876Z"
 }], "search_ms": 315, "total_found": 1}

let ctx = mem.recall("what does she drink?", "alice").await?;

{"short_term":  {"count": 2, "turns": [{"role": "user", "content": "hi", ...}]},
 "long_term":   {"count": 4, "memories": [{"content": "she prefers tea over coffee",
                                           "similarity": 0.63, ...}]},
 "context":     {"count": 4, "around_top_memory": [
                  "[match] she prefers tea over coffee",
                  "[after] Alice moved to Brooklyn in March. ..."]},
 "instruction": "Use short_term for recent context, long_term for relevant
                 past memories, context for surrounding conversation of the
                 most relevant memory."}

let turns = mem.history("alice").await?;

{"count": 2, "turns": [
   {"role": "user",      "content": "hi",     "timestamp": "2026-06-10T04:20:40.989011337Z"},
   {"role": "assistant", "content": "hello!", "timestamp": "2026-06-10T04:20:40.989013416Z"}
 ], "user_id": "alice"}

mem.stats("alice").await?;

{"short_term_turns": 2, "total_memories": 4, "user_id": "alice"}

삭제

mem.delete("alice", "576700aa-...").await?;

{"memory_id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "deleted"}

mem.delete_all("alice").await?;

{"memories_deleted": 4, "status": "deleted", "user_id": "alice"}

curl - 설치 없이, 같은 메서드.

설치할 SDK가 없습니다 - 어떤 HTTP 클라이언트든 됩니다. 키만 한 번 설정하면 SDK가 감싸는 그 엔드포인트를 그대로 호출해요. Base URL https://api.wontopos.com, 인증은 X-API-Key, 입출력은 JSON.

# set your key once (never hard-code it)
export WOS_API_KEY="wos-live-..."

쓰기

curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"she prefers tea over coffee"}'

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

curl -X POST https://api.wontopos.com/api/v1/memory/store-turn \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","user_msg":"hi","assistant_msg":"hello!"}'

{"status": "ok"}

curl -X POST https://api.wontopos.com/api/v1/memory/supersede \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","old_memory_id":"576700aa-...","new_content":"she switched to coffee this year"}'

{"new_memory_id": "07e94433-...", "old_memory_id": "576700aa-...", "status": "superseded"}

읽기

curl -X POST https://api.wontopos.com/api/v1/memory/search \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does she drink?","max_results":1}'

{"memories": [{"id": "576700aa-...", "content": "she prefers tea over coffee",
   "similarity": 0.63, "is_superseded": false}], "search_ms": 315, "total_found": 1}

curl -X POST https://api.wontopos.com/api/v1/memory/recall \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does she drink?"}'

{"short_term": {"count": 2, "turns": [...]},
 "long_term":  {"count": 4, "memories": [{"content": "she prefers tea over coffee", "similarity": 0.63}]},
 "context":    {"count": 4, "around_top_memory": ["[match] she prefers tea over coffee"]},
 "instruction": "Use short_term for recent context, long_term for relevant past memories..."}

삭제

curl -X POST https://api.wontopos.com/api/v1/memory/forget \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice"}'  # omit memory_id = delete all

{"memories_deleted": 1, "status": "deleted", "user_id": "alice"}

엔드포인트 + 바디 필드 전부 보기 →

Engrams

모델이 호출하는 회수 도구 - 같은 기억 위에서 서로 다른 검색 전략을 씁니다. 하나만 쓰거나 여러 개를 동시에 호출하세요.

엔그램은 계속 추가됩니다 - 목록은 늘어납니다.

회고록 & 아카이브 곧 나옴

이건 호출하는 도구가 아니라 모델 모드입니다. 모델에서 고르면 그냥 검색을 포함한 모든 회수에 시간이 그 방식으로 적혀 돌아옵니다. 곧 나옴.

Time_awareness 곧 나옴

호출 옵션이 아니라 모델 모드. 모델(Time_awareness-memoir 또는 Time_awareness-archive)을 고르면 - 그냥 검색이든 recall이든 엔그램이든 - 추가 파라미터 없이 모든 회수가 그 방식으로 돌아옵니다. 회고록은 사람이 기억하듯, 아카이브는 정확한 기록 그대로 - 차이는 시간을 적는 방식에서 가장 잘 드러납니다. Time_awareness- 접두는 앞으로 다른 능력이 들어올 자리를 남깁니다.

# plain search - no engram - on a memoir model
r = mem.search("what does Alice drink?", user_id="alice", model="Time_awareness-memoir", tz=9)
# every hit gets a .time field → "a couple weeks ago"  (archive model → "2 weeks ago (Jun 09)")

// plain search - no engram - on a memoir model
const r = await mem.withModel("Time_awareness-memoir").search("what does Alice drink?", "alice", 10, { tz: 9 });

// model picks the mode; tz over HTTP via the X-WOS-Timezone header
let r = mem.with_model("Time_awareness-memoir").search("what does Alice drink?", "alice", 10).await?;

curl -X POST https://api.wontopos.com/api/v1/memory/search \
  -H "X-API-Key: wos-live-..." -H "X-WOS-Model: Time_awareness-memoir" -H "X-WOS-Timezone: 9" \
  -d '{"user_id":"alice","query":"what does Alice drink?"}'
# each memory comes back with a "time" field; use Time_awareness-archive for exact time

tz는 호출자의 UTC 오프셋(시간) - 라 "this morning" 같은 표현과 새벽 4시 경계가 그 사람 현지 시간으로 찍힙니다. 안 주면 UTC, HTTP에선 X-WOS-Timezone 헤더. 지역별 대략값: 미국 동부 -5, 중부 -6, 서부 -8 · 영국 / 리스본 0 · 중부 유럽 +1 · 동유럽 +2 · 인도 +5.5 · 중국 / 싱가포르 +8 · 한국 / 일본 +9 · 시드니 +10. (표준시 기준 - 서머타임이면 일부 지역은 +1, 사용자가 실제로 쓰는 값을 그대로 넣으세요.)

같은 검색, 두 모델 - 기억은 똑같고 time만 달라집니다:

{ "count": 3, "memories": [
  { "content": "Alice prefers tea over coffee", "time": "a couple weeks ago" },
  { "content": "met Alice at the cafe downtown",  "time": "yesterday afternoon" },
  { "content": "Alice moved to Brooklyn",          "time": "about half a year ago" }
] }

{ "count": 3, "memories": [
  { "content": "Alice prefers tea over coffee", "time": "2 weeks ago (Jun 09)" },
  { "content": "met Alice at the cafe downtown",  "time": "yesterday at 14:00" },
  { "content": "Alice moved to Brooklyn",          "time": "6 months ago (Dec 2025)" }
] }

위 값은 전부 렌더러의 실제 출력입니다. "어제" 두 줄을 보세요: 회고록은 낮과 밤을 가르지만 - 하루는 잠 한 번 - 아카이브는 시계 시각 하나로 적고 낮·밤을 나누지 않습니다.

모드별 시간 읽는 법

회고록 - 사람이 실제로 말하는 방식. 최근은 비교적 또렷하다가(약 15분 전, 30분 전) 멀어질수록 표현이 넓어집니다 - 2주쯤 전, 반년쯤 전, 몇 년 전 - 기억 자체가 멀수록 풀어지듯. 하루 안에서는 시계 대신 landmark를 씁니다: 오늘 아침, 어젯밤, 어제 오후. 그리고 하루는 달력 한 칸이 아니라 잠 한 번: 경계가 현지 새벽 4시쯤이라, 늦은 밤도 여전히 '오늘 밤'으로 읽히지 벌써 내일이 되지 않습니다.

아카이브 - 정밀, 항상 앵커와 함께. 모든 줄에 정확한 경과 시간 + 모델이 계산할 수 있는 절대 기준이 붙고, 가까울수록 앵커가 촘촘해집니다: 오늘은 시계(8시간 전, 07:10), 이번 주는 요일+시계(2일 전 (화 15:10)), 이번 달은 날짜(지난주 (6월 16일)), 그 너머는 월·연도(6개월 전 (2025년 12월)). 모호함 없이, 틀림 없이.

deep_recall

멀티홉 회수. 쿼리로 검색한 뒤 최상위 매치의 내용으로 한 번 더 검색해 단일 검색이 놓칠 연결 맥락을 끌어옵니다. 기억이 서로를 참조할 때(사람 → 프로젝트 → 세부) 가장 좋습니다. 최대 ~12개.

out = mem.engram("deep_recall", "what should I know about Alice?", user_id="alice")

const out = await mem.engram("deep_recall", "what should I know about Alice?", "alice");

let out = mem.engram("deep_recall", "what should I know about Alice?", "alice").await?;

curl -X POST https://api.wontopos.com/api/v1/engram/run \
  -H "X-API-Key: wos-live-..." -H "Content-Type: application/json" \
  -d '{"name":"deep_recall","user_id":"alice","query":"what should I know about Alice?"}'

{ "engram": "deep_recall", "hops": 2, "count": 12,
  "memories": [ ... ],
  "usage": { "input_tokens": 5, "output_tokens": 61 } }

timeline

시간순 회수. 관련도가 아니라 사건 발생 시점 기준 최신순으로 정렬해 반환합니다. "언제 X했지", 이력, 순서 질문에. 최대 15개.

events = mem.engram("timeline", "project milestones", user_id="alice")

const events = await mem.engram("timeline", "project milestones", "alice");

let events = mem.engram("timeline", "project milestones", "alice").await?;

curl -X POST https://api.wontopos.com/api/v1/engram/run \
  -H "X-API-Key: wos-live-..." -H "Content-Type: application/json" \
  -d '{"name":"timeline","user_id":"alice","query":"project milestones"}'

{ "engram": "timeline", "hops": 1, "count": 15,
  "memories": [ ... ],
  "usage": { "input_tokens": 4, "output_tokens": 88 } }

gather

넓은 수집. 검색 후 상위 세 매치 주변을 확장해 deep_recall보다 더 넓게 훑습니다. 한 사람·프로젝트·주제 관련된 걸 한 번에 다 모을 때. 최대 ~18개.

related = mem.engram("gather", "everything about Project Atlas", user_id="alice")

const related = await mem.engram("gather", "everything about Project Atlas", "alice");

let related = mem.engram("gather", "everything about Project Atlas", "alice").await?;

curl -X POST https://api.wontopos.com/api/v1/engram/run \
  -H "X-API-Key: wos-live-..." -H "Content-Type: application/json" \
  -d '{"name":"gather","user_id":"alice","query":"everything about Project Atlas"}'

{ "engram": "gather", "hops": 4, "count": 18,
  "memories": [ ... ],
  "usage": { "input_tokens": 6, "output_tokens": 142 } }

모든 엔드포인트, 하나의 Base URL.

SDK 없이도 됩니다 - 어떤 HTTP 클라이언트든 가능. Base URL https://api.wontopos.com, 인증은 X-API-Key 헤더, 입출력은 JSON. 기억 작업은 POST, 저장소 관리는 /collection에 POST / GET / DELETE. 저장소가 먼저 있어야 하고(Stores 참고), 없으면 404.

# create the store once (stores are explicit)
curl -X POST https://api.wontopos.com/api/v1/memory/collection \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice"}'

# store a memory
curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"she prefers tea over coffee"}'

# recall - one call, ready for your prompt
curl -X POST https://api.wontopos.com/api/v1/memory/recall \
  -H "X-API-Key: $WOS_API_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","query":"what does alice drink?"}'

{"id": "576700aa-f0e0-4c26-99a0-10e2d5b0d624", "status": "stored (1 chunks)"}

기능은 모두에게 동일.
티어는 한도만 올립니다.

모든 티어가 같은 엔진을 씁니다 - 같은 recall 품질, 같은 다국어, 모든 메서드. Tier 5까지는 누적 충전액이 쌓이면 신청이나 영업 통화 없이 자동으로 올라갑니다. Enterprise(Tier 6)만 예외입니다.

지출 한도

티어마다 한 달에 쓸 수 있는 금액에 상한이 있습니다. 누적 충전액이 다음 기준에 도달하면 즉시 승급됩니다.

속도 한도

속도 한도는 계정 단위입니다 - 한 계정의 모든 API 키가 하나의 한도를 공유하며, 티어에 따라 올라갑니다. 넘으면 retry-after 헤더와 함께 429를 돌려주므로, 잠시 물러났다(1초 → 2초 → 4초) 재시도하면 됩니다. 모든 엔드포인트가 멱등에 친화적이라 재시도해도 안전합니다.

Enterprise(Tier 6)는 커스텀 한도, SLA, 전담 지원, 그리고 선택적 self-host 라이선스를 제공합니다 - 문의하세요.

문제가 생겼을 때.

에러는 안정적인 type, 사람이 읽는 메시지, 그리고 문의 시 함께 보낼 수 있는 request_id가 담긴 JSON 봉투로 옵니다.

{"type": "error", "error": {
   "type": "authentication_error",
   "message": "Invalid or revoked API key.",
   "request_id": "063f8b83-eee2-4383-a5cf-11e4bcd29d7c"
 }}

# SDK error handling (Python)
from wontopos import Client, WosError

try:
    mem.search("...", user_id="alice")
except WosError as e:
    if e.status == 401: ...  # bad key
    elif e.status == 429: ...  # back off and retry

요청 한도는 계정 단위로 모든 키가 공유하며, 티어에 따라 올라갑니다 - 사용량 티어 참고. 계정 사용량은 콘솔에 표시됩니다.

당신의 서버, 당신의 데이터.

엔진을 자체 인프라에서 운영할 수 있습니다 - 같은 API, 같은 SDK. 클라이언트가 바라보는 주소만 바꾸면 나머지는 그대로입니다.

mem = Client(api_key="...", base_url="https://wos.your-host.com")

const mem = new Client({ apiKey: "...", baseUrl: "https://wos.your-host.com" });

let mem = Client::with_base_url("...", "https://wos.your-host.com");

• 데이터 주권. 기억이 당신의 네트워크 밖으로 나가지 않습니다.
• 동일한 인터페이스. 같은 메서드와 엔드포인트가 동일하게 동작합니다.
• 라이선스. 셀프 호스팅 패키지는 배포 단위로 협의합니다 - 문의하기.

컨텍스트 윈도를 넘어서.

WOS는 어떤 LLM 컨텍스트 윈도보다도 큰 140만 토큰 히스토리에서도 회수하고, 여전히 ~1,470 토큰의 짧은 조각만 돌려줍니다.

에이전트의 기억은 프롬프트에 들어가는 양에 갇히지 않습니다. 전부 보관하고 중요한 것만 회수합니다. 히스토리가 아무리 커져도 마찬가지입니다.

비공개, 그리고 당신의 것.

데이터는 당신의 저장소에 머뭅니다. 저희는 그것으로 학습하지도, 열람하지도, 재사용하지도 않습니다 - 회수할 수 있게 정리만 합니다.

• BYOK. LLM 키는 요청마다 전달되며 저장되지 않습니다.
• 격리. 기억은 계정별, 그리고 user_id별로 분리됩니다.
• GDPR 삭제 & 셀프 호스팅. 한 번의 호출로 사용자를 삭제하고, 원하면 엔진을 자체 환경에서 운영할 수 있습니다.