메모리 도구

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 2048
tools:
  - type: memory_20250818
    name: memory
messages:
  - role: user
    content: Help me respond to this customer service ticket.
YAML

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=2048,
    messages=[
        {
            "role": "user",
            "content": "Help me respond to this customer service ticket.",
        }
    ],
    tools=[{"type": "memory_20250818", "name": "memory"}],
)

print(message)

const anthropic = new Anthropic();

const message = await anthropic.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 2048,
  messages: [
    {
      role: "user",
      content: "Help me respond to this customer service ticket."
    }
  ],
  tools: [{ type: "memory_20250818", name: "memory" }]
});

console.log(message);

var client = new AnthropicClient();

var message = await client.Messages.Create(
    new()
    {
        Model = Model.ClaudeOpus5_5,
        MaxTokens = 2048,
        Messages =
        [
            new()
            {
                Role = Role.User,
                Content = "Help me respond to this customer service ticket.",
            },
        ],
        Tools = [new MemoryTool20250818()],
    }
);

Console.WriteLine(message);

client := anthropic.NewClient()

message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 2048,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Help me respond to this customer service ticket.")),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfMemoryTool20250818: &anthropic.MemoryTool20250818Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(message)

import com.anthropic.models.messages.MemoryTool20250818;
// ...
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(2048L)
    .addTool(MemoryTool20250818.builder().build())
    .addUserMessage("Help me respond to this customer service ticket.")
    .build();

  Message message = client.messages().create(params);
  IO.println(message);

$client = new Client();

$message = $client->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    maxTokens: 2048,
    messages: [
        [
            'role' => 'user',
            'content' => 'Help me respond to this customer service ticket.',
        ],
    ],
    tools: [new MemoryTool20250818],
);

echo $message;

client = Anthropic::Client.new

message = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 2048,
  messages: [
    {
      role: "user",
      content: "Help me respond to this customer service ticket."
    }
  ],
  tools: [
    {
      type: "memory_20250818",
      name: "memory"
    }
  ]
)
puts message

client = anthropic.Anthropic() memory = BetaLocalFilesystemMemoryTool(base_path="./memory")

runner = client.beta.messages.tool_runner( model="claude-opus-5-5", max_tokens=1024, messages=[ { "role": "user", "content": "Remember that customer Acme Corp prefers email follow-ups.", } ], tools=[memory], )

final_message = runner.until_done() print(final_message.content)

