에이전트 메모리 사용하기
에이전트 메모리 사용하기 (Using agent memory)
각 Managed Agents 세션은 기본적으로 새로운 컨텍스트로 시작해요. 세션이 끝나면 에이전트가 쌓은 상태는 사라져요. 메모리 스토어(memory store)는 에이전트가 세션을 넘어 정보를 이어가게 해줘요: 사용자 선호, 프로젝트 규칙, 이전 실수, 도메인 컨텍스트 같은 것들이죠.
출처: 문서
본문
각 Managed Agents 세션은 기본적으로 새로운 컨텍스트로 시작해요. 세션이 끝나면 에이전트가 쌓아둔 상태는 사라져요. 메모리 스토어는 에이전트가 세션을 넘어 정보를 이어가게 해줘요: 사용자 선호, 프로젝트 규칙, 이전 실수, 도메인 컨텍스트 같은 것들이에요.
GET /v1/memory_stores/{memory_store_id}/memories behaves the same under either header: results come back in a stable, server-defined order, and path_prefix and depth apply the same way.
Overview
메모리 스토어는 클로드용으로 최적화된 텍스트 문서의 워크스페이스 범위 모음이에요. 스토어를 세션에 붙이면 세션 샌드박스 안의 디렉터리로 마운트돼요. 에이전트는 나머지 파일시스템에 쓰는 것과 같은 파일 도구로 그것을 읽고 쓰며, 각 마운트를 설명하는 메모가 시스템 프롬프트에 자동으로 추가되어 에이전트가 어디를 봐야 하는지 알려줘요. 이 상호작용에는 에이전트 도구세트가 필요하므로, 에이전트 생성 시 활성화하세요. 셀프 호스팅 샌드박스에서는 그 디렉터리가 라이브 마운트가 아니에요. 대신 SDK의 환경 워커가 에이전트의 도구가 실행되기 전에 각 붙은 스토어를 샌드박스로 다운로드하고 그 복사본을 스토어와 동기화 상태로 유지해요.
스토어의 각 memory는 경로로 주소가 매겨지며, API나 Claude Console로 직접 읽고 편집할 수 있어서 튜닝, 가져오기, 내보내기가 가능해요.
메모리의 모든 변경은 불변의 memory version(기억 버전)을 만들어, 에이전트가 쓰는 모든 것에 대한 감사 추적과 시점 복구를 제공해요.
Create a memory store
스토어에 name과 description을 주세요. 설명은 에이전트에게 전달되어 스토어가 무엇을 담고 있는지 알려줘요.
<File filename="memory_store.yaml">
```yaml
# yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/memory_store.json
name: User Preferences
description: Per-user preferences and project context.
```
</File>
store = client.beta.memory_stores.create(
name="User Preferences",
description="Per-user preferences and project context.",
)
print(store.id) # memstore_01Hx...
const store = await client.beta.memoryStores.create({
name: "User Preferences",
description: "Per-user preferences and project context."
});
console.log(store.id); // memstore_01Hx...
var store = await client.Beta.MemoryStores.Create(new()
{
Name = "User Preferences",
Description = "Per-user preferences and project context.",
});
Console.WriteLine(store.ID); // memstore_01Hx...
store, err := client.Beta.MemoryStores.New(ctx, anthropic.BetaMemoryStoreNewParams{
Name: "User Preferences",
Description: anthropic.String("Per-user preferences and project context."),
})
if err != nil {
panic(err)
}
fmt.Println(store.ID) // memstore_01Hx...
var store = client.beta().memoryStores().create(
MemoryStoreCreateParams.builder()
.name("User Preferences")
.description("Per-user preferences and project context.")
.build()
);
IO.println(store.id()); // memstore_01Hx...
use Anthropic\Client;
$client = new Client();
$store = $client->beta->memoryStores->create(
name: 'User Preferences',
description: 'Per-user preferences and project context.',
);
echo "{$store->id}\n"; // memstore_01Hx...
require "anthropic"
client = Anthropic::Client.new
store = client.beta.memory_stores.create(
name: "User Preferences",
description: "Per-user preferences and project context."
)
puts store.id # memstore_01Hx...
메모리 스토어 id(memstore_...)는 스토어를 세션에 붙일 때 전달하는 값이에요.
Seed it with content (optional)
어떤 에이전트도 실행되기 전에 스토어를 참조 자료로 미리 채워 두세요:
ant beta:memory-stores:memories create \
--memory-store-id "$store_id" \
--path "/formatting_standards.md" \
--content "All reports use GAAP formatting. Dates are ISO-8601..." \
> /dev/null
client.beta.memory_stores.memories.create(
store.id,
path="/formatting_standards.md",
content="All reports use GAAP formatting. Dates are ISO-8601...",
)
await client.beta.memoryStores.memories.create(store.id, {
path: "/formatting_standards.md",
content: "All reports use GAAP formatting. Dates are ISO-8601..."
});
await client.Beta.MemoryStores.Memories.Create(store.ID, new()
{
Path = "/formatting_standards.md",
Content = "All reports use GAAP formatting. Dates are ISO-8601...",
});
_, err = client.Beta.MemoryStores.Memories.New(ctx, store.ID, anthropic.BetaMemoryStoreMemoryNewParams{
Path: "/formatting_standards.md",
Content: anthropic.String("All reports use GAAP formatting. Dates are ISO-8601..."),
})
if err != nil {
panic(err)
}
client.beta().memoryStores().memories().create(
store.id(),
MemoryCreateParams.builder()
.path("/formatting_standards.md")
.content("All reports use GAAP formatting. Dates are ISO-8601...")
.build()
);
$client->beta->memoryStores->memories->create(
$store->id,
path: '/formatting_standards.md',
content: 'All reports use GAAP formatting. Dates are ISO-8601...',
);
client.beta.memory_stores.memories.create(
store.id,
path: "/formatting_standards.md",
content: "All reports use GAAP formatting. Dates are ISO-8601..."
)
Attach a memory store to a session
메모리 스토어는 세션이 만들어질 때 세션의 resources[] 배열에 붙여져요. 파일 리소스와 달리 메모리 스토어는 세션 생성 시에만 붙일 수 있으며, 실행 중인 세션에 추가하거나 제거하는 것은 지원되지 않아요. 클라우드와 셀프 호스팅 환경의 세션에서 메모리 스토어를 같은 방식으로 붙여요. 셀프 호스팅 환경은 memory_store 리소스만 받아요.
에이전트가 이 스토어를 어떻게 사용해야 하는지에 대한 세션별 지침을 주려면 선택적으로 instructions를 포함하세요. 스토어의 name과 description과 함께 에이전트에게 표시되며, 4,096자로 제한돼요.
access도 구성할 수 있어요. 기본은 read_write(다음 예시에 명시적으로 표시됨)이고 read_only도 지원돼요.
ant beta:sessions create <<YAML
agent: $agent_id
environment_id: $environment_id
resources:
- type: memory_store
memory_store_id: $store_id
access: read_write
instructions: User preferences and project context. Check before starting any task.
YAML
session = client.beta.sessions.create(
agent=agent.id,
environment_id=environment.id,
resources=[
{
"type": "memory_store",
"memory_store_id": store.id,
"access": "read_write",
"instructions": "User preferences and project context. Check before starting any task.",
}
],
)
const session = await client.beta.sessions.create({
agent: agent.id,
environment_id: environment.id,
resources: [
{
type: "memory_store",
memory_store_id: store.id,
access: "read_write",
instructions: "User preferences and project context. Check before starting any task."
}
]
});
var session = await client.Beta.Sessions.Create(new()
{
Agent = agent.ID,
EnvironmentID = environment.ID,
Resources =
[
new BetaManagedAgentsMemoryStoreResourceParam
{
Type = "memory_store",
MemoryStoreID = store.ID,
Access = "read_write",
Instructions = "User preferences and project context. Check before starting any task.",
},
],
});
session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
Agent: anthropic.BetaSessionNewParamsAgentUnion{
OfString: anthropic.String(agent.ID),
},
EnvironmentID: environment.ID,
Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
OfMemoryStore: &anthropic.BetaManagedAgentsMemoryStoreResourceParam{
Type: anthropic.BetaManagedAgentsMemoryStoreResourceParamTypeMemoryStore,
MemoryStoreID: store.ID,
Access: anthropic.BetaManagedAgentsMemoryStoreResourceParamAccessReadWrite,
Instructions: anthropic.String("User preferences and project context. Check before starting any task."),
},
}},
})
if err != nil {
panic(err)
}
var session = client.beta().sessions().create(
SessionCreateParams.builder()
.agent(agent.id())
.environmentId(environment.id())
.addResource(
BetaManagedAgentsMemoryStoreResourceParam.builder()
.type(BetaManagedAgentsMemoryStoreResourceParam.Type.MEMORY_STORE)
.memoryStoreId(store.id())
.access(BetaManagedAgentsMemoryStoreResourceParam.Access.READ_WRITE)
.instructions("User preferences and project context. Check before starting any task.")
.build()
)
.build()
);
$session = $client->beta->sessions->create(
agent: $agent->id,
environmentID: $environment->id,
resources: [
[
'type' => 'memory_store',
'memory_store_id' => $store->id,
'access' => 'read_write',
'instructions' => 'User preferences and project context. Check before starting any task.',
],
],
);
session = client.beta.sessions.create(
agent: agent.id,
environment_id: environment.id,
resources: [
{
type: "memory_store",
memory_store_id: store.id,
access: "read_write",
instructions: "User preferences and project context. Check before starting any task."
}
]
)
세션당 최대 8개 메모리 스토어가 지원돼요. 메모리의 다른 부분이 다른 소유자나 접근 규칙을 가질 때 여러 스토어를 붙이세요. 일반적인 이유:
- Shared reference material: one read-only store attached to many sessions (standards, conventions, domain knowledge), kept separate from each session's own read-write store.
- Mapping to your product's structure: one store per end user, per team, or per project, while sharing a single agent configuration.
- Different lifecycles: a store that outlives any single session, or one you want to archive on its own schedule.
How the agent accesses memory
각 붙은 스토어는 세션 샌드박스 안 /mnt/memory/ 아래의 디렉터리로 마운트돼요. 디렉터리 이름은 스토어의 표시 이름을 파일시스템 안전한 슬러그로 정화한 것이에요(소문자화, 영숫자가 아닌 연속은 단일 하이픈이 됨). 그래서 "Demo Memory"라는 스토어는 /mnt/memory/demo-memory/에 마운트돼요. 정확한 경로는 세션의 메모리 스토어 리소스에 있는 mount_path 필드로 반환되니, 직접 구성하지 말고 거기서 읽으세요. 에이전트는 표준 에이전트 도구세트로 스토어를 읽고 써요. 마운트 경로 아래의 쓰기는 스토어로 다시 저장되고, 공유하는 세션 간에 동기화 상태를 유지해요. /mnt/memory/ 아래의 다른 경로에 대한 쓰기는 실패해요. 샌드박스가 그 부모 디렉터리를 읽기 전용으로 마운트하기 때문이에요. 각 마운트에 대한 짧은 설명(표시 이름, 마운트 경로, 접근 모드, 스토어 description, 그리고 instructions)은 시스템 프롬프트에 자동으로 추가돼요.
access는 파일시스템 수준에서 강제돼요: read_only 마운트는 쓰기를 거부하고, read_write 마운트에 대한 쓰기는 세션에 귀속되는 memory version을 만들어요.
For a read_only store, the worker's write and edit tools refuse changes under that directory and the worker never uploads anything from it. To learn how the worker resolves write conflicts, and what the bash tool can still change in a read-only store's local copy, see Read-only stores and conflicts.
에이전트의 읽기와 쓰기는 마운트에 닿은 도구에 대한 평범한 agent.tool_use와 agent.tool_result 이벤트로 이벤트 스트림에 나타나요.
View and edit memories
메모리 스토어는 API를 통해 직접 관리할 수 있어요. 검토 워크플로 구축, 잘못된 메모리 수정, 세션이 실행되기 전 스토어 시드에 사용하세요.
List memories
스토어의 메모리를 나열해요. 결과는 안정적인 서버 정의 순서로 반환돼요.
path_prefixscopes the list to one directory. It must end with/and matches whole path segments, sopath_prefix=/notes/returns/notes/todo.mdbut not/notes-archive/todo.md.depthcontrols how deep the listing goes belowpath_prefix: omit it (or pass0) to list the whole subtree, or pass1to list only the immediate children. Other values return a400error.
ant beta:memory-stores:memories list \
--memory-store-id "$store_id" \
--path-prefix "/"
page = client.beta.memory_stores.memories.list(
store.id,
path_prefix="/",
)
for item in page.data:
print(item.type, item.path)
const page = await client.beta.memoryStores.memories.list(store.id, {
path_prefix: "/"
});
for (const item of page.data) {
console.log(item.type, item.path);
}
var page = await client.Beta.MemoryStores.Memories.List(store.ID, new()
{
PathPrefix = "/",
});
await foreach (var item in page.Paginate())
{
var line = item.Match(m => $"memory {m.Path}", p => $"memory_prefix {p.Path}");
Console.WriteLine(line);
}
page, err := client.Beta.MemoryStores.Memories.List(ctx, store.ID, anthropic.BetaMemoryStoreMemoryListParams{
PathPrefix: anthropic.String("/"),
})
if err != nil {
panic(err)
}
for _, item := range page.Data {
fmt.Println(item.Type, item.Path)
}
var page = client.beta().memoryStores().memories().list(
store.id(),
MemoryListParams.builder()
.pathPrefix("/")
.build()
);
for (var item : page.data()) {
item.memory().ifPresent(m -> IO.println("memory " + m.path()));
item.memoryPrefix().ifPresent(p -> IO.println("memory_prefix " + p.path()));
}
$page = $client->beta->memoryStores->memories->list(
$store->id,
pathPrefix: '/',
);
foreach ($page->data as $item) {
echo "{$item->type} {$item->path}\n";
}
page = client.beta.memory_stores.memories.list(
store.id,
path_prefix: "/"
)
page.data.each do |entry|
puts "#{entry.type} #{entry.path}"
end
전체 파라미터와 응답 스키마는 List memories reference를 참고하세요.
Read a memory
개별 메모리를 가져오면 전체 내용이 반환돼요.
ant beta:memory-stores:memories retrieve \
--memory-store-id "$store_id" \
--memory-id "$mem_id"
retrieved = client.beta.memory_stores.memories.retrieve(
mem.id,
memory_store_id=store.id,
)
print(retrieved.content)
const retrieved = await client.beta.memoryStores.memories.retrieve(mem.id, {
memory_store_id: store.id
});
console.log(retrieved.content);
var retrieved = await client.Beta.MemoryStores.Memories.Retrieve(mem.ID, new()
{
MemoryStoreID = store.ID,
});
Console.WriteLine(retrieved.Content);
retrieved, err := client.Beta.MemoryStores.Memories.Get(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryGetParams{
MemoryStoreID: store.ID,
})
if err != nil {
panic(err)
}
fmt.Println(retrieved.Content)
var retrieved = client.beta().memoryStores().memories().retrieve(
mem.id(),
MemoryRetrieveParams.builder().memoryStoreId(store.id()).build()
);
IO.println(retrieved.content().orElseThrow());
$retrieved = $client->beta->memoryStores->memories->retrieve($mem->id, memoryStoreID: $store->id);
echo "{$retrieved->content}\n";
retrieved = client.beta.memory_stores.memories.retrieve(
mem.id,
memory_store_id: store.id
)
puts retrieved.content
전체 파라미터와 응답 스키마는 Retrieve a memory reference를 참고하세요.
Create a memory
memories.create는 주어진 path에 메모리를 만들어요. Create는 덮어쓰지 않아요. 기존 메모리를 바꾸려면 memories.update를 사용하세요.
ant beta:memory-stores:memories create \
--memory-store-id "$store_id" \
--path "/preferences/formatting.md" \
--content "Always use tabs, not spaces."
mem = client.beta.memory_stores.memories.create(
store.id,
path="/preferences/formatting.md",
content="Always use tabs, not spaces.",
)
const mem = await client.beta.memoryStores.memories.create(store.id, {
path: "/preferences/formatting.md",
content: "Always use tabs, not spaces."
});
var mem = await client.Beta.MemoryStores.Memories.Create(store.ID, new()
{
Path = "/preferences/formatting.md",
Content = "Always use tabs, not spaces.",
});
mem, err := client.Beta.MemoryStores.Memories.New(ctx, store.ID, anthropic.BetaMemoryStoreMemoryNewParams{
Path: "/preferences/formatting.md",
Content: anthropic.String("Always use tabs, not spaces."),
})
if err != nil {
panic(err)
}
var mem = client.beta().memoryStores().memories().create(
store.id(),
MemoryCreateParams.builder()
.path("/preferences/formatting.md")
.content("Always use tabs, not spaces.")
.build()
);
$mem = $client->beta->memoryStores->memories->create(
$store->id,
path: '/preferences/formatting.md',
content: 'Always use tabs, not spaces.',
);
mem = client.beta.memory_stores.memories.create(
store.id,
path: "/preferences/formatting.md",
content: "Always use tabs, not spaces."
)
전체 파라미터와 응답 스키마는 Create a memory reference를 참고하세요.
Update a memory
memories.update는 ID로 기존 메모리를 수정해요. content, path(이름 변경), 또는 둘 다 변경할 수 있어요. 예시는 메모리를 보관 경로로 이름을 바꿔요:
ant beta:memory-stores:memories update \
--memory-store-id "$store_id" \
--memory-id "$mem_id" \
--path "/archive/2026_q1_formatting.md" \
> /dev/null
client.beta.memory_stores.memories.update(
mem.id,
memory_store_id=store.id,
path="/archive/2026_q1_formatting.md",
)
await client.beta.memoryStores.memories.update(mem.id, {
memory_store_id: store.id,
path: "/archive/2026_q1_formatting.md"
});
await client.Beta.MemoryStores.Memories.Update(mem.ID, new()
{
MemoryStoreID = store.ID,
Path = "/archive/2026_q1_formatting.md",
});
_, err = client.Beta.MemoryStores.Memories.Update(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryUpdateParams{
MemoryStoreID: store.ID,
Path: anthropic.String("/archive/2026_q1_formatting.md"),
})
if err != nil {
panic(err)
}
client.beta().memoryStores().memories().update(
mem.id(),
MemoryUpdateParams.builder()
.memoryStoreId(store.id())
.path("/archive/2026_q1_formatting.md")
.build()
);
$client->beta->memoryStores->memories->update(
$mem->id,
memoryStoreID: $store->id,
path: '/archive/2026_q1_formatting.md',
);
client.beta.memory_stores.memories.update(
mem.id,
memory_store_id: store.id,
path: "/archive/2026_q1_formatting.md"
)
전체 파라미터와 응답 스키마는 Update a memory reference를 참고하세요.
Safe content edits (optimistic concurrency)
동시 쓰기를 덮어쓰지 않으려면 content_sha256 선행 조건을 전달하세요. 저장된 콘텐츠 해시가 여러분이 읽은 것과 여전히 일치할 때만 업데이트가 적용돼요. 불일치 시 메모리를 다시 읽고 최신 상태에 대해 재시도하세요.
ant beta:memory-stores:memories update \
--memory-store-id "$store_id" \
--memory-id "$mem_id" \
--content "CORRECTED: Always use 2-space indentation." \
--precondition "{type: content_sha256, content_sha256: $mem_sha}" \
> /dev/null
client.beta.memory_stores.memories.update(
memory_id=mem.id,
memory_store_id=store.id,
content="CORRECTED: Always use 2-space indentation.",
precondition={"type": "content_sha256", "content_sha256": mem.content_sha256},
)
await client.beta.memoryStores.memories.update(mem.id, {
memory_store_id: store.id,
content: "CORRECTED: Always use 2-space indentation.",
precondition: { type: "content_sha256", content_sha256: mem.content_sha256 }
});
await client.Beta.MemoryStores.Memories.Update(mem.ID, new()
{
MemoryStoreID = store.ID,
Content = "CORRECTED: Always use 2-space indentation.",
Precondition = new BetaManagedAgentsPrecondition
{
Type = "content_sha256",
ContentSha256 = mem.ContentSha256,
},
});
_, err = client.Beta.MemoryStores.Memories.Update(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryUpdateParams{
MemoryStoreID: store.ID,
Content: anthropic.String("CORRECTED: Always use 2-space indentation."),
Precondition: anthropic.BetaManagedAgentsPreconditionParam{
Type: anthropic.BetaManagedAgentsPreconditionTypeContentSha256,
ContentSha256: anthropic.String(mem.ContentSha256),
},
})
if err != nil {
panic(err)
}
client.beta().memoryStores().memories().update(
mem.id(),
MemoryUpdateParams.builder()
.memoryStoreId(store.id())
.content("CORRECTED: Always use 2-space indentation.")
.precondition(
BetaManagedAgentsPrecondition.builder()
.type(BetaManagedAgentsPrecondition.Type.CONTENT_SHA256)
.contentSha256(mem.contentSha256())
.build()
)
.build()
);
$client->beta->memoryStores->memories->update(
$mem->id,
memoryStoreID: $store->id,
content: 'CORRECTED: Always use 2-space indentation.',
precondition: ['type' => 'content_sha256', 'content_sha256' => $mem->contentSha256],
);
client.beta.memory_stores.memories.update(
mem.id,
memory_store_id: store.id,
content: "CORRECTED: Always use 2-space indentation.",
precondition: {type: "content_sha256", content_sha256: mem.content_sha256}
)
Delete a memory
ant beta:memory-stores:memories delete \
--memory-store-id "$store_id" \
--memory-id "$mem_id" \
> /dev/null
client.beta.memory_stores.memories.delete(
mem.id,
memory_store_id=store.id,
)
await client.beta.memoryStores.memories.delete(mem.id, {
memory_store_id: store.id
});
await client.Beta.MemoryStores.Memories.Delete(mem.ID, new()
{
MemoryStoreID = store.ID,
});
_, err = client.Beta.MemoryStores.Memories.Delete(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryDeleteParams{
MemoryStoreID: store.ID,
})
if err != nil {
panic(err)
}
client.beta().memoryStores().memories().delete(
mem.id(),
MemoryDeleteParams.builder().memoryStoreId(store.id()).build()
);
$client->beta->memoryStores->memories->delete($mem->id, memoryStoreID: $store->id);
client.beta.memory_stores.memories.delete(
mem.id,
memory_store_id: store.id
)
전체 파라미터와 응답 스키마는 Delete a memory reference를 참고하세요.
Audit memory changes
메모리에 대한 모든 변경은 불변의 memory version(memver_...)을 만들어요. 버전 엔드포인트로 누가 언제 무엇을 바꿨는지 감사하고, 이전 스냅샷을 검사하거나 복원하고, redact로 이력에서 민감한 내용을 지울 수 있어요.
버전은 (개별 메모리가 아니라) 스토어에 속하며, 메모리 자체가 삭제돼도 삭제되지 않아요. 그래서 감사 추적은 아래 설명된 보존 조건에 따라 삭제된 메모리까지 다뤄요. 버전은 작성 후 30일 동안 보존되지만, 활성 메모리의 최근 버전은 나이와 무관하게 항상 유지되므로 자주 바뀌지 않는 메모리는 30일을 넘겨 이력을 보존할 수 있어요. 활성 memories.retrieve 호출은 항상 최신 버전을 반환하고, 버전 엔드포인트는 보존된 이력을 줘요.
전용 restore 엔드포인트는 없어요. 롤백하려면 원하는 버전을 조회하고 그 content를 memories.update(부모 메모리가 삭제됐다면, 원하는 버전이 여전히 보존되어 있을 때 memories.create)로 다시 써넣으세요.
과거 memory version은 30일 후에 삭제될 수 있어요. 메모리 이력을 더 오래 보존하려면 API로 버전을 내보내세요.
List versions
최신순으로 스토어의 버전 이력을 나열해요. 이 예시는 단일 메모리의 이력으로 필터링해요:
ant beta:memory-stores:memory-versions list \
--memory-store-id "$store_id" \
--memory-id "$mem_id" \
--format json
versions = client.beta.memory_stores.memory_versions.list(
store.id,
memory_id=mem.id,
)
for version in versions:
print(f"{version.id}: {version.operation}")
version_id = versions.data[1].id
const versions = await client.beta.memoryStores.memoryVersions.list(store.id, {
memory_id: mem.id
});
for await (const v of versions) {
console.log(`${v.id}: ${v.operation}`);
}
const versionId = versions.data[1].id;
var versions = await client.Beta.MemoryStores.MemoryVersions.List(store.ID, new()
{
MemoryID = mem.ID,
});
var versionIds = new List<string>();
await foreach (var v in versions.Paginate())
{
Console.WriteLine($"{v.ID}: {v.Operation.Raw()}");
versionIds.Add(v.ID);
}
var versionId = versionIds[1];
versions := client.Beta.MemoryStores.MemoryVersions.ListAutoPaging(ctx, store.ID, anthropic.BetaMemoryStoreMemoryVersionListParams{
MemoryID: anthropic.String(mem.ID),
})
for versions.Next() {
v := versions.Current()
fmt.Printf("%s: %s\n", v.ID, v.Operation)
}
if err := versions.Err(); err != nil {
panic(err)
}
vpage, err := client.Beta.MemoryStores.MemoryVersions.List(ctx, store.ID, anthropic.BetaMemoryStoreMemoryVersionListParams{
MemoryID: anthropic.String(mem.ID),
})
if err != nil {
panic(err)
}
versionID := vpage.Data[1].ID
var versions = client.beta().memoryStores().memoryVersions().list(
store.id(),
MemoryVersionListParams.builder().memoryId(mem.id()).build()
);
for (var v : versions.autoPager()) {
IO.println(v.id() + ": " + v.operation());
}
var versionId = versions.data().get(1).id();
$versions = $client->beta->memoryStores->memoryVersions->list(
$store->id,
memoryID: $mem->id,
);
foreach ($versions->pagingEachItem() as $v) {
echo "{$v->id}: {$v->operation}\n";
}
$versionId = $versions->data[1]->id;
versions = client.beta.memory_stores.memory_versions.list(
store.id,
memory_id: mem.id
)
versions.auto_paging_each do |version|
puts "#{version.id}: #{version.operation}"
end
version_id = versions.data[1].id
전체 파라미터와 응답 스키마는 List memory versions reference를 참고하세요.
Retrieve a version
개별 버전을 가져오면 목록 응답과 같은 필드에 전체 content 본문이 추가돼요.
ant beta:memory-stores:memory-versions retrieve \
--memory-store-id "$store_id" \
--memory-version-id "$version_id"
version = client.beta.memory_stores.memory_versions.retrieve(
version_id,
memory_store_id=store.id,
)
print(version.content)
const version = await client.beta.memoryStores.memoryVersions.retrieve(versionId, {
memory_store_id: store.id
});
console.log(version.content);
var version = await client.Beta.MemoryStores.MemoryVersions.Retrieve(versionId, new()
{
MemoryStoreID = store.ID,
});
Console.WriteLine(version.Content);
version, err := client.Beta.MemoryStores.MemoryVersions.Get(ctx, versionID, anthropic.BetaMemoryStoreMemoryVersionGetParams{
MemoryStoreID: store.ID,
})
if err != nil {
panic(err)
}
fmt.Println(version.Content)
var version = client.beta().memoryStores().memoryVersions().retrieve(
versionId,
MemoryVersionRetrieveParams.builder().memoryStoreId(store.id()).build()
);
IO.println(version.content().orElseThrow());
$version = $client->beta->memoryStores->memoryVersions->retrieve(
$versionId,
memoryStoreID: $store->id,
);
echo "{$version->content}\n";
version = client.beta.memory_stores.memory_versions.retrieve(
version_id,
memory_store_id: store.id
)
puts version.content
전체 파라미터와 응답 스키마는 Retrieve a memory version reference를 참고하세요.
Redact a version
Redact는 감사 추적(누가 언제 무엇을 했는지)을 보존하면서 과거 버전에서 콘텐츠를 지워요. 유출된 비밀, PII 제거, 사용자 삭제 요청 같은 컴플라이언스 워크플로에 사용해요.
활성 메모리의 현재 헤드인 버전은 redact할 수 없어요. 먼저 새 버전을 쓰고(또는 메모리를 삭제하고) 그다음 옛 버전을 redact하세요.
ant beta:memory-stores:memory-versions redact \
--memory-store-id "$store_id" \
--memory-version-id "$version_id"
client.beta.memory_stores.memory_versions.redact(
version_id,
memory_store_id=store.id,
)
await client.beta.memoryStores.memoryVersions.redact(versionId, {
memory_store_id: store.id
});
await client.Beta.MemoryStores.MemoryVersions.Redact(versionId, new()
{
MemoryStoreID = store.ID,
});
_, err = client.Beta.MemoryStores.MemoryVersions.Redact(ctx, versionID, anthropic.BetaMemoryStoreMemoryVersionRedactParams{
MemoryStoreID: store.ID,
})
if err != nil {
panic(err)
}
client.beta().memoryStores().memoryVersions().redact(
versionId,
MemoryVersionRedactParams.builder().memoryStoreId(store.id()).build()
);
$client->beta->memoryStores->memoryVersions->redact(
$versionId,
memoryStoreID: $store->id,
);
client.beta.memory_stores.memory_versions.redact(
version_id,
memory_store_id: store.id
)
전체 파라미터와 응답 스키마는 Redact a memory version reference를 참고하세요.
Manage memory stores
create 외에도 메모리 스토어는 retrieve, update, list, archive, delete를 지원해요.
List stores
워크스페이스의 스토어를 나열해요. 보관된 스토어는 기본적으로 제외되며, 포함하려면 include_archived: true를 전달하세요.
ant beta:memory-stores list --include-archived
for memory_store in client.beta.memory_stores.list(include_archived=True):
print(memory_store.id, memory_store.name, memory_store.archived_at)
for await (const s of client.beta.memoryStores.list({ include_archived: true })) {
console.log(s.id, s.name, s.archived_at);
}
var stores = await client.Beta.MemoryStores.List(new() { IncludeArchived = true });
await foreach (var s in stores.Paginate())
{
Console.WriteLine($"{s.ID} {s.Name} {s.ArchivedAt}");
}
stores := client.Beta.MemoryStores.ListAutoPaging(ctx, anthropic.BetaMemoryStoreListParams{
IncludeArchived: anthropic.Bool(true),
})
for stores.Next() {
s := stores.Current()
fmt.Println(s.ID, s.Name, s.ArchivedAt)
}
if err := stores.Err(); err != nil {
panic(err)
}
for (var s : client.beta().memoryStores().list(
MemoryStoreListParams.builder().includeArchived(true).build()
).autoPager()) {
IO.println(s.id() + " " + s.name() + " " + s.archivedAt());
}
foreach ($client->beta->memoryStores->list(includeArchived: true)->pagingEachItem() as $s) {
// archivedAt is only set on archived stores.
$archivedAt = isset($s->archivedAt) ? $s->archivedAt->format(DATE_ATOM) : '';
echo "{$s->id} {$s->name} {$archivedAt}\n";
}
client.beta.memory_stores.list(include_archived: true).auto_paging_each do |memory_store|
puts "#{memory_store.id} #{memory_store.name} #{memory_store.archived_at}"
end
전체 파라미터와 응답 스키마는 List memory stores reference를 참고하세요.
Archive a store
보관은 스토어를 읽기 전용으로 만들고 새 세션에 붙지 못하게 해요. 보관은 단방향이며 unarchive는 없어요.
ant beta:memory-stores archive --memory-store-id "$store_id"
client.beta.memory_stores.archive(store.id)
await client.beta.memoryStores.archive(store.id);
await client.Beta.MemoryStores.Archive(store.ID);
_, err = client.Beta.MemoryStores.Archive(ctx, store.ID, anthropic.BetaMemoryStoreArchiveParams{})
if err != nil {
panic(err)
}
client.beta().memoryStores().archive(store.id());
$client->beta->memoryStores->archive($store->id);
client.beta.memory_stores.archive(store.id)
전체 파라미터와 응답 스키마는 Archive a memory store reference를 참고하세요.
모든 메모리와 버전과 함께 스토어를 영구 제거하려면 memory_stores.delete를 사용하세요.
Best practices for memory management
스토어가 10,000개 메모리 한도에 도달하면 새 메모리 쓰기가 실패해요: 직접 memories.create 호출과 매핑되지 않은 경로에 대한 에이전트의 파일 쓰기 모두요. 기존 메모리는 계속 읽고 편집할 수 있어요. 다음 관행이 한도 아래를 유지하고, 도달했을 때 우아하게 회복하게 도와줘요.
-
Use focused stores. Rather than one large general-purpose store, use smaller purpose-built stores: one per user, one for shared domain knowledge, and one for project-specific context. Each store has its own 10,000-memory limit, so keeping stores scoped reduces the chance any single one fills up.
-
Condense or prune before the store fills up. Delete stale or redundant memories with
memories.delete. You can also run a dreaming session, which consolidates fragmented content into a separate new output store rather than modifying the original. Switch your sessions over to that output store, then archive or delete the original. -
Attach a new store when it makes sense. If a store has grown beyond its useful scope, attach a fresh one for new content and attach the original with
read_onlyaccess. The agent can read from both while only writing to the new one. -
Limit write access where appropriate. Sessions that only read shared reference material don't need
read_write. Keeping write access scoped to sessions that actually add new memories makes it easier to track where growth is coming from.
더 알아보기 (Learn more)
- Start a session — 세션 만들고 메모리 스토어 붙이기
- Dreams — 무질서한 메모리를 정리하기
- Agent toolset — 에이전트가 메모리를 읽고 쓰는 도구
- Self-hosted sandboxes — 셀프 호스팅 환경에서 메모리 스토어