```typescript TypeScript
import Anthropic from "@anthropic-ai/sdk";
import { betaMemoryTool } from "@anthropic-ai/sdk/helpers/beta/memory";
import { BetaLocalFilesystemMemoryTool } from "@anthropic-ai/sdk/tools/memory/node";

const client = new Anthropic();

const backend = await BetaLocalFilesystemMemoryTool.init("./memory");
const memory = betaMemoryTool(backend); // or pass your own handlers object

const runner = client.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "Remember that customer Acme Corp prefers email follow-ups."
    }
  ],
  tools: [memory],
  max_iterations: 10
});

const finalMessage = await runner;
console.log(finalMessage.content);

using Anthropic;
using Anthropic.Helpers.Beta;
using Anthropic.Models.Beta.Messages;

var client = new AnthropicClient();

// Your subclass of BetaAbstractMemoryTool
var memory = new FilesystemMemoryTool("./memories");

var runner = client.Beta.Messages.ToolRunner(
    new MessageCreateParams
    {
        Model = Anthropic.Models.Messages.Model.ClaudeOpus5_5,
        MaxTokens = 1024,
        Messages =
        [
            new()
            {
                Role = Role.User,
                Content = "Remember that customer Acme Corp prefers email follow-ups.",
            },
        ],
    },
    [memory],
    maxIterations: 10
);

var finalMessage = await runner.RunUntilDoneAsync();
Console.WriteLine(finalMessage);

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"slices"
	"sort"
	"strings"

	"github.com/anthropics/anthropic-sdk-go"
)

// An in-memory store that maps memory file paths to their contents.
// Use your own storage in production.
var store = map[string]string{}

type memoryCommand struct {
	Command    string `json:"command"`
	Path       string `json:"path"`
	FileText   string `json:"file_text"`
	OldStr     string `json:"old_str"`
	NewStr     string `json:"new_str"`
	InsertLine int    `json:"insert_line"`
	InsertText string `json:"insert_text"`
	OldPath    string `json:"old_path"`
	NewPath    string `json:"new_path"`
}

func executeMemory(raw json.RawMessage) string {
	var cmd memoryCommand
	if err := json.Unmarshal(raw, &cmd); err != nil {
		return "Error: invalid memory command"
	}
	switch cmd.Command {
	case "view":
		if content, ok := store[cmd.Path]; ok {
			lines := strings.Split(strings.TrimSuffix(content, "\n"), "\n")
			for i, line := range lines {
				lines[i] = fmt.Sprintf("%6d\t%s", i+1, line)
			}
			return fmt.Sprintf("Here's the content of %s with line numbers:\n%s", cmd.Path, strings.Join(lines, "\n"))
		}
		if cmd.Path == "/memories" {
			listing := []string{"1.0K\t/memories"}
			for path := range store {
				listing = append(listing, "1.0K\t"+path)
			}
			sort.Strings(listing[1:])
			return fmt.Sprintf("Here're the files and directories up to 2 levels deep in %s, excluding hidden items and node_modules:\n%s", cmd.Path, strings.Join(listing, "\n"))
		}
		return fmt.Sprintf("The path %s does not exist. Please provide a valid path.", cmd.Path)
	case "create":
		store[cmd.Path] = cmd.FileText
		return "File created successfully at: " + cmd.Path
	case "str_replace":
		content, ok := store[cmd.Path]
		if !ok || !strings.Contains(content, cmd.OldStr) {
			return fmt.Sprintf("No replacement was performed, old_str `%s` did not appear verbatim in %s.", cmd.OldStr, cmd.Path)
		}
		store[cmd.Path] = strings.Replace(content, cmd.OldStr, cmd.NewStr, 1)
		return "The memory file has been edited."
	case "insert":
		content, ok := store[cmd.Path]
		if !ok {
			return fmt.Sprintf("Error: The path %s does not exist", cmd.Path)
		}
		lines := strings.Split(content, "\n")
		if cmd.InsertLine < 0 || cmd.InsertLine > len(lines) {
			return fmt.Sprintf("Error: Invalid `insert_line` parameter: %d. It should be within the range of lines of the file: [0, %d]", cmd.InsertLine, len(lines))
		}
		lines = slices.Insert(lines, cmd.InsertLine, strings.TrimSuffix(cmd.InsertText, "\n"))
		store[cmd.Path] = strings.Join(lines, "\n")
		return fmt.Sprintf("The file %s has been edited.", cmd.Path)
	case "delete":
		if _, ok := store[cmd.Path]; !ok {
			return fmt.Sprintf("Error: The path %s does not exist", cmd.Path)
		}
		delete(store, cmd.Path)
		return "Successfully deleted " + cmd.Path
	case "rename":
		if _, ok := store[cmd.OldPath]; !ok {
			return fmt.Sprintf("Error: The path %s does not exist", cmd.OldPath)
		}
		if _, ok := store[cmd.NewPath]; ok {
			return fmt.Sprintf("Error: The destination %s already exists", cmd.NewPath)
		}
		store[cmd.NewPath] = store[cmd.OldPath]
		delete(store, cmd.OldPath)
		return fmt.Sprintf("Successfully renamed %s to %s", cmd.OldPath, cmd.NewPath)
	default:
		return "Error: unknown command " + cmd.Command
	}
}

func main() {
	client := anthropic.NewClient()
	tools := []anthropic.ToolUnionParam{{OfMemoryTool20250818: &anthropic.MemoryTool20250818Param{}}}
	messages := []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Remember that customer Acme Corp prefers email follow-ups.")),
	}

	for {
		message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
			Model:     anthropic.ModelClaudeOpus5_5,
			MaxTokens: 1024,
			Messages:  messages,
			Tools:     tools,
		})
		if err != nil {
			log.Fatal(err)
		}
		if message.StopReason != anthropic.StopReasonToolUse {
			for _, block := range message.Content {
				if block.Type == "text" {
					fmt.Println(block.Text)
				}
			}
			break
		}
		results := []anthropic.ContentBlockParamUnion{}
		for _, block := range message.Content {
			if block.Type == "tool_use" {
				results = append(results, anthropic.NewToolResultBlock(block.ID, executeMemory(block.Input), false))
			}
		}
		messages = append(messages, message.ToParam(), anthropic.NewUserMessage(results...))
	}
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.helpers.BetaMemoryToolHandler;
import com.anthropic.helpers.BetaToolRunner;
import com.anthropic.models.beta.messages.BetaMemoryTool20250818;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.MessageCreateParams; // beta package, not models.messages
import com.anthropic.models.beta.messages.ToolRunnerCreateParams;
import com.anthropic.models.messages.Model;
import java.nio.file.Path;

void main() {
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Your BetaMemoryToolHandler implementation of the six memory commands
  BetaMemoryToolHandler handler = new FileSystemMemoryToolHandler(Path.of("memories"));

  MessageCreateParams createParams = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(1024L)
    .addTool(BetaMemoryTool20250818.builder().build())
    .addUserMessage("Remember that customer Acme Corp prefers email follow-ups.")
    .build();

  ToolRunnerCreateParams runnerParams = ToolRunnerCreateParams.builder()
    .betaMemoryToolHandler(handler)
    .initialMessageParams(createParams)
    .maxIterations(10)
    .build();

  BetaToolRunner runner = client.beta().messages().toolRunner(runnerParams);
  for (BetaMessage message : runner) {
    IO.println(message);
  }
}

<?php

use Anthropic\Beta\Messages\BetaMemoryTool20250818;
use Anthropic\Client;
use Anthropic\Lib\Tools\BetaRunnableTool;
use Anthropic\Messages\Model;

$client = new Client();

// An in-memory store that maps memory file paths to their contents.
// Use your own storage in production.
$store = [];

$memory = new BetaRunnableTool(
    definition: new BetaMemoryTool20250818,
    run: function (array $input) use (&$store): string {
        $path = $input['path'] ?? '';
        switch ($input['command']) {
            case 'view':
                if (isset($store[$path])) {
                    $numbered = [];
                    foreach (explode("\n", preg_replace('/\n\z/', '', $store[$path])) as $i => $line) {
                        $numbered[] = sprintf("%6d\t%s", $i + 1, $line);
                    }
                    return "Here's the content of {$path} with line numbers:\n" . implode("\n", $numbered);
                }
                if ($path === '/memories') {
                    $listing = ["1.0K\t/memories"];
                    foreach (array_keys($store) as $stored) {
                        $listing[] = "1.0K\t{$stored}";
                    }
                    return "Here're the files and directories up to 2 levels deep in {$path}, excluding hidden items and node_modules:\n" . implode("\n", $listing);
                }
                return "The path {$path} does not exist. Please provide a valid path.";
            case 'create':
                $store[$path] = $input['file_text'];
                return "File created successfully at: {$path}";
            case 'str_replace':
                $position = strpos($store[$path] ?? '', $input['old_str']);
                if ($position === false) {
                    return "No replacement was performed, old_str `{$input['old_str']}` did not appear verbatim in {$path}.";
                }
                $store[$path] = substr_replace($store[$path], $input['new_str'] ?? '', $position, strlen($input['old_str']));
                return 'The memory file has been edited.';
            case 'insert':
                if (!isset($store[$path])) {
                    return "Error: The path {$path} does not exist";
                }
                $lines = explode("\n", $store[$path]);
                if ($input['insert_line'] < 0 || $input['insert_line'] > count($lines)) {
                    return "Error: Invalid `insert_line` parameter: {$input['insert_line']}. It should be within the range of lines of the file: [0, " . count($lines) . "]";
                }
                array_splice($lines, $input['insert_line'], 0, [preg_replace('/\n\z/', '', $input['insert_text'])]);
                $store[$path] = implode("\n", $lines);
                return "The file {$path} has been edited.";
            case 'delete':
                if (!isset($store[$path])) {
                    return "Error: The path {$path} does not exist";
                }
                unset($store[$path]);
                return "Successfully deleted {$path}";
            case 'rename':
                if (!isset($store[$input['old_path']])) {
                    return "Error: The path {$input['old_path']} does not exist";
                }
                if (isset($store[$input['new_path']])) {
                    return "Error: The destination {$input['new_path']} already exists";
                }
                $store[$input['new_path']] = $store[$input['old_path']];
                unset($store[$input['old_path']]);
                return "Successfully renamed {$input['old_path']} to {$input['new_path']}";
            default:
                return "Error: unknown command {$input['command']}";
        }
    },
);

$runner = $client->beta->messages->toolRunner(
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Remember that customer Acme Corp prefers email follow-ups.']],
    model: Model::CLAUDE_OPUS_5_5,
    tools: [$memory],
    maxIterations: 10,
);

$finalMessage = $runner->runUntilDone();
print_r($finalMessage->content);

require "anthropic"

client = Anthropic::Client.new
TOOLS = [{type: "memory_20250818", name: "memory"}].freeze

# An in-memory store that maps memory file paths to their contents.
# Use your own storage in production.
STORE = {}

def execute_memory(input)
  path = input[:path]
  case input[:command]
  when "view"
    if STORE.key?(path)
      lines = STORE[path].chomp.split("\n", -1)
      lines = [""] if lines.empty?
      numbered = lines.each_with_index.map { |line, i| format("%6d\t%s", i + 1, line) }
      "Here's the content of #{path} with line numbers:\n#{numbered.join("\n")}"
    elsif path == "/memories"
      listing = ["1.0K\t/memories"] + STORE.keys.map { |stored| "1.0K\t#{stored}" }
      "Here're the files and directories up to 2 levels deep in #{path}, excluding hidden items and node_modules:\n#{listing.join("\n")}"
    else
      "The path #{path} does not exist. Please provide a valid path."
    end
  when "create"
    STORE[path] = input[:file_text]
    "File created successfully at: #{path}"
  when "str_replace"
    unless STORE.key?(path) && STORE[path].include?(input[:old_str])
      return "No replacement was performed, old_str `#{input[:old_str]}` did not appear verbatim in #{path}."
    end
    STORE[path] = STORE[path].sub(input[:old_str]) { input[:new_str].to_s }
    "The memory file has been edited."
  when "insert"
    return "Error: The path #{path} does not exist" unless STORE.key?(path)
    lines = STORE[path].split("\n", -1)
    lines = [""] if lines.empty?
    if input[:insert_line] < 0 || input[:insert_line] > lines.length
      return "Error: Invalid `insert_line` parameter: #{input[:insert_line]}. It should be within the range of lines of the file: [0, #{lines.length}]"
    end
    lines.insert(input[:insert_line], input[:insert_text].chomp)
    STORE[path] = lines.join("\n")
    "The file #{path} has been edited."
  when "delete"
    return "Error: The path #{path} does not exist" unless STORE.key?(path)
    STORE.delete(path)
    "Successfully deleted #{path}"
  when "rename"
    return "Error: The path #{input[:old_path]} does not exist" unless STORE.key?(input[:old_path])
    return "Error: The destination #{input[:new_path]} already exists" if STORE.key?(input[:new_path])
    STORE[input[:new_path]] = STORE.delete(input[:old_path])
    "Successfully renamed #{input[:old_path]} to #{input[:new_path]}"
  else
    "Error: unknown command #{input[:command]}"
  end
end

messages = [{role: "user", content: "Remember that customer Acme Corp prefers email follow-ups."}]
loop do
  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: messages,
    tools: TOOLS
  )
  unless message.stop_reason == :tool_use
    puts message.content
    break
  end
  tool_results = message.content.filter_map do |block|
    next unless block.type == :tool_use
    {type: "tool_result", tool_use_id: block.id, content: execute_memory(block.input)}
  end
  messages << {role: "assistant", content: message.content} << {role: "user", content: tool_results}
end